Attachment #128139 for bug #188940

View | Details | Raw Unified | Return to bug 188940
Collapse All | Expand All

Lines 538-544 Link Here

(-)lighttpd-1.4.13/configure.in (-1 / +1 lines)
538	AC_OUTPUT	538	AC_OUTPUT
539		539
540		540
541	do_build="mod_cgi mod_fastcgi mod_proxy mod_evhost mod_simple_vhost mod_access mod_alias mod_setenv mod_usertrack mod_auth mod_status mod_accesslog mod_rrdtool mod_secdownload mod_expire mod_compress mod_dirlisting mod_indexfiles mod_userdir mod_webdav mod_staticfile mod_scgi mod_flv_streaming"	541	do_build="mod_cgi mod_fastcgi mod_proxy mod_evhost mod_simple_vhost mod_access mod_alias mod_setenv mod_usertrack mod_auth mod_status mod_accesslog mod_rrdtool mod_secdownload mod_expire mod_compress mod_dirlisting mod_indexfiles mod_userdir mod_webdav mod_staticfile mod_scgi mod_flv_streaming mod_deflate"
542		542
543	plugins="mod_rewrite mod_redirect mod_ssi mod_trigger_b4_dl"	543	plugins="mod_rewrite mod_redirect mod_ssi mod_trigger_b4_dl"
544	features="regex-conditionals"	544	features="regex-conditionals"





	http_method_t  http_method;
	http_version_t http_version;
	int true_http_10_client;

	buffer *request_line;



	int file_started;
	int file_finished;
	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 ] */
	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 ]*/



	connections *conns;
	connections *joblist;
	connections *joblist_prev;
	connections *fdwaitqueue;

	stat_cache  *stat_cache;




#include <errno.h>
#include <string.h>

#include "server.h"
#include "chunk.h"
#include "log.h"

chunkqueue *chunkqueue_init(void) {
	chunkqueue *cq;

	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;



	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;
}


Lines 52-57 Link Here

(-)lighttpd-1.4.13/src/chunk.h (+7 lines)
52	int chunkqueue_append_mem(chunkqueue c, const char mem, size_t len);	52	int chunkqueue_append_mem(chunkqueue c, const char mem, size_t len);
53	int chunkqueue_append_buffer(chunkqueue c, buffer mem);	53	int chunkqueue_append_buffer(chunkqueue c, buffer mem);
54	int chunkqueue_append_buffer_weak(chunkqueue c, buffer mem);	54	int chunkqueue_append_buffer_weak(chunkqueue c, buffer mem);
		55	int chunkqueue_append_chunkqueue(chunkqueue cq, chunkqueue src);
55	int chunkqueue_prepend_buffer(chunkqueue c, buffer mem);	56	int chunkqueue_prepend_buffer(chunkqueue c, buffer mem);
56		57
57	buffer * chunkqueue_get_append_buffer(chunkqueue *c);	58	buffer * chunkqueue_get_append_buffer(chunkqueue *c);
Lines 67-70 Link Here
67		68
68	int chunkqueue_is_empty(chunkqueue *c);	69	int chunkqueue_is_empty(chunkqueue *c);
69		70
		71	int chunk_encode_append_mem(chunkqueue cq, const char mem, size_t len);
		72	int chunk_encode_append_buffer(chunkqueue cq, buffer mem);
		73	int chunk_encode_append_file(chunkqueue cq, buffer fn, off_t offset, off_t len);
		74	int chunk_encode_append_queue(chunkqueue cq, chunkqueue src);
		75	int chunk_encode_end(chunkqueue *cq);
		76
70	#endif	77	#endif

Lines 18-23 Link Here

(-)lighttpd-1.4.13/src/connections.c (-10 / +85 lines)
18	#include "response.h"	18	#include "response.h"
19	#include "network.h"	19	#include "network.h"
20	#include "http_chunk.h"	20	#include "http_chunk.h"
		21	#include "chunk.h"
21	#include "stat_cache.h"	22	#include "stat_cache.h"
22	#include "joblist.h"	23	#include "joblist.h"
23		24
Lines 146-151 Link Here
146	return 0;	147	return 0;
147	}	148	}
148		149
		150	int connection_queue_is_empty(connection *con) {
		151	if(!chunkqueue_is_empty(con->write_queue)) return 0;
		152	if(!chunkqueue_is_empty(con->output_queue)) return 0;
		153	return 1;
		154	}
		155
149	#if 0	156	#if 0
150	static void dump_packet(const unsigned char *data, size_t len) {	157	static void dump_packet(const unsigned char *data, size_t len) {
151	size_t i, j;	158	size_t i, j;
Lines 402-407 Link Here
402	con->file_finished = 1;	409	con->file_finished = 1;
403		410
404	chunkqueue_reset(con->write_queue);	411	chunkqueue_reset(con->write_queue);
		412	chunkqueue_reset(con->output_queue);
405	}	413	}
406	break;	414	break;
407	default:	415	default:
Lines 512-523 Link Here
512	/* disable chunked encoding again as we have no body */	520	/* disable chunked encoding again as we have no body */
513	con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;	521	con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;
514	chunkqueue_reset(con->write_queue);	522	chunkqueue_reset(con->write_queue);
		523	chunkqueue_reset(con->output_queue);
515		524
516	con->file_finished = 1;	525	con->file_finished = 1;
517	break;	526	break;
518	}	527	}
519		528
520		529
		530	/* Allow filter plugins to change response headers before they are written. */
		531	switch(plugins_call_handle_response_start(srv, con)) {
		532	case HANDLER_GO_ON:
		533	case HANDLER_FINISHED:
		534	/* response start is finished */
		535	break;
		536	default:
		537	/* something strange happend */
		538	log_error_write(srv, __FILE__, __LINE__, "s", "Filter plugin failed.");
		539	connection_set_state(srv, con, CON_STATE_ERROR);
		540	joblist_append(srv, con);
		541	break;
		542	}
		543
