Add patch for experimental progress bar module. Bug #380093 thanks to Richard Homonnai <chain@rpgfiction.net>. Remove deprecated --oknodo from init script. Bug #375301 thanks to Laurent Bachelier <laurent@bachelier.name>

Package-Manager: portage-2.2.0_alpha55/cvs/Linux x86_64

6 files changed, 989 insertions, 12 deletions

diff --git a/www-servers/lighttpd/ChangeLog b/www-servers/lighttpd/ChangeLog
index 3fa4c3950d9b..11ada02ae092 100644
--- a/www-servers/lighttpd/ChangeLog
+++ b/www-servers/lighttpd/ChangeLog
@@ -1,6 +1,15 @@
 # ChangeLog for www-servers/lighttpd
 # Copyright 1999-2011 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/www-servers/lighttpd/ChangeLog,v 1.255 2011/08/29 06:39:13 jer Exp $
+# $Header: /var/cvsroot/gentoo-x86/www-servers/lighttpd/ChangeLog,v 1.256 2011/09/19 17:05:45 hwoarang Exp $
+
+*lighttpd-1.4.29-r2 (19 Sep 2011)
+
+  19 Sep 2011; Markos Chandras <hwoarang@gentoo.org>
+  +lighttpd-1.4.29-r2.ebuild, +files/lighttpd-1.4.29-mod_uploadprogress.patch,
+  files/lighttpd.initd:
+  Add patch for experimental progress bar module. Bug #380093 thanks to Richard
+  Homonnai <chain@rpgfiction.net>. Remove deprecated --oknodo from init script.
+  Bug #375301 thanks to Laurent Bachelier <laurent@bachelier.name>
 
   29 Aug 2011; Jeroen Roovers <jer@gentoo.org> lighttpd-1.4.28-r2.ebuild:
   Stable for HPPA (bug #373917).
diff --git a/www-servers/lighttpd/Manifest b/www-servers/lighttpd/Manifest
index e705c98a1f10..4b7e15727ed0 100644
--- a/www-servers/lighttpd/Manifest
+++ b/www-servers/lighttpd/Manifest
@@ -1,5 +1,5 @@
 -----BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA1
+Hash: SHA512
 
 AUX 1.4.25-fix-CVE-2010-0295.patch 6237 RMD160 cd9ce4410ed805d28899b0207bbc670e04491315 SHA1 2ba33d94f5628d97cb606ad97ef9630eef5191c4 SHA256 d4d269d993396cfd9146de621e0a3d5e9203ac7f6b2b6f351f9013dbbe956a4e
 AUX 1.4.25-fix-unknown-AM_SILENT_RULES.patch 744 RMD160 5da8bdca1728f2de730e90de4fb7e93a274406e8 SHA1 8ae6849a88aaaca76c1b8c13a62cc266dbebc2a7 SHA256 a1cf7c77b7ee1cbe9bf3efbb7704b8582c480ae69fd70934597d24ff3fddf663
@@ -10,8 +10,9 @@ AUX conf/mod_cgi.conf 869 RMD160 1d447bad36822657d014990128891cbdb6169468 SHA1 3
 AUX conf/mod_fastcgi.conf 677 RMD160 4403ca232cfcfc51d1d71529be9903bf4123451e SHA1 2b4a3d35215ba8824b5eca943156b373479f1a45 SHA256 954bf2a030e268e7cd880d4cd7d6c13317c09e0ec4e87a8d7d887fb4e7dc83bd
 AUX conf/mod_fastcgi.conf-1.4.13-r2 687 RMD160 f165f27a08f35c4792bd332be3a04370b69152e3 SHA1 ebb469944098a91772424a825fdd5a0464cef158 SHA256 d1adc1358b5d9e85353caa2e706bfa231d145dd59c075cdcb3f818b3cb5d722e
 AUX lighttpd-1.4.28-detect-libev.patch 441 RMD160 e65051bd918d784d3333dd0f6cde2ce4c5fe6c2e SHA1 0e7e6de46a80564c800674d19dcc05da7d97fc9d SHA256 223756902928f0f5de0100115b1e1def9e312363d16bedbc998b5d983d04ecbe
+AUX lighttpd-1.4.29-mod_uploadprogress.patch 22472 RMD160 595f07b55bbfac3d9fc41888f3e057a9e54bc1eb SHA1 c55e5eb72ebec2f933bdf9e2061fbeb47a72ba11 SHA256 b7b13ae1de4bbe2cf2687686ae4921d4ae2f66fc524703b3c63924b6d888934f
 AUX lighttpd.confd 383 RMD160 e7b5d446dcbb55c7855706aa566bf87ab0bad911 SHA1 c300230745dd060dc2b16000270dd33def6df6a7 SHA256 bb6e6721f33e6582a91025f3500e159a599fb856d699e9394093e1018c7925e0
-AUX lighttpd.initd 1631 RMD160 b2f8df79a2a7514d6b617b66b885eae153e70a76 SHA1 bb521ec6a93a9607e4db0afec0063e91d846bd90 SHA256 6d697a71257e972000df01f70aa6056628b91b9486bc8e3b8a16d1010cdeba21
+AUX lighttpd.initd 1613 RMD160 36487d7720533fc67b8d7a0758a8cf2c4d9dd6c7 SHA1 34f007511bdcf71ff52f7bdf80f30faff21265d3 SHA256 1ba2e9008b2788ab39aa1cc84e42d87fad3df493ec4406a7ee16af621415d609
 AUX lighttpd.initd-1.4.13-r3 1454 RMD160 287b7b5626559f61b17e113ca00ef0cee6c63962 SHA1 e9a0f6880e03db27082177634d9974bb7f4b3406 SHA256 9dfda47a18f3e7beada18cfec37b39c66d3029b6bde42c538d82cd1292c7616a
 AUX lighttpd.logrotate 487 RMD160 2edb8b4abf75031af0a3b4182efb5b589dfa0d3c SHA1 24e1b048d7be5520ca5ef8ce31b55df13cc8d72b SHA256 503ee1cd454e2c0f9a212ef60dc8321893eda06ccf721ecbe94d189a09e0bc6c
 AUX spawn-fcgi.confd 1076 RMD160 9468249fdedc39fa762a569622bae93f8b3481f9 SHA1 81bad945fc016275873e01e5f69838f73b275a3a SHA256 bfa452a849165f921a2febf0b06879db18c4c921f156b1452d06bb821063f768
@@ -30,12 +31,23 @@ EBUILD lighttpd-1.4.28-r1.ebuild 5739 RMD160 39f13a4f941e4f54f2ce1e15972c7df3327
 EBUILD lighttpd-1.4.28-r2.ebuild 5724 RMD160 010553db292467d43cfbbd06549f0e13004cc6c6 SHA1 537d4b521740bcface141649dbce3df0048af7cb SHA256 0e19a6c294ea24f88a99a8f1f5425eda89596d60176c7920a3ab0d90efc3c73f
 EBUILD lighttpd-1.4.28.ebuild 5676 RMD160 551c7b19158096b60f350f8db80ac6e61312af42 SHA1 005e0a5ed111b6cda8eb22c9cff9280e4542d3eb SHA256 8fb37b0afc97e260ffda15acc288f8e75418b84cfab9de0a9d62fc1a91f83bac
 EBUILD lighttpd-1.4.29-r1.ebuild 5929 RMD160 26b52584e2efdaf44f570ec15eb1b169bd1935b5 SHA1 b97d318ecdf9e6408c59a5f86383a9dcf7fea2ca SHA256 bc84cd09962cfe20fcc692fa3cca22caf5b163d8165f39fba4867a08999924ae
-MISC ChangeLog 54420 RMD160 6ad7e9fcc40c0913583bdd154d79098761a808b9 SHA1 886201191349ce7b6a8acc017b5c7dd477dc8194 SHA256 82e9d018a95cb4cd7b61090716aa67040289b3d5bac14d4e78346e23b5428d03
-MISC metadata.xml 1104 RMD160 445c36561695b89266cb1bb0b052167473e1568d SHA1 821390063f6a1d798fc036b14af8cb56c8e62492 SHA256 7b633eaadf23540735206a1ce6af010b7757affb753fc496c7b15de8c9cf78c2
+EBUILD lighttpd-1.4.29-r2.ebuild 6490 RMD160 a4b49928361a33c496fa9aca280b8f0ba6d8e746 SHA1 cab1a5d839d01be633e134ef2aa12110e4fe17a0 SHA256 936d679ff5fc7af35bca58a7e13989240b67e771b06228435d331a00e3e0ce25
+MISC ChangeLog 54844 RMD160 d156a24f036fab11955076cc207da4ebc491cf8e SHA1 97beade294ddb1ee53a7ecea82cae980fa5bb213 SHA256 65e3f2499be1a877b357a76054a5198544fc031b0672c7213730329285ddb603
+MISC metadata.xml 1193 RMD160 1fdffaaf6f865686842c2328277899a20c3ff4f1 SHA1 4c92866074579331b95b656e3eed56a5fd698c37 SHA256 bd3dbe66a93023547bd9cc688b51c050a1184d4a18d40f82171c5ca76757424e
 -----BEGIN PGP SIGNATURE-----
-Version: GnuPG v2.0.17 (GNU/Linux)
+Version: GnuPG v2.0.18 (GNU/Linux)
 
-iEUEARECAAYFAk5bNBcACgkQVWmRsqeSphOTYQCaAsX5QbbpoPD+zyci5B2UY8/h
-HcoAmPx9g5wgG/vLT6e7LSEmYYuJcG0=
-=n2r8
+iQIcBAEBCgAGBQJOd3ZWAAoJEPqDWhW0r/LC8XAQALuTVGL6kMJhLP4kRlByVPxc
+viDtupfOpA3r91AyTuimoaacOiq2O7iUmgv0vvoZjtOfhMq7okKuz9PBn4dvqpcz
+lb3xegcWlq4c4Q13xGv2W/nKiITaQ/DvtFdvCWT3f0Z++8kdiFJOTnimZwtUA9o4
+SWCAWN5xnccAKdTp+eIx8FlTD63ZD2Fg2e0NJ6O8cweRtt8ZMxDwJ81IoUHGErFw
+DRMYVCYgw+abIKnRbVgPyzrk/xVWShXe/X4GpY0T8QTYyKCykuGMHdn60GnbKXzH
+fMq7MENgIFMptiTsxDxn8bKzYcxXgGhchyhV108AtNMNwOudlUpWQtXc0QY037XU
+kL/EA6fq55qC2ieJfwPvGfQL0ULlhn/JCeESMmAcXIiQgEhASmKl5h2BKJc6eUmz
+w4VPeLIoy5B3zRqfF32wEwDjeGBTr8hy1dD54fi5SB3ZKi2O80bKe1jC+XPGK2X1
+YK064vSKYyno0uXwzeqHEBl7dMZHMEXkbyQC+xSNR5+c/ocA1G3GoR33g+yUdNhL
+Augs3PEWLRdxRuNgbf8G70s/Cb2eBA7dh6ARnUSw6BohETM+UZY+7Eh8ftL7YqCd
+NwGSDSMFIn6M0GMvXavjgpoTHBh9n93lavj/BIRXKnyEXiyxjR+WxTUH6q9JhUqT
+Kzr4HL+bX3w3pR4BikQR
+=Baa0
 -----END PGP SIGNATURE-----
diff --git a/www-servers/lighttpd/files/lighttpd-1.4.29-mod_uploadprogress.patch b/www-servers/lighttpd/files/lighttpd-1.4.29-mod_uploadprogress.patch
new file mode 100644
index 000000000000..c99886af1e7b
--- /dev/null
+++ b/www-servers/lighttpd/files/lighttpd-1.4.29-mod_uploadprogress.patch
@@ -0,0 +1,738 @@
+diff -Nru lighttpd-1.4.22.orig/src/connections.c lighttpd-1.4.22/src/connections.c
+--- lighttpd-1.4.22.orig/src/connections.c	2009-02-19 14:15:14.000000000 +0100
++++ lighttpd-1.4.28/src/connections.c	2009-04-22 17:45:20.000000000 +0200
+@@ -1401,11 +1401,15 @@
+ 			if (http_request_parse(srv, con)) {
+ 				/* we have to read some data from the POST request */
+ 
++				plugins_call_handle_request_end(srv, con);
++
+ 				connection_set_state(srv, con, CON_STATE_READ_POST);
+ 
+ 				break;
+ 			}
+ 
++			plugins_call_handle_request_end(srv, con);
++
+ 			connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
+ 
+ 			break;
+diff -Nru lighttpd-1.4.22.orig/src/Makefile.am lighttpd-1.4.22/src/Makefile.am
+--- lighttpd-1.4.22.orig/src/Makefile.am	2009-02-19 14:15:14.000000000 +0100
++++ lighttpd-1.4.28/src/Makefile.am	2009-04-22 17:46:34.000000000 +0200
+@@ -246,6 +246,11 @@
+ mod_accesslog_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
+ mod_accesslog_la_LIBADD = $(common_libadd)
+ 
++lib_LTLIBRARIES += mod_uploadprogress.la
++mod_uploadprogress_la_SOURCES = mod_uploadprogress.c
++mod_uploadprogress_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
++mod_uploadprogress_la_LIBADD = $(common_libadd)
++
+ 
+ hdr = server.h buffer.h network.h log.h keyvalue.h \
+       response.h request.h fastcgi.h chunk.h \
+diff -Nru lighttpd-1.4.22.orig/src/plugin.c lighttpd-1.4.22/src/plugin.c
+--- lighttpd-1.4.22.orig/src/plugin.c	2009-02-19 14:15:14.000000000 +0100
++++ lighttpd-1.4.28/src/plugin.c	2009-04-22 17:45:20.000000000 +0200
+@@ -34,6 +34,7 @@
+ 	PLUGIN_FUNC_UNSET,
+ 		PLUGIN_FUNC_HANDLE_URI_CLEAN,
+ 		PLUGIN_FUNC_HANDLE_URI_RAW,
++		PLUGIN_FUNC_HANDLE_REQUEST_END,
+ 		PLUGIN_FUNC_HANDLE_REQUEST_DONE,
+ 		PLUGIN_FUNC_HANDLE_CONNECTION_CLOSE,
+ 		PLUGIN_FUNC_HANDLE_TRIGGER,
+@@ -262,6 +263,7 @@
+ 
+ PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_URI_CLEAN, handle_uri_clean)
+ PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_URI_RAW, handle_uri_raw)
++PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_REQUEST_END, handle_request_end)
+ PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_REQUEST_DONE, handle_request_done)
+ PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_CONNECTION_CLOSE, handle_connection_close)
+ PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_SUBREQUEST, handle_subrequest)
+@@ -389,6 +391,7 @@
+ 
+ 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_URI_CLEAN, handle_uri_clean);
+ 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_URI_RAW, handle_uri_raw);
++		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_REQUEST_END, handle_request_end);
+ 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_REQUEST_DONE, handle_request_done);
+ 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_CONNECTION_CLOSE, handle_connection_close);
+ 		PLUGIN_TO_SLOT(PLUGIN_FUNC_HANDLE_TRIGGER, handle_trigger);
+diff -Nru lighttpd-1.4.22.orig/src/plugin.h lighttpd-1.4.22/src/plugin.h
+--- lighttpd-1.4.22.orig/src/plugin.h	2009-02-19 14:15:14.000000000 +0100
++++ lighttpd-1.4.28/src/plugin.h	2009-04-22 17:45:20.000000000 +0200
+@@ -42,12 +42,12 @@
+ 	handler_t (* handle_uri_clean)       (server *srv, connection *con, void *p_d);    /* after uri is set */
+ 	handler_t (* handle_docroot)         (server *srv, connection *con, void *p_d);    /* getting the document-root */
+ 	handler_t (* handle_physical)        (server *srv, connection *con, void *p_d);    /* mapping url to physical path */
++        handler_t (* handle_request_end)     (server *srv, connection *con, void *p_d);    /* a handler for the request content */
+ 	handler_t (* handle_request_done)    (server *srv, connection *con, void *p_d);    /* at the end of a request */
+ 	handler_t (* handle_connection_close)(server *srv, connection *con, void *p_d);    /* at the end of a connection */
+ 	handler_t (* handle_joblist)         (server *srv, connection *con, void *p_d);    /* after all events are handled */
+ 
+ 
+-
+ 	handler_t (* handle_subrequest_start)(server *srv, connection *con, void *p_d);
+ 
+ 	                                                                                   /* when a handler for the request
+@@ -68,6 +68,7 @@
+ 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_request_end(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 -Nru lighttpd-1.4.22.orig/src/mod_uploadprogress.c lighttpd-1.4.22/src/mod_uploadprogress.c
+--- lighttpd-1.4.22.orig/src/mod_uploadprogress.c	1970-01-01 01:00:00.000000000 +0100
++++ lighttpd-1.4.28/src/mod_uploadprogress.c	2009-04-22 17:32:38.000000000 +0200
+@@ -0,0 +1,648 @@
++#include <ctype.h>
++#include <stdlib.h>
++#include <string.h>
++
++#include "base.h"
++#include "log.h"
++#include "buffer.h"
++
++#include "plugin.h"
++
++#include "response.h"
++#include "stat_cache.h"
++
++#define CONFIG_UPLOAD_PROGRESS_URL "upload-progress.progress-url"
++#define CONFIG_UPLOAD_PROGRESS_TIMEOUT "upload-progress.remove-timeout"
++#define CONFIG_UPLOAD_PROGRESS_DEBUG "upload-progress.debug"
++
++#define SAFE_BUF_STR(x) x && x->ptr ? x->ptr : "(null)"
++
++/**
++ * uploadprogress for lighttpd
++ *
++ * Initial: Jan Kneschke <jan@kneschke.de>
++ * Timeout+Status addon: Bjoern Kalkbrenner <terminar@cyberphoria.org> [20070112]
++ *
++ * Ported to Lighttpd 1.4.22 by Radek Senfeld <rush@logic.cz>
++ *
++ * Backport based on revision 2369
++ * http://redmine.lighttpd.net/projects/lighttpd/repository/changes/trunk/src/mod_uploadprogress.c
++ *
++ * the timeout is used to keep in the status information intact even if the parent
++ * connection is gone already
++ *
++ */
++
++typedef struct {
++	buffer     *tracking_id;
++	connection *con;
++
++	time_t timeout;
++	int status;
++	off_t size;
++} connection_map_entry;
++
++typedef struct {
++	connection_map_entry **ptr;
++
++	size_t used;
++	size_t size;
++} connection_map;
++
++/* plugin config for all request/connections */
++
++typedef struct {
++	buffer *progress_url;
++	unsigned short debug;
++	unsigned short remove_timeout;
++} plugin_config;
++
++typedef struct {
++	PLUGIN_DATA;
++
++	connection_map *con_map;
++
++	buffer *tmp_buf; /** used as temporary buffer for extracting the tracking id */
++
++	plugin_config **config_storage;
++
++	plugin_config conf;
++} plugin_data;
++
++/**
++ *
++ * connection maps
++ *
++ */
++
++/* init the plugin data */
++static connection_map *connection_map_init() {
++	connection_map *cm;
++
++	cm = calloc(1, sizeof(*cm));
++
++	return cm;
++}
++
++static void connection_map_free(connection_map *cm) {
++	size_t i;
++	for (i = 0; i < cm->size; i++) {
++		connection_map_entry *cme = cm->ptr[i];
++
++		if (!cme) break;
++
++		if (cme->tracking_id) {
++			buffer_free(cme->tracking_id);
++		}
++		free(cme);
++	}
++
++	free(cm);
++}
++
++static connection_map_entry *connection_map_insert(connection_map *cm, buffer *tracking_id, connection *con) {
++	connection_map_entry *cme;
++	size_t i;
++
++	if (cm->size == 0) {
++		cm->size = 16;
++		cm->ptr = malloc(cm->size * sizeof(*(cm->ptr)));
++		for (i = 0; i < cm->size; i++) {
++			cm->ptr[i] = NULL;
++		}
++	} else if (cm->used == cm->size) {
++		cm->size += 16;
++		cm->ptr = realloc(cm->ptr, cm->size * sizeof(*(cm->ptr)));
++		for (i = cm->used; i < cm->size; i++) {
++			cm->ptr[i] = NULL;
++		}
++	}
++
++	if (cm->ptr[cm->used]) {
++		/* is already alloced, just reuse it */
++		cme = cm->ptr[cm->used];
++	} else {
++		cme = malloc(sizeof(*cme));
++		cme->tracking_id = buffer_init();
++	}
++	cme->timeout = 0;
++	cme->status = 0;
++	buffer_copy_string_buffer(cme->tracking_id, tracking_id);
++	cme->con = con;
++
++	cm->ptr[cm->used++] = cme;
++
++	return cme;
++}
++
++static connection_map_entry *connection_map_get_connection_entry(connection_map *cm, buffer *tracking_id) {
++	size_t i;
++
++	for (i = 0; i < cm->used; i++) {
++		connection_map_entry *cme = cm->ptr[i];
++
++		if (buffer_is_equal(cme->tracking_id, tracking_id)) {
++			/* found connection */
++			return cme;
++		}
++	}
++	return NULL;
++}
++
++static void connection_map_remove_connection(connection_map *cm, size_t i) {
++	connection_map_entry *cme = cm->ptr[i];
++
++	buffer_reset(cme->tracking_id);
++	cme->timeout=0;
++	cme->status=0;
++
++	cm->used--;
++
++	/* swap positions with the last entry */
++	if (cm->used) {
++		cm->ptr[i] = cm->ptr[cm->used];
++		cm->ptr[cm->used] = cme;
++	}
++}
++
++/**
++ * remove dead tracking IDs
++ *
++ * uploadprogress.remove-timeout sets a grace-period in which the
++ * connection status is still known even of the connection is already
++ * being removed
++ *
++ */
++static void connection_map_clear_timeout_connections(connection_map *cm) {
++	size_t i;
++	time_t now_t = time(NULL);
++
++	for (i = 0; i < cm->used; i++) {
++		connection_map_entry *cme = cm->ptr[i];
++
++		if (cme->timeout != 0 && cme->timeout < now_t) {
++			/* found connection */
++			connection_map_remove_connection(cm, i);
++		}
++	}
++}
++
++/**
++ * extract the tracking-id from the parameters
++ *
++ * for POST requests it is part of the request headers
++ * for GET requests ... too
++ */
++static buffer *get_tracking_id(plugin_data *p, server *srv, connection *con) {
++	data_string *ds;
++	buffer *b = NULL;
++	char *qstr=NULL;
++	size_t i;
++
++	/* the request has to contain a 32byte ID */
++	if (NULL == (ds = (data_string *)array_get_element(con->request.headers, "X-Progress-ID"))) {
++		char *amp = NULL;
++
++		/* perhaps the POST request is using the querystring to pass the X-Progress-ID */
++		if (buffer_is_empty(con->uri.query)) {
++			/*
++			 * con->uri.query will not be parsed out if a 413 error happens
++			 */
++			if (NULL != (qstr = strchr(con->request.uri->ptr, '?'))) {
++				/** extract query string from request.uri */
++				buffer_copy_string(con->uri.query, qstr + 1);
++			} else {
++				return NULL;
++			}
++		}
++
++		/** split the query-string and extract the X-Progress-ID */
++		do {
++			char *eq = NULL;
++			char *start = amp ? amp + 1 : con->uri.query->ptr;
++
++			amp = strchr(start, '&');
++
++			/* check the string between start and amp for = */
++
++			if (amp) {
++				buffer_copy_string_len(p->tmp_buf, start, amp - start);
++			} else {
++				buffer_copy_string(p->tmp_buf, start);
++			}
++
++			eq = strchr(p->tmp_buf->ptr, '=');
++
++			if (eq) {
++				*eq = '\0';
++
++				if (0 == strcmp(p->tmp_buf->ptr, "X-Progress-ID")) {
++					size_t key_len = sizeof("X-Progress-ID") - 1;
++					size_t var_len = p->tmp_buf->used - 1;
++					/* found */
++
++					buffer_copy_string_len(p->tmp_buf, start + key_len + 1, var_len - key_len - 1);
++
++					b = p->tmp_buf;
++
++					break;
++				}
++			}
++		} while (amp);
++
++		if (!b) return NULL;
++	} else {
++		/* request header was found, use it */
++		b = ds->value;
++	}
++
++	if (b->used != 32 + 1) {
++		if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "sds", "the Progress-ID has to be 32 characters long, got", b->used - 1, "characters");
++		return NULL;
++	}
++
++	for (i = 0; i < b->used - 1; i++) {
++		char c = b->ptr[i];
++
++		if (!light_isxdigit(c)) {
++			if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "sds", "only hex-digits are allowed (0-9 + a-f): (ascii:", c, ")");
++			return NULL;
++		}
++	}
++
++	return b;
++}
++
++/* init the plugin data */
++INIT_FUNC(mod_uploadprogress_init) {
++	plugin_data *p;
++
++	p = calloc(1, sizeof(*p));
++
++	p->con_map = connection_map_init();
++	p->tmp_buf = buffer_init();
++
++	return p;
++}
++
++/* detroy the plugin data */
++FREE_FUNC(mod_uploadprogress_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];
++
++			buffer_free(s->progress_url);
++			s->remove_timeout=0;
++
++			free(s);
++		}
++		free(p->config_storage);
++	}
++
++	connection_map_free(p->con_map);
++	buffer_free(p->tmp_buf);
++
++	free(p);
++
++	return HANDLER_GO_ON;
++}
++
++/* handle plugin config and check values */
++
++SETDEFAULTS_FUNC(mod_uploadprogress_set_defaults) {
++	plugin_data *p = p_d;
++	size_t i = 0;
++
++	config_values_t cv[] = {
++		{ CONFIG_UPLOAD_PROGRESS_URL, NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
++		{ CONFIG_UPLOAD_PROGRESS_TIMEOUT, NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },    /* 1 */
++		{ CONFIG_UPLOAD_PROGRESS_DEBUG, NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION },    /* 2 */
++		{ NULL,                         NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
++	};
++
++	if (!p) return HANDLER_ERROR;
++
++	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->progress_url    = buffer_init();
++		s->remove_timeout  = 60;
++		s->debug  = 0;
++
++		cv[0].destination = s->progress_url;
++		cv[1].destination = &(s->remove_timeout);
++		cv[2].destination = &(s->debug);
++
++		p->config_storage[i] = s;
++
++		if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
++			return HANDLER_ERROR;
++		}
++	}
++
++	return HANDLER_GO_ON;
++}
++
++#define PATCH_OPTION(x) \
++	p->conf.x = s->x;
++static int mod_uploadprogress_patch_connection(server *srv, connection *con, plugin_data *p) {
++	size_t i, j;
++	plugin_config *s = p->config_storage[0];
++
++	PATCH_OPTION(progress_url);
++	PATCH_OPTION(remove_timeout);
++	PATCH_OPTION(debug);
++
++	/* 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(CONFIG_UPLOAD_PROGRESS_URL))) {
++				PATCH_OPTION(progress_url);
++			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_UPLOAD_PROGRESS_TIMEOUT))) {
++				PATCH_OPTION(remove_timeout);
++			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_UPLOAD_PROGRESS_DEBUG))) {
++				PATCH_OPTION(debug);
++			}
++		}
++	}
++
++	return 0;
++}
++
++/**
++ *
++ * the idea:
++ *
++ * for the first request we check if it is a post-request
++ *
++ * if no, move out, don't care about them
++ *
++ * if yes, take the connection structure and register it locally
++ * in the progress-struct together with an session-id (md5 ... )
++ *
++ * if the connections closes, cleanup the entry in the progress-struct
++ *
++ * a second request can now get the info about the size of the upload,
++ * the received bytes
++ *
++ */
++
++URIHANDLER_FUNC(mod_uploadprogress_uri_handler) {
++	plugin_data *p = p_d;
++	buffer *tracking_id;
++	buffer *b;
++	connection_map_entry *post_con_entry = NULL;
++	connection_map_entry *map_con_entry = NULL;
++
++	if (buffer_is_empty(con->uri.path)) return HANDLER_GO_ON;
++
++	/* no progress URL set, ignore request */
++	if (buffer_is_empty(p->conf.progress_url)) return HANDLER_GO_ON;
++
++	switch(con->request.http_method) {
++	case HTTP_METHOD_POST:
++		/**
++		 * a POST request is the UPLOAD itself
++		 *
++		 * get the unique tracker id
++		 */
++		if (NULL == (tracking_id = get_tracking_id(p, srv, con))) {
++			return HANDLER_GO_ON;
++		}
++
++		if (NULL == (map_con_entry = connection_map_get_connection_entry(p->con_map, tracking_id))) {
++			connection_map_insert(p->con_map, tracking_id, con);
++
++			if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "ss", "POST: connection is new, registered:", SAFE_BUF_STR(tracking_id));
++		} else {
++			map_con_entry->timeout = 0;
++			map_con_entry->status = 0;
++
++			if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "ss", "POST: connection is known, id:", SAFE_BUF_STR(tracking_id));
++		}
++
++		return HANDLER_GO_ON;
++	case HTTP_METHOD_GET:
++		/**
++		 * the status request for the current connection
++		 */
++		if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "ssss", "(uploadprogress) urls", SAFE_BUF_STR(con->uri.path), "==", SAFE_BUF_STR(p->conf.progress_url));
++
++		if (!buffer_is_equal(con->uri.path, p->conf.progress_url)) {
++			return HANDLER_GO_ON;
++		}
++
++		/* get the tracker id */
++		if (NULL == (tracking_id = get_tracking_id(p, srv, con))) {
++			return HANDLER_GO_ON;
++		}
++
++		buffer_reset(con->physical.path);
++
++		con->file_started = 1;
++		con->http_status = 200;
++		con->file_finished = 1;
++
++		/* send JSON content */
++
++		response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/javascript"));
++
++		/* just an attempt the force the IE/proxies to NOT cache the request */
++		response_header_overwrite(srv, con, CONST_STR_LEN("Pragma"), CONST_STR_LEN("no-cache"));
++		response_header_overwrite(srv, con, CONST_STR_LEN("Expires"), CONST_STR_LEN("Thu, 19 Nov 1981 08:52:00 GMT"));
++		response_header_overwrite(srv, con, CONST_STR_LEN("Cache-Control"),
++				CONST_STR_LEN("no-store, no-cache, must-revalidate, post-check=0, pre-check=0"));
++
++		b = chunkqueue_get_append_buffer(con->write_queue);
++
++		/* get the connection */
++		if (NULL == (post_con_entry = connection_map_get_connection_entry(p->con_map, tracking_id))) {
++			/**
++			 * looks like we don't know the tracking id yet, GET and POST out of sync ? */
++			buffer_append_string_len(b, CONST_STR_LEN("{ \"state\" : \"unknown\" }\r\n"));
++			con->response.content_length += b->used - 1;
++
++			if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "ssss", "connection unknown:", SAFE_BUF_STR(tracking_id), ", sending:", SAFE_BUF_STR(b));
++
++			return HANDLER_FINISHED;
++		}
++
++		buffer_copy_string_len(b, CONST_STR_LEN("{ \"state\" : "));
++
++		if (post_con_entry->status == 413) {
++			/* the upload was too large */
++			buffer_append_string_len(b, CONST_STR_LEN("\"error\", \"status\" : 413"));
++		} else if (post_con_entry->con == NULL) {
++			/* the connection is already gone */
++			buffer_append_string_len(b, CONST_STR_LEN("\"done\", \"size\" : "));
++			buffer_append_off_t(b, post_con_entry->size);
++		} else {
++			/* the upload is already done, but the connection might be still open */
++			buffer_append_string(b, post_con_entry->con->state == CON_STATE_READ_POST ? "\"uploading\"" : "\"done\"");
++			buffer_append_string_len(b, CONST_STR_LEN(", \"received\" : "));
++			buffer_append_off_t(b, post_con_entry->con->bytes_read);
++			buffer_append_string_len(b, CONST_STR_LEN(", \"size\" : "));
++			buffer_append_off_t(b, post_con_entry->con->request.content_length);
++		}
++		buffer_append_string_len(b, CONST_STR_LEN("}\r\n"));
++		con->response.content_length += b->used - 1;
++
++		if (p->conf.debug) log_error_write(srv, __FILE__, __LINE__, "ssss", "connection is known:", SAFE_BUF_STR(tracking_id), ", sending:", SAFE_BUF_STR(b));
++
++		return HANDLER_FINISHED;
++	default:
++		break;
++	}
++
++	return HANDLER_GO_ON;
++}
++
++/**
++ * check for POST request
++ */
++CONNECTION_FUNC(mod_uploadprogress_request_end) {
++	plugin_data *p = p_d;
++
++	buffer *tracking_id;
++	connection_map_entry *map_con_entry = NULL;
++
++	UNUSED(srv);
++
++	/* no request URL, ignore request */
++	if (buffer_is_empty(con->request.uri)) return HANDLER_GO_ON;
++
++	mod_uploadprogress_patch_connection(srv, con, p);
++
++	/*
++	 * we only want to process the upload (POST request)
++	 */
++	if (con->request.http_method != HTTP_METHOD_POST) {
++		return HANDLER_GO_ON;
++	}
++
++	if (p->conf.debug) {
++		log_error_write(srv, __FILE__, __LINE__, "sxsdsd", "request_end: con=", (void *) con, ", http_method=", con->request.http_method, ", http_status=", con->http_status);
++	}
++
++	/* get the tracker id */
++	if (NULL == (tracking_id = get_tracking_id(p, srv, con))) {
++		return HANDLER_GO_ON;
++	}
++
++	if (NULL == (map_con_entry = connection_map_get_connection_entry(p->con_map, tracking_id))) {
++		/**
++		 * in case the request parser meant the request was too large the URI handler won't
++		 * get called. Insert the connection mapping here
++		 */
++		if (NULL == (map_con_entry = connection_map_insert(p->con_map, tracking_id, con))) {
++			return HANDLER_GO_ON;
++		}
++	}
++
++	/* ok, found our entries, setting status */
++	map_con_entry->status = con->http_status;
++
++	return HANDLER_GO_ON;
++}
++
++/**
++ * remove the parent connection from the connection mapping
++ * when it got closed
++ *
++ * keep the mapping active for a while to send a valid final status
++ */
++CONNECTION_FUNC(mod_uploadprogress_request_done) {
++	plugin_data *p = p_d;
++	buffer *tracking_id;
++	connection_map_entry *cm = NULL;
++
++	UNUSED(srv);
++
++	if (buffer_is_empty(con->request.uri)) return HANDLER_GO_ON;
++
++	/*
++	 * only need to handle the upload request.
++	 */
++	if (con->request.http_method != HTTP_METHOD_POST) {
++		return HANDLER_GO_ON;
++	}
++
++	if (NULL == (tracking_id = get_tracking_id(p, srv, con))) {
++		return HANDLER_GO_ON;
++	}
++
++	if (p->conf.debug) {
++		log_error_write(srv, __FILE__, __LINE__, "sssd", "upload is done, moving tracking-id to backlog: tracking-id=", SAFE_BUF_STR(tracking_id), ", http_status=", con->http_status);
++	}
++
++	/*
++	 * set timeout on the upload's connection_map_entry.
++	 */
++	if (NULL == (cm = connection_map_get_connection_entry(p->con_map, tracking_id))) {
++		if (p->conf.debug) {
++			log_error_write(srv, __FILE__, __LINE__, "sss", "tracking ID", SAFE_BUF_STR(tracking_id), "not found, can't set timeout");
++		}
++		return HANDLER_GO_ON;
++	}
++
++	/* save request size to be able to report it even when cm->con == NULL */
++	cm->size = con->request.content_length;
++
++	cm->timeout = time(NULL) + p->conf.remove_timeout;
++	cm->con     = NULL; /* con becomes invalid very soon */
++
++	return HANDLER_GO_ON;
++}
++
++/**
++ * remove dead connections once in while
++ */
++TRIGGER_FUNC(mod_uploadprogress_trigger) {
++	plugin_data *p = p_d;
++
++	if ((srv->cur_ts % 10) != 0) return HANDLER_GO_ON;
++
++	connection_map_clear_timeout_connections(p->con_map);
++
++	return HANDLER_GO_ON;
++}
++
++
++/* this function is called at dlopen() time and inits the callbacks */
++
++int mod_uploadprogress_plugin_init(plugin *p) {
++	p->version     = LIGHTTPD_VERSION_ID;
++	p->name        = buffer_init_string("uploadprogress");
++
++	p->init        = mod_uploadprogress_init;
++	p->handle_uri_clean = mod_uploadprogress_uri_handler;
++	p->handle_request_end = mod_uploadprogress_request_end;
++	p->handle_request_done = mod_uploadprogress_request_done;
++//	p->connection_reset = mod_uploadprogress_request_done;
++	p->set_defaults = mod_uploadprogress_set_defaults;
++	p->cleanup     = mod_uploadprogress_free;
++	p->handle_trigger = mod_uploadprogress_trigger;
++
++	p->data        = NULL;
++
++	return 0;
++}
diff --git a/www-servers/lighttpd/files/lighttpd.initd b/www-servers/lighttpd/files/lighttpd.initd
index e14598def328..5d61cbb2589d 100644
--- a/www-servers/lighttpd/files/lighttpd.initd
+++ b/www-servers/lighttpd/files/lighttpd.initd
@@ -1,7 +1,7 @@
 #!/sbin/runscript
 # Copyright 1999-2011 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/www-servers/lighttpd/files/lighttpd.initd,v 1.17 2011/05/13 14:06:56 hwoarang Exp $
