[picodrive.git] / unzip / unzip.c

#include "unzip.h"\r
\r
#include <stdlib.h>\r
#include <string.h>\r
#include <ctype.h>\r
#include <assert.h>\r
\r
#include <zlib.h>\r
\r
/* public globals */\r
//int	gUnzipQuiet = 0;		/* flag controls error messages */\r
\r
#define ERROR_CORRUPT "The zipfile seems to be corrupt, please check it"\r
#define ERROR_FILESYSTEM "Your filesystem seems to be corrupt, please check it"\r
#define ERROR_UNSUPPORTED "The format of this zipfile is not supported, please recompress it"\r
\r
#define INFLATE_INPUT_BUFFER_MAX 16384\r
#ifndef MIN\r
#define MIN(x,y) ((x)<(y)?(x):(y))\r
#endif\r
\r
\r
// notaz\r
#if 1 //def __DEBUG_PRINT\r
#define logerror printf\r
#define errormsg(str1,def,fname) printf("%s: " #def ": " str1 "\n", fname);\r
#else\r
#define logerror(x...)\r
#define errormsg(x...)\r
#endif\r
\r
/* Print a error message */\r
//void errormsg(const char* extmsg, const char* usermsg, const char* zipname) {\r
	/* Output to the user with no internal detail */\r
//	if (!gUnzipQuiet)\r
//		printf("Error in zipfile %s\n%s\n", zipname, usermsg);\r
	/* Output to log file with all informations */\r
//	logerror("Error in zipfile %s: %s\n", zipname, extmsg);\r
//	printf("Error in zipfile %s: %s\n", zipname, extmsg);\r
//}\r
\r
/* -------------------------------------------------------------------------\r
   Unzip support\r
 ------------------------------------------------------------------------- */\r
