Lighttpd

do_build="$do_build mod_rrdtool mod_secdownload mod_expire mod_compress mod_dirlisting mod_indexfile mod_userdir mod_webdav mod_staticfile mod_scgi mod_flv_streaming mod_deflate"

	int true_http_10_client;

	int end_chunk; /* used for chunked transfer encoding. */

	chunkqueue *write_queue;  /* a large queue for HTTP response content [ file, mem ] */

	chunkqueue *output_queue; /* a large queue for low-level write ( HTTP response ) [ file, mem ] */

	connections *joblist_prev;

#include "server.h"

#include "log.h"

int chunkqueue_append_chunkqueue(chunkqueue *cq, chunkqueue *src) {

	if(src == NULL) return 0;

	chunkqueue_append_chunk(cq, src->first);

	cq->last = src->last;

	src->first = NULL;

	src->last = NULL;

	return 0;

}

/**

 * the HTTP chunk-API

 * 

 * 

 */

static int chunk_encode_append_len(chunkqueue *cq, size_t len) {

	size_t i, olen = len, j;

	buffer *b;

	/*b = srv->tmp_chunk_len;*/

	/*b = buffer_init();*/

	b = chunkqueue_get_append_buffer(cq);

	if (len == 0) {

		buffer_copy_string(b, "0");

	} else {

		for (i = 0; i < 8 && len; i++) {

			len >>= 4;

		}

		/* i is the number of hex digits we have */

		buffer_prepare_copy(b, i + 1);

		for (j = i-1, len = olen; j+1 > 0; j--) {

			b->ptr[j] = (len & 0xf) + (((len & 0xf) <= 9) ? '0' : 'a' - 10);

			len >>= 4;

		}

		b->used = i;

		b->ptr[b->used++] = '\0';

	}

	buffer_append_string(b, "\r\n");

	/*

	chunkqueue_append_buffer(cq, b);

	buffer_free(b);

	*/

	return 0;

}

int chunk_encode_append_file(chunkqueue *cq, buffer *fn, off_t offset, off_t len) {

	if (!cq) return -1;

	if (len == 0) return 0;

	chunk_encode_append_len(cq, len);

	chunkqueue_append_file(cq, fn, offset, len);

	chunkqueue_append_mem(cq, "\r\n", 2 + 1);

	return 0;

}

int chunk_encode_append_buffer(chunkqueue *cq, buffer *mem) {

	if (!cq) return -1;

	if (mem->used <= 1) return 0;

	chunk_encode_append_len(cq, mem->used - 1);

	chunkqueue_append_buffer(cq, mem);

	chunkqueue_append_mem(cq, "\r\n", 2 + 1);

	return 0;

}

int chunk_encode_append_mem(chunkqueue *cq, const char * mem, size_t len) {

	if (!cq) return -1;

	if (len <= 1) return 0;

	chunk_encode_append_len(cq, len - 1);

	chunkqueue_append_mem(cq, mem, len);

	chunkqueue_append_mem(cq, "\r\n", 2 + 1);

	return 0;

}

int chunk_encode_append_queue(chunkqueue *cq, chunkqueue *src) {

	int len = chunkqueue_length(src);

	if (!cq) return -1;

	if (len == 0) return 0;

	chunk_encode_append_len(cq, len);

	chunkqueue_append_chunkqueue(cq, src);

	chunkqueue_append_mem(cq, "\r\n", 2 + 1);

	return 0;

}

int chunk_encode_end(chunkqueue *cq) {

	chunk_encode_append_len(cq, 0);

	chunkqueue_append_mem(cq, "\r\n", 2 + 1);

	return 0;

}

int chunkqueue_append_chunkqueue(chunkqueue *cq, chunkqueue *src);

int chunk_encode_append_mem(chunkqueue *cq, const char * mem, size_t len);

int chunk_encode_append_buffer(chunkqueue *cq, buffer *mem);

int chunk_encode_append_file(chunkqueue *cq, buffer *fn, off_t offset, off_t len);

int chunk_encode_append_queue(chunkqueue *cq, chunkqueue *src);

