serf/buckets/deflate_buckets.c

86     deflate_context_t *ctx;
88     ctx = serf_bucket_mem_alloc(allocator, sizeof(*ctx));
89     ctx->stream = stream;
90     ctx->stream_status = APR_SUCCESS;
91     ctx->inflate_stream = serf_bucket_aggregate_create(allocator);
92     ctx->format = format;
93     ctx->crc = 0;
95     memset(&ctx->zstream, 0, sizeof(ctx->zstream));
97     switch (ctx->format) {
99             ctx->state = STATE_READING_HEADER;
103             ctx->state = STATE_INIT;
111     ctx->stream_left = ctx->stream_size = DEFLATE_MAGIC_SIZE;
113     ctx->windowSize = DEFLATE_WINDOW_SIZE;
114     ctx->memLevel = DEFLATE_MEMLEVEL;
115     ctx->bufferSize = DEFLATE_BUFFER_SIZE;
117     return serf_bucket_create(&serf_bucket_type_deflate, allocator, ctx);
122     deflate_context_t *ctx = bucket->data;
124     if (ctx->state > STATE_INIT &&
125         ctx->state <= STATE_FINISH)
126         inflateEnd(&ctx->zstream);
131     if (ctx->inflate_stream) {
132         serf_bucket_destroy(ctx->inflate_stream);
134     serf_bucket_destroy(ctx->stream);
143     deflate_context_t *ctx = bucket->data;
151         switch (ctx->state) {
154             status = serf_bucket_read(ctx->stream, ctx->stream_left,
161             memcpy(ctx->hdr_buffer + (ctx->stream_size - ctx->stream_left),
164             ctx->stream_left -= private_len;
166             if (ctx->stream_left == 0) {
167                 ctx->state++;
179             if (ctx->hdr_buffer[0] != deflate_magic[0] ||
180                 ctx->hdr_buffer[1] != deflate_magic[1]) {
183             if (ctx->hdr_buffer[3] != 0) {
186             ctx->state++;
190             compCRC = getLong((unsigned char*)ctx->hdr_buffer);
191             if (ctx->crc != compCRC) {
194             compLen = getLong((unsigned char*)ctx->hdr_buffer + 4);
195             if (ctx->zstream.total_out != compLen) {
198             ctx->state++;
201             zRC = inflateInit2(&ctx->zstream, ctx->windowSize);
205             ctx->zstream.next_out = ctx->buffer;
206             ctx->zstream.avail_out = ctx->bufferSize;
207             ctx->state++;
210             inflateEnd(&ctx->zstream);
211             serf_bucket_aggregate_prepend(ctx->stream, ctx->inflate_stream);
212             ctx->inflate_stream = 0;
213             ctx->state++;
217             status = serf_bucket_read(ctx->inflate_stream, requested, data,
224                 status = ctx->stream_status;
244             if (ctx->zstream.avail_in == 0) {
248                 ctx->stream_status = serf_bucket_read(ctx->stream,
249                                                       ctx->bufferSize,
253                 if (SERF_BUCKET_READ_ERROR(ctx->stream_status)) {
254                     return ctx->stream_status;
257                 if (!private_len && APR_STATUS_IS_EAGAIN(ctx->stream_status)) {
259                     status = ctx->stream_status;
260                     ctx->stream_status = APR_SUCCESS;
264                 ctx->zstream.next_in = (unsigned char*)private_data;
265                 ctx->zstream.avail_in = private_len;
268             while (ctx->zstream.avail_in != 0) {
270                 if (ctx->zstream.avail_out == 0) {
272                     ctx->zstream.next_out = ctx->buffer;
273                     private_len = ctx->bufferSize - ctx->zstream.avail_out;
275                     ctx->crc = crc32(ctx->crc, (const Bytef *)ctx->buffer,
279                     tmp = SERF_BUCKET_SIMPLE_STRING_LEN((char *)ctx->buffer,
282                     serf_bucket_aggregate_append(ctx->inflate_stream, tmp);
283                     ctx->zstream.avail_out = ctx->bufferSize;
286                 zRC = inflate(&ctx->zstream, Z_NO_FLUSH);
291                     private_len = ctx->bufferSize - ctx->zstream.avail_out;
292                     ctx->crc = crc32(ctx->crc, (const Bytef *)ctx->buffer,
295                     tmp = SERF_BUCKET_SIMPLE_STRING_LEN((char *)ctx->buffer,
298                     serf_bucket_aggregate_append(ctx->inflate_stream, tmp);
300                     ctx->zstream.avail_out = ctx->bufferSize;
304                     serf_bucket_aggregate_prepend(tmp, ctx->stream);
305                     ctx->stream = tmp;
308                      * throw it in ctx->stream so our next read picks it up.
311                                         (const char*)ctx->zstream.next_in,
312                                                      ctx->zstream.avail_in,
314                     serf_bucket_aggregate_prepend(ctx->stream, tmp);
316                     switch (ctx->format) {
318                         ctx->stream_left = ctx->stream_size =
320                         ctx->state++;
324                         ctx->state = STATE_FINISH;
338             status = serf_bucket_read(ctx->inflate_stream, requested, data,
342                 status = ctx->stream_status;
352                     if (ctx->state != STATE_INFLATE)
361             return serf_bucket_read(ctx->stream, requested, data, len);