\r
/* Use these to avoid structure padding and byte-ordering problems */\r
static UINT16 read_word (char *buf) {\r
   unsigned char *ubuf = (unsigned char *) buf;\r
\r
   return ((UINT16)ubuf[1] << 8) | (UINT16)ubuf[0];\r
}\r
\r
/* Use these to avoid structure padding and byte-ordering problems */\r
static UINT32 read_dword (char *buf) {\r
   unsigned char *ubuf = (unsigned char *) buf;\r
\r
   return ((UINT32)ubuf[3] << 24) | ((UINT32)ubuf[2] << 16) | ((UINT32)ubuf[1] << 8) | (UINT32)ubuf[0];\r
}\r
\r
/* Locate end-of-central-dir sig in buffer and return offset\r
   out:\r
	*offset offset of cent dir start in buffer\r
   return:\r
	==0 not found\r
	!=0 found, *offset valid\r
*/\r
static int ecd_find_sig (char *buffer, int buflen, int *offset)\r
{\r
	static char ecdsig[] = { 'P', 'K', 0x05, 0x06 };\r
	int i;\r
	for (i=buflen-22; i>=0; i--) {\r
		if (memcmp(buffer+i, ecdsig, 4) == 0) {\r
			*offset = i;\r
			return 1;\r
		}\r
	}\r
	return 0;\r
}\r
\r
/* Read ecd data in zip structure\r
   in:\r
     zip->fp, zip->length zip file\r
   out:\r
     zip->ecd, zip->ecd_length ecd data\r
*/\r
static int ecd_read(ZIP* zip) {\r
	char* buf;\r
	int buf_length = 1024; /* initial buffer length */\r
\r
	while (1) {\r
		int offset;\r
\r
		if (buf_length > zip->length)\r
			buf_length = zip->length;\r
\r
		if (fseek(zip->fp, zip->length - buf_length, SEEK_SET) != 0) {\r
			return -1;\r
		}\r
\r
		/* allocate buffer */\r
		buf = (char*)malloc( buf_length );\r
		if (!buf) {\r
			return -1;\r
		}\r
\r
		if (fread( buf, buf_length, 1, zip->fp ) != 1) {\r
			free(buf);\r
			return -1;\r
		}\r
\r
		if (ecd_find_sig(buf, buf_length, &offset)) {\r
			zip->ecd_length = buf_length - offset;\r
\r
			zip->ecd = (char*)malloc( zip->ecd_length );\r
			if (!zip->ecd) {\r
				free(buf);\r
				return -1;\r
			}\r
\r
			memcpy(zip->ecd, buf + offset, zip->ecd_length);\r
\r
			free(buf);\r
			return 0;\r
		}\r
\r
		free(buf);\r
\r
		if (buf_length < zip->length) {\r
			/* double buffer */\r
			buf_length = 2*buf_length;\r
\r
			logerror("Retry reading of zip ecd for %d bytes\n",buf_length);\r
\r
		} else {\r
			return -1;\r
		}\r
	}\r
}\r
\r
/* offsets in end of central directory structure */\r
#define ZIPESIG		0x00\r
#define ZIPEDSK		0x04\r
#define ZIPECEN		0x06\r
#define ZIPENUM		0x08\r
#define ZIPECENN	0x0a\r
#define ZIPECSZ		0x0c\r
#define ZIPEOFST	0x10\r
#define ZIPECOML	0x14\r
#define ZIPECOM		0x16\r
\r
/* offsets in central directory entry structure */\r
#define ZIPCENSIG	0x0\r
#define ZIPCVER		0x4\r
#define ZIPCOS		0x5\r
#define	ZIPCVXT		0x6\r
#define	ZIPCEXOS	0x7\r
#define ZIPCFLG		0x8\r
#define ZIPCMTHD	0xa\r
#define ZIPCTIM		0xc\r
#define ZIPCDAT		0xe\r
#define ZIPCCRC		0x10\r
#define ZIPCSIZ		0x14\r
#define ZIPCUNC		0x18\r
#define ZIPCFNL		0x1c\r
#define ZIPCXTL		0x1e\r
#define ZIPCCML		0x20\r
#define ZIPDSK		0x22\r
#define ZIPINT		0x24\r
#define ZIPEXT		0x26\r
#define ZIPOFST		0x2a\r
#define ZIPCFN		0x2e\r
\r
/* offsets in local file header structure */\r
#define ZIPLOCSIG	0x00\r
#define ZIPVER		0x04\r
#define ZIPGENFLG	0x06\r
#define ZIPMTHD		0x08\r
#define ZIPTIME		0x0a\r
#define ZIPDATE		0x0c\r
#define ZIPCRC		0x0e\r
#define ZIPSIZE		0x12\r
#define ZIPUNCMP	0x16\r
#define ZIPFNLN		0x1a\r
#define ZIPXTRALN	0x1c\r
#define ZIPNAME		0x1e\r
\r
/* Opens a zip stream for reading\r
   return:\r
     !=0 success, zip stream\r
     ==0 error\r
*/\r
ZIP* openzip(const char* zipfile) {\r
	/* allocate */\r
	ZIP* zip = (ZIP*)malloc( sizeof(ZIP) );\r
	if (!zip) {\r
		return 0;\r
	}\r
\r
	/* open */\r
	zip->fp = fopen(zipfile, "rb");\r
	if (!zip->fp) {\r
		errormsg ("Opening for reading", ERROR_FILESYSTEM, zipfile);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	/* go to end */\r
	if (fseek(zip->fp, 0L, SEEK_END) != 0) {\r
		errormsg ("Seeking to end", ERROR_FILESYSTEM, zipfile);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	/* get length */\r
	zip->length = ftell(zip->fp);\r
	if (zip->length < 0) {\r
		errormsg ("Get file size", ERROR_FILESYSTEM, zipfile);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
	if (zip->length == 0) {\r
		errormsg ("Empty file", ERROR_CORRUPT, zipfile);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	/* read ecd data */\r
	if (ecd_read(zip)!=0) {\r
		errormsg ("Reading ECD (end of central directory)", ERROR_CORRUPT, zipfile);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	/* compile ecd info */\r
	zip->end_of_cent_dir_sig = read_dword (zip->ecd+ZIPESIG);\r
	zip->number_of_this_disk = read_word (zip->ecd+ZIPEDSK);\r
	zip->number_of_disk_start_cent_dir = read_word (zip->ecd+ZIPECEN);\r
	zip->total_entries_cent_dir_this_disk = read_word (zip->ecd+ZIPENUM);\r
	zip->total_entries_cent_dir = read_word (zip->ecd+ZIPECENN);\r
	zip->size_of_cent_dir = read_dword (zip->ecd+ZIPECSZ);\r
	zip->offset_to_start_of_cent_dir = read_dword (zip->ecd+ZIPEOFST);\r
	zip->zipfile_comment_length = read_word (zip->ecd+ZIPECOML);\r
	zip->zipfile_comment = zip->ecd+ZIPECOM;\r
\r
	/* verify that we can work with this zipfile (no disk spanning allowed) */\r
	if ((zip->number_of_this_disk != zip->number_of_disk_start_cent_dir) ||\r
		(zip->total_entries_cent_dir_this_disk != zip->total_entries_cent_dir) ||\r
		(zip->total_entries_cent_dir < 1)) {\r
		errormsg("Cannot span disks", ERROR_UNSUPPORTED, zipfile);\r
		free(zip->ecd);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	if (fseek(zip->fp, zip->offset_to_start_of_cent_dir, SEEK_SET)!=0) {\r
		errormsg ("Seeking to central directory", ERROR_CORRUPT, zipfile);\r
		free(zip->ecd);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	/* read from start of central directory */\r
	zip->cd = (char*)malloc( zip->size_of_cent_dir );\r
	if (!zip->cd) {\r
		free(zip->ecd);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	if (fread(zip->cd, zip->size_of_cent_dir, 1, zip->fp)!=1) {\r
		errormsg ("Reading central directory", ERROR_CORRUPT, zipfile);\r
		free(zip->cd);\r
		free(zip->ecd);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
\r
	/* reset ent */\r
	zip->ent.name = 0;\r
\r
	/* rewind */\r
	zip->cd_pos = 0;\r
\r
	/* file name */\r
	zip->zip = (char*)malloc(strlen(zipfile)+1);\r
	if (!zip->zip) {\r
		free(zip->cd);\r
		free(zip->ecd);\r
		fclose(zip->fp);\r
		free(zip);\r
		return 0;\r
	}\r
	strcpy(zip->zip, zipfile);\r
\r
	return zip;\r
}\r
\r
/* Reads the current entry from a zip stream\r
   in:\r
     zip opened zip\r
   return:\r
     !=0 success\r
     ==0 error\r
*/\r
struct zipent* readzip(ZIP* zip) {\r
\r
	/* end of directory */\r
	if (zip->cd_pos >= zip->size_of_cent_dir)\r
		return 0;\r
\r
	/* compile zipent info */\r
	zip->ent.cent_file_header_sig = read_dword (zip->cd+zip->cd_pos+ZIPCENSIG);\r
	zip->ent.version_made_by = *(zip->cd+zip->cd_pos+ZIPCVER);\r
	zip->ent.host_os = *(zip->cd+zip->cd_pos+ZIPCOS);\r
	zip->ent.version_needed_to_extract = *(zip->cd+zip->cd_pos+ZIPCVXT);\r
	zip->ent.os_needed_to_extract = *(zip->cd+zip->cd_pos+ZIPCEXOS);\r
	zip->ent.general_purpose_bit_flag = read_word (zip->cd+zip->cd_pos+ZIPCFLG);\r
	zip->ent.compression_method = read_word (zip->cd+zip->cd_pos+ZIPCMTHD);\r
	zip->ent.last_mod_file_time = read_word (zip->cd+zip->cd_pos+ZIPCTIM);\r
	zip->ent.last_mod_file_date = read_word (zip->cd+zip->cd_pos+ZIPCDAT);\r
	zip->ent.crc32 = read_dword (zip->cd+zip->cd_pos+ZIPCCRC);\r
	zip->ent.compressed_size = read_dword (zip->cd+zip->cd_pos+ZIPCSIZ);\r
	zip->ent.uncompressed_size = read_dword (zip->cd+zip->cd_pos+ZIPCUNC);\r
	zip->ent.filename_length = read_word (zip->cd+zip->cd_pos+ZIPCFNL);\r
	zip->ent.extra_field_length = read_word (zip->cd+zip->cd_pos+ZIPCXTL);\r
	zip->ent.file_comment_length = read_word (zip->cd+zip->cd_pos+ZIPCCML);\r
	zip->ent.disk_number_start = read_word (zip->cd+zip->cd_pos+ZIPDSK);\r
	zip->ent.internal_file_attrib = read_word (zip->cd+zip->cd_pos+ZIPINT);\r
	zip->ent.external_file_attrib = read_dword (zip->cd+zip->cd_pos+ZIPEXT);\r
	zip->ent.offset_lcl_hdr_frm_frst_disk = read_dword (zip->cd+zip->cd_pos+ZIPOFST);\r
\r
    /* check to see if filename length is illegally long (past the size of this directory\r
       entry) */\r
    if (zip->cd_pos + ZIPCFN + zip->ent.filename_length > zip->size_of_cent_dir)\r
    {\r
        errormsg("Invalid filename length in directory", ERROR_CORRUPT,zip->zip);\r
        return 0;\r
    }\r
\r
	/* copy filename */\r
	free(zip->ent.name);\r
	zip->ent.name = (char*)malloc(zip->ent.filename_length + 1);\r
	memcpy(zip->ent.name, zip->cd+zip->cd_pos+ZIPCFN, zip->ent.filename_length);\r
	zip->ent.name[zip->ent.filename_length] = 0;\r
\r
	/* skip to next entry in central dir */\r
	zip->cd_pos += ZIPCFN + zip->ent.filename_length + zip->ent.extra_field_length + zip->ent.file_comment_length;\r
\r
	return &zip->ent;\r
}\r
\r
/* Closes a zip stream */\r
void closezip(ZIP* zip) {\r
	/* release all */\r
	free(zip->ent.name);\r
	free(zip->cd);\r
	free(zip->ecd);\r
	/* only if not suspended */\r
	if (zip->fp)\r
		fclose(zip->fp);\r
	free(zip->zip);\r
	free(zip);\r
}\r
\r
/* Suspend access to a zip file (release file handler)\r
   in:\r
      zip opened zip\r
   note:\r
     A suspended zip is automatically reopened at first call of\r
     readuncompressd() or readcompressed() functions\r
*/\r
void suspendzip(ZIP* zip) {\r
	if (zip->fp) {\r
		fclose(zip->fp);\r
		zip->fp = 0;\r
	}\r
}\r
\r
/* Revive a suspended zip file (reopen file handler)\r
   in:\r
     zip suspended zip\r
   return:\r
	zip success\r
	==0 error (zip must be closed with closezip)\r
*/\r
static ZIP* revivezip(ZIP* zip) {\r
	if (!zip->fp) {\r
		zip->fp = fopen(zip->zip, "rb");\r
		if (!zip->fp) {\r
			return 0;\r
		}\r
	}\r
	return zip;\r
\r
}\r
\r
/* Reset a zip stream to the first entry\r
   in:\r
     zip opened zip\r
   note:\r
     ZIP file must be opened and not suspended\r
*/\r
void rewindzip(ZIP* zip) {\r
	zip->cd_pos = 0;\r
}\r
\r
/* Seek zip->fp to compressed data\r
   return:\r
	==0 success\r
	<0 error\r
*/\r
int seekcompresszip(ZIP* zip, struct zipent* ent) {\r
	char buf[ZIPNAME];\r
	long offset;\r
\r
	if (!zip->fp) {\r
		if (!revivezip(zip))\r
			return -1;\r
	}\r
\r
	if (fseek(zip->fp, ent->offset_lcl_hdr_frm_frst_disk, SEEK_SET)!=0) {\r
		errormsg ("Seeking to header", ERROR_CORRUPT, zip->zip);\r
		return -1;\r
	}\r
\r
	if (fread(buf, ZIPNAME, 1, zip->fp)!=1) {\r
		errormsg ("Reading header", ERROR_CORRUPT, zip->zip);\r
		return -1;\r
	}\r
\r
	{\r
		UINT16 filename_length = read_word (buf+ZIPFNLN);\r
		UINT16 extra_field_length = read_word (buf+ZIPXTRALN);\r
\r
		/* calculate offset to data and fseek() there */\r
		offset = ent->offset_lcl_hdr_frm_frst_disk + ZIPNAME + filename_length + extra_field_length;\r
\r
		if (fseek(zip->fp, offset, SEEK_SET) != 0) {\r
			errormsg ("Seeking to compressed data", ERROR_CORRUPT, zip->zip);\r
			return -1;\r
		}\r
\r
	}\r
\r
	return 0;\r
}\r
\r
/* Inflate a file\r
   in:\r
   in_file stream to inflate\r
   in_size size of the compressed data to read\r
   out_size size of decompressed data\r
   out:\r
   out_data buffer for decompressed data\r
   return:\r
   ==0 ok\r
\r
   990525 rewritten for use with zlib MLR\r
*/\r
static int inflate_file(FILE* in_file, unsigned in_size, unsigned char* out_data, unsigned out_size)\r
{\r
    int err;\r
	unsigned char* in_buffer;\r
    z_stream d_stream; /* decompression stream */\r
\r
    d_stream.zalloc = 0;\r
    d_stream.zfree = 0;\r
    d_stream.opaque = 0;\r
\r
	d_stream.next_in  = 0;\r
	d_stream.avail_in = 0;\r
    d_stream.next_out = out_data;\r
    d_stream.avail_out = out_size;\r
\r
    err = inflateInit2(&d_stream, -MAX_WBITS);\r
	/* windowBits is passed < 0 to tell that there is no zlib header.\r
	 * Note that in this case inflate *requires* an extra "dummy" byte\r
	 * after the compressed stream in order to complete decompression and\r
	 * return Z_STREAM_END.\r
	 */\r
    if (err != Z_OK)\r
	{\r
		logerror("inflateInit error: %d\n", err);\r
        return -1;\r
	}\r
\r
	in_buffer = (unsigned char*)malloc(INFLATE_INPUT_BUFFER_MAX+1);\r
	if (!in_buffer)\r
		return -1;\r
\r
    for (;;)\r
	{\r
		if (in_size <= 0)\r
		{\r
			logerror("inflate error: compressed size too small\n");\r
			free (in_buffer);\r
			return -1;\r
		}\r
		d_stream.next_in  = in_buffer;\r
		d_stream.avail_in = fread (in_buffer, 1, MIN(in_size, INFLATE_INPUT_BUFFER_MAX), in_file);\r
		in_size -= d_stream.avail_in;\r
		if (in_size == 0)\r
			d_stream.avail_in++; /* add dummy byte at end of compressed data */\r
\r
        err = inflate(&d_stream, Z_NO_FLUSH);\r
        if (err == Z_STREAM_END)\r
			break;\r
		if (err != Z_OK)\r
		{\r
			logerror("inflate error: %d\n", err);\r
			free (in_buffer);\r
			return -1;\r
		}\r
    }\r
\r
    err = inflateEnd(&d_stream);\r
	if (err != Z_OK)\r
	{\r
		logerror("inflateEnd error: %d\n", err);\r
		free (in_buffer);\r
		return -1;\r
	}\r
\r
	free (in_buffer);\r
\r
	if ((d_stream.avail_out > 0) || (in_size > 0))\r
	{\r
		logerror("zip size mismatch. %i\n", in_size);\r
		return -1;\r
	}\r
\r
	return 0;\r
}\r
\r
/* Read compressed data\r
   out:\r
	data compressed data read\r
   return:\r
	==0 success\r
	<0 error\r
*/\r
int readcompresszip(ZIP* zip, struct zipent* ent, char* data) {\r
	int err = seekcompresszip(zip,ent);\r
	if (err!=0)\r
		return err;\r
\r
	if (fread(data, ent->compressed_size, 1, zip->fp)!=1) {\r
		errormsg ("Reading compressed data", ERROR_CORRUPT, zip->zip);\r
		return -1;\r
	}\r
\r
	return 0;\r
}\r
\r
/* Read UNcompressed data\r
   out:\r
	data UNcompressed data\r
   return:\r
	==0 success\r
	<0 error\r
*/\r
int readuncompresszip(ZIP* zip, struct zipent* ent, char* data) {\r
	if (ent->compression_method == 0x0000) {\r
		/* file is not compressed, simply stored */\r
\r
		/* check if size are equal */\r
		if (ent->compressed_size != ent->uncompressed_size) {\r
			errormsg("Wrong uncompressed size in store compression", ERROR_CORRUPT,zip->zip);\r
			return -3;\r
		}\r
\r
		return readcompresszip(zip,ent,data);\r
	} else if (ent->compression_method == 0x0008) {\r
		/* file is compressed using "Deflate" method */\r
		if (ent->version_needed_to_extract > 0x14) {\r
			errormsg("Version too new", ERROR_UNSUPPORTED,zip->zip);\r
			return -2;\r
		}\r
\r
		if (ent->os_needed_to_extract != 0x00) {\r
			errormsg("OS not supported", ERROR_UNSUPPORTED,zip->zip);\r
			return -2;\r
		}\r
\r
		if (ent->disk_number_start != zip->number_of_this_disk) {\r
			errormsg("Cannot span disks", ERROR_UNSUPPORTED,zip->zip);\r
			return -2;\r
		}\r
\r
		/* read compressed data */\r
		if (seekcompresszip(zip,ent)!=0) {\r
			return -1;\r
		}\r
\r
		/* configure inflate */\r
		if (inflate_file( zip->fp, ent->compressed_size, (unsigned char*)data, ent->uncompressed_size))\r
		{\r
			errormsg("Inflating compressed data", ERROR_CORRUPT, zip->zip);\r
			return -3;\r
		}\r
\r
		return 0;\r
	} else {\r
		errormsg("Compression method unsupported", ERROR_UNSUPPORTED, zip->zip);\r
		return -2;\r
	}\r
}\r
Commit	Line	Data
cc68a136	1	#include "unzip.h"\r
	2	\r
	3	#include <stdlib.h>\r
	4	#include <string.h>\r
	5	#include <ctype.h>\r
	6	#include <assert.h>\r
	7	\r
325ee167	8	#include <zlib.h>\r
cc68a136	9	\r
	10	/* public globals */\r
	11	//int gUnzipQuiet = 0; /* flag controls error messages */\r
	12	\r
	13	#define ERROR_CORRUPT "The zipfile seems to be corrupt, please check it"\r
	14	#define ERROR_FILESYSTEM "Your filesystem seems to be corrupt, please check it"\r
	15	#define ERROR_UNSUPPORTED "The format of this zipfile is not supported, please recompress it"\r
	16	\r
	17	#define INFLATE_INPUT_BUFFER_MAX 16384\r
	18	#ifndef MIN\r
	19	#define MIN(x,y) ((x)<(y)?(x):(y))\r
	20	#endif\r
	21	\r
	22	\r
	23	// notaz\r
83bd0b76	24	#if 1 //def __DEBUG_PRINT\r
	25	#define logerror printf\r
	26	#define errormsg(str1,def,fname) printf("%s: " #def ": " str1 "\n", fname);\r
cc68a136	27	#else\r
	28	#define logerror(x...)\r
	29	#define errormsg(x...)\r
	30	#endif\r
	31	\r
	32	/* Print a error message */\r
	33	//void errormsg(const char* extmsg, const char* usermsg, const char* zipname) {\r
	34	/* Output to the user with no internal detail */\r
	35	// if (!gUnzipQuiet)\r
	36	// printf("Error in zipfile %s\n%s\n", zipname, usermsg);\r
	37	/* Output to log file with all informations */\r
	38	// logerror("Error in zipfile %s: %s\n", zipname, extmsg);\r
	39	// printf("Error in zipfile %s: %s\n", zipname, extmsg);\r
	40	//}\r
	41	\r
	42	/* -------------------------------------------------------------------------\r
	43	Unzip support\r
	44	------------------------------------------------------------------------- */\r
	45	\r
	46	/* Use these to avoid structure padding and byte-ordering problems */\r
	47	static UINT16 read_word (char *buf) {\r
	48	unsigned char ubuf = (unsigned char ) buf;\r
	49	\r
	50	return ((UINT16)ubuf[1] << 8) \| (UINT16)ubuf[0];\r
	51	}\r
	52	\r
	53	/* Use these to avoid structure padding and byte-ordering problems */\r
	54	static UINT32 read_dword (char *buf) {\r
	55	unsigned char ubuf = (unsigned char ) buf;\r
	56	\r
	57	return ((UINT32)ubuf[3] << 24) \| ((UINT32)ubuf[2] << 16) \| ((UINT32)ubuf[1] << 8) \| (UINT32)ubuf[0];\r
	58	}\r
	59	\r
	60	/* Locate end-of-central-dir sig in buffer and return offset\r
	61	out:\r
	62	*offset offset of cent dir start in buffer\r
	63	return:\r
	64	==0 not found\r
	65	!=0 found, *offset valid\r
	66	*/\r
	67	static int ecd_find_sig (char buffer, int buflen, int offset)\r
	68	{\r
	69	static char ecdsig[] = { 'P', 'K', 0x05, 0x06 };\r
	70	int i;\r
	71	for (i=buflen-22; i>=0; i--) {\r
	72	if (memcmp(buffer+i, ecdsig, 4) == 0) {\r
	73	*offset = i;\r
	74	return 1;\r
	75	}\r
	76	}\r
	77	return 0;\r
	78	}\r
	79	\r
	80	/* Read ecd data in zip structure\r
	81	in:\r
	82	zip->fp, zip->length zip file\r
	83	out:\r
	84	zip->ecd, zip->ecd_length ecd data\r
	85	*/\r
	86	static int ecd_read(ZIP* zip) {\r
	87	char* buf;\r
	88	int buf_length = 1024; /* initial buffer length */\r
	89	\r
	90	while (1) {\r
91	int offset;\r
92	\r
93	if (buf_length > zip->length)\r
94	buf_length = zip->length;\r
95	\r
96	if (fseek(zip->fp, zip->length - buf_length, SEEK_SET) != 0) {\r
97	return -1;\r
98	}\r
99	\r
100	/* allocate buffer */\r
101	buf = (char*)malloc( buf_length );\r
102	if (!buf) {\r
103	return -1;\r
104	}\r
105	\r
106	if (fread( buf, buf_length, 1, zip->fp ) != 1) {\r
107	free(buf);\r
108	return -1;\r
109	}\r
110	\r
111	if (ecd_find_sig(buf, buf_length, &offset)) {\r
112	zip->ecd_length = buf_length - offset;\r
113	\r
114	zip->ecd = (char*)malloc( zip->ecd_length );\r
115	if (!zip->ecd) {\r
116	free(buf);\r
117	return -1;\r
118	}\r
119	\r
120	memcpy(zip->ecd, buf + offset, zip->ecd_length);\r
121	\r
122	free(buf);\r
123	return 0;\r
124	}\r
125	\r
126	free(buf);\r
127	\r
128	if (buf_length < zip->length) {\r
129	/* double buffer */\r
130	buf_length = 2*buf_length;\r
131	\r
132	logerror("Retry reading of zip ecd for %d bytes\n",buf_length);\r
133	\r
134	} else {\r
135	return -1;\r
136	}\r
137	}\r
138	}\r
139	\r
140	/* offsets in end of central directory structure */\r
141	#define ZIPESIG 0x00\r
142	#define ZIPEDSK 0x04\r
143	#define ZIPECEN 0x06\r
144	#define ZIPENUM 0x08\r
145	#define ZIPECENN 0x0a\r
146	#define ZIPECSZ 0x0c\r
147	#define ZIPEOFST 0x10\r
148	#define ZIPECOML 0x14\r
149	#define ZIPECOM 0x16\r
150	\r
151	/* offsets in central directory entry structure */\r
152	#define ZIPCENSIG 0x0\r
153	#define ZIPCVER 0x4\r
154	#define ZIPCOS 0x5\r
155	#define ZIPCVXT 0x6\r
156	#define ZIPCEXOS 0x7\r
157	#define ZIPCFLG 0x8\r
158	#define ZIPCMTHD 0xa\r
159	#define ZIPCTIM 0xc\r
160	#define ZIPCDAT 0xe\r
161	#define ZIPCCRC 0x10\r
162	#define ZIPCSIZ 0x14\r
163	#define ZIPCUNC 0x18\r
164	#define ZIPCFNL 0x1c\r
165	#define ZIPCXTL 0x1e\r
166	#define ZIPCCML 0x20\r
167	#define ZIPDSK 0x22\r
168	#define ZIPINT 0x24\r
169	#define ZIPEXT 0x26\r
170	#define ZIPOFST 0x2a\r
171	#define ZIPCFN 0x2e\r
172	\r
173	/* offsets in local file header structure */\r
174	#define ZIPLOCSIG 0x00\r
175	#define ZIPVER 0x04\r
176	#define ZIPGENFLG 0x06\r
177	#define ZIPMTHD 0x08\r
178	#define ZIPTIME 0x0a\r
179	#define ZIPDATE 0x0c\r
180	#define ZIPCRC 0x0e\r
181	#define ZIPSIZE 0x12\r
182	#define ZIPUNCMP 0x16\r
183	#define ZIPFNLN 0x1a\r
184	#define ZIPXTRALN 0x1c\r
185	#define ZIPNAME 0x1e\r
186	\r
187	/* Opens a zip stream for reading\r
188	return:\r
189	!=0 success, zip stream\r
190	==0 error\r
191	*/\r
192	ZIP* openzip(const char* zipfile) {\r
193	/* allocate */\r
194	ZIP* zip = (ZIP*)malloc( sizeof(ZIP) );\r
195	if (!zip) {\r
196	return 0;\r
197	}\r
198	\r
199	/* open */\r
200	zip->fp = fopen(zipfile, "rb");\r
201	if (!zip->fp) {\r
202	errormsg ("Opening for reading", ERROR_FILESYSTEM, zipfile);\r
203	free(zip);\r
204	return 0;\r
205	}\r
206	\r
207	/* go to end */\r
208	if (fseek(zip->fp, 0L, SEEK_END) != 0) {\r
209	errormsg ("Seeking to end", ERROR_FILESYSTEM, zipfile);\r
210	fclose(zip->fp);\r
211	free(zip);\r
212	return 0;\r
213	}\r
214	\r
215	/* get length */\r
216	zip->length = ftell(zip->fp);\r
217	if (zip->length < 0) {\r
218	errormsg ("Get file size", ERROR_FILESYSTEM, zipfile);\r
219	fclose(zip->fp);\r
220	free(zip);\r
221	return 0;\r
222	}\r
223	if (zip->length == 0) {\r
224	errormsg ("Empty file", ERROR_CORRUPT, zipfile);\r
225	fclose(zip->fp);\r
226	free(zip);\r
227	return 0;\r
228	}\r
229	\r
230	/* read ecd data */\r
231	if (ecd_read(zip)!=0) {\r
232	errormsg ("Reading ECD (end of central directory)", ERROR_CORRUPT, zipfile);\r
233	fclose(zip->fp);\r
234	free(zip);\r
235	return 0;\r
236	}\r
237	\r
238	/* compile ecd info */\r
239	zip->end_of_cent_dir_sig = read_dword (zip->ecd+ZIPESIG);\r
240	zip->number_of_this_disk = read_word (zip->ecd+ZIPEDSK);\r
241	zip->number_of_disk_start_cent_dir = read_word (zip->ecd+ZIPECEN);\r
242	zip->total_entries_cent_dir_this_disk = read_word (zip->ecd+ZIPENUM);\r
243	zip->total_entries_cent_dir = read_word (zip->ecd+ZIPECENN);\r
244	zip->size_of_cent_dir = read_dword (zip->ecd+ZIPECSZ);\r
245	zip->offset_to_start_of_cent_dir = read_dword (zip->ecd+ZIPEOFST);\r
246	zip->zipfile_comment_length = read_word (zip->ecd+ZIPECOML);\r
247	zip->zipfile_comment = zip->ecd+ZIPECOM;\r
248	\r
249	/* verify that we can work with this zipfile (no disk spanning allowed) */\r
250	if ((zip->number_of_this_disk != zip->number_of_disk_start_cent_dir) \|\|\r
251	(zip->total_entries_cent_dir_this_disk != zip->total_entries_cent_dir) \|\|\r
252	(zip->total_entries_cent_dir < 1)) {\r
253	errormsg("Cannot span disks", ERROR_UNSUPPORTED, zipfile);\r
254	free(zip->ecd);\r
255	fclose(zip->fp);\r
256	free(zip);\r
257	return 0;\r
258	}\r
259	\r
260	if (fseek(zip->fp, zip->offset_to_start_of_cent_dir, SEEK_SET)!=0) {\r
261	errormsg ("Seeking to central directory", ERROR_CORRUPT, zipfile);\r
262	free(zip->ecd);\r
263	fclose(zip->fp);\r
264	free(zip);\r
265	return 0;\r
266	}\r
267	\r
268	/* read from start of central directory */\r
269	zip->cd = (char*)malloc( zip->size_of_cent_dir );\r
270	if (!zip->cd) {\r
271	free(zip->ecd);\r
272	fclose(zip->fp);\r
273	free(zip);\r
274	return 0;\r
275	}\r
276	\r
277	if (fread(zip->cd, zip->size_of_cent_dir, 1, zip->fp)!=1) {\r
278	errormsg ("Reading central directory", ERROR_CORRUPT, zipfile);\r
279	free(zip->cd);\r
280	free(zip->ecd);\r
281	fclose(zip->fp);\r
282	free(zip);\r
283	return 0;\r
284	}\r
285	\r
286	/* reset ent */\r
287	zip->ent.name = 0;\r
288	\r
289	/* rewind */\r
290	zip->cd_pos = 0;\r
291	\r
292	/* file name */\r
293	zip->zip = (char*)malloc(strlen(zipfile)+1);\r
294	if (!zip->zip) {\r
295	free(zip->cd);\r
296	free(zip->ecd);\r
297	fclose(zip->fp);\r
298	free(zip);\r
299	return 0;\r
300	}\r
301	strcpy(zip->zip, zipfile);\r
302	\r
303	return zip;\r
304	}\r
305	\r
306	/* Reads the current entry from a zip stream\r
307	in:\r
308	zip opened zip\r
309	return:\r
310	!=0 success\r
311	==0 error\r
312	*/\r
313	struct zipent* readzip(ZIP* zip) {\r
314	\r
315	/* end of directory */\r
316	if (zip->cd_pos >= zip->size_of_cent_dir)\r
317	return 0;\r
318	\r
319	/* compile zipent info */\r
320	zip->ent.cent_file_header_sig = read_dword (zip->cd+zip->cd_pos+ZIPCENSIG);\r
321	zip->ent.version_made_by = *(zip->cd+zip->cd_pos+ZIPCVER);\r
322	zip->ent.host_os = *(zip->cd+zip->cd_pos+ZIPCOS);\r
323	zip->ent.version_needed_to_extract = *(zip->cd+zip->cd_pos+ZIPCVXT);\r
324	zip->ent.os_needed_to_extract = *(zip->cd+zip->cd_pos+ZIPCEXOS);\r
325	zip->ent.general_purpose_bit_flag = read_word (zip->cd+zip->cd_pos+ZIPCFLG);\r
326	zip->ent.compression_method = read_word (zip->cd+zip->cd_pos+ZIPCMTHD);\r
327	zip->ent.last_mod_file_time = read_word (zip->cd+zip->cd_pos+ZIPCTIM);\r
328	zip->ent.last_mod_file_date = read_word (zip->cd+zip->cd_pos+ZIPCDAT);\r
329	zip->ent.crc32 = read_dword (zip->cd+zip->cd_pos+ZIPCCRC);\r
330	zip->ent.compressed_size = read_dword (zip->cd+zip->cd_pos+ZIPCSIZ);\r
331	zip->ent.uncompressed_size = read_dword (zip->cd+zip->cd_pos+ZIPCUNC);\r
332	zip->ent.filename_length = read_word (zip->cd+zip->cd_pos+ZIPCFNL);\r
333	zip->ent.extra_field_length = read_word (zip->cd+zip->cd_pos+ZIPCXTL);\r
334	zip->ent.file_comment_length = read_word (zip->cd+zip->cd_pos+ZIPCCML);\r
335	zip->ent.disk_number_start = read_word (zip->cd+zip->cd_pos+ZIPDSK);\r
336	zip->ent.internal_file_attrib = read_word (zip->cd+zip->cd_pos+ZIPINT);\r
337	zip->ent.external_file_attrib = read_dword (zip->cd+zip->cd_pos+ZIPEXT);\r
338	zip->ent.offset_lcl_hdr_frm_frst_disk = read_dword (zip->cd+zip->cd_pos+ZIPOFST);\r
339	\r
340	/* check to see if filename length is illegally long (past the size of this directory\r
341	entry) */\r
342	if (zip->cd_pos + ZIPCFN + zip->ent.filename_length > zip->size_of_cent_dir)\r
343	{\r
344	errormsg("Invalid filename length in directory", ERROR_CORRUPT,zip->zip);\r
345	return 0;\r
346	}\r
347	\r
348	/* copy filename */\r
349	free(zip->ent.name);\r
350	zip->ent.name = (char*)malloc(zip->ent.filename_length + 1);\r
351	memcpy(zip->ent.name, zip->cd+zip->cd_pos+ZIPCFN, zip->ent.filename_length);\r
352	zip->ent.name[zip->ent.filename_length] = 0;\r
353	\r
354	/* skip to next entry in central dir */\r
355	zip->cd_pos += ZIPCFN + zip->ent.filename_length + zip->ent.extra_field_length + zip->ent.file_comment_length;\r
356	\r
357	return &zip->ent;\r
358	}\r
359	\r
360	/* Closes a zip stream */\r
361	void closezip(ZIP* zip) {\r
362	/* release all */\r
363	free(zip->ent.name);\r
364	free(zip->cd);\r
365	free(zip->ecd);\r
366	/* only if not suspended */\r
367	if (zip->fp)\r
368	fclose(zip->fp);\r
369	free(zip->zip);\r
370	free(zip);\r
371	}\r
372	\r
373	/* Suspend access to a zip file (release file handler)\r
374	in:\r
375	zip opened zip\r
376	note:\r
377	A suspended zip is automatically reopened at first call of\r
378	readuncompressd() or readcompressed() functions\r
379	*/\r
380	void suspendzip(ZIP* zip) {\r
381	if (zip->fp) {\r
382	fclose(zip->fp);\r
383	zip->fp = 0;\r
384	}\r
385	}\r
386	\r
387	/* Revive a suspended zip file (reopen file handler)\r
388	in:\r
389	zip suspended zip\r
390	return:\r
391	zip success\r
392	==0 error (zip must be closed with closezip)\r
393	*/\r
394	static ZIP* revivezip(ZIP* zip) {\r
395	if (!zip->fp) {\r
396	zip->fp = fopen(zip->zip, "rb");\r
397	if (!zip->fp) {\r
398	return 0;\r
399	}\r
400	}\r
401	return zip;\r
402	\r
403	}\r
404	\r
405	/* Reset a zip stream to the first entry\r
406	in:\r
407	zip opened zip\r
408	note:\r
409	ZIP file must be opened and not suspended\r
410	*/\r
411	void rewindzip(ZIP* zip) {\r
412	zip->cd_pos = 0;\r
413	}\r
414	\r
415	/* Seek zip->fp to compressed data\r
416	return:\r
417	==0 success\r
418	<0 error\r
419	*/\r
420	int seekcompresszip(ZIP* zip, struct zipent* ent) {\r
421	char buf[ZIPNAME];\r
422	long offset;\r
423	\r
424	if (!zip->fp) {\r
425	if (!revivezip(zip))\r
426	return -1;\r
427	}\r
428	\r
429	if (fseek(zip->fp, ent->offset_lcl_hdr_frm_frst_disk, SEEK_SET)!=0) {\r
430	errormsg ("Seeking to header", ERROR_CORRUPT, zip->zip);\r
431	return -1;\r
432	}\r
433	\r
434	if (fread(buf, ZIPNAME, 1, zip->fp)!=1) {\r
435	errormsg ("Reading header", ERROR_CORRUPT, zip->zip);\r
436	return -1;\r
437	}\r
438	\r
439	{\r
440	UINT16 filename_length = read_word (buf+ZIPFNLN);\r
441	UINT16 extra_field_length = read_word (buf+ZIPXTRALN);\r
442	\r
443	/* calculate offset to data and fseek() there */\r
444	offset = ent->offset_lcl_hdr_frm_frst_disk + ZIPNAME + filename_length + extra_field_length;\r
445	\r
446	if (fseek(zip->fp, offset, SEEK_SET) != 0) {\r
447	errormsg ("Seeking to compressed data", ERROR_CORRUPT, zip->zip);\r
448	return -1;\r
449	}\r
450	\r
451	}\r
452	\r
453	return 0;\r
454	}\r
455	\r
456	/* Inflate a file\r
457	in:\r
458	in_file stream to inflate\r
459	in_size size of the compressed data to read\r
460	out_size size of decompressed data\r
461	out:\r
462	out_data buffer for decompressed data\r
463	return:\r
464	==0 ok\r
465	\r
466	990525 rewritten for use with zlib MLR\r
467	*/\r
468	static int inflate_file(FILE* in_file, unsigned in_size, unsigned char* out_data, unsigned out_size)\r
469	{\r
470	int err;\r
471	unsigned char* in_buffer;\r
472	z_stream d_stream; /* decompression stream */\r
473	\r
474	d_stream.zalloc = 0;\r
475	d_stream.zfree = 0;\r
476	d_stream.opaque = 0;\r
477	\r
478	d_stream.next_in = 0;\r
479	d_stream.avail_in = 0;\r
480	d_stream.next_out = out_data;\r
481	d_stream.avail_out = out_size;\r
482	\r
483	err = inflateInit2(&d_stream, -MAX_WBITS);\r
484	/* windowBits is passed < 0 to tell that there is no zlib header.\r
485	* Note that in this case inflate requires an extra "dummy" byte\r
486	* after the compressed stream in order to complete decompression and\r
487	* return Z_STREAM_END.\r
488	*/\r
489	if (err != Z_OK)\r
490	{\r
491	logerror("inflateInit error: %d\n", err);\r
492	return -1;\r
493	}\r
494	\r
495	in_buffer = (unsigned char*)malloc(INFLATE_INPUT_BUFFER_MAX+1);\r
496	if (!in_buffer)\r
497	return -1;\r
498	\r
499	for (;;)\r
500	{\r
501	if (in_size <= 0)\r
502	{\r
503	logerror("inflate error: compressed size too small\n");\r
504	free (in_buffer);\r
505	return -1;\r
506	}\r
507	d_stream.next_in = in_buffer;\r
508	d_stream.avail_in = fread (in_buffer, 1, MIN(in_size, INFLATE_INPUT_BUFFER_MAX), in_file);\r
509	in_size -= d_stream.avail_in;\r
510	if (in_size == 0)\r
511	d_stream.avail_in++; /* add dummy byte at end of compressed data */\r
512	\r
513	err = inflate(&d_stream, Z_NO_FLUSH);\r
514	if (err == Z_STREAM_END)\r
515	break;\r
516	if (err != Z_OK)\r
517	{\r
518	logerror("inflate error: %d\n", err);\r
519	free (in_buffer);\r
520	return -1;\r
521	}\r
522	}\r
523	\r
524	err = inflateEnd(&d_stream);\r
525	if (err != Z_OK)\r
526	{\r
527	logerror("inflateEnd error: %d\n", err);\r
528	free (in_buffer);\r
529	return -1;\r
530	}\r
531	\r
532	free (in_buffer);\r
533	\r
534	if ((d_stream.avail_out > 0) \|\| (in_size > 0))\r
535	{\r
536	logerror("zip size mismatch. %i\n", in_size);\r
537	return -1;\r
538	}\r
539	\r
540	return 0;\r
541	}\r
542	\r
543	/* Read compressed data\r
544	out:\r
545	data compressed data read\r
546	return:\r
547	==0 success\r
548	<0 error\r
549	*/\r
550	int readcompresszip(ZIP* zip, struct zipent* ent, char* data) {\r
551	int err = seekcompresszip(zip,ent);\r
552	if (err!=0)\r
553	return err;\r
554	\r
555	if (fread(data, ent->compressed_size, 1, zip->fp)!=1) {\r
556	errormsg ("Reading compressed data", ERROR_CORRUPT, zip->zip);\r
557	return -1;\r
558	}\r
559	\r
560	return 0;\r
561	}\r
562	\r
563	/* Read UNcompressed data\r
564	out:\r
565	data UNcompressed data\r
566	return:\r
567	==0 success\r
568	<0 error\r
569	*/\r
570	int readuncompresszip(ZIP* zip, struct zipent* ent, char* data) {\r
571	if (ent->compression_method == 0x0000) {\r
572	/* file is not compressed, simply stored */\r
573	\r
574	/* check if size are equal */\r
575	if (ent->compressed_size != ent->uncompressed_size) {\r
576	errormsg("Wrong uncompressed size in store compression", ERROR_CORRUPT,zip->zip);\r
577	return -3;\r
578	}\r
579	\r
580	return readcompresszip(zip,ent,data);\r
581	} else if (ent->compression_method == 0x0008) {\r
582	/* file is compressed using "Deflate" method */\r
583	if (ent->version_needed_to_extract > 0x14) {\r
584	errormsg("Version too new", ERROR_UNSUPPORTED,zip->zip);\r
585	return -2;\r
586	}\r
587	\r
588	if (ent->os_needed_to_extract != 0x00) {\r
589	errormsg("OS not supported", ERROR_UNSUPPORTED,zip->zip);\r
590	return -2;\r
591	}\r
592	\r
593	if (ent->disk_number_start != zip->number_of_this_disk) {\r
594	errormsg("Cannot span disks", ERROR_UNSUPPORTED,zip->zip);\r
595	return -2;\r
596	}\r
597	\r
598	/* read compressed data */\r
599	if (seekcompresszip(zip,ent)!=0) {\r
600	return -1;\r
601	}\r
602	\r
603	/* configure inflate */\r
604	if (inflate_file( zip->fp, ent->compressed_size, (unsigned char*)data, ent->uncompressed_size))\r
605	{\r
606	errormsg("Inflating compressed data", ERROR_CORRUPT, zip->zip);\r
607	return -3;\r
608	}\r
609	\r
610	return 0;\r
611	} else {\r
612	errormsg("Compression method unsupported", ERROR_UNSUPPORTED, zip->zip);\r
613	return -2;\r
614	}\r
615	}\r