diff --git a/event.c b/event.c
index 74ba5c4..06984b8 100644
--- a/event.c
+++ b/event.c
@@ -138,10 +138,12 @@ detect_monotonic(void)
 static int
 gettime(struct event_base *base, struct timeval *tp)
 {
+/*
 	if (base->tv_cache.tv_sec) {
 		*tp = base->tv_cache;
 		return (0);
 	}
+*/
 
 #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
 	if (use_monotonic) {
@@ -481,7 +483,7 @@ event_base_loop(struct event_base *base, int flags)
 	int res, done;
 
 	/* clear time cache */
-	base->tv_cache.tv_sec = 0;
+	/* base->tv_cache.tv_sec = 0; */
 
 	if (base->sig.ev_signal_added)
 		evsignal_base = base;
@@ -533,13 +535,13 @@ event_base_loop(struct event_base *base, int flags)
 		gettime(base, &base->event_tv);
 
 		/* clear time cache */
-		base->tv_cache.tv_sec = 0;
+		/* base->tv_cache.tv_sec = 0; */
 
 		res = evsel->dispatch(base, evbase, tv_p);
 
 		if (res == -1)
 			return (-1);
-		gettime(base, &base->tv_cache);
+		/* gettime(base, &base->tv_cache); */
 
 		timeout_process(base);
 
@@ -552,7 +554,7 @@ event_base_loop(struct event_base *base, int flags)
 	}
 
 	/* clear time cache */
-	base->tv_cache.tv_sec = 0;
+	/* base->tv_cache.tv_sec = 0; */
 
 	event_debug(("%s: asked to terminate loop.", __func__));
 	return (0);
diff --git a/evhttp.h b/evhttp.h
index 7ddf720..13c8b79 100644
--- a/evhttp.h
+++ b/evhttp.h
@@ -81,12 +81,50 @@ struct evhttp *evhttp_new(struct event_base *base);
  * @param http a pointer to an evhttp object
  * @param address a string containing the IP address to listen(2) on
  * @param port the port number to listen on
- * @return a newly allocated evhttp struct
+ * @return 0 on success, -1 on error
  * @see evhttp_free()
  */
 int evhttp_bind_socket(struct evhttp *http, const char *address, u_short port);
 
 /**
+ * Binds an HTTP server on the specified address and port, using backlog.
+ *
+ * Can be called multiple times to bind the same http server
+ * to multiple different ports.
+ *
+ * @param http a pointer to an evhttp object
+ * @param address a string containing the IP address to listen(2) on
+ * @param port the port number to listen on
+ * @param backlog the backlog value for listen(2)
+ * @return 0 on success, -1 on error
+ * @see evhttp_free()
+ */
+int evhttp_bind_socket_backlog(struct evhttp *http, const char *address, u_short port, int backlog);
+
+/**
+ * Like evhttp_bind_socket(), but returns the socket file descriptor.
+ *
+ * @param http a pointer to an evhttp object
+ * @param address a string containing the IP address to listen(2) on
+ * @param port the port number to listen on
+ * @return Socket file descriptor on success, -1 on failure
+ * @see evhttp_bind_socket()
+ */
+int evhttp_bind_socket_with_fd(struct evhttp *http, const char *address, u_short port);
+
+/**
+ * Like evhttp_bind_socket(), but returns the socket file descriptor.
+ *
+ * @param http a pointer to an evhttp object
+ * @param address a string containing the IP address to listen(2) on
+ * @param port the port number to listen on
+ * @param backlog the backlog value for listen(2)
+ * @return Socket file descriptor on success, -1 on failure
+ * @see evhttp_bind_socket()
+ */
+int evhttp_bind_socket_backlog_fd(struct evhttp *http, const char *address, u_short port, int backlog);
+
+/**
  * Makes an HTTP server accept connections on the specified socket
  *
  * This may be useful to create a socket and then fork multiple instances
@@ -105,6 +143,21 @@ int evhttp_bind_socket(struct evhttp *http, const char *address, u_short port);
 int evhttp_accept_socket(struct evhttp *http, int fd);
 
 /**
+ * Makes an HTTP server stop accepting connections on the specified socket
+ *
+ * This may be useful when a socket has been sent via file descriptor passing
+ * and is no longer needed by the current process.
+ *
+ * This function does not close the socket.
+ *
+ * @param http a pointer to an evhttp object
+ * @param fd a socket fd that is currently accepting connections
+ * @return 0 on success, -1 on failure.
+ * @see evhttp_accept_socket()
+ */
+int evhttp_del_accept_socket(struct evhttp *http, int fd);
+
+/**
  * Free the previously created HTTP server.
  *
  * Works only if no requests are currently being served.
@@ -134,6 +187,28 @@ void evhttp_set_gencb(struct evhttp *,
  */
 void evhttp_set_timeout(struct evhttp *, int timeout_in_secs);
 
+/**
+ * Limit the number of simultaneous connections via this http instance.
+ *
+ * @param http an evhttp object
+ * @param nlimit the maximum number of connections, zero is unlimited
+ */
+int evhttp_set_connection_limit(struct evhttp *http, int nlimit);
+ 
+/**
+ * Return the maximum number of connections allowed for this instance.
+ *
+ * @param http an evhttp object
+ */
+int evhttp_get_connection_limit(struct evhttp *http);
+
+/**
+ * Return the number of connections in this instance.
+ *
+ * @param http an evhttp object
+ */
+int evhttp_get_connection_count(struct evhttp *http);
+
 /* Request/Response functionality */
 
 /**
@@ -157,6 +232,19 @@ void evhttp_send_error(struct evhttp_request *req, int error,
 void evhttp_send_reply(struct evhttp_request *req, int code,
     const char *reason, struct evbuffer *databuf);
 
+/**
+ * Send an HTML reply synchronously as much as possible by calling _begin().
+ * Great for a worker thread to send the reply immediately without queuing up
+ * events back to the loop. Call _end() to send the rest of the packet from
+ * event loop.
+ *
+ * When _begin() returns needs to be fed into _end() as the 1st parameter
+ * "nwritten".
+ */
+int evhttp_send_reply_sync_begin(struct evhttp_request *req, int code,
+                                 const char *reason, struct evbuffer *databuf);
+void evhttp_send_reply_sync_end(int nwritten, struct evhttp_request *req);
+
 /* Low-level response interface, for streaming/chunked replies */
 void evhttp_send_reply_start(struct evhttp_request *, int, const char *);
 void evhttp_send_reply_chunk(struct evhttp_request *, struct evbuffer *);
@@ -210,6 +298,7 @@ struct {
 
 	enum evhttp_request_kind kind;
 	enum evhttp_cmd_type type;
+	char *ext_method; /* webdav methods, for example */
 
 	char *uri;			/* uri after HTTP request was parsed */
 
@@ -224,6 +313,8 @@ struct {
 	int chunked:1,                  /* a chunked request */
 	    userdone:1;                 /* the user has sent all data */
 
+	int referenced;
+
 	struct evbuffer *output_buffer;	/* outgoing post or data */
 
 	/* Callback */
diff --git a/http-internal.h b/http-internal.h
index 9cd03cd..3f60f54 100644
--- a/http-internal.h
+++ b/http-internal.h
@@ -116,6 +116,9 @@ struct evhttp {
 	TAILQ_HEAD(httpcbq, evhttp_cb) callbacks;
         struct evconq connections;
 
+        int connection_count;
+        int connection_limit;
+
         int timeout;
 
 	void (*gencb)(struct evhttp_request *req, void *);
diff --git a/http.c b/http.c
index efcec40..e10d114 100644
--- a/http.c
+++ b/http.c
@@ -219,6 +219,13 @@ static int evhttp_decode_uri_internal(const char *uri, size_t length,
 void evhttp_read(int, short, void *);
 void evhttp_write(int, short, void *);
 
+
+void evhttp_server_drop_connection(struct evhttp_connection *evcon);
+void evhttp_server_add_connection(struct evhttp *http,
+				  struct evhttp_connection *evcon);
+void evhttp_pause(struct evhttp *http);
+void evhttp_resume(struct evhttp *http);
+
 #ifndef HAVE_STRSEP
 /* strsep replacement for platforms that lack it.  Only works if
  * del is one character long. */
@@ -478,7 +485,6 @@ evhttp_make_header_response(struct evhttp_connection *evcon,
 			evhttp_add_header(req->output_headers,
 			    "Connection", "keep-alive");
 
-		if (req->minor == 1 || is_keepalive) {
 			/* 
 			 * we need to add the content length if the
 			 * user did not give it, this is required for
@@ -488,7 +494,6 @@ evhttp_make_header_response(struct evhttp_connection *evcon,
 				req->output_headers,
 				(long)EVBUFFER_LENGTH(req->output_buffer));
 		}
-	}
 
 	/* Potentially add headers for unidentified content. */
 	if (EVBUFFER_LENGTH(req->output_buffer)) {
@@ -687,14 +692,14 @@ void
 evhttp_write(int fd, short what, void *arg)
 {
 	struct evhttp_connection *evcon = arg;
-	int n;
 
 	if (what == EV_TIMEOUT) {
 		evhttp_connection_fail(evcon, EVCON_HTTP_TIMEOUT);
 		return;
 	}
 
-	n = evbuffer_write(evcon->output_buffer, fd);
+	if (EVBUFFER_LENGTH(evcon->output_buffer) != 0) {
+		int n = evbuffer_write(evcon->output_buffer, fd);
 	if (n == -1) {
 		event_debug(("%s: evbuffer_write", __func__));
 		evhttp_connection_fail(evcon, EVCON_HTTP_EOF);
@@ -706,6 +711,7 @@ evhttp_write(int fd, short what, void *arg)
 		evhttp_connection_fail(evcon, EVCON_HTTP_EOF);
 		return;
 	}
+	}
 
 	if (EVBUFFER_LENGTH(evcon->output_buffer) != 0) {
 		evhttp_add_event(&evcon->ev, 
@@ -1012,11 +1018,9 @@ evhttp_connection_free(struct evhttp_connection *evcon)
 		TAILQ_REMOVE(&evcon->requests, req, next);
 		evhttp_request_free(req);
 	}
-
-	if (evcon->http_server != NULL) {
-		struct evhttp *http = evcon->http_server;
-		TAILQ_REMOVE(&http->connections, evcon, next);
-	}
+	
+	if (evcon->http_server != NULL)
+		evhttp_server_drop_connection(evcon);
 
 	if (event_initialized(&evcon->close_ev))
 		event_del(&evcon->close_ev);
@@ -1101,10 +1105,16 @@ evhttp_connection_reset(struct evhttp_connection *evcon)
 	}
 	evcon->state = EVCON_DISCONNECTED;
 
-	evbuffer_drain(evcon->input_buffer,
-	    EVBUFFER_LENGTH(evcon->input_buffer));
-	evbuffer_drain(evcon->output_buffer,
-	    EVBUFFER_LENGTH(evcon->output_buffer));
+	/*
+	 * These can grow quite large if processing a large photo or video
+	 * upload/download.  Instead of keeping the buffers around, just
+	 * free and allocate new.
+	 */
+	evbuffer_free(evcon->input_buffer);
+	evcon->input_buffer = evbuffer_new();
+
+	evbuffer_free(evcon->output_buffer);
+	evcon->output_buffer = evbuffer_new();
 }
 
 static void
@@ -1278,19 +1288,52 @@ evhttp_parse_request_line(struct evhttp_request *req, char *line)
 	if (line == NULL)
 		return (-1);
 	uri = strsep(&line, " ");
-	if (line == NULL)
-		return (-1);
+	if (line == NULL) {
+		version = "HTTP/1.0";
+	} else {
 	version = strsep(&line, " ");
 	if (line != NULL)
 		return (-1);
+	}
 
 	/* First line */
+	req->ext_method = NULL;
 	if (strcmp(method, "GET") == 0) {
 		req->type = EVHTTP_REQ_GET;
 	} else if (strcmp(method, "POST") == 0) {
 		req->type = EVHTTP_REQ_POST;
 	} else if (strcmp(method, "HEAD") == 0) {
 		req->type = EVHTTP_REQ_HEAD;
+	} else if (strcmp(method, "OPTIONS") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "OPTIONS";
+	} else if (strcmp(method, "REPORT") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "REPORT";
+	} else if (strcmp(method, "PROPFIND") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "PROPFIND";
+	} else if (strcmp(method, "PROPPATH") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "PROPPATH";
+	} else if (strcmp(method, "MKCOL") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "MKCOL";
+	} else if (strcmp(method, "MKCALENDAR") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "MKCALENDAR";
+	} else if (strcmp(method, "PUT") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "PUT";
+	} else if (strcmp(method, "DELETE") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "DELETE";
+	} else if (strcmp(method, "LOCK") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "LOCK";
+	} else if (strcmp(method, "UNLOCK") == 0) {
+		req->type = EVHTTP_REQ_POST;
+		req->ext_method = "UNLOCK";
 	} else {
 		event_debug(("%s: bad method %s on request %p from %s",
 			__func__, method, req, req->remote_host));
@@ -1963,10 +2006,44 @@ evhttp_send_reply(struct evhttp_request *req, int code, const char *reason,
 	evhttp_send(req, databuf);
 }
 
+int
+evhttp_send_reply_sync_begin(struct evhttp_request *req, int code,
+                             const char *reason, struct evbuffer *databuf) {
+  evhttp_response_code(req, code, reason);
+	struct evhttp_connection *evcon = req->evcon;
+
+	assert(TAILQ_FIRST(&evcon->requests) == req);
+
+	/* xxx: not sure if we really should expose the data buffer this way */
+	if (databuf != NULL)
+		evbuffer_add_buffer(req->output_buffer, databuf);
+
+	/* Adds headers to the response */
+	evhttp_make_header(evcon, req);
+
+	return evbuffer_write(evcon->output_buffer, evcon->fd);
+}
+
+void
+evhttp_send_reply_sync_end(int nwritten, struct evhttp_request *req) {
+  struct evhttp_connection *evcon = req->evcon;
+
+	if (nwritten <= 0) {
+		evhttp_connection_fail(evcon, EVCON_HTTP_EOF);
+	} else if (EVBUFFER_LENGTH(evcon->output_buffer) == 0) {
+		evhttp_send_done(evcon, NULL);
+	} else {
+		evhttp_write_buffer(evcon, evhttp_send_done, NULL);
+	}
+}
+
+
 void
 evhttp_send_reply_start(struct evhttp_request *req, int code,
     const char *reason)
 {
+	req->referenced = 1;
+
 	evhttp_response_code(req, code, reason);
 	if (req->major == 1 && req->minor == 1) {
 		/* use chunked encoding for HTTP/1.1 */
@@ -1986,6 +2063,8 @@ evhttp_send_reply_chunk(struct evhttp_request *req, struct evbuffer *databuf)
 	if (evcon == NULL)
 		return;
 
+	if (req->referenced < 0) return;
+
 	if (req->chunked) {
 		evbuffer_add_printf(evcon->output_buffer, "%x\r\n",
 				    (unsigned)EVBUFFER_LENGTH(databuf));
@@ -2007,7 +2086,14 @@ evhttp_send_reply_end(struct evhttp_request *req)
 		return;
 	}
 
-	/* we expect no more calls form the user on this request */
+ 	if (req->referenced < 0) {
+ 		req->referenced = 0;
+ 		evhttp_request_free(req);
+ 		return;
+ 	}
+ 	req->referenced = 0;
+ 	
+ 	/* we expect no more calls form the user on this request */
 	req->userdone = 1;
 
 	if (req->chunked) {
@@ -2293,7 +2379,8 @@ accept_socket(int fd, short what, void *arg)
 }
 
 int
-evhttp_bind_socket(struct evhttp *http, const char *address, u_short port)
+evhttp_bind_socket_backlog_fd(struct evhttp *http, const char *address,
+				u_short port, int backlog)
 {
 	int fd;
 	int res;
@@ -2301,7 +2388,7 @@ evhttp_bind_socket(struct evhttp *http, const char *address, u_short port)
 	if ((fd = bind_socket(address, port, 1 /*reuse*/)) == -1)
 		return (-1);
 
-	if (listen(fd, 128) == -1) {
+	if (listen(fd, backlog) == -1) {
 		event_warn("%s: listen", __func__);
 		EVUTIL_CLOSESOCKET(fd);
 		return (-1);
@@ -2309,13 +2396,42 @@ evhttp_bind_socket(struct evhttp *http, const char *address, u_short port)
 
 	res = evhttp_accept_socket(http, fd);
 	
-	if (res != -1)
+	if (res != -1) {
 		event_debug(("Bound to port %d - Awaiting connections ... ",
 			port));
+		return (fd);
+	}
 
 	return (res);
 }
 
+static int
+mask_fd(int fd)
+{
+	return fd > 0 ? 0 : fd;
+}
+
+int
+evhttp_bind_socket(struct evhttp *http, const char *address, u_short port)
+{
+	return mask_fd(evhttp_bind_socket_backlog_fd(http, address, port, 128));
+}
+
+int
+evhttp_bind_socket_with_fd(struct evhttp *http, const char *address,
+				u_short port) 
+{
+	return evhttp_bind_socket_backlog_fd(http, address, port, 128);
+}
+
+int
+evhttp_bind_socket_backlog(struct evhttp *http, const char *address,
+				u_short port, int backlog) 
+{
+	return mask_fd(
+		evhttp_bind_socket_backlog_fd(http, address, port, backlog));
+}
+
 int
 evhttp_accept_socket(struct evhttp *http, int fd)
 {
@@ -2345,6 +2461,25 @@ evhttp_accept_socket(struct evhttp *http, int fd)
 	return (0);
 }
 
+int
+evhttp_del_accept_socket(struct evhttp *http, int fd)
+{
+	struct evhttp_bound_socket *bound;
+	TAILQ_FOREACH(bound, &http->sockets, next) {
+		if (bound->bind_ev.ev_fd == fd)
+			break;
+	}
+
+	if (bound == NULL)
+		return (-1);
+
+	TAILQ_REMOVE(&http->sockets, bound, next);
+	event_del(&bound->bind_ev);
+	free(bound);
+
+	return (0);
+}
+
 static struct evhttp*
 evhttp_new_object(void)
 {
@@ -2527,6 +2662,11 @@ evhttp_request_new(void (*cb)(struct evhttp_request *, void *), void *arg)
 void
 evhttp_request_free(struct evhttp_request *req)
 {
+	if (req->referenced) {
+		req->referenced = -1;
+		return;
+	}
+
 	if (req->remote_host != NULL)
 		free(req->remote_host);
 	if (req->uri != NULL)
@@ -2657,13 +2797,78 @@ evhttp_get_request(struct evhttp *http, int fd,
 	 * if we want to accept more than one request on a connection,
 	 * we need to know which http server it belongs to.
 	 */
-	evcon->http_server = http;
-	TAILQ_INSERT_TAIL(&http->connections, evcon, next);
+	 
+	evhttp_server_add_connection(http, evcon);
 	
 	if (evhttp_associate_new_request_with_connection(evcon) == -1)
 		evhttp_connection_free(evcon);
 }
 
+void
+evhttp_pause(struct evhttp *http)
+{
+	struct evhttp_bound_socket *bound;
+	TAILQ_FOREACH(bound, &http->sockets, next) {
+		event_del(&bound->bind_ev);
+	}
+}
+
+void
+evhttp_resume(struct evhttp *http)
+{
+	struct evhttp_bound_socket *bound;
+	TAILQ_FOREACH(bound, &http->sockets, next) {
+		event_add(&bound->bind_ev, 0);
+	}
+}
+
+int
+evhttp_get_connection_limit(struct evhttp *http)
+{
+	return http->connection_limit;
+}
+
+int
+evhttp_set_connection_limit(struct evhttp *http, int nlimit)
+{
+	int olimit = http->connection_limit;
+	http->connection_limit = nlimit;
+	return olimit;
+}
+
+int
+evhttp_get_connection_count(struct evhttp *http)
+{
+	return http != NULL ? http->connection_count : 0;
+}
+
+void
+evhttp_server_add_connection(struct evhttp *http,
+			     struct evhttp_connection *evcon)
+{
+	evcon->http_server = http;
+	TAILQ_INSERT_TAIL(&http->connections, evcon, next);
+
+	http->connection_count++;
+	if (http->connection_limit > 0
+		&& http->connection_count >= http->connection_limit)
+	{
+		evhttp_pause(http);
+	}
+}
+
+void
+evhttp_server_drop_connection(struct evhttp_connection *evcon)
+{
+	struct evhttp *http = evcon->http_server;
+	TAILQ_REMOVE(&http->connections, evcon, next);
+	http->connection_count--;
+	if (http->connection_limit > 0
+		&& http->connection_count < http->connection_limit)
+	{
+		evhttp_resume(http);
+	}
+}
 
 /*
  * Network helper functions that we do not want to export to the rest of