![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zip_source_deflate.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / zip / lib|
Return to zip_source_deflate.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / zip / lib |
1.1 misho 1: /*
2: zip_source_deflate.c -- deflate (de)compressoin routines
3: Copyright (C) 2009 Dieter Baron and Thomas Klausner
4:
5: This file is part of libzip, a library to manipulate ZIP archives.
6: The authors can be contacted at <libzip@nih.at>
7:
8: Redistribution and use in source and binary forms, with or without
9: modification, are permitted provided that the following conditions
10: are met:
11: 1. Redistributions of source code must retain the above copyright
12: notice, this list of conditions and the following disclaimer.
13: 2. Redistributions in binary form must reproduce the above copyright
14: notice, this list of conditions and the following disclaimer in
15: the documentation and/or other materials provided with the
16: distribution.
17: 3. The names of the authors may not be used to endorse or promote
18: products derived from this software without specific prior
19: written permission.
20:
21: THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
22: OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23: WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25: DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
27: GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
29: IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
30: OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
31: IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: */
33:
34:
35:
36: #include <stdlib.h>
37: #include <string.h>
38:
39: #include "zipint.h"
40:
41: struct deflate {
42: int e[2];
43:
44: int eof;
45: int mem_level;
46: zip_uint64_t size;
47: char buffer[BUFSIZE];
48: z_stream zstr;
49: };
50:
51: static zip_int64_t compress_read(struct zip_source *, struct deflate *,
52: void *, zip_uint64_t);
53: static zip_int64_t decompress_read(struct zip_source *, struct deflate *,
54: void *, zip_uint64_t);
55: static zip_int64_t deflate_compress(struct zip_source *, void *, void *,
56: zip_uint64_t, enum zip_source_cmd);
57: static zip_int64_t deflate_decompress(struct zip_source *, void *, void *,
58: zip_uint64_t, enum zip_source_cmd);
59: static void deflate_free(struct deflate *);
60:
61:
62:
63: ZIP_EXTERN(struct zip_source *)
64: zip_source_deflate(struct zip *za, struct zip_source *src,
65: zip_uint16_t cm, int flags)
66: {
67: struct deflate *ctx;
68: struct zip_source *s2;
69:
70: if (src == NULL || cm != ZIP_CM_DEFLATE) {
71: _zip_error_set(&za->error, ZIP_ER_INVAL, 0);
72: return NULL;
73: }
74:
75: if ((ctx=(struct deflate *)malloc(sizeof(*ctx))) == NULL) {
76: _zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
77: return NULL;
78: }
79:
80: ctx->e[0] = ctx->e[1] = 0;
81: ctx->eof = 0;
82: if (flags & ZIP_CODEC_ENCODE) {
83: if (zip_get_archive_flag(za, ZIP_AFL_TORRENT, 0))
84: ctx->mem_level = TORRENT_MEM_LEVEL;
85: else
86: ctx->mem_level = MAX_MEM_LEVEL;
87: }
88:
89: if ((s2=zip_source_layered(za, src,
90: ((flags & ZIP_CODEC_ENCODE)
91: ? deflate_compress : deflate_decompress),
92: ctx)) == NULL) {
93: deflate_free(ctx);
94: return NULL;
95: }
96:
97: return s2;
98: }
99:
100:
101:
102: static zip_int64_t
103: compress_read(struct zip_source *src, struct deflate *ctx,
104: void *data, zip_uint64_t len)
105: {
106: int end, ret;
107: zip_int64_t n;
108:
109: if (ctx->e[0] != 0)
110: return -1;
111:
112: if (len == 0)
113: return 0;
114:
115: ctx->zstr.next_out = (Bytef *)data;
116: ctx->zstr.avail_out = len;
117:
118: end = 0;
119: while (!end) {
120: ret = deflate(&ctx->zstr, ctx->eof ? Z_FINISH : 0);
121:
122: switch (ret) {
123: case Z_OK:
124: case Z_STREAM_END:
125: /* all ok */
126:
127: if (ctx->zstr.avail_out == 0
128: || (ctx->eof && ctx->zstr.avail_in == 0))
129: end = 1;
130: break;
131:
132: case Z_BUF_ERROR:
133: if (ctx->zstr.avail_in == 0) {
134: if (ctx->eof) {
135: end = 1;
136: break;
137: }
138:
139: if ((n=zip_source_read(src, ctx->buffer,
140: sizeof(ctx->buffer))) < 0) {
141: zip_source_error(src, ctx->e, ctx->e+1);
142: end = 1;
143: break;
144: }
145: else if (n == 0) {
146: ctx->eof = 1;
147: ctx->size = ctx->zstr.total_in;
148: /* XXX: check against stat of src? */
149: }
150: else {
151: ctx->zstr.next_in = (Bytef *)ctx->buffer;
152: ctx->zstr.avail_in = n;
153: }
154: continue;
155: }
156: /* fallthrough */
157: case Z_NEED_DICT:
158: case Z_DATA_ERROR:
159: case Z_STREAM_ERROR:
160: case Z_MEM_ERROR:
161: ctx->e[0] = ZIP_ER_ZLIB;
162: ctx->e[1] = ret;
163:
164: end = 1;
165: break;
166: }
167: }
168:
169: if (ctx->zstr.avail_out < len)
170: return len - ctx->zstr.avail_out;
171:
172: return (ctx->e[0] == 0) ? 0 : -1;
173: }
174:
175:
176:
177: static zip_int64_t
178: decompress_read(struct zip_source *src, struct deflate *ctx,
179: void *data, zip_uint64_t len)
180: {
181: int end, ret;
182: zip_int64_t n;
183:
184: if (ctx->e[0] != 0)
185: return -1;
186:
187: if (len == 0)
188: return 0;
189:
190: ctx->zstr.next_out = (Bytef *)data;
191: ctx->zstr.avail_out = len;
192:
193: end = 0;
194: while (!end && ctx->zstr.avail_out) {
195: ret = inflate(&ctx->zstr, Z_SYNC_FLUSH);
196:
197: switch (ret) {
198: case Z_OK:
199: break;
200:
201: case Z_STREAM_END:
202: ctx->eof = 1;
203: end = 1;
204: break;
205:
206: case Z_BUF_ERROR:
207: if (ctx->zstr.avail_in == 0) {
208: if (ctx->eof) {
209: end = 1;
210: break;
211: }
212:
213: if ((n=zip_source_read(src, ctx->buffer,
214: sizeof(ctx->buffer))) < 0) {
215: zip_source_error(src, ctx->e, ctx->e+1);
216: end = 1;
217: break;
218: }
219: else if (n == 0)
220: ctx->eof = 1;
221: else {
222: ctx->zstr.next_in = (Bytef *)ctx->buffer;
223: ctx->zstr.avail_in = n;
224: }
225: continue;
226: }
227: /* fallthrough */
228: case Z_NEED_DICT:
229: case Z_DATA_ERROR:
230: case Z_STREAM_ERROR:
231: case Z_MEM_ERROR:
232: ctx->e[0] = ZIP_ER_ZLIB;
233: ctx->e[1] = ret;
234: end = 1;
235: break;
236: }
237: }
238:
239: if (ctx->zstr.avail_out < len)
240: return len - ctx->zstr.avail_out;
241:
242: return (ctx->e[0] == 0) ? 0 : -1;
243: }
244:
245:
246:
247: static zip_int64_t
248: deflate_compress(struct zip_source *src, void *ud, void *data,
249: zip_uint64_t len, enum zip_source_cmd cmd)
250: {
251: struct deflate *ctx;
252: int ret;
253:
254: ctx = (struct deflate *)ud;
255:
256: switch (cmd) {
257: case ZIP_SOURCE_OPEN:
258: ctx->zstr.zalloc = Z_NULL;
259: ctx->zstr.zfree = Z_NULL;
260: ctx->zstr.opaque = NULL;
261: ctx->zstr.avail_in = 0;
262: ctx->zstr.next_in = NULL;
263: ctx->zstr.avail_out = 0;
264: ctx->zstr.next_out = NULL;
265:
266: /* negative value to tell zlib not to write a header */
267: if ((ret=deflateInit2(&ctx->zstr, Z_BEST_COMPRESSION, Z_DEFLATED,
268: -MAX_WBITS, ctx->mem_level,
269: Z_DEFAULT_STRATEGY)) != Z_OK) {
270: ctx->e[0] = ZIP_ER_ZLIB;
271: ctx->e[1] = ret;
272: return -1;
273: }
274:
275: return 0;
276:
277: case ZIP_SOURCE_READ:
278: return compress_read(src, ctx, data, len);
279:
280: case ZIP_SOURCE_CLOSE:
281: deflateEnd(&ctx->zstr);
282: return 0;
283:
284: case ZIP_SOURCE_STAT:
285: {
286: struct zip_stat *st;
287:
288: st = (struct zip_stat *)data;
289:
290: st->comp_method = ZIP_CM_DEFLATE;
291: st->valid |= ZIP_STAT_COMP_METHOD;
292: if (ctx->eof) {
293: st->comp_size = ctx->size;
294: st->valid |= ZIP_STAT_COMP_SIZE;
295: }
296: else
297: st->valid &= ~ZIP_STAT_COMP_SIZE;
298: }
299: return 0;
300:
301: case ZIP_SOURCE_ERROR:
302: memcpy(data, ctx->e, sizeof(int)*2);
303: return sizeof(int)*2;
304:
305: case ZIP_SOURCE_FREE:
306: deflate_free(ctx);
307: return 0;
308:
309: default:
310: ctx->e[0] = ZIP_ER_INVAL;
311: ctx->e[1] = 0;
312: return -1;
313: }
314: }
315:
316:
317:
318: static zip_int64_t
319: deflate_decompress(struct zip_source *src, void *ud, void *data,
320: zip_uint64_t len, enum zip_source_cmd cmd)
321: {
322: struct deflate *ctx;
323: zip_int64_t n;
324: int ret;
325:
326: ctx = (struct deflate *)ud;
327:
328: switch (cmd) {
329: case ZIP_SOURCE_OPEN:
330: if ((n=zip_source_read(src, ctx->buffer, sizeof(ctx->buffer))) < 0)
331: return ZIP_SOURCE_ERR_LOWER;
332:
333: ctx->zstr.zalloc = Z_NULL;
334: ctx->zstr.zfree = Z_NULL;
335: ctx->zstr.opaque = NULL;
336: ctx->zstr.next_in = (Bytef *)ctx->buffer;
337: ctx->zstr.avail_in = n;
338:
339: /* negative value to tell zlib that there is no header */
340: if ((ret=inflateInit2(&ctx->zstr, -MAX_WBITS)) != Z_OK) {
341: ctx->e[0] = ZIP_ER_ZLIB;
342: ctx->e[1] = ret;
343:
344: return -1;
345: }
346: return 0;
347:
348: case ZIP_SOURCE_READ:
349: return decompress_read(src, ctx, data, len);
350:
351: case ZIP_SOURCE_CLOSE:
352: inflateEnd(&ctx->zstr);
353: return 0;
354:
355: case ZIP_SOURCE_STAT:
356: {
357: struct zip_stat *st;
358:
359: st = (struct zip_stat *)data;
360:
361: st->comp_method = ZIP_CM_STORE;
362: if (st->comp_size > 0 && st->size > 0)
363: st->comp_size = st->size;
364: }
365: return 0;
366:
367: case ZIP_SOURCE_ERROR:
368: if (len < sizeof(int)*2)
369: return -1;
370:
371: memcpy(data, ctx->e, sizeof(int)*2);
372: return sizeof(int)*2;
373:
374: case ZIP_SOURCE_FREE:
375: /* XXX: inflateEnd if close was not called */
376: free(ctx);
377: return 0;
378:
379: default:
380: ctx->e[0] = ZIP_ER_INVAL;
381: ctx->e[1] = 0;
382: return -1;
383: }
384:
385: }
386:
387:
388:
389: static void
390: deflate_free(struct deflate *ctx)
391: {
392: /* XXX: deflateEnd if close was not called */
393: free(ctx);
394: }