diff -Naur lighttpd-1.4.10.orig/src/Makefile.am lighttpd-1.4.10/src/Makefile.am
--- lighttpd-1.4.10.orig/src/Makefile.am	2006-01-04 06:08:03.000000000 -0800
+++ lighttpd-1.4.10/src/Makefile.am	2006-02-16 22:25:16.504347041 -0800
@@ -28,7 +28,7 @@
 mod_ssi_expr.c: mod_ssi_exprparser.h
 
 common_src=buffer.c log.c \
-      keyvalue.c chunk.c  \
+      keyvalue.c chunk.c chunk_encode.c \
       http_chunk.c stream.c fdevent.c \
       stat_cache.c plugin.c joblist.c etag.c array.c \
       data_string.c data_count.c data_array.c \
@@ -222,9 +222,14 @@
 mod_accesslog_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
 mod_accesslog_la_LIBADD = $(common_libadd)
 
+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)
+
 
 hdr = server.h buffer.h network.h log.h keyvalue.h \
-      response.h request.h fastcgi.h chunk.h \
+      response.h request.h fastcgi.h chunk.h chunk_encode.h \
       settings.h http_chunk.h http_auth_digest.h \
       md5.h http_auth.h stream.h \
       fdevent.h connections.h base.h stat_cache.h \
diff -Naur lighttpd-1.4.10.orig/src/base.h lighttpd-1.4.10/src/base.h
--- lighttpd-1.4.10.orig/src/base.h	2006-01-11 06:51:04.000000000 -0800
+++ lighttpd-1.4.10/src/base.h	2006-02-16 22:25:16.504347041 -0800
@@ -345,8 +345,10 @@
 	
 	int file_started;
 	int file_finished;
+	int end_chunk; /* used for chunked transfer encoding. */
 	
-	chunkqueue *write_queue;      /* a large queue for low-level write ( HTTP response ) [ file, mem ] */
+	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 ] */
 	chunkqueue *read_queue;       /* a small queue for low-level read ( HTTP request ) [ mem ] */
 	chunkqueue *request_content_queue; /* takes request-content into tempfile if necessary [ tempfile, mem ]*/
 	
@@ -570,6 +572,7 @@
 	
 	connections *conns;
 	connections *joblist;
+	connections *joblist_prev;
 	connections *fdwaitqueue;
 	
 	stat_cache  *stat_cache;
diff -Naur lighttpd-1.4.10.orig/src/chunk.c lighttpd-1.4.10/src/chunk.c
--- lighttpd-1.4.10.orig/src/chunk.c	2005-11-18 05:18:19.000000000 -0800
+++ lighttpd-1.4.10/src/chunk.c	2006-02-16 22:25:16.505346873 -0800
@@ -224,6 +224,16 @@
 	return 0;
 }
 
+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;
+}
+
 buffer * chunkqueue_get_prepend_buffer(chunkqueue *cq) {
 	chunk *c;
 	
diff -Naur lighttpd-1.4.10.orig/src/chunk.h lighttpd-1.4.10/src/chunk.h
--- lighttpd-1.4.10.orig/src/chunk.h	2005-10-31 23:32:21.000000000 -0800
+++ lighttpd-1.4.10/src/chunk.h	2006-02-16 22:25:16.505346873 -0800
@@ -51,6 +51,7 @@
 int chunkqueue_append_file(chunkqueue *c, buffer *fn, off_t offset, off_t len);
 int chunkqueue_append_mem(chunkqueue *c, const char *mem, size_t len);
 int chunkqueue_append_buffer(chunkqueue *c, buffer *mem);
+int chunkqueue_append_chunkqueue(chunkqueue *cq, chunkqueue *src);
 int chunkqueue_prepend_buffer(chunkqueue *c, buffer *mem);
 
 buffer * chunkqueue_get_append_buffer(chunkqueue *c);
diff -Naur lighttpd-1.4.10.orig/src/chunk_encode.c lighttpd-1.4.10/src/chunk_encode.c
--- lighttpd-1.4.10.orig/src/chunk_encode.c	1969-12-31 16:00:00.000000000 -0800
+++ lighttpd-1.4.10/src/chunk_encode.c	2006-02-16 22:25:16.505346873 -0800
@@ -0,0 +1,117 @@
+/**
+ * the HTTP chunk-API
+ * 
+ * 
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include "server.h"
+#include "chunk.h"
+#include "chunk_encode.h"
+#include "log.h"
+
+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;
+}
+
diff -Naur lighttpd-1.4.10.orig/src/chunk_encode.h lighttpd-1.4.10/src/chunk_encode.h
--- lighttpd-1.4.10.orig/src/chunk_encode.h	1969-12-31 16:00:00.000000000 -0800
+++ lighttpd-1.4.10/src/chunk_encode.h	2006-02-16 22:25:16.506346704 -0800
@@ -0,0 +1,13 @@
+#ifndef _CHUNK_ENCODE_H_
+#define _CHUNK_ENCODE_H_
+
+#include "server.h"
+#include <sys/types.h>
+
+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);
+
+#endif
diff -Naur lighttpd-1.4.10.orig/src/connections.c lighttpd-1.4.10/src/connections.c
--- lighttpd-1.4.10.orig/src/connections.c	2006-02-08 04:27:20.000000000 -0800
+++ lighttpd-1.4.10/src/connections.c	2006-02-16 22:25:16.507346536 -0800
@@ -18,6 +18,7 @@
 #include "response.h"
 #include "network.h"
 #include "http_chunk.h"
+#include "chunk_encode.h"
 #include "stat_cache.h"
 #include "joblist.h"
 
@@ -146,6 +147,12 @@
 	return 0;
 }
 
+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;
+}
+
 #if 0
 static void dump_packet(const unsigned char *data, size_t len) {
 	size_t i, j;
@@ -365,6 +372,7 @@
 				con->file_finished = 1;
 
 				chunkqueue_reset(con->write_queue);
+				chunkqueue_reset(con->output_queue);
 			}
 			break;
 		default:
@@ -472,12 +480,27 @@
 		/* disable chunked encoding again as we have no body */
 		con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;
 		chunkqueue_reset(con->write_queue);
+		chunkqueue_reset(con->output_queue);
 		
 		con->file_finished = 1;
 		break;
 	}
 	
 