521	if (con->file_finished) {	544	if (con->file_finished) {
522	/* we have all the content and chunked encoding is not used, set a content-length */	545	/* we have all the content and chunked encoding is not used, set a content-length */
523		546
Lines 568-573 Link Here
568	* without the content	591	* without the content
569	*/	592	*/
570	chunkqueue_reset(con->write_queue);	593	chunkqueue_reset(con->write_queue);
		594	chunkqueue_reset(con->output_queue);
571	con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;	595	con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;
572	}	596	}
573		597
Lines 577-587 Link Here
577	}	601	}
578		602
579	static int connection_handle_write(server srv, connection con) {	603	static int connection_handle_write(server srv, connection con) {
580	switch(network_write_chunkqueue(srv, con, con->write_queue)) {	604	int finished = 0;
		605	int len;
		606
		607	/* Allow filter plugins to modify response conent */
		608	switch(plugins_call_handle_response_filter(srv, con)) {
		609	case HANDLER_GO_ON:
		610	finished = con->file_finished;
		611	/* response content not changed */
		612	break;
		613	case HANDLER_COMEBACK:
		614	/* response filter has more work */
		615	finished = 0;
		616	break;
		617	case HANDLER_FINISHED:
		618	/* response filter is finished */
		619	finished = 1;
		620	break;
		621	default:
		622	/* something strange happend */
		623	log_error_write(srv, __FILE__, __LINE__, "s", "Filter plugin failed.");
		624	connection_set_state(srv, con, CON_STATE_ERROR);
		625	joblist_append(srv, con);
		626	finished = 1;
		627	break;
		628	}
		629
		630	/* move chunks from write_queue to output_queue. */
		631	if (con->request.http_method == HTTP_METHOD_HEAD) {
		632	chunkqueue_reset(con->write_queue);
		633	} else {
		634	len = chunkqueue_length(con->write_queue);
		635	if(con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
		636	chunk_encode_append_queue(con->output_queue, con->write_queue);
		637	if(finished && !con->end_chunk) {
		638	con->end_chunk = 1;
		639	chunk_encode_end(con->output_queue);
		640	}
		641	} else {
		642	chunkqueue_append_chunkqueue(con->output_queue, con->write_queue);
		643	}
		644	con->write_queue->bytes_out += len;
		645	}
		646	/* write chunks from output_queue to network */
		647	switch(network_write_chunkqueue(srv, con, con->output_queue)) {
581	case 0:	648	case 0:
582	if (con->file_finished) {	649	if (finished) {
583	connection_set_state(srv, con, CON_STATE_RESPONSE_END);	650	connection_set_state(srv, con, CON_STATE_RESPONSE_END);
584	joblist_append(srv, con);	651	joblist_append(srv, con);
		652	} else {
		653	/* not finished yet -> WRITE */
		654	con->is_writable = 1;
585	}	655	}
586	break;	656	break;
587	case -1: /* error on our side */	657	case -1: /* error on our side */
Lines 651-656 Link Here
651		721
652	#undef CLEAN	722	#undef CLEAN
653	con->write_queue = chunkqueue_init();	723	con->write_queue = chunkqueue_init();
		724	con->output_queue = chunkqueue_init();
654	con->read_queue = chunkqueue_init();	725	con->read_queue = chunkqueue_init();
655	con->request_content_queue = chunkqueue_init();	726	con->request_content_queue = chunkqueue_init();
656	chunkqueue_set_tempdirs(con->request_content_queue, srv->srvconf.upload_tempdirs);	727	chunkqueue_set_tempdirs(con->request_content_queue, srv->srvconf.upload_tempdirs);
Lines 679-684 Link Here
679	connection_reset(srv, con);	750	connection_reset(srv, con);
680		751
681	chunkqueue_free(con->write_queue);	752	chunkqueue_free(con->write_queue);
		753	chunkqueue_free(con->output_queue);
682	chunkqueue_free(con->read_queue);	754	chunkqueue_free(con->read_queue);
683	chunkqueue_free(con->request_content_queue);	755	chunkqueue_free(con->request_content_queue);
684	array_free(con->request.headers);	756	array_free(con->request.headers);
Lines 733-739 Link Here
733	con->http_status = 0;	805	con->http_status = 0;
734	con->file_finished = 0;	806	con->file_finished = 0;
735	con->file_started = 0;	807	con->file_started = 0;
		808	con->end_chunk = 0;
736	con->got_response = 0;	809	con->got_response = 0;
		810	// con->use_cache_file = 0;
		811	// con->write_cache_file = 0;
737		812
738	con->parsed_response = 0;	813	con->parsed_response = 0;
739		814
Lines 803-808 Link Here
803	array_reset(con->environment);	878	array_reset(con->environment);
804		879
805	chunkqueue_reset(con->write_queue);	880	chunkqueue_reset(con->write_queue);
		881	chunkqueue_reset(con->output_queue);
806	chunkqueue_reset(con->request_content_queue);	882	chunkqueue_reset(con->request_content_queue);
807		883
808	/* the plugins should cleanup themself */	884	/* the plugins should cleanup themself */
Lines 1203-1209 Link Here
1203	}	1279	}
1204		1280
1205	if (con->state == CON_STATE_WRITE &&	1281	if (con->state == CON_STATE_WRITE &&
1206	!chunkqueue_is_empty(con->write_queue) &&
1207	con->is_writable) {	1282	con->is_writable) {
1208		1283
1209	if (-1 == connection_handle_write(srv, con)) {	1284	if (-1 == connection_handle_write(srv, con)) {
Lines 1606-1620 Link Here
1606	}	1681	}
1607		1682
1608	/* only try to write if we have something in the queue */	1683	/* only try to write if we have something in the queue */
1609	if (!chunkqueue_is_empty(con->write_queue)) {
1610	#if 0	1684	#if 0
		1685	if (!connection_queue_is_empty(con)) {
1611	log_error_write(srv, __FILE__, __LINE__, "dsd",	1686	log_error_write(srv, __FILE__, __LINE__, "dsd",
1612	con->fd,	1687	con->fd,
1613	"packets to write:",	1688	"packets to write:",
1614	con->write_queue->used);	1689	con->output_queue->used);
1615	#endif
1616	}	1690	}
1617	if (!chunkqueue_is_empty(con->write_queue) && con->is_writable) {	1691	#endif
		1692	if (con->is_writable) {
1618	if (-1 == connection_handle_write(srv, con)) {	1693	if (-1 == connection_handle_write(srv, con)) {
1619	log_error_write(srv, __FILE__, __LINE__, "ds",	1694	log_error_write(srv, __FILE__, __LINE__, "ds",
1620	con->fd,	1695	con->fd,
Lines 1724-1732 Link Here
1724	* - if we have data to write	1799	* - if we have data to write
1725	* - if the socket is not writable yet	1800	* - if the socket is not writable yet
1726	*/	1801	*/
1727	if (!chunkqueue_is_empty(con->write_queue) &&	1802	if ((con->is_writable == 0) &&
1728	(con->is_writable == 0) &&	1803	(con->traffic_limit_reached == 0) &&
1729	(con->traffic_limit_reached == 0)) {	1804	!connection_queue_is_empty(con)) {
1730	fdevent_event_add(srv->ev, &(con->fde_ndx), con->fd, FDEVENT_OUT);	1805	fdevent_event_add(srv->ev, &(con->fde_ndx), con->fd, FDEVENT_OUT);
1731	} else {	1806	} else {
1732	fdevent_event_del(srv->ev, &(con->fde_ndx), con->fd);	1807	fdevent_event_del(srv->ev, &(con->fde_ndx), con->fd);





	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;
}



	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;
}


	cq = con->write_queue;

	if (len == 0) {
		if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
			chunkqueue_append_mem(cq, "0\r\n\r\n", 5 + 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;
}


Lines 7-12 Link Here

(-)lighttpd-1.4.13/src/joblist.c (+1 lines)
7		7
8	int joblist_append(server srv, connection con) {	8	int joblist_append(server srv, connection con) {
9	if (con->in_joblist) return 0;	9	if (con->in_joblist) return 0;
		10	con->in_joblist = 1;
10		11
11	if (srv->joblist->size == 0) {	12	if (srv->joblist->size == 0) {
12	srv->joblist->size = 16;	13	srv->joblist->size = 16;

Lines 234-239 Link Here

(-)lighttpd-1.4.13/src/Makefile.am (+5 lines)
234	mod_accesslog_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined	234	mod_accesslog_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
235	mod_accesslog_la_LIBADD = $(common_libadd)	235	mod_accesslog_la_LIBADD = $(common_libadd)
236		236
		237	lib_LTLIBRARIES += mod_deflate.la
		238	mod_deflate_la_SOURCES = mod_deflate.c
		239	mod_deflate_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
		240	mod_deflate_la_LIBADD = $(Z_LIB) $(BZ_LIB) $(common_libadd)
		241
237		242
238	hdr = server.h buffer.h network.h log.h keyvalue.h \	243	hdr = server.h buffer.h network.h log.h keyvalue.h \
239	response.h request.h fastcgi.h chunk.h \	244	response.h request.h fastcgi.h chunk.h \




/* 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;
	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 (hctx->bytes_in < hctx->bytes_out) {
		log_error_write(srv, __FILE__, __LINE__, "sbsdsd",
				"uri ", con->uri.path_raw, " in=", hctx->bytes_in, " smaller than out=", hctx->bytes_out);
	}

	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 rc=-1;
	int close_stream = 0, len = 0;
	unsigned int out = 0, 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);
#if defined(HAVE_PCRE_H)
	PATCH(nocompress_regex);
#endif	
	
	/* 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);
			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.nocompress-url"))) {
#if defined(HAVE_PCRE_H)
				PATCH(nocompress_regex);
#endif
			}
		}
	}
	
	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;
	int end = 0;
	size_t m;
#if defined(HAVE_PCRE_H)
	int n;
# define N 10
	int ovec[N * 3];
#endif
	
	/* 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;
	}

#if defined(HAVE_PCRE_H)
	if(p->conf.nocompress_regex) { /*check no compress regex now */
		if ((n = pcre_exec(p->conf.nocompress_regex, NULL, con->uri.path->ptr, con->uri.path->used - 1, 0, 0, ovec, 3 * N)) < 0) {
			if (n != PCRE_ERROR_NOMATCH) {
			       	log_error_write(srv, __FILE__, __LINE__, "sd",
					"execution error while matching:", n);
			       	return HANDLER_ERROR;
		       	}
	       	} else {
			if(p->conf.debug) {
			       	log_error_write(srv, __FILE__, __LINE__, "sb", "no compress for url:", con->uri.path);
		       	}
		       	return HANDLER_GO_ON;
	       	}
	}
#endif
	/* 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;
	}

	if (con->request.true_http_10_client) { 
		/*disable gzip/bzip2 when we meet HTTP 1.0 client with Accept-Encoding
		 * maybe old buggy proxy server
		 */
		/* most of buggy clients are Yahoo Slurp;) */
		if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "ss",
				"Buggy HTTP 1.0 client sending Accept Encoding: gzip, deflate", 
				(char *) inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
		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 (strncmp(mimetype->value->ptr, ds->value->ptr, mimetype->value->used-1) == 0) {
/*			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 0
		if(strncasecmp(ds->value->ptr, "application/x-javascript", 24) == 0) {
			/*reset compress type to deflate for javascript
			 * prevent buggy IE6 SP1 doesn't work for js in IFrame
			 */
			matched_encodings = HTTP_ACCEPT_ENCODING_DEFLATE;
		}
#endif
	}
	
	if(p->conf.debug) {
		log_error_write(srv, __FILE__, __LINE__, "sb",
				"enable compression for ", con->uri.path);
	}

	/* 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");
			if (p->conf.debug) {
				log_error_write(srv, __FILE__, __LINE__, "sb",
						"appending ,Accept-Encoding for ", con->uri.path);
			}
		}
	} else {
		if (p->conf.debug) {
			log_error_write(srv, __FILE__, __LINE__, "sb",
					"add Vary: Accept-Encoding for ", con->uri.path);
		}
		response_header_insert(srv, con, CONST_STR_LEN("Vary"),
				CONST_STR_LEN("Accept-Encoding"));
	}

	/* 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 (con->file_finished)	end = 1;

	con->parsed_response &= ~(HTTP_CONTENT_LENGTH); 
#if 0
	/* debug */
	if (con->parsed_response & HTTP_TRANSFER_ENCODING_CHUNKED)
		log_error_write(srv, __FILE__, __LINE__, "s",
			"deflate: response with chunked encoding");
	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED)
		log_error_write(srv, __FILE__, __LINE__, "s",
			"deflate: transfer encoding with chunked encoding");
#endif

	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) {
		/* disable chunk transfer */
		con->response.transfer_encoding = 0; 
		con->parsed_response &= ~(HTTP_TRANSFER_ENCODING_CHUNKED);
		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, end); 
	} else {
		if (con->request.http_version == HTTP_VERSION_1_1) {
			if (p->conf.debug) 
				log_error_write(srv, __FILE__, __LINE__, "sb",
					"chunk transfer encoding for uri", con->uri.path);
			/* Make sure to use chunked encoding. */
			con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED; 
		} else {
			if (p->conf.debug) 
				log_error_write(srv, __FILE__, __LINE__, "sb",
					"http 1.0 encoding for uri", con->uri.path);
			/* We don't have to use chunked encoding because HTTP 1.0 don't support it. */
			con->response.transfer_encoding = 0;
			con->parsed_response &= ~(HTTP_TRANSFER_ENCODING_CHUNKED);
		}
	}

	if (p->conf.debug) 
		log_error_write(srv, __FILE__, __LINE__, "sdsb", "end =", end, "for uri", con->uri.path);

	deflate_compress_response(srv, con, hctx, end);
	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;
}

Lines 40-45 Link Here

(-)lighttpd-1.4.13/src/plugin.c (+6 lines)
40	PLUGIN_FUNC_HANDLE_SIGHUP,	40	PLUGIN_FUNC_HANDLE_SIGHUP,
41	PLUGIN_FUNC_HANDLE_SUBREQUEST,	41	PLUGIN_FUNC_HANDLE_SUBREQUEST,
42	PLUGIN_FUNC_HANDLE_SUBREQUEST_START,	42	PLUGIN_FUNC_HANDLE_SUBREQUEST_START,
		43	PLUGIN_FUNC_HANDLE_RESPONSE_START,
		44	PLUGIN_FUNC_HANDLE_RESPONSE_FILTER,
43	PLUGIN_FUNC_HANDLE_JOBLIST,	45	PLUGIN_FUNC_HANDLE_JOBLIST,
44	PLUGIN_FUNC_HANDLE_DOCROOT,	46	PLUGIN_FUNC_HANDLE_DOCROOT,
45	PLUGIN_FUNC_HANDLE_PHYSICAL,	47	PLUGIN_FUNC_HANDLE_PHYSICAL,
Lines 266-271 Link Here
266	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_CONNECTION_CLOSE, handle_connection_close)	268	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_CONNECTION_CLOSE, handle_connection_close)
267	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST, handle_subrequest)	269	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST, handle_subrequest)
268	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST_START, handle_subrequest_start)	270	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST_START, handle_subrequest_start)
		271	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_START, handle_response_start)
		272	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_FILTER, handle_response_filter)
269	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_JOBLIST, handle_joblist)	273	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_JOBLIST, handle_joblist)
270	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_DOCROOT, handle_docroot)	274	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_DOCROOT, handle_docroot)
271	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_PHYSICAL, handle_physical)	275	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_PHYSICAL, handle_physical)
Lines 395-400 Link Here
395	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SIGHUP, handle_sighup);	399	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SIGHUP, handle_sighup);
396	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST, handle_subrequest);	400	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST, handle_subrequest);
397	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST_START, handle_subrequest_start);	401	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST_START, handle_subrequest_start);
		402	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_START, handle_response_start);
		403	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_RESPONSE_FILTER, handle_response_filter);
