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