navit/maptool/zip.c

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2008 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include <zlib.h>
#include <string.h>
#include <stdlib.h>
#include "maptool.h"
#include "zipfile.h"

#ifdef HAVE_LIBCRYPTO
#include <openssl/sha.h>
#include <openssl/hmac.h>
#include <openssl/aes.h>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/md5.h>
#endif

struct zip_info {
        int zipnum;
        int dir_size;
        long long offset;
        int compression_level;
        int maxnamelen;
        int zip64;
        short date;
        short time;
        char *passwd;
        FILE *res2;
        FILE *index;
        FILE *dir;
#ifdef HAVE_LIBCRYPTO
        MD5_CTX md5_ctx;
#endif
        int md5;
};

static int
zip_write(struct zip_info *info, void *data, int len)
{
        if (fwrite(data, len, 1, info->res2) != 1)
                return 0;
#ifdef HAVE_LIBCRYPTO
        if (info->md5) 
                MD5_Update(&info->md5_ctx, data, len);
#endif
        return 1;
}

#ifdef HAVE_ZLIB
static int
compress2_int(Byte *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)
{
        z_stream stream;
        int err;

        stream.next_in = (Bytef*)source;
        stream.avail_in = (uInt)sourceLen;
        stream.next_out = dest;
        stream.avail_out = (uInt)*destLen;
        if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;

        stream.zalloc = (alloc_func)0;
        stream.zfree = (free_func)0;
        stream.opaque = (voidpf)0;

        err = deflateInit2(&stream, level, Z_DEFLATED, -15, 9, Z_DEFAULT_STRATEGY);
        if (err != Z_OK) return err;

        err = deflate(&stream, Z_FINISH);
        if (err != Z_STREAM_END) {
                deflateEnd(&stream);
                return err == Z_OK ? Z_BUF_ERROR : err;
        }
        *destLen = stream.total_out;

        err = deflateEnd(&stream);
        return err;
}
#endif