int chunk_encode_end(chunkqueue *cq);

#line 5 "./configparser.y"

#line 144 "./configparser.y"

#line 135 "./configparser.y"

#line 136 "./configparser.y"

#line 137 "./configparser.y"

#line 138 "./configparser.y"

#line 139 "./configparser.y"

#line 140 "./configparser.y"

#line 141 "./configparser.y"

#line 117 "./configparser.y"

#line 146 "./configparser.y"

#line 170 "./configparser.y"

#line 209 "./configparser.y"

#line 221 "./configparser.y"

#line 231 "./configparser.y"

#line 236 "./configparser.y"

#line 263 "./configparser.y"

#line 270 "./configparser.y"

#line 276 "./configparser.y"

#line 282 "./configparser.y"

#line 285 "./configparser.y"

#line 290 "./configparser.y"

#line 307 "./configparser.y"

#line 312 "./configparser.y"

#line 318 "./configparser.y"

#line 322 "./configparser.y"

#line 334 "./configparser.y"

#line 341 "./configparser.y"

#line 352 "./configparser.y"

#line 364 "./configparser.y"

#line 369 "./configparser.y"

#line 380 "./configparser.y"

#line 529 "./configparser.y"

#line 532 "./configparser.y"

#line 535 "./configparser.y"

#line 538 "./configparser.y"

#line 542 "./configparser.y"

#line 559 "./configparser.y"

#line 569 "./configparser.y"

#line 108 "./configparser.y"

#include "chunk.h"