+	/* 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;
+	}
+
 	if (con->file_finished) {
 		/* we have all the content and chunked encoding is not used, set a content-length */ 
 		
@@ -517,6 +540,7 @@
 	
 	if (con->request.http_method == HTTP_METHOD_HEAD) {
 		chunkqueue_reset(con->write_queue);
+		chunkqueue_reset(con->output_queue);
 	}
 
 	http_response_write_header(srv, con);
@@ -525,11 +549,57 @@
 }
 
 static int connection_handle_write(server *srv, connection *con) {
-	switch(network_write_chunkqueue(srv, con, con->write_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)) {
 	case 0:
-		if (con->file_finished) {
+		if (finished) {
 			connection_set_state(srv, con, CON_STATE_RESPONSE_END);
 			joblist_append(srv, con);
+		} else {
+			/* not finished yet -> WRITE */
+			con->is_writable = 1;
 		}
 		break;
 	case -1: /* error on our side */
@@ -599,6 +669,7 @@
 	
 #undef CLEAN
 	con->write_queue = chunkqueue_init();
+	con->output_queue = chunkqueue_init();
 	con->read_queue = chunkqueue_init();
 	con->request_content_queue = chunkqueue_init();
 	chunkqueue_set_tempdirs(con->request_content_queue, srv->srvconf.upload_tempdirs);
@@ -627,6 +698,7 @@
 		connection_reset(srv, con);
 		
 		chunkqueue_free(con->write_queue);
+		chunkqueue_free(con->output_queue);
 		chunkqueue_free(con->read_queue);
 		chunkqueue_free(con->request_content_queue);
 		array_free(con->request.headers);
@@ -681,6 +753,7 @@
 	con->http_status = 0;
 	con->file_finished = 0;
 	con->file_started = 0;
+	con->end_chunk = 0;
 	con->got_response = 0;
 	
 	con->parsed_response = 0;
@@ -751,6 +824,7 @@
 	array_reset(con->environment);
 	
 	chunkqueue_reset(con->write_queue);
+	chunkqueue_reset(con->output_queue);
 	chunkqueue_reset(con->request_content_queue);
 
 	/* the plugins should cleanup themself */	
@@ -1178,7 +1252,6 @@
 	}
 	
 	if (con->state == CON_STATE_WRITE &&
-	    !chunkqueue_is_empty(con->write_queue) &&
 	    con->is_writable) {
 		
 		if (-1 == connection_handle_write(srv, con)) {
@@ -1573,15 +1646,15 @@
 			}
 			
 			/* only try to write if we have something in the queue */
-			if (!chunkqueue_is_empty(con->write_queue)) {
 #if 0
+			if (!connection_queue_is_empty(con)) {
 				log_error_write(srv, __FILE__, __LINE__, "dsd",
 						con->fd,
 						"packets to write:",
-						con->write_queue->used);
-#endif
+						con->output_queue->used);
 			}
-			if (!chunkqueue_is_empty(con->write_queue) && con->is_writable) {
+#endif
+			if (con->is_writable) {
 				if (-1 == connection_handle_write(srv, con)) {
 					log_error_write(srv, __FILE__, __LINE__, "ds",
 							con->fd,
@@ -1691,9 +1764,9 @@
 		 * - if we have data to write
 		 * - if the socket is not writable yet 
 		 */
-		if (!chunkqueue_is_empty(con->write_queue) && 
-		    (con->is_writable == 0) &&
-		    (con->traffic_limit_reached == 0)) {
+		if ((con->is_writable == 0) &&
+		    (con->traffic_limit_reached == 0) &&
+				!connection_queue_is_empty(con)) {
 			fdevent_event_add(srv->ev, &(con->fde_ndx), con->fd, FDEVENT_OUT);
 		} else {
 			fdevent_event_del(srv->ev, &(con->fde_ndx), con->fd);
diff -Naur lighttpd-1.4.10.orig/src/http_chunk.c lighttpd-1.4.10/src/http_chunk.c
--- lighttpd-1.4.10.orig/src/http_chunk.c	2005-08-10 15:26:50.000000000 -0700
+++ lighttpd-1.4.10/src/http_chunk.c	2006-02-16 22:25:16.508346367 -0800
@@ -58,16 +58,9 @@
 	
 	cq = con->write_queue;
 	
-	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
-		http_chunk_append_len(srv, con, len);
-	}
-	
+
 	chunkqueue_append_file(cq, fn, offset, len);
 	
-	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED && len > 0) {
-		chunkqueue_append_mem(cq, "\r\n", 2 + 1);
-	}
-	
 	return 0;
 }
 
@@ -78,16 +71,9 @@
 	
 	cq = con->write_queue;
 	
-	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
-		http_chunk_append_len(srv, con, mem->used - 1);
-	}
-	
+
 	chunkqueue_append_buffer(cq, mem);
 	
-	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED && mem->used > 0) {
-		chunkqueue_append_mem(cq, "\r\n", 2 + 1);
-	}
-	
 	return 0;
 }
 
@@ -99,25 +85,11 @@
 	cq = con->write_queue;
 	
 	if (len == 0) {
-		if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
-			http_chunk_append_len(srv, con, 0);
-			chunkqueue_append_mem(cq, "\r\n", 2 + 1);
-		} else {
-			chunkqueue_append_mem(cq, "", 1);
-		}
 		return 0;
 	}
 	
-	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
-		http_chunk_append_len(srv, con, len - 1);
-	}
-	
 	chunkqueue_append_mem(cq, mem, len);
 	
-	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
-		chunkqueue_append_mem(cq, "\r\n", 2 + 1);
-	}
-	
 	return 0;
 }
 