398	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_JOBLIST, handle_joblist);	404	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_JOBLIST, handle_joblist);
399	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_DOCROOT, handle_docroot);	405	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_DOCROOT, handle_docroot);
400	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_PHYSICAL, handle_physical);	406	PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_PHYSICAL, handle_physical);

Lines 54-59 Link Here

(-)lighttpd-1.4.13/src/plugin.h (+4 lines)
54	* has to be found	54	* has to be found
55	*/	55	*/
56	handler_t (* handle_subrequest) (server srv, connection con, void p_d); / */	56	handler_t (* handle_subrequest) (server srv, connection con, void p_d); / */
		57	handler_t (* handle_response_start) (server srv, connection con, void p_d); / before response headers are written */
		58	handler_t (* handle_response_filter) (server srv, connection con, void p_d); / response content filter */
57	handler_t (* connection_reset) (server srv, connection con, void p_d); / */	59	handler_t (* connection_reset) (server srv, connection con, void p_d); / */
58	void *data;	60	void *data;
59		61
Lines 68-73 Link Here
68	handler_t plugins_call_handle_uri_clean(server srv, connection con);	70	handler_t plugins_call_handle_uri_clean(server srv, connection con);
69	handler_t plugins_call_handle_subrequest_start(server srv, connection con);	71	handler_t plugins_call_handle_subrequest_start(server srv, connection con);
70	handler_t plugins_call_handle_subrequest(server srv, connection con);	72	handler_t plugins_call_handle_subrequest(server srv, connection con);
		73	handler_t plugins_call_handle_response_start(server srv, connection con);
		74	handler_t plugins_call_handle_response_filter(server srv, connection con);