void
write_zipmember(struct zip_info *zip_info, char *name, int filelen, char *data, int data_size)
{
        struct zip_lfh lfh = {
                0x04034b50,
                0x0a,
                0x0,
                0x0,
                zip_info->time,
                zip_info->date,
                0x0,
                0x0,
                0x0,
                filelen,
                0x0,
        };
        struct zip_cd cd = {
                0x02014b50,
                0x17,
                0x00,
                0x0a,
                0x00,
                0x0000,
                0x0,
                zip_info->time,
                zip_info->date,
                0x0,
                0x0,
                0x0,
                filelen,
                0x0000,
                0x0000,
                0x0000,
                0x0000,
                0x0,
                zip_info->offset,
        };
        struct zip_cd_ext cd_ext = {
                0x1,
                0x8,
                zip_info->offset,
        };
#ifdef HAVE_LIBCRYPTO
        struct zip_enc enc = {
                0x9901,
                0x7,
                0x2,
                'A','E',
                0x1,
                0x0,
        };
        unsigned char salt[8], key[34], verify[2], mac[10];
#endif
        char filename[filelen+1];
        int error,crc=0,len,comp_size=data_size;
        uLongf destlen=data_size+data_size/500+12;
        char *compbuffer;

        compbuffer = malloc(destlen);
        if (!compbuffer) {
          fprintf(stderr, "No more memory.\n");
          exit (1);
        }
#ifdef HAVE_LIBCRYPTO
        if (zip_info->passwd) { 
                RAND_bytes(salt, sizeof(salt));
                PKCS5_PBKDF2_HMAC_SHA1(zip_info->passwd, strlen(zip_info->passwd), salt, sizeof(salt), 1000, sizeof(key), key);
                verify[0]=key[32];
                verify[1]=key[33];
        } else {
#endif
                crc=crc32(0, NULL, 0);
                crc=crc32(crc, (unsigned char *)data, data_size);
#ifdef HAVE_LIBCRYPTO
        }
#endif
        lfh.zipmthd=zip_info->compression_level ? 8:0;
#ifdef HAVE_ZLIB
        if (zip_info->compression_level) {
                error=compress2_int((Byte *)compbuffer, &destlen, (Bytef *)data, data_size, zip_info->compression_level);
                if (error == Z_OK) {
                        if (destlen < data_size) {
                                data=compbuffer;
                                comp_size=destlen;
                        } else
                                lfh.zipmthd=0;
                } else {
                        fprintf(stderr,"compress2 returned %d\n", error);
                }
        }
#endif
        lfh.zipcrc=crc;
        lfh.zipsize=comp_size;
        lfh.zipuncmp=data_size;
#ifdef HAVE_LIBCRYPTO
        if (zip_info->passwd) {
                enc.compress_method=lfh.zipmthd;
                lfh.zipmthd=99;
                lfh.zipxtraln+=sizeof(enc);
                lfh.zipgenfld|=1;
                lfh.zipsize+=sizeof(salt)+sizeof(verify)+sizeof(mac);
        }
#endif
        cd.zipccrc=crc;
        cd.zipcsiz=lfh.zipsize;
        cd.zipcunc=data_size;
        cd.zipcmthd=lfh.zipmthd;
        if (zip_info->zip64) {
                cd.zipofst=0xffffffff;
                cd.zipcxtl+=sizeof(cd_ext);
        }
#ifdef HAVE_LIBCRYPTO
        if (zip_info->passwd) {
                cd.zipcmthd=99;
                cd.zipcxtl+=sizeof(enc);
                cd.zipcflg|=1;
        }
#endif
        strcpy(filename, name);
        len=strlen(filename);
        while (len < filelen) {
                filename[len++]='_';
        }
        filename[filelen]='\0';
        zip_write(zip_info, &lfh, sizeof(lfh));
        zip_write(zip_info, filename, filelen);
        zip_info->offset+=sizeof(lfh)+filelen;
#ifdef HAVE_LIBCRYPTO
        if (zip_info->passwd) {
                unsigned char counter[16], xor[16], *datap=(unsigned char *)data;
                int size=comp_size;
                AES_KEY aeskey;
                zip_write(zip_info, &enc, sizeof(enc));
                zip_write(zip_info, salt, sizeof(salt));
                zip_write(zip_info, verify, sizeof(verify));
                zip_info->offset+=sizeof(enc)+sizeof(salt)+sizeof(verify);
                AES_set_encrypt_key(key, 128, &aeskey);
                memset(counter, 0, sizeof(counter));
                while (size > 0) {
                        int i,curr_size,idx=0;
                        do {
                                counter[idx]++;
                        } while (!counter[idx++]);
                        AES_encrypt(counter, xor, &aeskey);
                        curr_size=size;
                        if (curr_size > sizeof(xor))
                                curr_size=sizeof(xor);
                        for (i = 0 ; i < curr_size ; i++) 
                                *datap++^=xor[i];
                        size-=curr_size;
                }
        }
#endif
        zip_write(zip_info, data, comp_size);
        zip_info->offset+=comp_size;
#ifdef HAVE_LIBCRYPTO
        if (zip_info->passwd) {
                unsigned int maclen=sizeof(mac);
                unsigned char mactmp[maclen*2];
                HMAC(EVP_sha1(), key+16, 16, (unsigned char *)data, comp_size, mactmp, &maclen);
                zip_write(zip_info, mactmp, sizeof(mac));
                zip_info->offset+=sizeof(mac);
        }
#endif
        fwrite(&cd, sizeof(cd), 1, zip_info->dir);
        fwrite(filename, filelen, 1, zip_info->dir);
        zip_info->dir_size+=sizeof(cd)+filelen;
        if (zip_info->zip64) {
                fwrite(&cd_ext, sizeof(cd_ext), 1, zip_info->dir);
                zip_info->dir_size+=sizeof(cd_ext);
        }
#ifdef HAVE_LIBCRYPTO
        if (zip_info->passwd) {
                fwrite(&enc, sizeof(enc), 1, zip_info->dir);
                zip_info->dir_size+=sizeof(enc);
        }
#endif
        
        free(compbuffer);
}

void
zip_write_index(struct zip_info *info)
{
        int size=ftell(info->index);
        char buffer[size];

        fseek(info->index, 0, SEEK_SET);
        fread(buffer, size, 1, info->index);
        write_zipmember(info, "index", strlen("index"), buffer, size);
        info->zipnum++;
}

static void
zip_write_file_data(struct zip_info *info, FILE *in)
{
        size_t size;
        char buffer[4096];
        while ((size=fread(buffer, 1, 4096, in)))
                zip_write(info, buffer, size);
}