int connection_queue_is_empty(connection *con) {

	if(!chunkqueue_is_empty(con->write_queue)) return 0;

	if(!chunkqueue_is_empty(con->output_queue)) return 0;

	return 1;

}

				chunkqueue_reset(con->output_queue);

		chunkqueue_reset(con->output_queue);

	/* Allow filter plugins to change response headers before they are written. */

	switch(plugins_call_handle_response_start(srv, con)) {

	case HANDLER_GO_ON:

	case HANDLER_FINISHED:

		/* response start is finished */

		break;

	default:

		/* something strange happend */

		log_error_write(srv, __FILE__, __LINE__, "s", "Filter plugin failed.");

		connection_set_state(srv, con, CON_STATE_ERROR);

		joblist_append(srv, con);

		break;

	}

		chunkqueue_reset(con->output_queue);

	int finished = 0;

	int len;

	/* Allow filter plugins to modify response conent */

	switch(plugins_call_handle_response_filter(srv, con)) {

	case HANDLER_GO_ON:

		finished = con->file_finished;

		/* response content not changed */

		break;

	case HANDLER_COMEBACK:

		/* response filter has more work */

		finished = 0;

		break;

	case HANDLER_FINISHED:

		/* response filter is finished */

		finished = 1;

		break;

	default:

		/* something strange happend */

		log_error_write(srv, __FILE__, __LINE__, "s", "Filter plugin failed.");

		connection_set_state(srv, con, CON_STATE_ERROR);

		joblist_append(srv, con);

		finished = 1;

		break;

	}

	/* move chunks from write_queue to output_queue. */

	if (con->request.http_method == HTTP_METHOD_HEAD) {

		chunkqueue_reset(con->write_queue);

	} else {

		len = chunkqueue_length(con->write_queue);

		if(con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {

			chunk_encode_append_queue(con->output_queue, con->write_queue);

			if(finished && !con->end_chunk) {

				con->end_chunk = 1;

				chunk_encode_end(con->output_queue);

			}

		} else {

			chunkqueue_append_chunkqueue(con->output_queue, con->write_queue);

		}

		con->write_queue->bytes_out += len;

	}

	/* write chunks from output_queue to network */

	switch(network_write_chunkqueue(srv, con, con->output_queue)) {

		if (finished) {

		} else {

			/* not finished yet -> WRITE */

			con->is_writable = 1;

	con->output_queue = chunkqueue_init();

		chunkqueue_free(con->output_queue);

	con->end_chunk = 0;

//	con->use_cache_file = 0;

//	con->write_cache_file = 0;

	chunkqueue_reset(con->output_queue);

			if (!connection_queue_is_empty(con)) {

						con->output_queue->used);

#endif

			if (con->is_writable) {

		if ((con->is_writable == 0) &&

		    (con->traffic_limit_reached == 0) &&

				!connection_queue_is_empty(con)) {

	con->in_joblist = 1;

lib_LTLIBRARIES += mod_deflate.la

mod_deflate_la_SOURCES = mod_deflate.c 

mod_deflate_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined

mod_deflate_la_LIBADD = $(Z_LIB) $(BZ_LIB) $(common_libadd)

mod_deflate_la_DEPENDENCIES = $(am__DEPENDENCIES_1) \

       $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2)

am_mod_deflate_la_OBJECTS = mod_deflate.lo

mod_deflate_la_OBJECTS = $(am_mod_deflate_la_OBJECTS)

mod_deflate_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \

       $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \

       $(mod_deflate_la_LDFLAGS) $(LDFLAGS) -o $@

	$(mod_deflate_la_SOURCES) \

	mod_redirect.la mod_status.la mod_accesslog.la mod_deflate.la

mod_deflate_la_SOURCES = mod_deflate.c 

mod_deflate_la_LDFLAGS = -module -export-dynamic -no-undefined

mod_deflate_la_LIBADD = $(Z_LIB) $(BZ_LIB) $(common_libadd)

mod_deflate.la: $(mod_deflate_la_OBJECTS) $(mod_deflate_la_DEPENDENCIES) 

	$(AM_V_CCLD)$(mod_deflate_la_LINK) -rpath $(libdir) $(mod_deflate_la_LDFLAGS) $(mod_deflate_la_OBJECTS) $(mod_deflate_la_LIBADD) $(LIBS)

@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_deflate.Plo@am__quote@

/* bug fix on Robert Jakabosky from alphatrade.com's lighttp 1.4.10 mod_deflate path

 *

 * new module option:

 * deflate.nocompress-url = "^/nocompressurl/" # pcre regex which don't compress

 *

 * Bug fix and new features:

 * 1) fix loop bug when content-length is bigger than work-block-size*k

 * 2) prevent compress on buggy http 1.0 client with Accept Encoding: gzip, deflate

 * 3) fix bug with chunk transfer encoding (under mod_fastcgi+php environment)

 * 

 * deflate.sync-flush = "enable" is buggy on chunk encoding transfer. Use it carefully,

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <ctype.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <time.h>

#include <assert.h>

#if defined(HAVE_PCRE_H)

#include <pcre.h>

#endif

#include "base.h"

#include "log.h"

#include "buffer.h"

#include "response.h"

#include "joblist.h"

#include "stat_cache.h"

#include "plugin.h"

#include "crc32.h"

#include "etag.h"

#include "inet_ntop_cache.h"

#if defined HAVE_ZLIB_H && defined HAVE_LIBZ

# define USE_ZLIB

# include <zlib.h>

#else

# define Z_DEFAULT_COMPRESSION 1

#endif

#if defined HAVE_BZLIB_H && defined HAVE_LIBBZ2

# define USE_BZ2LIB

/* we don't need stdio interface */

# define BZ_NO_STDIO

# include <bzlib.h>

#endif

#include "sys-mmap.h"

/* request: accept-encoding */

#define HTTP_ACCEPT_ENCODING_IDENTITY BV(0)

#define HTTP_ACCEPT_ENCODING_GZIP     BV(1)

#define HTTP_ACCEPT_ENCODING_DEFLATE  BV(2)

#define HTTP_ACCEPT_ENCODING_COMPRESS BV(3)

#define HTTP_ACCEPT_ENCODING_BZIP2    BV(4)

#define KByte * 1024

#define MByte * 1024 KByte

#define GByte * 1024 MByte

typedef struct {

	unsigned short	debug;

	unsigned short	enabled;

	unsigned short	bzip2;

	unsigned short	sync_flush;

	unsigned short	output_buffer_size;

	unsigned short	min_compress_size;

	unsigned short	work_block_size;

	short		mem_level;

	short		compression_level;

	short		window_size;

	array		*mimetypes;

	buffer 		*nocompress_url;

#if defined(HAVE_PCRE_H)

	pcre	*nocompress_regex;

#endif

} plugin_config;

typedef struct {

	PLUGIN_DATA;

	buffer *tmp_buf;

	plugin_config **config_storage;

	plugin_config conf; 

} plugin_data;

typedef struct {

	int bytes_in;

	int bytes_out;

	chunkqueue *in_queue;

	buffer *output;

	/* compression type & state */

	int compression_type;

	int stream_open;

#ifdef USE_ZLIB

	unsigned long crc;

	z_stream z;

	unsigned short gzip_header;

#endif

#ifdef USE_BZ2LIB

	bz_stream bz;

#endif

	plugin_data *plugin_data;

} handler_ctx;

static handler_ctx *handler_ctx_init() {

	handler_ctx *hctx;

	hctx = calloc(1, sizeof(*hctx));

	hctx->in_queue = chunkqueue_init();

	return hctx;

}

static void handler_ctx_free(handler_ctx *hctx) {

	chunkqueue_free(hctx->in_queue);

	free(hctx);

}

INIT_FUNC(mod_deflate_init) {

	plugin_data *p;

	p = calloc(1, sizeof(*p));

	p->tmp_buf = buffer_init();

	return p;

}

FREE_FUNC(mod_deflate_free) {

	plugin_data *p = p_d;

	UNUSED(srv);

	if (!p) return HANDLER_GO_ON;

	if (p->config_storage) {

		size_t i;

		for (i = 0; i < srv->config_context->used; i++) {

			plugin_config *s = p->config_storage[i];

			if (!s) continue;

			array_free(s->mimetypes);

			buffer_free(s->nocompress_url);

#if defined(HAVE_PCRE_H)

		       	if (s->nocompress_regex) pcre_free(s->nocompress_regex);

#endif

			free(s);

		}

		free(p->config_storage);

	}

	buffer_free(p->tmp_buf);

	free(p);

	return HANDLER_GO_ON;

}

SETDEFAULTS_FUNC(mod_deflate_setdefaults) {

	plugin_data *p = p_d;

	size_t i = 0;

	config_values_t cv[] = { 

		{ "deflate.output-buffer-size",    NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.mimetypes",             NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.compression-level",     NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.mem-level",             NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.window-size",           NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.min-compress-size",     NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.work-block-size",       NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.enabled",               NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.debug",                 NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.bzip2",                 NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.sync-flush",            NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION },

		{ "deflate.nocompress-url",        NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },

		{ NULL,                            NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }

	};

	p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));

	for (i = 0; i < srv->config_context->used; i++) {

		plugin_config *s;

#if defined(HAVE_PCRE_H)

		const char *errptr;

		int erroff;

#endif

		s = calloc(1, sizeof(plugin_config));

		s->enabled = 1;

		s->bzip2 = 1;

		s->sync_flush = 0;

		s->debug = 0;

		s->output_buffer_size = 0;

		s->mem_level = 9;

		s->window_size = 15;

		s->min_compress_size = 0;

		s->work_block_size = 2048;

		s->compression_level = Z_DEFAULT_COMPRESSION;

		s->mimetypes = array_init();

		s->nocompress_url = buffer_init();

#if defined(HAVE_PCRE_H)

		s->nocompress_regex = NULL;

#endif

		cv[0].destination = &(s->output_buffer_size);

		cv[1].destination = s->mimetypes;

		cv[2].destination = &(s->compression_level);

		cv[3].destination = &(s->mem_level);

		cv[4].destination = &(s->window_size);

		cv[5].destination = &(s->min_compress_size);

		cv[6].destination = &(s->work_block_size);

		cv[7].destination = &(s->enabled);

		cv[8].destination = &(s->debug);

		cv[9].destination = &(s->bzip2);

		cv[10].destination = &(s->sync_flush);

		cv[11].destination = s->nocompress_url;

		p->config_storage[i] = s;

		if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {

			return HANDLER_ERROR;

		}

#if defined(HAVE_PCRE_H)		

		if (!buffer_is_empty(s->nocompress_url)) {

			if (NULL == (s->nocompress_regex = pcre_compile(s->nocompress_url->ptr,

								      0, &errptr, &erroff, NULL))) {

				log_error_write(srv, __FILE__, __LINE__, "sbss", 

						"compiling regex for nocompress-url failed:", 

						s->nocompress_url, "pos:", erroff);

				return HANDLER_ERROR;

			}

		}

#endif

		if((s->compression_level < 1 || s->compression_level > 9) &&

				s->compression_level != Z_DEFAULT_COMPRESSION) {

			log_error_write(srv, __FILE__, __LINE__, "sd", 

				"compression-level must be between 1 and 9:", s->compression_level);

			return HANDLER_ERROR;

		}

		if(s->mem_level < 1 || s->mem_level > 9) {

			log_error_write(srv, __FILE__, __LINE__, "sd", 

				"mem-level must be between 1 and 9:", s->mem_level);

			return HANDLER_ERROR;

		}

		if(s->window_size < 1 || s->window_size > 15) {

			log_error_write(srv, __FILE__, __LINE__, "sd", 

				"window-size must be between 1 and 15:", s->window_size);

			return HANDLER_ERROR;

		}

		s->window_size = 0 - s->window_size;

		if(s->sync_flush) {

			s->output_buffer_size = 0;

		}

	}

	return HANDLER_GO_ON;

}

#ifdef USE_ZLIB

/* Copied gzip_header from apache 2.2's mod_deflate.c */

/* RFC 1952 Section 2.3 defines the gzip header:

 *

 * +---+---+---+---+---+---+---+---+---+---+

 * |ID1|ID2|CM |FLG|     MTIME     |XFL|OS |

 * +---+---+---+---+---+---+---+---+---+---+

 */

static const char gzip_header[10] =

{ '\037', '\213', Z_DEFLATED, 0,

  0, 0, 0, 0, /* mtime */

  0, 0x03 /* Unix OS_CODE */

};

static int stream_deflate_init(server *srv, connection *con, handler_ctx *hctx) {

	plugin_data *p = hctx->plugin_data;

	z_stream *z;

	UNUSED(srv);

	UNUSED(con);

	z = &(hctx->z);

	z->zalloc = Z_NULL;

	z->zfree = Z_NULL;

	z->opaque = Z_NULL;

	z->total_in = 0;

	z->total_out = 0;

	z->next_out = NULL;

	z->avail_out = 0;

	if(p->conf.debug) {

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"output-buffer-size:", p->conf.output_buffer_size);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"compression-level:", p->conf.compression_level);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"mem-level:", p->conf.mem_level);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"window-size:", p->conf.window_size);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"min-compress-size:", p->conf.min_compress_size);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"work-block-size:", p->conf.work_block_size);

	}

	if (Z_OK != deflateInit2(z, 

				 p->conf.compression_level,

				 Z_DEFLATED, 

				 p->conf.window_size,  /* supress zlib-header */

				 p->conf.mem_level,

				 Z_DEFAULT_STRATEGY)) {

		return -1;

	}

	hctx->stream_open = 1;

	return 0;

}