diff -Naur lighttpd-1.4.10.orig/src/joblist.c lighttpd-1.4.10/src/joblist.c
--- lighttpd-1.4.10.orig/src/joblist.c	2005-08-10 15:26:41.000000000 -0700
+++ lighttpd-1.4.10/src/joblist.c	2006-02-16 22:25:16.508346367 -0800
@@ -7,6 +7,7 @@
 
 int joblist_append(server *srv, connection *con) {
 	if (con->in_joblist) return 0;
+	con->in_joblist = 1;
 	
 	if (srv->joblist->size == 0) {
 		srv->joblist->size  = 16;
diff -Naur lighttpd-1.4.10.orig/src/mod_deflate.c lighttpd-1.4.10/src/mod_deflate.c
--- lighttpd-1.4.10.orig/src/mod_deflate.c	1969-12-31 16:00:00.000000000 -0800
+++ lighttpd-1.4.10/src/mod_deflate.c	2006-02-17 23:26:45.885437687 -0800
@@ -0,0 +1,1291 @@
+#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>
+
+#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"
+
+#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;
+} 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);
+			
+			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 },
+		{ 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;
+		
+		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();
+
+		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);
+		
+		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((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 &&
+			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;
+	int len;
+	int rc;
+	int done;
+	int flush = 1;
+	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;
+	}
+	/* compress data */
+	in = bz->avail_in;
+	do {
+		done = 1;
+		if(end) {
+			rc = BZ2_bzCompress(bz, BZ_FINISH);
+			if (rc == BZ_FINISH_OK) {
+				done = 0;
+			} else if (rc != BZ_STREAM_END) {
+				BZ2_bzCompressEnd(bz);
+				hctx->stream_open = 0;
+				return -1;
+			}
+		} else if(bz->avail_in > 0) {
+			rc = BZ2_bzCompress(bz, BZ_RUN);
+			if (rc != BZ_RUN_OK) {
+				BZ2_bzCompressEnd(bz);
+				hctx->stream_open = 0;
+				return -1;
+			}
+			if(p->conf.output_buffer_size > 0) flush = 0;
+		}
+
+		len = hctx->output->size - bz->avail_out;
+		if(bz->avail_out == 0 || (flush && len > 0)) {
+			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 || !done);
+	if(p->conf.debug) {
+		log_error_write(srv, __FILE__, __LINE__, "sdsd",
+				"flush: in=", in, ", out=", out);
+	}
+	if(p->conf.sync_flush) {
+		bz->next_out = NULL;
+		bz->avail_out = 0;
+	}
+	return 0;
+}
+
+static int stream_bzip2_end(server *srv, connection *con, handler_ctx *hctx) {
+	plugin_data *p = hctx->plugin_data;
+	bz_stream *bz;
+	int rc;
+
+	UNUSED(p);
+	UNUSED(con);
+
+	bz = &(hctx->bz);
+	if(!hctx->stream_open) return 0;
+	hctx->stream_open = 0;
+
+	if ((rc = BZ2_bzCompressEnd(bz)) != BZ_OK) {
+		if(rc == BZ_DATA_ERROR) return 0;
+		log_error_write(srv, __FILE__, __LINE__, "sd",
+				"BZ2_bzCompressEnd error ret=", rc);
+		return -1;
+	}
+	return 0;
+}
+
+#endif
+
+static int mod_deflate_compress(server *srv, connection *con, handler_ctx *hctx, unsigned char *start, off_t st_size) {
+	int ret = -1;
+	if(st_size == 0) return 0;
+	switch(hctx->compression_type) {
+#ifdef USE_ZLIB
+	case HTTP_ACCEPT_ENCODING_GZIP: 
+	case HTTP_ACCEPT_ENCODING_DEFLATE: 
+		ret = stream_deflate_compress(srv, con, hctx, start, st_size);
+		break;
+#endif
+#ifdef USE_BZ2LIB
+	case HTTP_ACCEPT_ENCODING_BZIP2: 
+		ret = stream_bzip2_compress(srv, con, hctx, start, st_size);
+		break;
+#endif
+	default:
+		ret = -1;
+		break;
+	}
+
+	return ret;
+}
+
+static int mod_deflate_stream_flush(server *srv, connection *con, handler_ctx *hctx, int end) {
+	int ret = -1;
+	if(hctx->bytes_in == 0) return 0;
+	switch(hctx->compression_type) {
+#ifdef USE_ZLIB
+	case HTTP_ACCEPT_ENCODING_GZIP: 
+	case HTTP_ACCEPT_ENCODING_DEFLATE: 
+		ret = stream_deflate_flush(srv, con, hctx, end);
+		break;
+#endif
+#ifdef USE_BZ2LIB
+	case HTTP_ACCEPT_ENCODING_BZIP2: 
+		ret = stream_bzip2_flush(srv, con, hctx, end);
+		break;
+#endif
+	default:
+		ret = -1;
+		break;
+	}
+
+	return ret;
+}
+
+static int mod_deflate_stream_end(server *srv, connection *con, handler_ctx *hctx) {
+	int ret = -1;
+	switch(hctx->compression_type) {
+#ifdef USE_ZLIB
+	case HTTP_ACCEPT_ENCODING_GZIP: 
+	case HTTP_ACCEPT_ENCODING_DEFLATE: 
+		ret = stream_deflate_end(srv, con, hctx);
+		break;
+#endif
+#ifdef USE_BZ2LIB
+	case HTTP_ACCEPT_ENCODING_BZIP2: 
+		ret = stream_bzip2_end(srv, con, hctx);
+		break;
+#endif
+	default:
+		ret = -1;
+		break;
+	}
+
+	return ret;
+}
+
+static int mod_deflate_file_chunk(server *srv, connection *con, handler_ctx *hctx, chunk *c, off_t st_size) {
+	plugin_data *p = hctx->plugin_data;
+	off_t abs_offset;
+	off_t toSend;
+	stat_cache_entry *sce = NULL;
+	off_t we_want_to_mmap = 2 MByte; 
+	off_t we_want_to_send = st_size;
+	char *start = NULL;
+
+	if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
+		log_error_write(srv, __FILE__, __LINE__, "sb",
+				strerror(errno), c->file.name);
+		return -1;
+	}
+
+	abs_offset = c->file.start + c->offset;
+	
+	if (abs_offset > sce->st.st_size) {
+		log_error_write(srv, __FILE__, __LINE__, "sb", 
+				"file was shrinked:", c->file.name);
+		
+		return -1;
+	}
+
+	we_want_to_send = st_size;
+	/* mmap the buffer 
+	 * - first mmap 
+	 * - new mmap as the we are at the end of the last one */
+	if (c->file.mmap.start == MAP_FAILED ||
+	    abs_offset == (off_t)(c->file.mmap.offset + c->file.mmap.length)) {
+
+		/* Optimizations for the future:
+		 *
+		 * adaptive mem-mapping
+		 *   the problem:
+		 *     we mmap() the whole file. If someone has alot large files and 32bit
+		 *     machine the virtual address area will be unrun and we will have a failing 
+		 *     mmap() call.
+		 *   solution:
+		 *     only mmap 16M in one chunk and move the window as soon as we have finished
+		 *     the first 8M
+		 *
+		 * read-ahead buffering
+		 *   the problem:
+		 *     sending out several large files in parallel trashes the read-ahead of the
+		 *     kernel leading to long wait-for-seek times.
+		 *   solutions: (increasing complexity)
+		 *     1. use madvise
+		 *     2. use a internal read-ahead buffer in the chunk-structure
+		 *     3. use non-blocking IO for file-transfers
+		 *   */
+
+		/* all mmap()ed areas are 512kb expect the last which might be smaller */
+		size_t to_mmap;
+
+		/* this is a remap, move the mmap-offset */
+		if (c->file.mmap.start != MAP_FAILED) {
+			munmap(c->file.mmap.start, c->file.mmap.length);
+			c->file.mmap.offset += we_want_to_mmap;
+		} else {
+			/* in case the range-offset is after the first mmap()ed area we skip the area */
+			c->file.mmap.offset = 0;
+
+			while (c->file.mmap.offset + we_want_to_mmap < c->file.start) {
+				c->file.mmap.offset += we_want_to_mmap;
+			}
+		}
+
+		/* length is rel, c->offset too, assume there is no limit at the mmap-boundaries */
+		to_mmap = (c->file.start + c->file.length) - c->file.mmap.offset;
+		if(to_mmap > we_want_to_mmap) to_mmap = we_want_to_mmap;
+		/* we have more to send than we can mmap() at once */
+		if(we_want_to_send > to_mmap) we_want_to_send = to_mmap;
+
+		if (-1 == c->file.fd) {  /* open the file if not already open */
+			if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
+				log_error_write(srv, __FILE__, __LINE__, "sbs", "open failed for:", c->file.name, strerror(errno));
+		
+				return -1;
+			}
+#ifdef FD_CLOEXEC
+			fcntl(c->file.fd, F_SETFD, FD_CLOEXEC);
+#endif
+		}
+
+		if (MAP_FAILED == (c->file.mmap.start = mmap(0, to_mmap, PROT_READ, MAP_SHARED, c->file.fd, c->file.mmap.offset))) {
+			/* close it here, otherwise we'd have to set FD_CLOEXEC */
+
+			log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed:", 
+					strerror(errno), c->file.name, c->file.fd);
+
+			return -1;
+		}
+
+		c->file.mmap.length = to_mmap;
+#ifdef LOCAL_BUFFERING
+		buffer_copy_string_len(c->mem, c->file.mmap.start, c->file.mmap.length);
+#else
+#ifdef HAVE_MADVISE
+		/* don't advise files < 64Kb */
+		if (c->file.mmap.length > (64 KByte) && 
+		    0 != madvise(c->file.mmap.start, c->file.mmap.length, MADV_WILLNEED)) {
+			log_error_write(srv, __FILE__, __LINE__, "ssbd", "madvise failed:", 
+					strerror(errno), c->file.name, c->file.fd);
+		}
+#endif
+#endif
+
+		/* chunk_reset() or chunk_free() will cleanup for us */
+	}
+
+	/* to_send = abs_mmap_end - abs_offset */
+	toSend = (c->file.mmap.offset + c->file.mmap.length) - (abs_offset);
+	if(toSend > we_want_to_send) toSend = we_want_to_send;
+
+	if (toSend < 0) {
+		log_error_write(srv, __FILE__, __LINE__, "soooo", 
+				"toSend is negative:",
+				toSend,
+				c->file.mmap.length,
+				abs_offset,
+				c->file.mmap.offset); 
+		assert(toSend < 0);
+	}
+
+#ifdef LOCAL_BUFFERING
+	start = c->mem->ptr;
+#else
+	start = c->file.mmap.start;
+#endif
+
+	if(p->conf.debug) {
+		log_error_write(srv, __FILE__, __LINE__, "sdsd",
+				"compress file chunk: offset=", (int)c->offset,
+				", toSend=", (int)toSend);
+	}
+	if (mod_deflate_compress(srv, con, hctx,
+				(unsigned char *)start + (abs_offset - c->file.mmap.offset), toSend) < 0) {
+		log_error_write(srv, __FILE__, __LINE__, "s", 
+				"compress failed.");
+		return -1;
+	}
+
+	c->offset += toSend;
+	if (c->offset == c->file.length) {
+		/* we don't need the mmaping anymore */
+		if (c->file.mmap.start != MAP_FAILED) {
+			munmap(c->file.mmap.start, c->file.mmap.length);
+			c->file.mmap.start = MAP_FAILED;
+		}
+	}
+
+	return toSend;
+}
+
+static int deflate_compress_cleanup(server *srv, connection *con, handler_ctx *hctx) {
+	plugin_data *p = hctx->plugin_data;
+	int rc;
+
+	rc = mod_deflate_stream_end(srv, con, hctx);
+	if(rc < 0) {
+		log_error_write(srv, __FILE__, __LINE__, "s", "error closing stream");
+	}
+	if(p->conf.debug) {
+		log_error_write(srv, __FILE__, __LINE__, "sdsd",
+				" in:", hctx->bytes_in,
+				" out:", hctx->bytes_out);
+	}
+
+	/* cleanup compression state */
+	if(hctx->output != p->tmp_buf) {
+		buffer_free(hctx->output);
+	}
+	handler_ctx_free(hctx);
+	con->plugin_ctx[p->id] = NULL;
+
+	return 0;
+}
+
+static handler_t deflate_compress_response(server *srv, connection *con, handler_ctx *hctx, int end) {
+	plugin_data *p = hctx->plugin_data;
+	chunk *c;
+	size_t chunks_written = 0;
+	int chunk_finished = 0;
+	int len = 0;
+	int rc=-1;
+	int close_stream = 0;
+	int out = 0;
+	int max = 0;
+	
+	/* move all chunk from write_queue into our in_queue */
+	chunkqueue_append_chunkqueue(hctx->in_queue, con->write_queue);
+
+	len = chunkqueue_length(hctx->in_queue);
+	if(p->conf.debug) {
+		log_error_write(srv, __FILE__, __LINE__, "sd",
+				"compress: in_queue len=", len);
+	}
+	/* calculate max bytes to compress for this call. */
+	if(!end) {
+		max = p->conf.work_block_size * 1024;
+		if(max == 0 || max > len) max = len;
+	} else {
+		max = len;
+	}
+
+	/* Compress chunks from in_queue into chunks for write_queue */
+	for(c = hctx->in_queue->first; c && out < max; c = c->next) {
+		chunk_finished = 0;
+		len = 0;
+		
+		switch(c->type) {
+		case MEM_CHUNK:
+			len = c->mem->used - 1;
+			if(len > (max - out)) len = max - out;
+			if (mod_deflate_compress(srv, con, hctx, (unsigned char *)c->mem->ptr, len) < 0) {
+				log_error_write(srv, __FILE__, __LINE__, "s", 
+						"compress failed.");
+				return HANDLER_ERROR;
+			}
+			c->offset += len;
+			out += len;
+			if (c->offset == c->mem->used - 1) {
+				chunk_finished = 1;
+				chunks_written++;
+			}
+			break;
+		case FILE_CHUNK:
+			len = c->file.length - c->offset;
+			if(len > (max - out)) len = max - out;
+			if ((len = mod_deflate_file_chunk(srv, con, hctx, c, len)) < 0) {
+				log_error_write(srv, __FILE__, __LINE__, "s", 
+						"compress file chunk failed.");
+				return HANDLER_ERROR;
+			}
+			out += len;
+			if (c->offset == c->file.length) {
+				chunk_finished = 1;
+				chunks_written++;
+			}
+			break;
+		default:
+			
+			log_error_write(srv, __FILE__, __LINE__, "ds", c, "type not known");
+			
+			return HANDLER_ERROR;
+		}
+		if(!chunk_finished) break;
+	}
+	if(p->conf.debug) {
+		log_error_write(srv, __FILE__, __LINE__, "sd",
+				"compressed bytes:", out);
+	}
+	hctx->in_queue->bytes_out += out;
+
+	if(chunks_written > 0) {
+		chunkqueue_remove_finished_chunks(hctx->in_queue);
+	}
+
+	close_stream = (con->file_finished && chunkqueue_is_empty(hctx->in_queue));
+	rc = mod_deflate_stream_flush(srv, con, hctx, close_stream);
+	if(rc < 0) {
+		log_error_write(srv, __FILE__, __LINE__, "s", "flush error");
+	}
+	if(close_stream || end) {
+		deflate_compress_cleanup(srv, con, hctx);
+		if(p->conf.debug) {
+			log_error_write(srv, __FILE__, __LINE__, "sbsb",
+					"finished uri:", con->uri.path_raw, ", query:", con->uri.query);
+		}
+		return HANDLER_FINISHED;
+	} else {
+		if(!chunkqueue_is_empty(hctx->in_queue)) {
+			/* We have more data to compress. */
+			joblist_append(srv, con);
+		}
+		return HANDLER_COMEBACK;
+	}
+}
+
+#define PATCH(x) \
+	p->conf.x = s->x;
+static int mod_deflate_patch_connection(server *srv, connection *con, plugin_data *p) {
+	size_t i, j;
+	plugin_config *s = p->config_storage[0];
+
+	PATCH(output_buffer_size);
+	PATCH(mimetypes);
+	PATCH(compression_level);
+	PATCH(mem_level);
+	PATCH(window_size);
+	PATCH(min_compress_size);
+	PATCH(work_block_size);
+	PATCH(enabled);
+	PATCH(debug);
+	PATCH(bzip2);
+	PATCH(sync_flush);
+	
+	/* skip the first, the global context */
+	for (i = 1; i < srv->config_context->used; i++) {
+		data_config *dc = (data_config *)srv->config_context->data[i];
+		s = p->config_storage[i];
+		
+		/* condition didn't match */
+		if (!config_check_cond(srv, con, dc)) continue;
+		
+		/* merge config */
+		for (j = 0; j < dc->value->used; j++) {
+			data_unset *du = dc->value->data[j];
+			
+			if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.output-buffer-size"))) {
+				PATCH(output_buffer_size);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.mimetypes"))) {
+				PATCH(mimetypes);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.compression-level"))) {
+				PATCH(compression_level);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.mem-level"))) {
+				PATCH(mem_level);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.window-size"))) {
+				PATCH(window_size);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.min-compress-size"))) {
+				PATCH(min_compress_size);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.work-block-size"))) {
+				PATCH(work_block_size);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.enabled"))) {
+				PATCH(enabled);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.debug"))) {
+				PATCH(debug);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.bzip2"))) {
+				PATCH(bzip2);
+			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.sync-flush"))) {
+				PATCH(sync_flush);
+			}
+		}
+	}
+	
+	return 0;
+}
+#undef PATCH
+
+PHYSICALPATH_FUNC(mod_deflate_handle_response_start) {
+	plugin_data *p = p_d;
+	handler_ctx *hctx;
+	data_string *ds;
+	int accept_encoding = 0;
+	char *value;
+	int srv_encodings = 0;
+	int matched_encodings = 0;
+	const char *dflt_gzip = "gzip";
+	const char *dflt_deflate = "deflate";
+	const char *dflt_bzip2 = "bzip2";
+	const char *compression_name = NULL;
+	int file_len=0;
+	int rc=-2;
+	size_t m;
+	
+	/* disable compression for some http status types. */
+	switch(con->http_status) {
+	case 100:
+	case 101:
+	case 204:
+	case 205:
+	case 304:
+		/* disable compression as we have no response entity */
+		return HANDLER_GO_ON;
+	default:
+		break;
+	}
+
+	mod_deflate_patch_connection(srv, con, p);
+
+	/* is compression allowed */
+	if(!p->conf.enabled) {
+		if(p->conf.debug) {
+			log_error_write(srv, __FILE__, __LINE__, "s", "compression disabled.");
+		}
+		return HANDLER_GO_ON;
+	}
+	
+	/* the response might change according to Accept-Encoding */
+	if (NULL != (ds = (data_string *)array_get_element(con->response.headers, "Vary"))) {
+		/* append Accept-Encoding to Vary header */
+		if (NULL == strstr(ds->value->ptr, "Accept-Encoding")) {
+			buffer_append_string(ds->value, ",Accept-Encoding");
+		}
+	} else {
+		response_header_insert(srv, con, CONST_STR_LEN("Vary"),
+				CONST_STR_LEN("Accept-Encoding"));
+	}
+
+	/* Check if response has a Content-Encoding. */
+	if (NULL != (ds = (data_string *)array_get_element(con->response.headers, "Content-Encoding"))) {
+		return HANDLER_GO_ON;
+	}
+
+	/* Check Accept-Encoding for supported encoding. */
+	if (NULL == (ds = (data_string *)array_get_element(con->request.headers, "Accept-Encoding"))) {
+		return HANDLER_GO_ON;
+	}
+		
+	/* get client side support encodings */
+	value = ds->value->ptr;
+#ifdef USE_ZLIB
+	if (NULL != strstr(value, "gzip")) accept_encoding |= HTTP_ACCEPT_ENCODING_GZIP;
+	if (NULL != strstr(value, "deflate")) accept_encoding |= HTTP_ACCEPT_ENCODING_DEFLATE;
+#endif
+	/* if (NULL != strstr(value, "compress")) accept_encoding |= HTTP_ACCEPT_ENCODING_COMPRESS; */
+#ifdef USE_BZ2LIB
+	if(p->conf.bzip2) {
+		if (NULL != strstr(value, "bzip2")) accept_encoding |= HTTP_ACCEPT_ENCODING_BZIP2;
+	}
+#endif
+	if (NULL != strstr(value, "identity")) accept_encoding |= HTTP_ACCEPT_ENCODING_IDENTITY;
+		
+	/* get server side supported ones */
+#ifdef USE_BZ2LIB
+	if(p->conf.bzip2) {
+		srv_encodings |= HTTP_ACCEPT_ENCODING_BZIP2;
+	}
+#endif
+#ifdef USE_ZLIB
+	srv_encodings |= HTTP_ACCEPT_ENCODING_GZIP;
+	srv_encodings |= HTTP_ACCEPT_ENCODING_DEFLATE;
+#endif
+		
+	/* find matching encodings */
+	matched_encodings = accept_encoding & srv_encodings;
+	if (!matched_encodings) {
+		return HANDLER_GO_ON;
+	}
+
+	/* check if size of response is below min-compress-size */
+	if(con->file_finished && con->request.http_method != HTTP_METHOD_HEAD) {
+		file_len = chunkqueue_length(con->write_queue);
+		if(file_len == 0) return HANDLER_GO_ON;
+	} else {
+		file_len = 0;
+	}
+	if(file_len > 0 && p->conf.min_compress_size > 0 && file_len < p->conf.min_compress_size) {
+		if(p->conf.debug) {
+			log_error_write(srv, __FILE__, __LINE__, "sd",
+					"Content-Length smaller then min_compress_size: file_len=", file_len);
+		}
+		return HANDLER_GO_ON;
+	}
+
+	/* Check mimetype in response header "Content-Type" */
+	if (NULL != (ds = (data_string *)array_get_element(con->response.headers, "Content-Type"))) {
+		int found = 0;
+		if(p->conf.debug) {
+			log_error_write(srv, __FILE__, __LINE__, "sb",
+					"Content-Type:", ds->value);
+		}
+		for (m = 0; m < p->conf.mimetypes->used; m++) {
+			data_string *mimetype = (data_string *)p->conf.mimetypes->data[m];
+
+			if(p->conf.debug) {
+				log_error_write(srv, __FILE__, __LINE__, "sb",
+						"mime-type:", mimetype->value);
+			}
+			if (buffer_is_equal(mimetype->value, ds->value)) {
+				/* mimetype found */
+				found = 1;
+				break;
+			}
+		}
+		if(!found && p->conf.mimetypes->used > 0) {
+			if(p->conf.debug) {
+				log_error_write(srv, __FILE__, __LINE__, "sb",
+						"No compression for mimetype:", ds->value);
+			}
+			return HANDLER_GO_ON;
+		}
+	}
+	
+	if(p->conf.debug) {
+		log_error_write(srv, __FILE__, __LINE__, "s",
+				"enable compression.");
+	}
+	/* enable compression */
+	hctx = handler_ctx_init();
+	hctx->plugin_data = p;
+
+	/* select best matching encoding */
+	if (matched_encodings & HTTP_ACCEPT_ENCODING_BZIP2) {
+		hctx->compression_type = HTTP_ACCEPT_ENCODING_BZIP2;
+		compression_name = dflt_bzip2;
+		rc = stream_bzip2_init(srv, con, hctx);
+	} else if (matched_encodings & HTTP_ACCEPT_ENCODING_GZIP) {
+		hctx->compression_type = HTTP_ACCEPT_ENCODING_GZIP;
+		compression_name = dflt_gzip;
+		rc = stream_deflate_init(srv, con, hctx);
+	} else if (matched_encodings & HTTP_ACCEPT_ENCODING_DEFLATE) {
+		hctx->compression_type = HTTP_ACCEPT_ENCODING_DEFLATE;
+		compression_name = dflt_deflate;
+		rc = stream_deflate_init(srv, con, hctx);
+	}
+	if(rc == -1) {
+		log_error_write(srv, __FILE__, __LINE__, "s",
+				"Failed to initialize compression.");
+	}
+	if(rc < 0) {
+		handler_ctx_free(hctx);
+		return HANDLER_GO_ON;
+	}
+
+	/* setup output buffer. */
+	if(p->conf.sync_flush || p->conf.output_buffer_size == 0) {
+		buffer_prepare_copy(p->tmp_buf, 32 * 1024);
+		hctx->output = p->tmp_buf;
+	} else {
+		hctx->output = buffer_init();
+		buffer_prepare_copy(hctx->output, p->conf.output_buffer_size);
+	}
+	con->plugin_ctx[p->id] = hctx;
+
+	/* set Content-Encoding to show selected compression type. */
+	response_header_overwrite(srv, con, CONST_STR_LEN("Content-Encoding"), compression_name, strlen(compression_name));
+
+	/* if file finished and size less then work-block-size, then compress the content now. */
+	if(con->file_finished && (p->conf.work_block_size == 0 || file_len < (p->conf.work_block_size * 1024)) &&
+			con->request.http_method != HTTP_METHOD_HEAD) {
+		/* We don't have to use chunked encoding. */
+		con->response.transfer_encoding = 0;
+		con->parsed_response &= ~(HTTP_CONTENT_LENGTH);
+		/* Compress all response content. */
+		if(p->conf.debug) {
+			log_error_write(srv, __FILE__, __LINE__, "sd",
+					"Compress all content and use Content-Length header: uncompress len=", file_len);
+		}
+		return deflate_compress_response(srv, con, hctx, 1);
+	} else {
+		/* Remove Content-Length header.  We don't know the length. */
+		con->parsed_response &= ~(HTTP_CONTENT_LENGTH);
+		if (con->request.http_version == HTTP_VERSION_1_1) {
+			/* Make sure to use chunked encoding. */
+			con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
+			/* Remove Content-Length header.  We don't know the length. */
+			con->parsed_response &= ~(HTTP_CONTENT_LENGTH);
+		} else {
+			/* HTTP/1.0 doesn't support chunked transfer encoding. */
+			con->response.transfer_encoding = 0;
+			return deflate_compress_response(srv, con, hctx, 1);
+		}
+	}
+
+	return HANDLER_GO_ON;
+}
+
+JOBLIST_FUNC(mod_deflate_handle_response_filter) {
+	plugin_data *p = p_d;
+	handler_ctx *hctx = con->plugin_ctx[p->id];
+
+	if(hctx == NULL) return HANDLER_GO_ON;
+	if(!hctx->stream_open) return HANDLER_GO_ON;
+	if(con->request.http_method == HTTP_METHOD_HEAD) return HANDLER_GO_ON;
+
+	return deflate_compress_response(srv, con, hctx, 0);
+}
+
+handler_t mod_deflate_cleanup(server *srv, connection *con, void *p_d) {
+	plugin_data *p = p_d;
+	handler_ctx *hctx = con->plugin_ctx[p->id];
+
+	if(hctx == NULL) return HANDLER_GO_ON;
+
+	if(p->conf.debug && hctx->stream_open) {
+		log_error_write(srv, __FILE__, __LINE__, "sbsb",
+				"stream open at cleanup. uri=", con->uri.path_raw, ", query=", con->uri.query);
+	}
+
+	deflate_compress_cleanup(srv, con, hctx);
+
+	return HANDLER_GO_ON;
+}
+
+int mod_deflate_plugin_init(plugin *p) {
+	p->version     = LIGHTTPD_VERSION_ID;
+	p->name        = buffer_init_string("deflate");
+	
+	p->init					= mod_deflate_init;
+	p->cleanup			= mod_deflate_free;
+	p->set_defaults	= mod_deflate_setdefaults;
+	p->connection_reset					= mod_deflate_cleanup;
+	p->handle_connection_close	= mod_deflate_cleanup;
+	p->handle_response_start		= mod_deflate_handle_response_start;
+	p->handle_response_filter		= mod_deflate_handle_response_filter;
+	
+	p->data        = NULL;
+	
+	return 0;
+}
diff -Naur lighttpd-1.4.10.orig/src/plugin.c lighttpd-1.4.10/src/plugin.c
--- lighttpd-1.4.10.orig/src/plugin.c	2006-02-08 04:00:54.000000000 -0800
+++ lighttpd-1.4.10/src/plugin.c	2006-02-16 22:25:16.514345356 -0800
@@ -40,6 +40,8 @@
 		PLUGIN_FUNC_HANDLE_SIGHUP,
 		PLUGIN_FUNC_HANDLE_SUBREQUEST,
 		PLUGIN_FUNC_HANDLE_SUBREQUEST_START,