71	handler_t plugins_call_handle_request_done(server srv, connection con);	75	handler_t plugins_call_handle_request_done(server srv, connection con);
72	handler_t plugins_call_handle_docroot(server srv, connection con);	76	handler_t plugins_call_handle_docroot(server srv, connection con);
73	handler_t plugins_call_handle_physical(server srv, connection con);	77	handler_t plugins_call_handle_physical(server srv, connection con);

Lines 414-421 Link Here

(-)lighttpd-1.4.13/src/request.c (+2 lines)
414		414
415	if (major_num == 1 && minor_num == 1) {	415	if (major_num == 1 && minor_num == 1) {
416	con->request.http_version = con->conf.allow_http11 ? HTTP_VERSION_1_1 : HTTP_VERSION_1_0;	416	con->request.http_version = con->conf.allow_http11 ? HTTP_VERSION_1_1 : HTTP_VERSION_1_0;
		417	con->request.true_http_10_client = 0;
417	} else if (major_num == 1 && minor_num == 0) {	418	} else if (major_num == 1 && minor_num == 0) {
418	con->request.http_version = HTTP_VERSION_1_0;	419	con->request.http_version = HTTP_VERSION_1_0;
		420	con->request.true_http_10_client = 1;
419	} else {	421	} else {
420	con->http_status = 505;	422	con->http_status = 505;
421		423

Lines 31-37 Link Here

(-)lighttpd-1.4.13/src/response.c (-2 / +14 lines)
31	int have_date = 0;	31	int have_date = 0;
32	int have_server = 0;	32	int have_server = 0;
33		33
34	b = chunkqueue_get_prepend_buffer(con->write_queue);	34	b = chunkqueue_get_prepend_buffer(con->output_queue);
35		35
36	if (con->request.http_version == HTTP_VERSION_1_1) {	36	if (con->request.http_version == HTTP_VERSION_1_1) {
37	BUFFER_COPY_STRING_CONST(b, "HTTP/1.1 ");	37	BUFFER_COPY_STRING_CONST(b, "HTTP/1.1 ");
Lines 48-53 Link Here
48	}	48	}
49		49
50	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {	50	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
		51	/* if (!(con->parsed_response & HTTP_TRANSFER_ENCODING_CHUNKED) &&
		52	(con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED)) { */
51	BUFFER_APPEND_STRING_CONST(b, "\r\nTransfer-Encoding: chunked");	53	BUFFER_APPEND_STRING_CONST(b, "\r\nTransfer-Encoding: chunked");
52	}	54	}
53		55
Lines 63-68 Link Here
63	if (buffer_is_equal_string(ds->key, CONST_STR_LEN("Date"))) have_date = 1;	65	if (buffer_is_equal_string(ds->key, CONST_STR_LEN("Date"))) have_date = 1;
64	if (buffer_is_equal_string(ds->key, CONST_STR_LEN("Server"))) have_server = 1;	66	if (buffer_is_equal_string(ds->key, CONST_STR_LEN("Server"))) have_server = 1;
65		67
		68	/* remove Transfer-Encoding: chunked header when HTTP 1.0
		69	* or transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED == 0
		70	*/
		71	if ( (con->request.http_version == HTTP_VERSION_1_0 \|\|
		72	!(con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED)) &&
		73	0 == strncasecmp(ds->value->ptr, "chunked", sizeof("chunked")-1) &&
		74	0 == strncasecmp(ds->key->ptr, "Transfer-Encoding", sizeof("Transfer-Encoding") - 1)) {
		75	continue ;
		76	}
		77
66	BUFFER_APPEND_STRING_CONST(b, "\r\n");	78	BUFFER_APPEND_STRING_CONST(b, "\r\n");
67	buffer_append_string_buffer(b, ds->key);	79	buffer_append_string_buffer(b, ds->key);
68	BUFFER_APPEND_STRING_CONST(b, ": ");	80	BUFFER_APPEND_STRING_CONST(b, ": ");
Lines 569-575 Link Here
569	}	581	}
570		582
571	if (slash) pathinfo = slash;	583	if (slash) pathinfo = slash;
572	} while ((found == 0) && (slash != NULL) && ((size_t)(slash - srv->tmp_buf->ptr) > (con->physical.basedir->used - 2)));	584	} while ((found == 0) && (slash != NULL) && ((size_t)(slash - srv->tmp_buf->ptr) > con->physical.basedir->used - 2));
573		585
574	if (found == 0) {	586	if (found == 0) {
575	/* no it really doesn't exists */	587	/* no it really doesn't exists */

Lines 175-180 Link Here

(-)lighttpd-1.4.13/src/server.c (-7 / +21 lines)
175	srv->joblist = calloc(1, sizeof(*srv->joblist));	175	srv->joblist = calloc(1, sizeof(*srv->joblist));
176	assert(srv->joblist);	176	assert(srv->joblist);
177		177
		178	srv->joblist_prev = calloc(1, sizeof(*srv->joblist));
		179	assert(srv->joblist_prev);
		180
178	srv->fdwaitqueue = calloc(1, sizeof(*srv->fdwaitqueue));	181	srv->fdwaitqueue = calloc(1, sizeof(*srv->fdwaitqueue));
179	assert(srv->fdwaitqueue);	182	assert(srv->fdwaitqueue);
180		183
Lines 266-271 Link Here
266	#undef CLEAN	269	#undef CLEAN
267		270
268	joblist_free(srv, srv->joblist);	271	joblist_free(srv, srv->joblist);
		272	joblist_free(srv, srv->joblist_prev);
269	fdwaitqueue_free(srv, srv->fdwaitqueue);	273	fdwaitqueue_free(srv, srv->fdwaitqueue);
270		274
271	if (srv->stat_cache) {	275	if (srv->stat_cache) {
Lines 1038-1043 Link Here
1038	/* main-loop */	1042	/* main-loop */
1039	while (!srv_shutdown) {	1043	while (!srv_shutdown) {
1040	int n;	1044	int n;
		1045	int timeout;
1041	size_t ndx;	1046	size_t ndx;
1042	time_t min_ts;	1047	time_t min_ts;
1043		1048
Lines 1265-1271 Link Here
1265	}	1270	}
1266	}	1271	}
1267		1272
1268	if ((n = fdevent_poll(srv->ev, 1000)) > 0) {	1273	if(srv->joblist->used > 0) {
		1274	timeout = 500;
		1275	} else {
		1276	timeout = 1000;
		1277	}
		1278	if ((n = fdevent_poll(srv->ev, timeout)) > 0) {
1269	/* n is the number of events */	1279	/* n is the number of events */
1270	int revents;	1280	int revents;
1271	int fd_ndx;	1281	int fd_ndx;
Lines 1313-1322 Link Here
1313	strerror(errno));	1323	strerror(errno));
1314	}	1324	}
1315		1325
1316	for (ndx = 0; ndx < srv->joblist->used; ndx++) {	1326	if(srv->joblist->used > 0) {
1317	connection *con = srv->joblist->ptr[ndx];	1327	connections *joblist = srv->joblist;
		1328	/* switch joblist queues. */
		1329	srv->joblist = srv->joblist_prev;
		1330	srv->joblist_prev = joblist;
		1331	for (ndx = 0; ndx < joblist->used; ndx++) {
		1332	connection *con = joblist->ptr[ndx];
1318	handler_t r;	1333	handler_t r;
1319		1334
		1335	con->in_joblist = 0;
1320	connection_state_machine(srv, con);	1336	connection_state_machine(srv, con);
1321		1337
1322	switch(r = plugins_call_handle_joblist(srv, con)) {	1338	switch(r = plugins_call_handle_joblist(srv, con)) {
Lines 1327-1337 Link Here
1327	log_error_write(srv, __FILE__, __LINE__, "d", r);	1343	log_error_write(srv, __FILE__, __LINE__, "d", r);
1328	break;	1344	break;
1329	}	1345	}
1330
1331	con->in_joblist = 0;
1332	}	1346	}
1333		1347	joblist->used = 0;
1334	srv->joblist->used = 0;	1348	}
1335	}	1349	}
1336		1350
1337	if (srv->srvconf.pid_file->used &&	1351	if (srv->srvconf.pid_file->used &&

Return to bug 188940

Lines 148-153 Link Here

(-)lighttpd-1.4.13/src/base.h (-1 / +5 lines)
148		148
149	http_method_t http_method;	149	http_method_t http_method;
150	http_version_t http_version;	150	http_version_t http_version;
		151	int true_http_10_client;
151		152
152	buffer *request_line;	153	buffer *request_line;
153		154
Lines 354-361 Link Here
354		355
355	int file_started;	356	int file_started;
356	int file_finished;	357	int file_finished;
		358	int end_chunk; /* used for chunked transfer encoding. */
357		359
358	chunkqueue write_queue; / a large queue for low-level write ( HTTP response ) [ file, mem ] */	360	chunkqueue write_queue; / a large queue for HTTP response content [ file, mem ] */
		361	chunkqueue output_queue; / a large queue for low-level write ( HTTP response ) [ file, mem ] */
359	chunkqueue read_queue; / a small queue for low-level read ( HTTP request ) [ mem ] */	362	chunkqueue read_queue; / a small queue for low-level read ( HTTP request ) [ mem ] */
360	chunkqueue request_content_queue; / takes request-content into tempfile if necessary [ tempfile, mem ]*/	363	chunkqueue request_content_queue; / takes request-content into tempfile if necessary [ tempfile, mem ]*/
361		364
Lines 583-588 Link Here
583		586
584	connections *conns;	587	connections *conns;
585	connections *joblist;	588	connections *joblist;
		589	connections *joblist_prev;
586	connections *fdwaitqueue;	590	connections *fdwaitqueue;
587		591
588	stat_cache *stat_cache;	592	stat_cache *stat_cache;

Lines 16-22 Link Here

(-)lighttpd-1.4.13/src/chunk.c (+114 lines)
16	#include <errno.h>	16	#include <errno.h>
17	#include <string.h>	17	#include <string.h>
18		18
		19	#include "server.h"
19	#include "chunk.h"	20	#include "chunk.h"
		21	#include "log.h"
20		22
21	chunkqueue *chunkqueue_init(void) {	23	chunkqueue *chunkqueue_init(void) {
22	chunkqueue *cq;	24	chunkqueue *cq;
Lines 241-246 Link Here
241	return 0;	243	return 0;
242	}	244	}
243		245
		246	int chunkqueue_append_chunkqueue(chunkqueue cq, chunkqueue src) {
		247	if(src == NULL) return 0;
		248	chunkqueue_append_chunk(cq, src->first);
		249	cq->last = src->last;
		250	src->first = NULL;
		251	src->last = NULL;
		252
		253	return 0;
		254	}
		255
244	buffer * chunkqueue_get_prepend_buffer(chunkqueue *cq) {	256	buffer * chunkqueue_get_prepend_buffer(chunkqueue *cq) {
245	chunk *c;	257	chunk *c;
246		258
Lines 400-402 Link Here
400		412
401	return 0;	413	return 0;
402	}	414	}
		415
		416	/**
		417	* the HTTP chunk-API
		418	*
		419	*
		420	*/
		421
		422	static int chunk_encode_append_len(chunkqueue *cq, size_t len) {
		423	size_t i, olen = len, j;
		424	buffer *b;
		425
		426	/b = srv->tmp_chunk_len;/
		427	/b = buffer_init();/
		428	b = chunkqueue_get_append_buffer(cq);
		429
		430	if (len == 0) {
		431	buffer_copy_string(b, "0");
		432	} else {
		433	for (i = 0; i < 8 && len; i++) {
		434	len >>= 4;
		435	}
		436
		437	/* i is the number of hex digits we have */
		438	buffer_prepare_copy(b, i + 1);
		439
		440	for (j = i-1, len = olen; j+1 > 0; j--) {
		441	b->ptr[j] = (len & 0xf) + (((len & 0xf) <= 9) ? '0' : 'a' - 10);
		442	len >>= 4;
		443	}
		444	b->used = i;
		445	b->ptr[b->used++] = '\0';
		446	}
		447
		448	buffer_append_string(b, "\r\n");
		449	/*
		450	chunkqueue_append_buffer(cq, b);
		451	buffer_free(b);
		452	*/
		453
		454	return 0;
		455	}
		456
		457
		458	int chunk_encode_append_file(chunkqueue cq, buffer fn, off_t offset, off_t len) {
		459	if (!cq) return -1;
		460	if (len == 0) return 0;
		461
		462	chunk_encode_append_len(cq, len);
		463
		464	chunkqueue_append_file(cq, fn, offset, len);
		465
		466	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
		467
		468	return 0;
		469	}
		470
		471	int chunk_encode_append_buffer(chunkqueue cq, buffer mem) {
		472	if (!cq) return -1;
		473	if (mem->used <= 1) return 0;
		474
		475	chunk_encode_append_len(cq, mem->used - 1);
		476
		477	chunkqueue_append_buffer(cq, mem);
		478
479	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
480
481	return 0;
482	}
483
484	int chunk_encode_append_mem(chunkqueue cq, const char mem, size_t len) {
485	if (!cq) return -1;
486	if (len <= 1) return 0;
487
488	chunk_encode_append_len(cq, len - 1);
489
490	chunkqueue_append_mem(cq, mem, len);
491
492	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
493
494	return 0;
495	}
496
497	int chunk_encode_append_queue(chunkqueue cq, chunkqueue src) {
498	int len = chunkqueue_length(src);
499	if (!cq) return -1;
500	if (len == 0) return 0;
501
502	chunk_encode_append_len(cq, len);
503
504	chunkqueue_append_chunkqueue(cq, src);
505
506	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
507
508	return 0;
509	}
510
511	int chunk_encode_end(chunkqueue *cq) {
512	chunk_encode_append_len(cq, 0);
513	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
514	return 0;
515	}
516

Lines 58-73 Link Here

(-)lighttpd-1.4.13/src/http_chunk.c (-27 lines)
58		58
59	cq = con->write_queue;	59	cq = con->write_queue;
60		60
61	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
62	http_chunk_append_len(srv, con, len);
63	}
64		61
65	chunkqueue_append_file(cq, fn, offset, len);	62	chunkqueue_append_file(cq, fn, offset, len);
66		63
67	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED && len > 0) {
68	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
69	}
70
71	return 0;	64	return 0;
72	}	65	}
73		66
Lines 78-93 Link Here
78		71
79	cq = con->write_queue;	72	cq = con->write_queue;
80		73
81	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
82	http_chunk_append_len(srv, con, mem->used - 1);
83	}
84		74
85	chunkqueue_append_buffer(cq, mem);	75	chunkqueue_append_buffer(cq, mem);
86		76
87	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED && mem->used > 0) {
88	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
89	}
90
91	return 0;	77	return 0;
92	}	78	}
93		79
Lines 99-122 Link Here
99	cq = con->write_queue;	85	cq = con->write_queue;
100		86
101	if (len == 0) {	87	if (len == 0) {
102	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
103	chunkqueue_append_mem(cq, "0\r\n\r\n", 5 + 1);
104	} else {
105	chunkqueue_append_mem(cq, "", 1);
106	}
107	return 0;	88	return 0;
108	}	89	}
109		90
110	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
111	http_chunk_append_len(srv, con, len - 1);
112	}
113
114	chunkqueue_append_mem(cq, mem, len);	91	chunkqueue_append_mem(cq, mem, len);
115		92
116	if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
117	chunkqueue_append_mem(cq, "\r\n", 2 + 1);
118	}
119
120	return 0;	93	return 0;
121	}	94	}
122		95