static int stream_deflate_compress(server *srv, connection *con, handler_ctx *hctx, unsigned char *start, off_t st_size) {

	plugin_data *p = hctx->plugin_data;

	z_stream *z;

	int len;

	int in = 0, out = 0;

	UNUSED(srv);

	z = &(hctx->z);

	if(z->next_out == NULL) {

		z->next_out = (unsigned char *)hctx->output->ptr;

		z->avail_out = hctx->output->size;

	}

	if(hctx->compression_type == HTTP_ACCEPT_ENCODING_GZIP) {

		if(hctx->gzip_header == 0) {

			hctx->gzip_header = 1;

			/* copy gzip header into output buffer */

			buffer_copy_memory(hctx->output, gzip_header, sizeof(gzip_header));

			if(p->conf.debug) {

				log_error_write(srv, __FILE__, __LINE__, "sd",

						"gzip_header len=", sizeof(gzip_header));

			}

			/* initialize crc32 */

			hctx->crc = crc32(0L, Z_NULL, 0);

			z->next_out = (unsigned char *)(hctx->output->ptr + sizeof(gzip_header));

			z->avail_out = hctx->output->size - sizeof(gzip_header);

		}

		hctx->crc = crc32(hctx->crc, start, st_size);

	}

	z->next_in = start;

	z->avail_in = st_size;

	hctx->bytes_in += st_size;

	/* compress data */

	in = z->avail_in;

	do {

		if (Z_OK != deflate(z, Z_NO_FLUSH)) {

			deflateEnd(z);

			hctx->stream_open = 0;

			return -1;

		}

		if(z->avail_out == 0 || z->avail_in > 0) {

			len = hctx->output->size - z->avail_out;

			hctx->bytes_out += len;

			out += len;

			chunkqueue_append_mem(con->write_queue, hctx->output->ptr, len+1);

			z->next_out = (unsigned char *)hctx->output->ptr;

			z->avail_out = hctx->output->size;

		}

	} while (z->avail_in > 0);

	if(p->conf.debug) {

		log_error_write(srv, __FILE__, __LINE__, "sdsd",

				"compress: in=", in, ", out=", out);

	}

	return 0;

}