+		PLUGIN_FUNC_HANDLE_RESPONSE_START,
+		PLUGIN_FUNC_HANDLE_RESPONSE_FILTER,
 		PLUGIN_FUNC_HANDLE_JOBLIST,
 		PLUGIN_FUNC_HANDLE_DOCROOT,
 		PLUGIN_FUNC_HANDLE_PHYSICAL,
@@ -266,6 +268,8 @@
 PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_CONNECTION_CLOSE, handle_connection_close)
 PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST, handle_subrequest)
 PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST_START, handle_subrequest_start)
+PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_START, handle_response_start)
+PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_FILTER, handle_response_filter)
 PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_JOBLIST, handle_joblist)
 PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_DOCROOT, handle_docroot)
 PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_PHYSICAL, handle_physical)
@@ -395,6 +399,8 @@
 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SIGHUP, handle_sighup);
 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST, handle_subrequest);
 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST_START, handle_subrequest_start);
+		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_START, handle_response_start);
+		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_FILTER, handle_response_filter);
 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_JOBLIST, handle_joblist);
 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_DOCROOT, handle_docroot);
 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_PHYSICAL, handle_physical);
diff -Naur lighttpd-1.4.10.orig/src/plugin.h lighttpd-1.4.10/src/plugin.h
--- lighttpd-1.4.10.orig/src/plugin.h	2005-08-15 02:28:56.000000000 -0700
+++ lighttpd-1.4.10/src/plugin.h	2006-02-16 22:25:16.514345356 -0800
@@ -54,6 +54,8 @@
 											    * has to be found
 											    */
 	handler_t (* handle_subrequest)      (server *srv, connection *con, void *p_d);    /* */