Lines 16-22 Link Here

(-)lighttpd-1.4.13/src/Makefile.in (-2 / +13 lines)
16		16
17		17
18		18
19	SOURCES = $(liblightcomp_la_SOURCES) $(mod_access_la_SOURCES) $(mod_accesslog_la_SOURCES) $(mod_alias_la_SOURCES) $(mod_auth_la_SOURCES) $(mod_cgi_la_SOURCES) $(mod_cml_la_SOURCES) $(mod_compress_la_SOURCES) $(mod_dirlisting_la_SOURCES) $(mod_evasive_la_SOURCES) $(mod_evhost_la_SOURCES) $(mod_expire_la_SOURCES) $(mod_fastcgi_la_SOURCES) $(mod_flv_streaming_la_SOURCES) $(mod_indexfile_la_SOURCES) $(mod_magnet_la_SOURCES) $(mod_mysql_vhost_la_SOURCES) $(mod_proxy_la_SOURCES) $(mod_redirect_la_SOURCES) $(mod_rewrite_la_SOURCES) $(mod_rrdtool_la_SOURCES) $(mod_scgi_la_SOURCES) $(mod_secdownload_la_SOURCES) $(mod_setenv_la_SOURCES) $(mod_simple_vhost_la_SOURCES) $(mod_ssi_la_SOURCES) $(mod_staticfile_la_SOURCES) $(mod_status_la_SOURCES) $(mod_trigger_b4_dl_la_SOURCES) $(mod_userdir_la_SOURCES) $(mod_usertrack_la_SOURCES) $(mod_webdav_la_SOURCES) $(lemon_SOURCES) $(lighttpd_SOURCES) $(proc_open_SOURCES) $(spawn_fcgi_SOURCES)	19	SOURCES = $(liblightcomp_la_SOURCES) $(mod_access_la_SOURCES) $(mod_accesslog_la_SOURCES) $(mod_alias_la_SOURCES) $(mod_auth_la_SOURCES) $(mod_cgi_la_SOURCES) $(mod_cml_la_SOURCES) $(mod_compress_la_SOURCES) $(mod_deflate_la_SOURCES) $(mod_dirlisting_la_SOURCES) $(mod_evasive_la_SOURCES) $(mod_evhost_la_SOURCES) $(mod_expire_la_SOURCES) $(mod_fastcgi_la_SOURCES) $(mod_flv_streaming_la_SOURCES) $(mod_indexfile_la_SOURCES) $(mod_magnet_la_SOURCES) $(mod_mysql_vhost_la_SOURCES) $(mod_proxy_la_SOURCES) $(mod_redirect_la_SOURCES) $(mod_rewrite_la_SOURCES) $(mod_rrdtool_la_SOURCES) $(mod_scgi_la_SOURCES) $(mod_secdownload_la_SOURCES) $(mod_setenv_la_SOURCES) $(mod_simple_vhost_la_SOURCES) $(mod_ssi_la_SOURCES) $(mod_staticfile_la_SOURCES) $(mod_status_la_SOURCES) $(mod_trigger_b4_dl_la_SOURCES) $(mod_userdir_la_SOURCES) $(mod_usertrack_la_SOURCES) $(mod_webdav_la_SOURCES) $(lemon_SOURCES) $(lighttpd_SOURCES) $(proc_open_SOURCES) $(spawn_fcgi_SOURCES)
20		20
21	srcdir = @srcdir@	21	srcdir = @srcdir@
22	top_srcdir = @top_srcdir@	22	top_srcdir = @top_srcdir@
Lines 142-147 Link Here
142	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2)	142	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2)
143	am_mod_compress_la_OBJECTS = mod_compress.lo	143	am_mod_compress_la_OBJECTS = mod_compress.lo
144	mod_compress_la_OBJECTS = $(am_mod_compress_la_OBJECTS)	144	mod_compress_la_OBJECTS = $(am_mod_compress_la_OBJECTS)
		145	mod_deflate_la_DEPENDENCIES = $(am__DEPENDENCIES_1) \
		146	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2)
		147	am_mod_deflate_la_OBJECTS = mod_deflate.lo
		148	mod_deflate_la_OBJECTS = $(am_mod_deflate_la_OBJECTS)