static int stream_deflate_flush(server *srv, connection *con, handler_ctx *hctx, int end) {

	plugin_data *p = hctx->plugin_data;

	z_stream *z;

	int len;

	int rc = 0;

	int done;

	int flush = 1;

	int in = 0, out = 0;

	UNUSED(srv);

	z = &(hctx->z);

	if(z->next_out == NULL) {

		z->next_out = (unsigned char *)hctx->output->ptr;

		z->avail_out = hctx->output->size;

	}

	/* compress data */

	in = z->avail_in;

	do {

		done = 1;

		if(end) {

			rc = deflate(z, Z_FINISH);

			if (rc == Z_OK) {

				done = 0;

			} else if (rc != Z_STREAM_END) {

				deflateEnd(z);

				hctx->stream_open = 0;

				return -1;

			}

		} else {

			if(p->conf.sync_flush) {

				rc = deflate(z, Z_SYNC_FLUSH);

			} else if(z->avail_in > 0) {

				if(p->conf.output_buffer_size > 0) flush = 0;

				rc = deflate(z, Z_NO_FLUSH);

			} else {

				if(p->conf.output_buffer_size > 0) flush = 0;

				rc = Z_OK;

			}

			if (rc != Z_OK) {

				deflateEnd(z);

				hctx->stream_open = 0;

				return -1;

			}

		}

		len = hctx->output->size - z->avail_out;

		if(z->avail_out == 0 || (flush && len > 0)) {

			hctx->bytes_out += len;

			out += len;

			chunkqueue_append_mem(con->write_queue, hctx->output->ptr, len+1);

			z->next_out = (unsigned char *)hctx->output->ptr;

			z->avail_out = hctx->output->size;

		}

	} while (z->avail_in != 0 || !done);

	if(p->conf.debug) {

		log_error_write(srv, __FILE__, __LINE__, "sdsd",

				"flush: in=", in, ", out=", out);

	}

	if(p->conf.sync_flush) {

		z->next_out = NULL;

		z->avail_out = 0;

	}

	return 0;

}