int
zip_write_directory(struct zip_info *info)
{
        struct zip_eoc eoc = {
                0x06054b50,
                0x0000,
                0x0000,
                0x0000,
                0x0000,
                0x0,
                0x0,
                0x0,
        };
        struct zip64_eoc eoc64 = {
                0x06064b50,
                0x0,
                0x0,
                0x0403,
                0x0,
                0x0,
                0x0,
                0x0,
                0x0,
                0x0,            
        };
        struct zip64_eocl eocl = {
                0x07064b50,
                0x0,
                0x0,
                0x0,
        };

        fseek(info->dir, 0, SEEK_SET);
        zip_write_file_data(info, info->dir);
        if (info->zip64) {
                eoc64.zip64esize=sizeof(eoc64)-12;
                eoc64.zip64enum=info->zipnum;
                eoc64.zip64ecenn=info->zipnum;
                eoc64.zip64ecsz=info->dir_size;
                eoc64.zip64eofst=info->offset;
                zip_write(info, &eoc64, sizeof(eoc64));
                eocl.zip64lofst=info->offset+info->dir_size;
                zip_write(info, &eocl, sizeof(eocl));
        }
        eoc.zipenum=info->zipnum;
        eoc.zipecenn=info->zipnum;
        eoc.zipecsz=info->dir_size;
        eoc.zipeofst=info->offset;
        zip_write(info, &eoc, sizeof(eoc));
        sig_alrm(0);
#ifndef _WIN32
        alarm(0);
#endif
        return 0;
}

struct zip_info *
zip_new(void)
{
        return g_new0(struct zip_info, 1);
}

void
zip_set_md5(struct zip_info *info, int on)
{
#ifdef HAVE_LIBCRYPTO
        info->md5=on;
        if (on) 
                MD5_Init(&info->md5_ctx);
#endif
}

int
zip_get_md5(struct zip_info *info, unsigned char *out)
{
        if (!info->md5)
                return 0;
#ifdef HAVE_LIBCRYPTO
        MD5_Final(out, &info->md5_ctx);
        return 1;
#endif
        return 0;
}

void
zip_set_zip64(struct zip_info *info, int on)
{
        info->zip64=on;
}

void
zip_set_compression_level(struct zip_info *info, int level)
{
        info->compression_level=level;
}

void
zip_set_maxnamelen(struct zip_info *info, int max)
{
        info->maxnamelen=max;
}

int
zip_get_maxnamelen(struct zip_info *info)
{
        return info->maxnamelen;
}

int
zip_add_member(struct zip_info *info)
{
        return info->zipnum++;
}


int
zip_set_timestamp(struct zip_info *info, char *timestamp)
{
        int year,month,day,hour,min,sec;

        if (sscanf(timestamp,"%d-%d-%dT%d:%d:%d",&year,&month,&day,&hour,&min,&sec) == 6) {
                info->date=day | (month << 5) | ((year-1980) << 9);
                info->time=(sec >> 1) | (min << 5) | (hour << 11);
                return 1;
        }
        return 0;
}

int
zip_set_password(struct zip_info *info, char *passwd)
{
        info->passwd=passwd;
        return 1;
}


void
zip_open(struct zip_info *info, char *out, char *dir, char *index)
{
        info->res2=fopen(out,"wb+");
        info->dir=fopen(dir,"wb+");
        info->index=fopen(index,"wb+");
}

FILE *
zip_get_index(struct zip_info *info)
{
        return info->index;
}

int
zip_get_zipnum(struct zip_info *info)
{
        return info->zipnum;
}

void
zip_set_zipnum(struct zip_info *info, int num)
{
        info->zipnum=num;
}

void
zip_close(struct zip_info *info)
{
        fclose(info->index);
        fclose(info->dir);
        fclose(info->res2);
}