145	mod_dirlisting_la_DEPENDENCIES = $(am__DEPENDENCIES_2) \	149	mod_dirlisting_la_DEPENDENCIES = $(am__DEPENDENCIES_2) \
146	$(am__DEPENDENCIES_1)	150	$(am__DEPENDENCIES_1)
147	am_mod_dirlisting_la_OBJECTS = mod_dirlisting.lo	151	am_mod_dirlisting_la_OBJECTS = mod_dirlisting.lo
Lines 296-301 Link Here
296	$(mod_accesslog_la_SOURCES) $(mod_alias_la_SOURCES) \	300	$(mod_accesslog_la_SOURCES) $(mod_alias_la_SOURCES) \
297	$(mod_auth_la_SOURCES) $(mod_cgi_la_SOURCES) \	301	$(mod_auth_la_SOURCES) $(mod_cgi_la_SOURCES) \
298	$(mod_cml_la_SOURCES) $(mod_compress_la_SOURCES) \	302	$(mod_cml_la_SOURCES) $(mod_compress_la_SOURCES) \
		303	$(mod_deflate_la_SOURCES) \
299	$(mod_dirlisting_la_SOURCES) $(mod_evasive_la_SOURCES) \	304	$(mod_dirlisting_la_SOURCES) $(mod_evasive_la_SOURCES) \
300	$(mod_evhost_la_SOURCES) $(mod_expire_la_SOURCES) \	305	$(mod_evhost_la_SOURCES) $(mod_expire_la_SOURCES) \
301	$(mod_fastcgi_la_SOURCES) $(mod_flv_streaming_la_SOURCES) \	306	$(mod_fastcgi_la_SOURCES) $(mod_flv_streaming_la_SOURCES) \
Lines 508-514 Link Here
508	mod_ssi.la mod_secdownload.la mod_expire.la mod_evhost.la \	513	mod_ssi.la mod_secdownload.la mod_expire.la mod_evhost.la \
509	mod_simple_vhost.la mod_fastcgi.la mod_access.la \	514	mod_simple_vhost.la mod_fastcgi.la mod_access.la \
510	mod_compress.la mod_auth.la mod_rewrite.la mod_redirect.la \	515	mod_compress.la mod_auth.la mod_rewrite.la mod_redirect.la \
511	mod_status.la mod_accesslog.la	516	mod_status.la mod_accesslog.la mod_deflate.la
512	@NO_RDYNAMIC_TRUE@liblightcomp_la_SOURCES = $(common_src)	517	@NO_RDYNAMIC_TRUE@liblightcomp_la_SOURCES = $(common_src)
513	@NO_RDYNAMIC_TRUE@liblightcomp_la_CFLAGS = $(AM_CFLAGS)	518	@NO_RDYNAMIC_TRUE@liblightcomp_la_CFLAGS = $(AM_CFLAGS)
514	@NO_RDYNAMIC_TRUE@liblightcomp_la_LDFLAGS = -avoid-version -no-undefined	519	@NO_RDYNAMIC_TRUE@liblightcomp_la_LDFLAGS = -avoid-version -no-undefined
Lines 612-617 Link Here
612	mod_accesslog_la_SOURCES = mod_accesslog.c	617	mod_accesslog_la_SOURCES = mod_accesslog.c
613	mod_accesslog_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined	618	mod_accesslog_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
614	mod_accesslog_la_LIBADD = $(common_libadd)	619	mod_accesslog_la_LIBADD = $(common_libadd)
		620	mod_deflate_la_SOURCES = mod_deflate.c
		621	mod_deflate_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
		622	mod_deflate_la_LIBADD = $(Z_LIB) $(BZ_LIB) $(common_libadd)