static int stream_deflate_end(server *srv, connection *con, handler_ctx *hctx) {

	plugin_data *p = hctx->plugin_data;

	z_stream *z;

	int rc;

	UNUSED(srv);

	z = &(hctx->z);

	if(!hctx->stream_open) return 0;

	hctx->stream_open = 0;

	if(hctx->compression_type == HTTP_ACCEPT_ENCODING_GZIP && hctx->bytes_out > 0 &&

			(unsigned int )hctx->bytes_out >= sizeof(gzip_header)) {

		/* write gzip footer */

		unsigned char c[8];

		c[0] = (hctx->crc >>  0) & 0xff;

		c[1] = (hctx->crc >>  8) & 0xff;

		c[2] = (hctx->crc >> 16) & 0xff;

		c[3] = (hctx->crc >> 24) & 0xff;

		c[4] = (z->total_in >>  0) & 0xff;

		c[5] = (z->total_in >>  8) & 0xff;

		c[6] = (z->total_in >> 16) & 0xff;

		c[7] = (z->total_in >> 24) & 0xff;

		/* append footer to write_queue */

		chunkqueue_append_mem(con->write_queue, (char *)c, 9);

		hctx->bytes_out += 8;

		if(p->conf.debug) {

			log_error_write(srv, __FILE__, __LINE__, "sd",

					"gzip_footer len=", 8);

		}

	}

	if ((rc = deflateEnd(z)) != Z_OK) {

		if(rc == Z_DATA_ERROR) return 0;

		if(z->msg != NULL) {

			log_error_write(srv, __FILE__, __LINE__, "sdss",

					"deflateEnd error ret=", rc, ", msg=", z->msg);

		} else {

			log_error_write(srv, __FILE__, __LINE__, "sd",

					"deflateEnd error ret=", rc);

		}

		return -1;

	}

	return 0;

}