+	handler_t (* handle_response_start)  (server *srv, connection *con, void *p_d);    /* before response headers are written */
+	handler_t (* handle_response_filter) (server *srv, connection *con, void *p_d);    /* response content filter */
 	handler_t (* connection_reset)       (server *srv, connection *con, void *p_d);    /* */
 	void *data;
 	
@@ -68,6 +70,8 @@
 handler_t plugins_call_handle_uri_clean(server *srv, connection *con);
 handler_t plugins_call_handle_subrequest_start(server *srv, connection *con);
 handler_t plugins_call_handle_subrequest(server *srv, connection *con);
+handler_t plugins_call_handle_response_start(server *srv, connection *con);
+handler_t plugins_call_handle_response_filter(server *srv, connection *con);
 handler_t plugins_call_handle_request_done(server *srv, connection *con);
 handler_t plugins_call_handle_docroot(server *srv, connection *con);
 handler_t plugins_call_handle_physical(server *srv, connection *con);
diff -Naur lighttpd-1.4.10.orig/src/response.c lighttpd-1.4.10/src/response.c
--- lighttpd-1.4.10.orig/src/response.c	2006-02-08 04:01:01.000000000 -0800
+++ lighttpd-1.4.10/src/response.c	2006-02-16 22:25:16.515345187 -0800
@@ -31,7 +31,7 @@
 	int have_date = 0;
 	int have_server = 0;
 	