615	hdr = server.h buffer.h network.h log.h keyvalue.h \	623	hdr = server.h buffer.h network.h log.h keyvalue.h \
616	response.h request.h fastcgi.h chunk.h \	624	response.h request.h fastcgi.h chunk.h \
617	settings.h http_chunk.h http_auth_digest.h \	625	settings.h http_chunk.h http_auth_digest.h \
Lines 723-728 Link Here
723	$(LINK) -rpath $(libdir) $(mod_cml_la_LDFLAGS) $(mod_cml_la_OBJECTS) $(mod_cml_la_LIBADD) $(LIBS)	731	$(LINK) -rpath $(libdir) $(mod_cml_la_LDFLAGS) $(mod_cml_la_OBJECTS) $(mod_cml_la_LIBADD) $(LIBS)
724	mod_compress.la: $(mod_compress_la_OBJECTS) $(mod_compress_la_DEPENDENCIES)	732	mod_compress.la: $(mod_compress_la_OBJECTS) $(mod_compress_la_DEPENDENCIES)
725	$(LINK) -rpath $(libdir) $(mod_compress_la_LDFLAGS) $(mod_compress_la_OBJECTS) $(mod_compress_la_LIBADD) $(LIBS)	733	$(LINK) -rpath $(libdir) $(mod_compress_la_LDFLAGS) $(mod_compress_la_OBJECTS) $(mod_compress_la_LIBADD) $(LIBS)
		734	mod_deflate.la: $(mod_deflate_la_OBJECTS) $(mod_deflate_la_DEPENDENCIES)
		735	$(LINK) -rpath $(libdir) $(mod_deflate_la_LDFLAGS) $(mod_deflate_la_OBJECTS) $(mod_deflate_la_LIBADD) $(LIBS)