#endif

#ifdef USE_BZ2LIB

static int stream_bzip2_init(server *srv, connection *con, handler_ctx *hctx) {

	plugin_data *p = hctx->plugin_data;

	bz_stream *bz;

	UNUSED(srv);

	UNUSED(con);

	bz = &(hctx->bz);

	bz->bzalloc = NULL;

	bz->bzfree = NULL;

	bz->opaque = NULL;

	bz->total_in_lo32 = 0;

	bz->total_in_hi32 = 0;

	bz->total_out_lo32 = 0;

	bz->total_out_hi32 = 0;

	if(p->conf.debug) {

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"output-buffer-size:", p->conf.output_buffer_size);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"compression-level:", p->conf.compression_level);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"mem-level:", p->conf.mem_level);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"window-size:", p->conf.window_size);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"min-compress-size:", p->conf.min_compress_size);

		log_error_write(srv, __FILE__, __LINE__, "sd", 

			"work-block-size:", p->conf.work_block_size);

	}

	if (BZ_OK != BZ2_bzCompressInit(bz, 

					p->conf.compression_level, /* blocksize = 900k */

					0, /* no output */

					30)) { /* workFactor: default */

		return -1;

	}

	hctx->stream_open = 1;

	return 0;

}

static int stream_bzip2_compress(server *srv, connection *con, handler_ctx *hctx, unsigned char *start, off_t st_size) {

	plugin_data *p = hctx->plugin_data;

	bz_stream *bz;

	int len;

	int rc;

	int in = 0, out = 0;

	UNUSED(srv);

	bz = &(hctx->bz);

	if(bz->next_out == NULL) {

		bz->next_out = hctx->output->ptr;

		bz->avail_out = hctx->output->size;

	}

	bz->next_in = (char *)start;

	bz->avail_in = st_size;

	hctx->bytes_in += st_size;

	/* compress data */

	in = bz->avail_in;

	do {

		rc = BZ2_bzCompress(bz, BZ_RUN);

		if (rc != BZ_RUN_OK) {

			BZ2_bzCompressEnd(bz);

			hctx->stream_open = 0;

			return -1;

		}

		if(bz->avail_out == 0 || bz->avail_in > 0) {

			len = hctx->output->size - bz->avail_out;

			hctx->bytes_out += len;

			out += len;

			chunkqueue_append_mem(con->write_queue, hctx->output->ptr, len+1);

			bz->next_out = hctx->output->ptr;

			bz->avail_out = hctx->output->size;

		}

	} while (bz->avail_in > 0);

	if(p->conf.debug) {

		log_error_write(srv, __FILE__, __LINE__, "sdsd",

				"compress: in=", in, ", out=", out);

	}

	return 0;

}

static int stream_bzip2_flush(server *srv, connection *con, handler_ctx *hctx, int end) {

	plugin_data *p = hctx->plugin_data;

	bz_stream *bz;