Annotation of libwww/Library/src/HTZip.c, revision 2.8.6.1
2.1 frystyk 1: /*
2: ** ZIP ENCODING / DECODING MODULE
3: **
4: ** (c) COPYRIGHT MIT 1995.
5: ** Please first read the full copyright statement in the file COPYRIGH.
2.8.6.1 ! kahan 6: ** @(#) $Id: HTZip.c,v 2.8 1999/02/22 22:10:12 frystyk Exp $
2.1 frystyk 7: **
8: ** This module requires zlib in order to compile/link
9: */
10:
11: /* Library include files */
2.7 frystyk 12: #include "wwwsys.h"
2.1 frystyk 13: #include "WWWUtil.h"
14: #include "WWWCore.h"
15: #include "HTZip.h" /* Implemented here */
16:
2.8.6.1 ! kahan 17: /* JK: Amaya patch for libwww. libwww always tries to use a zlib.dll */
2.3 frystyk 18: #ifdef WWW_MSWINDOWS
2.8.6.1 ! kahan 19: #ifdef WWW_WIN_DLL
2.3 frystyk 20: #define ZLIB_DLL
2.8.6.1 ! kahan 21: #endif /*WWW_WIN_DLL */
2.3 frystyk 22: #endif
23:
2.6 frystyk 24: #include <zlib.h>
2.1 frystyk 25:
2.6 frystyk 26: #define OUTBUF_SIZE 32768
2.1 frystyk 27:
28: struct _HTStream {
29: const HTStreamClass * isa;
30: int state;
31: HTRequest * request;
32: HTStream * target; /* Our output target */
33: z_stream * zstream; /* Zlib stream */
34: char outbuf [OUTBUF_SIZE]; /* Inflated data */
35: };
36:
37: PRIVATE int CompressionLevel = Z_DEFAULT_COMPRESSION;
38:
39: /* ------------------------------------------------------------------------- */
40:
41: PRIVATE BOOL Zlib_init (HTStream * me, int level)
42: {
43: if (me && me->zstream &&
44: (level == Z_DEFAULT_COMPRESSION ||
45: (level >= Z_BEST_SPEED && level <= Z_BEST_COMPRESSION))) {
46: int status;
2.8 frystyk 47: HTTRACE(STREAM_TRACE, "Zlib Inflate Init stream %p with compression level %d\n" _ me _ level);
2.1 frystyk 48: if ((status = inflateInit(me->zstream)) != Z_OK) {
2.8 frystyk 49: HTTRACE(STREAM_TRACE, "Zlib........ Failed with status %d\n" _ status);
2.1 frystyk 50: return NO;
51: }
52: return YES;
53: }
54: return NO;
55: }
56:
57: PRIVATE BOOL ZLib_terminate (HTStream * me)
58: {
2.8 frystyk 59: HTTRACE(STREAM_TRACE, "Zlib Inflate Terminating stream %p\n" _ me);
2.1 frystyk 60: if (me) {
61: int status;
2.8 frystyk 62: HTTRACE(STREAM_TRACE, "Results..... Inflated incoming data: deflated %lu, inflated %lu, factor %.2f\n" _
63: me->zstream->total_in _ me->zstream->total_out _
2.4 frystyk 64: me->zstream->total_in == 0 ? 0.0 :
65: (double) me->zstream->total_out / me->zstream->total_in);
2.1 frystyk 66: if ((status = inflateEnd(me->zstream)) != Z_OK) {
2.8 frystyk 67: HTTRACE(STREAM_TRACE, "Zlib........ Failed with status %d\n" _ status);
2.1 frystyk 68: return NO;
69: }
70: return YES;
71: }
72: return NO;
73: }
74:
75: PRIVATE int HTZLibInflate_flush (HTStream * me)
76: {
77: return (*me->target->isa->flush)(me->target);
78: }
79:
80: PRIVATE int HTZLibInflate_free (HTStream * me)
81: {
82: int status = HT_OK;
83: ZLib_terminate(me);
84: if ((status = (*me->target->isa->_free)(me->target)) == HT_WOULD_BLOCK)
85: return HT_WOULD_BLOCK;
2.8 frystyk 86: HTTRACE(STREAM_TRACE, "Zlib Inflate FREEING...\n");
2.1 frystyk 87: HT_FREE(me->zstream);
88: HT_FREE(me);
89: return status;
90: }
91:
92: PRIVATE int HTZLibInflate_abort (HTStream * me, HTList * e)
93: {
2.8 frystyk 94: HTTRACE(STREAM_TRACE, "Zlib Inflate ABORTING...\n");
2.1 frystyk 95: ZLib_terminate(me);
96: (*me->target->isa->abort)(me->target, NULL);
97: HT_FREE(me->zstream);
98: HT_FREE(me);
99: return HT_ERROR;
100: }
101:
102: PRIVATE int HTZLibInflate_write (HTStream * me, const char * buf, int len)
103: {
104: if (me->state != HT_OK) {
105: me->state = (*me->target->isa->put_block)(me->target,
106: me->outbuf,
107: OUTBUF_SIZE - me->zstream->avail_out);
108: if (me->state != HT_OK) return me->state;
109: }
110:
111: /*
112: ** Setup the zstream buffers to handle the new data
113: */
114: me->zstream->next_in = (unsigned char *) buf;
115: me->zstream->avail_in = len;
116: me->zstream->next_out = (unsigned char *) me->outbuf;
117: me->zstream->avail_out = OUTBUF_SIZE;
118:
119: /*
120: ** Now run through the data and inflate it. We use Z_PARTIAL_FLUSH
121: ** in order to put as much data in the output buffer as quick as
122: ** possible.
123: */
124: for (;;) {
125: int status = inflate(me->zstream, Z_PARTIAL_FLUSH);
126: switch (status) {
127: case Z_OK:
128: me->state = (*me->target->isa->put_block)(me->target,
129: me->outbuf,
130: OUTBUF_SIZE - me->zstream->avail_out);
131: if (me->state != HT_OK) return me->state;
132:
133: /*
134: ** All data was consumed and we are ready to handle the
135: ** next data.
136: */
137: me->zstream->next_out = (unsigned char *) me->outbuf;
138: me->zstream->avail_out = OUTBUF_SIZE;
139: break;
140:
141: case Z_MEM_ERROR:
142: HT_OUTOFMEM("HTZLibInflate_write");
143: return HT_ERROR;
144:
145: case Z_BUF_ERROR:
146: /*
147: ** No action was taken anf we can take this as a sign ot it
148: ** having finished all data in the input buffer.
149: */
2.5 frystyk 150: return HT_OK;
151:
152: case Z_STREAM_END:
153: me->state = (*me->target->isa->put_block)(me->target,
154: me->outbuf,
155: OUTBUF_SIZE - me->zstream->avail_out);
156: if (me->state != HT_OK) return me->state;
157:
2.8 frystyk 158: HTTRACE(STREAM_TRACE, "Zlib Inflate End of Stream\n");
2.1 frystyk 159: return HT_OK;
160:
161: default:
2.8 frystyk 162: HTTRACE(STREAM_TRACE, "Zlib Inflate Inflate returned %d\n" _ status);
2.1 frystyk 163: return HT_ERROR;
164: }
165: }
166: return HT_OK;
167: }
168:
169: PRIVATE int HTZLibInflate_put_character (HTStream * me, char c)
170: {
171: return HTZLibInflate_write(me, &c, 1);
172: }
173:
174: PRIVATE int HTZLibInflate_put_string (HTStream * me, const char * s)
175: {
176: return HTZLibInflate_write(me, s, (int) strlen(s));
177: }
178:
179: PRIVATE const HTStreamClass HTInflate =
180: {
181: "ZlibInflate",
182: HTZLibInflate_flush,
183: HTZLibInflate_free,
184: HTZLibInflate_abort,
185: HTZLibInflate_put_character,
186: HTZLibInflate_put_string,
187: HTZLibInflate_write
188: };
189:
190: PUBLIC BOOL HTZLib_setCompressionLevel (int level)
191: {
192: if (level >= Z_BEST_SPEED && level <= Z_BEST_COMPRESSION) {
193: CompressionLevel = level;
2.8 frystyk 194: HTTRACE(STREAM_TRACE, "Zlib........ Compression level set to %d\n" _ level);
2.1 frystyk 195: }
196: return NO;
197: }
198:
199: PUBLIC int HTZLib_compressionLevel (void)
200: {
201: return CompressionLevel;
202: }
203:
204: PUBLIC HTStream * HTZLib_inflate (HTRequest * request,
205: void * param,
206: HTEncoding coding,
207: HTStream * target)
208: {
209: HTStream * me = NULL;
210: if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL ||
211: (me->zstream = (z_stream *) HT_CALLOC(1, sizeof(z_stream))) == NULL)
212: HT_OUTOFMEM("HTZLib_inflate");
213: me->isa = &HTInflate;
214: me->state = HT_OK;
215: me->request = request;
216: me->target = target ? target : HTErrorStream();
217: if (Zlib_init(me, CompressionLevel) != YES) {
218: HT_FREE(me);
219: return HTErrorStream();
220: }
2.8 frystyk 221: HTTRACE(STREAM_TRACE, "Zlib Inflate Stream created\n");
2.1 frystyk 222: return me;
223: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTZip.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src