void
zip_destroy(struct zip_info *info)
{
        g_free(info);
}
1	zoff99	8	/**
2			* Navit, a modular navigation system.
3			* Copyright (C) 2005-2008 Navit Team
4			*
5			* This program is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU General Public License
7			* version 2 as published by the Free Software Foundation.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the
16			* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17			* Boston, MA 02110-1301, USA.
18			*/
19
20			#include <zlib.h>
21			#include <string.h>
22			#include <stdlib.h>
23			#include "maptool.h"
24			#include "zipfile.h"
25
26			#ifdef HAVE_LIBCRYPTO
27			#include <openssl/sha.h>
28			#include <openssl/hmac.h>
29			#include <openssl/aes.h>
30			#include <openssl/evp.h>
31			#include <openssl/rand.h>
32			#include <openssl/md5.h>
33			#endif
34
35			struct zip_info {
36			int zipnum;
37			int dir_size;
38			long long offset;
39			int compression_level;
40			int maxnamelen;
41			int zip64;
42			short date;
43			short time;
44			char *passwd;
45			FILE *res2;
46			FILE *index;
47			FILE *dir;
48			#ifdef HAVE_LIBCRYPTO
49			MD5_CTX md5_ctx;
50			#endif
51			int md5;
52			};
53
54			static int
55			zip_write(struct zip_info info, void data, int len)
56			{
57			if (fwrite(data, len, 1, info->res2) != 1)
58			return 0;
59			#ifdef HAVE_LIBCRYPTO
60			if (info->md5)
61			MD5_Update(&info->md5_ctx, data, len);
62			#endif
63			return 1;
64			}
65
66			#ifdef HAVE_ZLIB
67			static int
68			compress2_int(Byte dest, uLongf destLen, const Bytef *source, uLong sourceLen, int level)
69			{
70			z_stream stream;
71			int err;
72
73			stream.next_in = (Bytef*)source;
74			stream.avail_in = (uInt)sourceLen;
75			stream.next_out = dest;
76			stream.avail_out = (uInt)*destLen;
77			if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
78
79			stream.zalloc = (alloc_func)0;
80			stream.zfree = (free_func)0;
81			stream.opaque = (voidpf)0;
82
83			err = deflateInit2(&stream, level, Z_DEFLATED, -15, 9, Z_DEFAULT_STRATEGY);
84			if (err != Z_OK) return err;
85
86			err = deflate(&stream, Z_FINISH);
87			if (err != Z_STREAM_END) {
88			deflateEnd(&stream);
89			return err == Z_OK ? Z_BUF_ERROR : err;
90			}
91			*destLen = stream.total_out;
92
93			err = deflateEnd(&stream);
94			return err;
95			}
96			#endif
97
98			void
99			write_zipmember(struct zip_info zip_info, char name, int filelen, char *data, int data_size)
100			{
101			struct zip_lfh lfh = {
102			0x04034b50,
103			0x0a,
104			0x0,
105			0x0,
106			zip_info->time,
107			zip_info->date,
108			0x0,
109			0x0,
110			0x0,
111			filelen,
112			0x0,
113			};
114			struct zip_cd cd = {
115			0x02014b50,
116			0x17,
117			0x00,
118			0x0a,
119			0x00,
120			0x0000,
121			0x0,
122			zip_info->time,
123			zip_info->date,
124			0x0,
125			0x0,
126			0x0,
127			filelen,
128			0x0000,
129			0x0000,
130			0x0000,
131			0x0000,
132			0x0,
133			zip_info->offset,
134			};
135			struct zip_cd_ext cd_ext = {
136			0x1,
137			0x8,
138			zip_info->offset,
139			};
140			#ifdef HAVE_LIBCRYPTO
141			struct zip_enc enc = {
142			0x9901,
143			0x7,
144			0x2,
145			'A','E',
146			0x1,
147			0x0,
148			};
149			unsigned char salt[8], key[34], verify[2], mac[10];
150			#endif
151			char filename[filelen+1];
152			int error,crc=0,len,comp_size=data_size;
153			uLongf destlen=data_size+data_size/500+12;
154			char *compbuffer;
155
156			compbuffer = malloc(destlen);
157			if (!compbuffer) {
158			fprintf(stderr, "No more memory.\n");
159			exit (1);
160			}
161			#ifdef HAVE_LIBCRYPTO
162			if (zip_info->passwd) {
163			RAND_bytes(salt, sizeof(salt));
164			PKCS5_PBKDF2_HMAC_SHA1(zip_info->passwd, strlen(zip_info->passwd), salt, sizeof(salt), 1000, sizeof(key), key);
165			verify[0]=key[32];
166			verify[1]=key[33];
167			} else {
168			#endif
169			crc=crc32(0, NULL, 0);
170			crc=crc32(crc, (unsigned char *)data, data_size);
171			#ifdef HAVE_LIBCRYPTO
172			}
173			#endif
174			lfh.zipmthd=zip_info->compression_level ? 8:0;
175			#ifdef HAVE_ZLIB
176			if (zip_info->compression_level) {
177			error=compress2_int((Byte )compbuffer, &destlen, (Bytef )data, data_size, zip_info->compression_level);
178			if (error == Z_OK) {
179			if (destlen < data_size) {
180			data=compbuffer;
181			comp_size=destlen;
182			} else
183			lfh.zipmthd=0;
184			} else {
185			fprintf(stderr,"compress2 returned %d\n", error);
186			}
187			}
188			#endif
189			lfh.zipcrc=crc;
190			lfh.zipsize=comp_size;
191			lfh.zipuncmp=data_size;
192			#ifdef HAVE_LIBCRYPTO
193			if (zip_info->passwd) {
194			enc.compress_method=lfh.zipmthd;
195			lfh.zipmthd=99;
196			lfh.zipxtraln+=sizeof(enc);
197			lfh.zipgenfld\|=1;
198			lfh.zipsize+=sizeof(salt)+sizeof(verify)+sizeof(mac);
199			}
200			#endif
201			cd.zipccrc=crc;
202			cd.zipcsiz=lfh.zipsize;
203			cd.zipcunc=data_size;
204			cd.zipcmthd=lfh.zipmthd;
205			if (zip_info->zip64) {
206			cd.zipofst=0xffffffff;
207			cd.zipcxtl+=sizeof(cd_ext);
208			}
209			#ifdef HAVE_LIBCRYPTO
210			if (zip_info->passwd) {
211			cd.zipcmthd=99;
212			cd.zipcxtl+=sizeof(enc);
213			cd.zipcflg\|=1;
214			}
215			#endif
216			strcpy(filename, name);
217			len=strlen(filename);
218			while (len < filelen) {
219			filename[len++]='_';
220			}
221			filename[filelen]='\0';
222			zip_write(zip_info, &lfh, sizeof(lfh));
223			zip_write(zip_info, filename, filelen);
224			zip_info->offset+=sizeof(lfh)+filelen;
225			#ifdef HAVE_LIBCRYPTO
226			if (zip_info->passwd) {
227			unsigned char counter[16], xor[16], datap=(unsigned char )data;
228			int size=comp_size;
229			AES_KEY aeskey;
230			zip_write(zip_info, &enc, sizeof(enc));
231			zip_write(zip_info, salt, sizeof(salt));
232			zip_write(zip_info, verify, sizeof(verify));
233			zip_info->offset+=sizeof(enc)+sizeof(salt)+sizeof(verify);
234			AES_set_encrypt_key(key, 128, &aeskey);
235			memset(counter, 0, sizeof(counter));
236			while (size > 0) {
237			int i,curr_size,idx=0;
238			do {
239			counter[idx]++;
240			} while (!counter[idx++]);
241			AES_encrypt(counter, xor, &aeskey);
242			curr_size=size;
243			if (curr_size > sizeof(xor))
244			curr_size=sizeof(xor);
245			for (i = 0 ; i < curr_size ; i++)
246			*datap++^=xor[i];
247			size-=curr_size;
248			}
249			}
250			#endif
251			zip_write(zip_info, data, comp_size);
252			zip_info->offset+=comp_size;
253			#ifdef HAVE_LIBCRYPTO
254			if (zip_info->passwd) {
255			unsigned int maclen=sizeof(mac);
256			unsigned char mactmp[maclen*2];
257			HMAC(EVP_sha1(), key+16, 16, (unsigned char *)data, comp_size, mactmp, &maclen);
258			zip_write(zip_info, mactmp, sizeof(mac));
259			zip_info->offset+=sizeof(mac);
260			}
261			#endif
262			fwrite(&cd, sizeof(cd), 1, zip_info->dir);
263			fwrite(filename, filelen, 1, zip_info->dir);
264			zip_info->dir_size+=sizeof(cd)+filelen;
265			if (zip_info->zip64) {
266			fwrite(&cd_ext, sizeof(cd_ext), 1, zip_info->dir);
267			zip_info->dir_size+=sizeof(cd_ext);
268			}
269			#ifdef HAVE_LIBCRYPTO
270			if (zip_info->passwd) {
271			fwrite(&enc, sizeof(enc), 1, zip_info->dir);
272			zip_info->dir_size+=sizeof(enc);
273			}
274			#endif
275
276			free(compbuffer);
277			}
278
279			void
280			zip_write_index(struct zip_info *info)
281			{
282			int size=ftell(info->index);
283			char buffer[size];
284
285			fseek(info->index, 0, SEEK_SET);
286			fread(buffer, size, 1, info->index);
287			write_zipmember(info, "index", strlen("index"), buffer, size);
288			info->zipnum++;
289			}
290
291			static void
292			zip_write_file_data(struct zip_info info, FILE in)
293			{
294			size_t size;
295			char buffer[4096];
296			while ((size=fread(buffer, 1, 4096, in)))
297			zip_write(info, buffer, size);
298			}
299
300			int
301			zip_write_directory(struct zip_info *info)
302			{
303			struct zip_eoc eoc = {
304			0x06054b50,
305			0x0000,
306			0x0000,
307			0x0000,
308			0x0000,
309			0x0,
310			0x0,
311			0x0,
312			};
313			struct zip64_eoc eoc64 = {
314			0x06064b50,
315			0x0,
316			0x0,
317			0x0403,
318			0x0,
319			0x0,
320			0x0,
321			0x0,
322			0x0,
323			0x0,
324			};
325			struct zip64_eocl eocl = {
326			0x07064b50,
327			0x0,
328			0x0,
329			0x0,
330			};
331
332			fseek(info->dir, 0, SEEK_SET);
333			zip_write_file_data(info, info->dir);
334			if (info->zip64) {
335			eoc64.zip64esize=sizeof(eoc64)-12;
336			eoc64.zip64enum=info->zipnum;
337			eoc64.zip64ecenn=info->zipnum;
338			eoc64.zip64ecsz=info->dir_size;
339			eoc64.zip64eofst=info->offset;
340			zip_write(info, &eoc64, sizeof(eoc64));
341			eocl.zip64lofst=info->offset+info->dir_size;
342			zip_write(info, &eocl, sizeof(eocl));
343			}
344			eoc.zipenum=info->zipnum;
345			eoc.zipecenn=info->zipnum;
346			eoc.zipecsz=info->dir_size;
347			eoc.zipeofst=info->offset;
348			zip_write(info, &eoc, sizeof(eoc));
349			sig_alrm(0);
350			#ifndef _WIN32
351			alarm(0);
352			#endif
353			return 0;
354			}
355
356			struct zip_info *
357			zip_new(void)
358			{
359			return g_new0(struct zip_info, 1);
360			}
361
362			void
363			zip_set_md5(struct zip_info *info, int on)
364			{
365			#ifdef HAVE_LIBCRYPTO
366			info->md5=on;
367			if (on)
368			MD5_Init(&info->md5_ctx);
369			#endif
370			}
371
372			int
373			zip_get_md5(struct zip_info info, unsigned char out)
374			{
375			if (!info->md5)
376			return 0;
377			#ifdef HAVE_LIBCRYPTO
378			MD5_Final(out, &info->md5_ctx);
379			return 1;
380			#endif
381			return 0;
382			}
383
384			void
385			zip_set_zip64(struct zip_info *info, int on)
386			{
387			info->zip64=on;
388			}
389
390			void
391			zip_set_compression_level(struct zip_info *info, int level)
392			{
393			info->compression_level=level;
394			}
395
396			void
397			zip_set_maxnamelen(struct zip_info *info, int max)
398			{
399			info->maxnamelen=max;
400			}
401
402			int
403			zip_get_maxnamelen(struct zip_info *info)
404			{
405			return info->maxnamelen;
406			}
407
408			int
409			zip_add_member(struct zip_info *info)
410			{
411			return info->zipnum++;
412			}
413
414
415			int
416			zip_set_timestamp(struct zip_info info, char timestamp)
417			{
418			int year,month,day,hour,min,sec;
419
420			if (sscanf(timestamp,"%d-%d-%dT%d:%d:%d",&year,&month,&day,&hour,&min,&sec) == 6) {
421			info->date=day \| (month << 5) \| ((year-1980) << 9);
422			info->time=(sec >> 1) \| (min << 5) \| (hour << 11);
423			return 1;
424			}
425			return 0;
426			}
427
428			int
429			zip_set_password(struct zip_info info, char passwd)
430			{
431			info->passwd=passwd;
432			return 1;
433			}
434
435
436			void
437			zip_open(struct zip_info info, char out, char dir, char index)
438			{
439			info->res2=fopen(out,"wb+");
440			info->dir=fopen(dir,"wb+");
441			info->index=fopen(index,"wb+");
442			}
443
444			FILE *
445			zip_get_index(struct zip_info *info)
446			{
447			return info->index;
448			}
449
450			int
451			zip_get_zipnum(struct zip_info *info)
452			{
453			return info->zipnum;
454			}
455
456			void
457			zip_set_zipnum(struct zip_info *info, int num)
458			{
459			info->zipnum=num;
460			}
461
462			void
463			zip_close(struct zip_info *info)
464			{
465			fclose(info->index);
466			fclose(info->dir);
467			fclose(info->res2);
468			}
469
470			void
471			zip_destroy(struct zip_info *info)
472			{
473			g_free(info);
474			}