+# $Header: /var/cvsroot/gentoo-x86/www-servers/lighttpd/files/lighttpd.initd,v 1.18 2011/09/19 17:05:45 hwoarang Exp $
 
 opts="reload graceful"
 
@@ -50,7 +50,7 @@ reload() {
 	checkconfig || return 1
 
 	ebegin "Re-opening lighttpd log files"
-	start-stop-daemon --stop --oknodo --quiet --pidfile "${LIGHTTPD_PID}" \
+	start-stop-daemon --stop --quiet --pidfile "${LIGHTTPD_PID}" \
 		--signal HUP
 	eend $?
 }
@@ -63,7 +63,7 @@ graceful() {
 	checkconfig || return 1
 
 	ebegin "Gracefully stopping lighttpd"
-	start-stop-daemon --stop --oknodo --quiet --pidfile "${LIGHTTPD_PID}" \
+	start-stop-daemon --stop --quiet --pidfile "${LIGHTTPD_PID}" \
 		--signal INT
 	if eend $? ; then
 		rm -f "${LIGHTTPD_PID}"
diff --git a/www-servers/lighttpd/lighttpd-1.4.29-r2.ebuild b/www-servers/lighttpd/lighttpd-1.4.29-r2.ebuild
new file mode 100644
index 000000000000..b20c629118e9
--- /dev/null
+++ b/www-servers/lighttpd/lighttpd-1.4.29-r2.ebuild
@@ -0,0 +1,217 @@
+# Copyright 1999-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/www-servers/lighttpd/lighttpd-1.4.29-r2.ebuild,v 1.1 2011/09/19 17:05:45 hwoarang Exp $
+
+EAPI="4"
+
+inherit base autotools eutils depend.php
+
+DESCRIPTION="Lightweight high-performance web server"
+HOMEPAGE="http://www.lighttpd.net/"
+SRC_URI="http://download.lighttpd.net/lighttpd/releases-1.4.x/${P}.tar.bz2"
+
+LICENSE="BSD"
+SLOT="0"
+KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~sh ~sparc ~x86 ~sparc-fbsd ~x86-fbsd"
+IUSE="bzip2 doc fam gdbm ipv6 kerberos ldap libev lua minimal memcache mysql pcre php rrdtool ssl test uploadprogress webdav xattr zlib"
+
+REQUIRED_USE="kerberos? ( ssl )"
+
+RDEPEND="
+	bzip2?    ( app-arch/bzip2 )
+	fam?      ( virtual/fam )
+	gdbm?     ( sys-libs/gdbm )
+	ldap?     ( >=net-nds/openldap-2.1.26 )
+	libev?    ( >=dev-libs/libev-4.01 )
+	lua?      ( >=dev-lang/lua-5.1 )
+	memcache? ( dev-libs/libmemcache )
+	mysql?    ( >=virtual/mysql-4.0 )
+	pcre?     ( >=dev-libs/libpcre-3.1 )
+	php?      ( dev-lang/php[cgi] )
+	rrdtool?  ( net-analyzer/rrdtool )
+	ssl?    ( >=dev-libs/openssl-0.9.7[kerberos?] )
+	webdav? (
+		dev-libs/libxml2
+		>=dev-db/sqlite-3
+		sys-fs/e2fsprogs
+	)
+	xattr? ( kernel_linux? ( sys-apps/attr ) )
+	zlib? (	>=sys-libs/zlib-1.1 )"
+
+DEPEND="${RDEPEND}
+	dev-util/pkgconfig
+	doc?  ( dev-python/docutils )
+	test? (
+		virtual/perl-Test-Harness
+		dev-libs/fcgi
+	)"
+
+# update certain parts of lighttpd.conf based on conditionals
+update_config() {
+	local config="${D}/etc/lighttpd/lighttpd.conf"
+
+	# enable php/mod_fastcgi settings
+	use php && { sed -i -e 's|#.*\(include.*fastcgi.*$\)|\1|' ${config} || die; }
+
+	# enable stat() caching
+	use fam && { sed -i -e 's|#\(.*stat-cache.*$\)|\1|' ${config} || die; }
+
+	# automatically listen on IPv6 if built with USE=ipv6. Bug #234987
+	use ipv6 && { sed -i -e 's|# server.use-ipv6|server.use-ipv6|' ${config} || die; }
+}
+
+# remove non-essential stuff (for USE=minimal)
+remove_non_essential() {
+	local libdir="${D}/usr/$(get_libdir)/${PN}"
+
+	# text docs
+	use doc || rm -fr "${D}"/usr/share/doc/${PF}/txt
+
+	# non-essential modules
+	rm -f \
+		${libdir}/mod_{compress,evhost,expire,proxy,scgi,secdownload,simple_vhost,status,setenv,trigger*,usertrack}.*
+
+	# allow users to keep some based on USE flags
+	use pcre    || rm -f ${libdir}/mod_{ssi,re{direct,write}}.*
+	use webdav  || rm -f ${libdir}/mod_webdav.*
+	use mysql   || rm -f ${libdir}/mod_mysql_vhost.*
+	use lua     || rm -f ${libdir}/mod_{cml,magnet}.*
+	use rrdtool || rm -f ${libdir}/mod_rrdtool.*
+	use zlib    || rm -f ${libdir}/mod_compress.*
+}
+
+pkg_setup() {
+	if ! use pcre ; then
+		ewarn "It is highly recommended that you build ${PN}"
+		ewarn "with perl regular expressions support via USE=pcre."
+		ewarn "Otherwise you lose support for some core options such"
+		ewarn "as conditionals and modules such as mod_re{write,direct}"
+		ewarn "and mod_ssi."
+	fi
+
+	enewgroup lighttpd
+	enewuser lighttpd -1 -1 /var/www/localhost/htdocs lighttpd
+}
+
+src_prepare() {
+	base_src_prepare
+	#dev-python/docutils installs rst2html.py not rst2html
+	sed -i -e 's|\(rst2html\)|\1.py|g' doc/outdated/Makefile.am || \
+		die "sed doc/Makefile.am failed"
+	# Experimental patch for progress bar. Bug #380093
+	if use uploadprogress; then
+	    epatch "${FILESDIR}"/${P}-mod_uploadprogress.patch
+	fi
+	eautoreconf
+}
+src_configure() {
+	econf --libdir=/usr/$(get_libdir)/${PN} \
+		--enable-lfs \
+		$(use_enable ipv6) \
+		$(use_with bzip2) \
+		$(use_with fam) \
+		$(use_with gdbm) \
+		$(use_with kerberos kerberos5) \
+		$(use_with ldap) \
+		$(use_with libev) \
+		$(use_with lua) \
+		$(use_with memcache) \
+		$(use_with mysql) \
+		$(use_with pcre) \
+		$(use_with ssl openssl) \
+		$(use_with webdav webdav-props) \
+		$(use_with webdav webdav-locks) \
+		$(use_with xattr attr) \
+		$(use_with zlib)
+}
+
+src_compile() {
+	emake || die "emake failed"
+
+	if use doc ; then
+		einfo "Building HTML documentation"
+		cd doc
+		emake html || die "failed to build HTML documentation"
+	fi
+}
+
+src_test() {
+	if [[ ${EUID} -eq 0 ]]; then
+		default_src_test
+	else
+		ewarn "test skipped, please re-run as root if you wish to test ${PN}"
+	fi
+}
+
+src_install() {
+	make DESTDIR="${D}" install || die "make install failed"
+
+	# init script stuff
+	newinitd "${FILESDIR}"/lighttpd.initd lighttpd || die
+	newconfd "${FILESDIR}"/lighttpd.confd lighttpd || die
+	use fam && has_version app-admin/fam && \
+		sed -i 's/after famd/need famd/g' "${D}"/etc/init.d/lighttpd
+
+	# configs
+	insinto /etc/lighttpd
+	doins "${FILESDIR}"/conf/lighttpd.conf
+	doins "${FILESDIR}"/conf/mime-types.conf
+	doins "${FILESDIR}"/conf/mod_cgi.conf
+	doins "${FILESDIR}"/conf/mod_fastcgi.conf
+	# Secure directory for fastcgi sockets
+	keepdir /var/run/lighttpd/
+	fperms 0750 /var/run/lighttpd/
+	fowners lighttpd:lighttpd /var/run/lighttpd/
+
+	# update lighttpd.conf directives based on conditionals
+	update_config
+
+	# docs
+	dodoc AUTHORS README NEWS doc/scripts/*.sh
+	newdoc doc/config//lighttpd.conf lighttpd.conf.distrib
+
+	use doc && dohtml -r doc/*
+
+	docinto txt
+	dodoc doc/outdated/*.txt || die
+
+	# logrotate
+	insinto /etc/logrotate.d
+	newins "${FILESDIR}"/lighttpd.logrotate lighttpd || die
+
+	keepdir /var/l{ib,og}/lighttpd /var/www/localhost/htdocs
+	fowners lighttpd:lighttpd /var/l{ib,og}/lighttpd
+	fperms 0750 /var/l{ib,og}/lighttpd
+
+	#spawn-fcgi may optionally be installed via www-servers/spawn-fcgi
+	rm -f "${D}"/usr/bin/spawn-fcgi "${D}"/usr/share/man/man1/spawn-fcgi.*
+
+	use minimal && remove_non_essential
+}
+
+pkg_postinst () {
+	if use ipv6; then
+		elog "IPv6 migration guide:"
+		elog "http://redmine.lighttpd.net/projects/lighttpd/wiki/IPv6-Config"
+	fi
+	if [[ -f ${ROOT}etc/conf.d/spawn-fcgi.conf ]] ; then
+		einfo "spawn-fcgi is now provided by www-servers/spawn-fcgi."
+		einfo "spawn-fcgi's init script configuration is now located"
+		einfo "at /etc/conf.d/spawn-fcgi."
+	fi
+
+	if [[ -f ${ROOT}etc/lighttpd.conf ]] ; then
+		elog "Gentoo has a customized configuration,"
+		elog "which is now located in /etc/lighttpd.  Please migrate your"
+		elog "existing configuration."
+	fi
+
+	if use uploadprogress; then
+		elog "WARNING! mod_uploadprogress is a backported module from the"
+		elog "1.5x-branch, which is not considered stable yet. Please go to"
+		elog "http://redmine.lighttpd.net/wiki/1/Docs:ModUploadProgress"
+		elog "for more information. This configuration also is NOT supported"
+		elog "by upstream, so please refrain from reporting bugs. You have"
+		elog "been warned!"
+	fi
+}
diff --git a/www-servers/lighttpd/metadata.xml b/www-servers/lighttpd/metadata.xml
index 4264d2b49257..11a4bc56ab8c 100644
--- a/www-servers/lighttpd/metadata.xml
+++ b/www-servers/lighttpd/metadata.xml
@@ -23,6 +23,7 @@
 		<flag name='memcache'>Enable memcache support for mod_cml and
 			mod_trigger_b4_dl</flag>
 		<flag name='rrdtool'>Enable rrdtool support via mod_rrdtool</flag>
+		<flag name='uploadprogress'>Apply experimental patch for upload progress module</flag>
 		<flag name='webdav'>Enable webdav properties</flag>
 	</use>
 </pkgmetadata>