726	mod_dirlisting.la: $(mod_dirlisting_la_OBJECTS) $(mod_dirlisting_la_DEPENDENCIES)	736	mod_dirlisting.la: $(mod_dirlisting_la_OBJECTS) $(mod_dirlisting_la_DEPENDENCIES)
727	$(LINK) -rpath $(libdir) $(mod_dirlisting_la_LDFLAGS) $(mod_dirlisting_la_OBJECTS) $(mod_dirlisting_la_LIBADD) $(LIBS)	737	$(LINK) -rpath $(libdir) $(mod_dirlisting_la_LDFLAGS) $(mod_dirlisting_la_OBJECTS) $(mod_dirlisting_la_LIBADD) $(LIBS)
728	mod_evasive.la: $(mod_evasive_la_OBJECTS) $(mod_evasive_la_DEPENDENCIES)	738	mod_evasive.la: $(mod_evasive_la_OBJECTS) $(mod_evasive_la_DEPENDENCIES)
Lines 935-940 Link Here
935	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_cml_la-mod_cml_funcs.Plo@am__quote@	945	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_cml_la-mod_cml_funcs.Plo@am__quote@
936	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_cml_la-mod_cml_lua.Plo@am__quote@	946	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_cml_la-mod_cml_lua.Plo@am__quote@
937	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_compress.Plo@am__quote@	947	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_compress.Plo@am__quote@
		948	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_deflate.Plo@am__quote@
938	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_dirlisting.Plo@am__quote@	949	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_dirlisting.Plo@am__quote@
939	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_evasive.Plo@am__quote@	950	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_evasive.Plo@am__quote@
940	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_evhost.Plo@am__quote@	951	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mod_evhost.Plo@am__quote@