-	b = chunkqueue_get_prepend_buffer(con->write_queue);
+	b = chunkqueue_get_prepend_buffer(con->output_queue);
 	
 	if (con->request.http_version == HTTP_VERSION_1_1) {
 		BUFFER_COPY_STRING_CONST(b, "HTTP/1.1 ");
diff -Naur lighttpd-1.4.10.orig/src/server.c lighttpd-1.4.10/src/server.c
--- lighttpd-1.4.10.orig/src/server.c	2006-02-01 03:50:02.000000000 -0800
+++ lighttpd-1.4.10/src/server.c	2006-02-16 22:25:16.516345019 -0800
@@ -173,6 +173,9 @@
 	srv->joblist = calloc(1, sizeof(*srv->joblist));
 	assert(srv->joblist);
 	
+	srv->joblist_prev = calloc(1, sizeof(*srv->joblist));
+	assert(srv->joblist_prev);
+
 	srv->fdwaitqueue = calloc(1, sizeof(*srv->fdwaitqueue));
 	assert(srv->fdwaitqueue);
 	
@@ -259,6 +262,7 @@
 #undef CLEAN
 	
 	joblist_free(srv, srv->joblist);
+	joblist_free(srv, srv->joblist_prev);
 	fdwaitqueue_free(srv, srv->fdwaitqueue);
 	
 	if (srv->stat_cache) {
@@ -1016,6 +1020,7 @@
 	/* main-loop */
 	while (!srv_shutdown) {
 		int n;
+		int timeout;
 		size_t ndx;
 		time_t min_ts;
 		
@@ -1243,7 +1248,12 @@
 			}
 		}
 
-		if ((n = fdevent_poll(srv->ev, 1000)) > 0) {
+		if(srv->joblist->used > 0) {
+			timeout = 500;
+		} else {
+			timeout = 1000;
+		}
+		if ((n = fdevent_poll(srv->ev, timeout)) > 0) {
 			/* n is the number of events */
 			int revents;
 			int fd_ndx;
@@ -1291,25 +1301,29 @@
 					strerror(errno));
 		}
 		
-		for (ndx = 0; ndx < srv->joblist->used; ndx++) {
-			connection *con = srv->joblist->ptr[ndx];
-			handler_t r;
-			
-			connection_state_machine(srv, con);
-			
-			switch(r = plugins_call_handle_joblist(srv, con)) {
-			case HANDLER_FINISHED:
-			case HANDLER_GO_ON:
-				break;
-			default:
-				log_error_write(srv, __FILE__, __LINE__, "d", r);
-				break;
+		if(srv->joblist->used > 0) {
+			connections *joblist = srv->joblist;
+			/* switch joblist queues. */
+			srv->joblist = srv->joblist_prev;
+			srv->joblist_prev = joblist;
+			for (ndx = 0; ndx < joblist->used; ndx++) {
+				connection *con = joblist->ptr[ndx];
+				handler_t r;
+
+				con->in_joblist = 0;
+				connection_state_machine(srv, con);
+
+				switch(r = plugins_call_handle_joblist(srv, con)) {
+				case HANDLER_FINISHED:
+				case HANDLER_GO_ON:
+					break;
+				default:
+					log_error_write(srv, __FILE__, __LINE__, "d", r);
+					break;
+				}
 			}
-			
-			con->in_joblist = 0;
+			joblist->used = 0;
 		}
-		
-		srv->joblist->used = 0;
 	}
 	
 	if (srv->srvconf.pid_file->used &&