[multiple] prefer (connection *) to (srv *)

convert all log_error_write() to log_error() and pass (log_error_st *)

use con->errh in preference to srv->errh (even though currently same)

avoid passing (server *) when previously used only for logging (errh)

src/array.c

@@ -8,9 +8,6 @@
 #include <stdlib.h>
 #include <limits.h>
 
-#include <errno.h>
-#include <assert.h>
-
 __attribute_cold__
 static void array_extend(array * const a, uint32_t n) {
     a->size  += n;

src/base.h

@@ -86,6 +86,7 @@ typedef struct {
 	const buffer *error_handler;
 	const buffer *error_handler_404;
 	const buffer *errorfile_prefix;
+	log_error_st *errh;
 
 	unsigned short max_keep_alive_requests;
 	unsigned short max_keep_alive_idle;
@@ -211,7 +212,6 @@ struct connection {
 	int mode;                    /* DIRECT (0) or plugin id */
 	int async_callback;
 
-	log_error_st *errh;
 	server *srv;
 
 	void **plugin_ctx;           /* plugin connection specific config */
@@ -230,8 +230,8 @@ struct connection {
 	http_method_t error_handler_saved_method;
 
 	struct server_socket *srv_socket;   /* reference to the server-socket */
-	int (* network_write)(struct server *srv, struct connection *con, chunkqueue *cq, off_t max_bytes);
-	int (* network_read)(struct server *srv, struct connection *con, chunkqueue *cq, off_t max_bytes);
+	int (* network_write)(struct connection *con, chunkqueue *cq, off_t max_bytes);
+	int (* network_read)(struct connection *con, chunkqueue *cq, off_t max_bytes);
 };
 
 typedef struct {
@@ -322,7 +322,7 @@ struct server {
 	struct stat_cache *stat_cache;
 
 	struct fdevents *ev;
-	int (* network_backend_write)(struct server *srv, int fd, chunkqueue *cq, off_t max_bytes);
+	int (* network_backend_write)(int fd, chunkqueue *cq, off_t max_bytes, log_error_st *errh);
 	handler_t (* request_env)(struct server *srv, connection *con);
 
 	/* buffers */

src/chunk.c

@@ -503,7 +503,7 @@ void chunkqueue_steal(chunkqueue *dest, chunkqueue *src, off_t len) {
 	}
 }
 
-static chunk *chunkqueue_get_append_tempfile(server *srv, chunkqueue *cq) {
+static chunk *chunkqueue_get_append_tempfile(chunkqueue *cq, log_error_st *errh) {
 	chunk *c;
 	buffer *template = buffer_init_string("/var/tmp/lighttpd-upload-XXXXXX");
 	int fd = -1;
@@ -525,9 +525,8 @@ static chunk *chunkqueue_get_append_tempfile(server *srv, chunkqueue *cq) {
 	if (fd < 0) {
 		/* (report only the last error to mkstemp()
 		 *  if multiple temp dirs attempted) */
-		log_error_write(srv, __FILE__, __LINE__, "sbs",
-				"opening temp-file failed:",
-				template, strerror(errno));
+		log_perror(errh, __FILE__, __LINE__,
+		  "opening temp-file failed: %s", template->ptr);
 		buffer_free(template);
 		return NULL;
 	}
@@ -541,7 +540,7 @@ static chunk *chunkqueue_get_append_tempfile(server *srv, chunkqueue *cq) {
 	return c;
 }
 
-int chunkqueue_append_mem_to_tempfile(server *srv, chunkqueue *dest, const char *mem, size_t len) {
+int chunkqueue_append_mem_to_tempfile(chunkqueue *dest, const char *mem, size_t len, log_error_st *errh) {
 	chunk *dst_c;
 	ssize_t written;
 
@@ -569,9 +568,8 @@ int chunkqueue_append_mem_to_tempfile(server *srv, chunkqueue *dest, const char
 				int rc = close(dst_c->file.fd);
 				dst_c->file.fd = -1;
 				if (0 != rc) {
-					log_error_write(srv, __FILE__, __LINE__, "sbss",
-						"close() temp-file", dst_c->mem, "failed:",
-						strerror(errno));
+					log_perror(errh, __FILE__, __LINE__,
+					  "close() temp-file %s failed", dst_c->mem->ptr);
 					return -1;
 				}
 				dst_c = NULL;
@@ -580,7 +578,7 @@ int chunkqueue_append_mem_to_tempfile(server *srv, chunkqueue *dest, const char
 			dst_c = NULL;
 		}
 
-		if (NULL == dst_c && NULL == (dst_c = chunkqueue_get_append_tempfile(srv, dest))) {
+		if (NULL == dst_c && NULL == (dst_c = chunkqueue_get_append_tempfile(dest, errh))) {
 			return -1;
 		}
 	      #ifdef __COVERITY__
@@ -609,9 +607,8 @@ int chunkqueue_append_mem_to_tempfile(server *srv, chunkqueue *dest, const char
 		} else {
 			int retry = (errno == ENOSPC && dest->tempdirs && ++dest->tempdir_idx < dest->tempdirs->used);
 			if (!retry) {
-				log_error_write(srv, __FILE__, __LINE__, "sbs",
-						"write() temp-file", dst_c->mem, "failed:",
-						strerror(errno));
+				log_perror(errh, __FILE__, __LINE__,
+				  "write() temp-file %s failed", dst_c->mem->ptr);
 			}
 
 			if (0 == chunk_remaining_length(dst_c)) {
@@ -621,9 +618,8 @@ int chunkqueue_append_mem_to_tempfile(server *srv, chunkqueue *dest, const char
 				int rc = close(dst_c->file.fd);
 				dst_c->file.fd = -1;
 				if (0 != rc) {
-					log_error_write(srv, __FILE__, __LINE__, "sbss",
-						"close() temp-file", dst_c->mem, "failed:",
-						strerror(errno));
+					log_perror(errh, __FILE__, __LINE__,
+					  "close() temp-file %s failed", dst_c->mem->ptr);
 					return -1;
 				}
 			}
@@ -637,7 +633,7 @@ int chunkqueue_append_mem_to_tempfile(server *srv, chunkqueue *dest, const char
 	return -1;
 }
 
-int chunkqueue_steal_with_tempfiles(server *srv, chunkqueue *dest, chunkqueue *src, off_t len) {
+int chunkqueue_steal_with_tempfiles(chunkqueue *dest, chunkqueue *src, off_t len, log_error_st *errh) {
 	while (len > 0) {
 		chunk *c = src->first;
 		off_t clen = 0, use;
@@ -676,7 +672,7 @@ int chunkqueue_steal_with_tempfiles(server *srv, chunkqueue *dest, chunkqueue *s
 
 		case MEM_CHUNK:
 			/* store "use" bytes from memory chunk in tempfile */
-			if (0 != chunkqueue_append_mem_to_tempfile(srv, dest, c->mem->ptr + c->offset, use)) {
+			if (0 != chunkqueue_append_mem_to_tempfile(dest, c->mem->ptr + c->offset, use, errh)) {
 				return -1;
 			}
 
@@ -783,7 +779,7 @@ void chunkqueue_compact_mem(chunkqueue *cq, size_t clen) {
      * no data added/removed from chunkqueue; consolidated only */
 }
 
-int chunkqueue_open_file_chunk(server *srv, chunkqueue *cq) {
+int chunkqueue_open_file_chunk(chunkqueue *cq, log_error_st *errh) {
 	chunk* const c = cq->first;
 	off_t offset, toSend;
 	struct stat st;
@@ -798,7 +794,7 @@ int chunkqueue_open_file_chunk(server *srv, chunkqueue *cq) {
 	if (-1 == c->file.fd) {
 		/* (permit symlinks; should already have been checked.  However, TOC-TOU remains) */
 		if (-1 == (c->file.fd = fdevent_open_cloexec(c->mem->ptr, 1, O_RDONLY, 0))) {
-			log_error_write(srv, __FILE__, __LINE__, "ssb", "open failed:", strerror(errno), c->mem);
+			log_perror(errh, __FILE__, __LINE__, "open failed: %s",c->mem->ptr);
 			return -1;
 		}
 	}
@@ -807,12 +803,12 @@ int chunkqueue_open_file_chunk(server *srv, chunkqueue *cq) {
 	if (c->file.is_temp) return 0;
 
 	if (-1 == fstat(c->file.fd, &st)) {
-		log_error_write(srv, __FILE__, __LINE__, "ss", "fstat failed:", strerror(errno));
+		log_perror(errh, __FILE__, __LINE__, "fstat failed");
 		return -1;
 	}
 
 	if (offset > st.st_size || toSend > st.st_size || offset > st.st_size - toSend) {
-		log_error_write(srv, __FILE__, __LINE__, "sb", "file shrunk:", c->mem);
+		log_error(errh, __FILE__, __LINE__, "file shrunk: %s", c->mem->ptr);
 		return -1;
 	}
 

src/chunk.h

@@ -9,6 +9,8 @@
 #include "buffer.h"
 #include "array.h"
 
+struct log_error_st;    /*(declaration)*/
+
 typedef struct chunk {
 	struct chunk *next;
 	enum { MEM_CHUNK, FILE_CHUNK } type;
@@ -85,8 +87,7 @@ buffer * chunkqueue_append_buffer_open(chunkqueue *cq);
 
 void chunkqueue_append_buffer_commit(chunkqueue *cq);
 
-struct server; /*(declaration)*/
-int chunkqueue_append_mem_to_tempfile(struct server *srv, chunkqueue *cq, const char *mem, size_t len);
+int chunkqueue_append_mem_to_tempfile(chunkqueue *cq, const char *mem, size_t len, struct log_error_st *errh);
 
 /* functions to handle buffers to read into: */
 /* obtain/reserve memory in chunkqueue at least len (input) size,
@@ -109,10 +110,9 @@ void chunkqueue_mark_written(chunkqueue *cq, off_t len);
 void chunkqueue_remove_finished_chunks(chunkqueue *cq);
 
 void chunkqueue_steal(chunkqueue *dest, chunkqueue *src, off_t len);
-struct server;
-int chunkqueue_steal_with_tempfiles(struct server *srv, chunkqueue *dest, chunkqueue *src, off_t len);
+int chunkqueue_steal_with_tempfiles(chunkqueue *dest, chunkqueue *src, off_t len, struct log_error_st *errh);
 
-int chunkqueue_open_file_chunk(struct server *srv, chunkqueue *cq);
+int chunkqueue_open_file_chunk(chunkqueue *cq, struct log_error_st *errh);
 
 void chunkqueue_compact_mem(chunkqueue *cq, size_t clen);
 

src/configfile-glue.c

@@ -270,7 +270,7 @@ static void config_cond_result_trace(connection *con, const data_config *dc, int
       case COND_RESULT_TRUE:  msg = "true"; break;
       default:                msg = "invalid cond_result_t"; break;
     }
-    log_error(con->errh, __FILE__, __LINE__, "%d (%s) result: %s",
+    log_error(con->conf.errh, __FILE__, __LINE__, "%d (%s) result: %s",
               dc->context_ndx, "uncached"+(cached ? 2 : 0), msg);
 }
 
@@ -305,16 +305,16 @@ static int config_addrstr_eq_remote_ip_mask(connection *con, const char *addrstr
 	sock_addr addr;
 	if (1 == sock_addr_inet_pton(&addr, addrstr, AF_INET, 0)) {
 		if (nm_bits > 32) {
-			log_error(con->errh, __FILE__, __LINE__, "ERROR: ipv4 netmask too large: %d", nm_bits);
+			log_error(con->conf.errh, __FILE__, __LINE__, "ERROR: ipv4 netmask too large: %d", nm_bits);
 			return -1;
 		}
 	} else if (1 == sock_addr_inet_pton(&addr, addrstr, AF_INET6, 0)) {
 		if (nm_bits > 128) {
-			log_error(con->errh, __FILE__, __LINE__, "ERROR: ipv6 netmask too large: %d", nm_bits);
+			log_error(con->conf.errh, __FILE__, __LINE__, "ERROR: ipv6 netmask too large: %d", nm_bits);
 			return -1;
 		}
 	} else {
-		log_error(con->errh, __FILE__, __LINE__, "ERROR: ip addr is invalid: %s", addrstr);
+		log_error(con->conf.errh, __FILE__, __LINE__, "ERROR: ip addr is invalid: %s", addrstr);
 		return -1;
 	}
 	return sock_addr_is_addr_eq_bits(&addr, rmt, nm_bits);
@@ -327,21 +327,21 @@ static int config_addrbuf_eq_remote_ip_mask(connection *con, const buffer *strin
 	char addrstr[64]; /*(larger than INET_ADDRSTRLEN and INET6_ADDRSTRLEN)*/
 
 	if (*err) {
-		log_error(con->errh, __FILE__, __LINE__, "ERROR: non-digit found in netmask: %s %s", string->ptr, err);
+		log_error(con->conf.errh, __FILE__, __LINE__, "ERROR: non-digit found in netmask: %s %s", string->ptr, err);
 		return -1;
 	}
 
 	if (nm_bits <= 0) {
 		if (*(nm_slash+1) == '\0') {
-			log_error(con->errh, __FILE__, __LINE__, "ERROR: no number after / %s", string->ptr);
+			log_error(con->conf.errh, __FILE__, __LINE__, "ERROR: no number after / %s", string->ptr);
 		} else {
-			log_error(con->errh, __FILE__, __LINE__, "ERROR: invalid netmask <= 0: %s %s", string->ptr, err);
+			log_error(con->conf.errh, __FILE__, __LINE__, "ERROR: invalid netmask <= 0: %s %s", string->ptr, err);
 		}
 		return -1;
 	}
 
 	if (addrstrlen >= sizeof(addrstr)) {
-		log_error(con->errh, __FILE__, __LINE__, "ERROR: address string too long: %s", string->ptr);
+		log_error(con->conf.errh, __FILE__, __LINE__, "ERROR: address string too long: %s", string->ptr);
 		return -1;
 	}
 
@@ -368,7 +368,7 @@ static cond_result_t config_check_cond_nocache(connection *con, const data_confi
 		 * if the parent is not decided yet or false, we can't be true either 
 		 */
 		if (debug_cond) {
-			log_error(con->errh, __FILE__, __LINE__, "go parent %s", dc->parent->key.ptr);
+			log_error(con->conf.errh, __FILE__, __LINE__, "go parent %s", dc->parent->key.ptr);
 		}
 
 		switch (config_check_cond_cached(con, dc->parent, debug_cond)) {
@@ -391,7 +391,7 @@ static cond_result_t config_check_cond_nocache(connection *con, const data_confi
 		 * was evaluated as "false" (not unset/skipped/true)
 		 */
 		if (debug_cond) {
-			log_error(con->errh, __FILE__, __LINE__, "go prev %s", dc->prev->key.ptr);
+			log_error(con->conf.errh, __FILE__, __LINE__, "go prev %s", dc->prev->key.ptr);
 		}
 
 		/* make sure prev is checked first */
@@ -411,7 +411,7 @@ static cond_result_t config_check_cond_nocache(connection *con, const data_confi
 
 	if (!(con->conditional_is_valid & (1 << dc->comp))) {
 		if (debug_cond) {
-			log_error(con->errh, __FILE__, __LINE__, "%d %s not available yet",
+			log_error(con->conf.errh, __FILE__, __LINE__, "%d %s not available yet",
 				dc->comp,
 				dc->key.ptr);
 		}
@@ -505,6 +505,7 @@ static cond_result_t config_check_cond_nocache(connection *con, const data_confi
 
 	case COMP_HTTP_QUERY_STRING:
 		l = con->uri.query;
+		if (NULL == l->ptr) l = (buffer *)&empty_string;
 		break;
 
 	case COMP_SERVER_SOCKET:
@@ -525,12 +526,12 @@ static cond_result_t config_check_cond_nocache(connection *con, const data_confi
 	}
 
 	if (NULL == l) { /*(should not happen)*/
-		log_error(con->errh, __FILE__, __LINE__,
+		log_error(con->conf.errh, __FILE__, __LINE__,
 			"%s () compare to NULL", dc->comp_key->ptr);
 		return COND_RESULT_FALSE;
 	}
 	else if (debug_cond) {
-		log_error(con->errh, __FILE__, __LINE__,
+		log_error(con->conf.errh, __FILE__, __LINE__,
 			"%s (%s) compare to %s", dc->comp_key->ptr, l->ptr, dc->string.ptr);
 	}
 
@@ -566,7 +567,7 @@ static cond_result_t config_check_cond_calc(connection *con, const int context_n
           con->srv->config_context->data[context_ndx];
     const int debug_cond = con->conf.log_condition_handling;
     if (debug_cond) {
-        log_error(con->errh, __FILE__, __LINE__,
+        log_error(con->conf.errh, __FILE__, __LINE__,
                   "=== start of condition block ===");
     }
     return config_check_cond_nocache_calc(con, dc, debug_cond, cache);
@@ -604,10 +605,11 @@ static void config_cond_clear_node(cond_cache_t * const cond_cache, const data_c
  *
  * if the item is COND_LAST_ELEMENT we reset all items
  */
-void config_cond_cache_reset_item(server *srv, connection *con, comp_key_t item) {
+void config_cond_cache_reset_item(connection *con, comp_key_t item) {
 	cond_cache_t * const cond_cache = con->cond_cache;
-	for (uint32_t i = 0; i < srv->config_context->used; ++i) {
-		const data_config *dc = (data_config *)srv->config_context->data[i];
+	const array * const config_context = con->srv->config_context;
+	for (uint32_t i = 0; i < config_context->used; ++i) {
+		const data_config *dc = (data_config *)config_context->data[i];
 
 		if (item == dc->comp) {
 			/* clear local_result */
@@ -621,11 +623,11 @@ void config_cond_cache_reset_item(server *srv, connection *con, comp_key_t item)
 /**
  * reset the config cache to its initial state at connection start
  */
-void config_cond_cache_reset(server *srv, connection *con) {
+void config_cond_cache_reset(connection *con) {
 	con->conditional_is_valid = 0;
 	/* resetting all entries; no need to follow children as in config_cond_cache_reset_item */
 	/* static_assert(0 == COND_RESULT_UNSET); */
-	const uint32_t used = srv->config_context->used;
+	const uint32_t used = con->srv->config_context->used;
 	if (used > 1)
 		memset(con->cond_cache, 0, used*sizeof(cond_cache_t));
 }

src/configfile.c

@@ -231,7 +231,7 @@ static int config_burl_normalize_cond (server *srv) {
 
 #if defined(HAVE_MYSQL) || (defined(HAVE_LDAP_H) && defined(HAVE_LBER_H) && defined(HAVE_LIBLDAP) && defined(HAVE_LIBLBER))
 static void config_warn_authn_module (server *srv, const char *module, size_t len) {
-	for (size_t i = 0; i < srv->config_context->used; ++i) {
+	for (uint32_t i = 0; i < srv->config_context->used; ++i) {
 		const data_config *config = (data_config const*)srv->config_context->data[i];
 		const data_unset *du = array_get_element_klen(config->value, CONST_STR_LEN("auth.backend"));
 		if (NULL != du && du->type == TYPE_STRING) {
@@ -240,7 +240,12 @@ static void config_warn_authn_module (server *srv, const char *module, size_t le
 				buffer_copy_string_len(srv->tmp_buf, CONST_STR_LEN("mod_authn_"));
 				buffer_append_string_len(srv->tmp_buf, module, len);
 				array_insert_value(srv->srvconf.modules, CONST_BUF_LEN(srv->tmp_buf));
-				log_error_write(srv, __FILE__, __LINE__, "SSSsSSS", "Warning: please add \"mod_authn_", module, "\" to server.modules list in lighttpd.conf.  A future release of lighttpd 1.4.x will not automatically load mod_authn_", module, "and lighttpd will fail to start up since your lighttpd.conf uses auth.backend = \"", module, "\".");
+				log_error(srv->errh, __FILE__, __LINE__,
+				  "Warning: please add \"mod_authn_%s\" to server.modules list "
+				  "in lighttpd.conf.  A future release of lighttpd 1.4.x will "
+				  "not automatically load mod_authn_%s and lighttpd will fail "
+				  "to start up since your lighttpd.conf uses "
+				  "auth.backend = \"%s\".", module, module, module);
 				return;
 			}
 		}
@@ -250,14 +255,19 @@ static void config_warn_authn_module (server *srv, const char *module, size_t le
 
 #ifdef USE_OPENSSL_CRYPTO
 static void config_warn_openssl_module (server *srv) {
-	for (size_t i = 0; i < srv->config_context->used; ++i) {
+	for (uint32_t i = 0; i < srv->config_context->used; ++i) {
 		const data_config *config = (data_config const*)srv->config_context->data[i];
-		for (size_t j = 0; j < config->value->used; ++j) {
+		for (uint32_t j = 0; j < config->value->used; ++j) {
 			data_unset *du = config->value->data[j];
 			if (0 == strncmp(du->key.ptr, "ssl.", sizeof("ssl.")-1)) {
 				/* mod_openssl should be loaded after mod_extforward */
 				array_insert_value(srv->srvconf.modules, CONST_STR_LEN("mod_openssl"));
-				log_error_write(srv, __FILE__, __LINE__, "S", "Warning: please add \"mod_openssl\" to server.modules list in lighttpd.conf.  A future release of lighttpd 1.4.x *will not* automatically load mod_openssl and lighttpd *will not* use SSL/TLS where your lighttpd.conf contains ssl.* directives");
+				log_error(srv->errh, __FILE__, __LINE__,
+				  "Warning: please add \"mod_openssl\" to server.modules list "
+				  "in lighttpd.conf.  A future release of lighttpd 1.4.x "
+				  "*will not* automatically load mod_openssl and lighttpd "
+				  "*will not* use SSL/TLS where your lighttpd.conf contains "
+				  "ssl.* directives");
 				return;
 			}
 		}
@@ -942,6 +952,7 @@ static int config_insert(server *srv) {
         }
     }
 
+    p->defaults.errh = srv->errh;
     p->defaults.max_keep_alive_requests = 100;
     p->defaults.max_keep_alive_idle = 5;
     p->defaults.max_read_idle = 60;
@@ -1461,7 +1472,7 @@ static int config_tokenizer(server *srv, tokenizer_t *t, int *token_id, buffer *
 		*token_id = tid;
 		return 1;
 	} else if (t->offset < t->size) {
-		log_error_write(srv, __FILE__, __LINE__, "Dsb", tid, ",", token);
+		log_error(srv->errh, __FILE__, __LINE__, "%d, %s", tid, token->ptr);
 	}
 	return 0;
 }
@@ -1524,8 +1535,8 @@ static int config_parse_file_stream(server *srv, config_t *context, const char *
 	stream s;
 
 	if (0 != stream_open(&s, fn)) {
-		log_error(srv->errh, __FILE__, __LINE__,
-		          "opening configfile %s failed: %s", fn, strerror(errno));
+		log_perror(srv->errh, __FILE__, __LINE__,
+		  "opening configfile %s failed", fn);
 		return -1;
 	}
 
@@ -1566,12 +1577,12 @@ int config_parse_file(server *srv, config_t *context, const char *fn) {
 			ret = 0; /* not an error if no files match glob pattern */
 		}
 		else {
-			log_error_write(srv, __FILE__, __LINE__, "sb", "include file not found: ", filename);
+			log_error(srv->errh, __FILE__, __LINE__, "include file not found: %s", filename->ptr);
 		}
 		break;
 	case GLOB_ABORTED:
 	case GLOB_NOSPACE:
-		log_error_write(srv, __FILE__, __LINE__, "sbss", "glob()", filename, "failed:", strerror(errno));
+		log_perror(srv->errh, __FILE__, __LINE__, "glob() %s failed", filename->ptr);
 		break;
 	}
 
@@ -1601,22 +1612,20 @@ int config_parse_cmd(server *srv, config_t *context, const char *cmd) {
 	char oldpwd[PATH_MAX];
 
 	if (NULL == getcwd(oldpwd, sizeof(oldpwd))) {
-		log_error_write(srv, __FILE__, __LINE__, "s",
-			"cannot get cwd", strerror(errno));
+		log_perror(srv->errh, __FILE__, __LINE__, "getcwd()");
 		return -1;
 	}
 
 	if (!buffer_string_is_empty(context->basedir)) {
 		if (0 != chdir(context->basedir->ptr)) {
-			log_error_write(srv, __FILE__, __LINE__, "sbs",
-				"cannot change directory to", context->basedir, strerror(errno));
+			log_perror(srv->errh, __FILE__, __LINE__,
+			  "cannot change directory to %s", context->basedir->ptr);
 			return -1;
 		}
 	}
 
 	if (pipe(fds)) {
-		log_error_write(srv, __FILE__, __LINE__, "ss",
-				"pipe failed: ", strerror(errno));
+		log_perror(srv->errh, __FILE__, __LINE__, "pipe()");
 		ret = -1;
 	}
 	else {
@@ -1631,8 +1640,7 @@ int config_parse_cmd(server *srv, config_t *context, const char *cmd) {
 		fdevent_setfd_cloexec(fds[0]);
 		pid = fdevent_fork_execve(args[0], args, NULL, -1, fds[1], -1, -1);
 		if (-1 == pid) {
-			log_error_write(srv, __FILE__, __LINE__, "SSss",
-					"fork/exec(", cmd, "):", strerror(errno));
+			log_perror(srv->errh, __FILE__, __LINE__, "fork/exec(%s)", cmd);
 			ret = -1;
 		}
 		else {
@@ -1647,21 +1655,20 @@ int config_parse_cmd(server *srv, config_t *context, const char *cmd) {
 				if (rd >= 0) buffer_commit(out, (size_t)rd);
 			} while (rd > 0 || (-1 == rd && errno == EINTR));
 			if (0 != rd) {
-				log_error_write(srv, __FILE__, __LINE__, "SSss",
-						"read \"", cmd, "\" failed:", strerror(errno));
+				log_perror(srv->errh, __FILE__, __LINE__, "read \"%s\"", cmd);
 				ret = -1;
 			}
 			close(fds[0]);
 			fds[0] = -1;
 			while (-1 == (wpid = waitpid(pid, &wstatus, 0)) && errno == EINTR) ;
 			if (wpid != pid) {
-				log_error_write(srv, __FILE__, __LINE__, "SSss",
-						"waitpid \"", cmd, "\" failed:", strerror(errno));
+				log_perror(srv->errh, __FILE__, __LINE__, "waitpid \"%s\"",cmd);
 				ret = -1;
 			}
 			if (0 != wstatus) {
-				log_error_write(srv, __FILE__, __LINE__, "SSsd",
-						"command \"", cmd, "\" exited non-zero:", WEXITSTATUS(wstatus));
+				log_error(srv->errh, __FILE__, __LINE__,
+				  "command \"%s\" exited non-zero: %d",
+				  cmd, WEXITSTATUS(wstatus));
 				ret = -1;
 			}
 
@@ -1675,8 +1682,8 @@ int config_parse_cmd(server *srv, config_t *context, const char *cmd) {
 	}
 
 	if (0 != chdir(oldpwd)) {
-		log_error_write(srv, __FILE__, __LINE__, "sss",
-			"cannot change directory to", oldpwd, strerror(errno));
+		log_perror(srv->errh, __FILE__, __LINE__,
+		  "cannot change directory to %s", oldpwd);
 		ret = -1;
 	}
 	return ret;
@@ -1761,13 +1768,15 @@ int config_set_defaults(server *srv) {
 
 	if (!buffer_string_is_empty(srv->srvconf.changeroot)) {
 		if (-1 == stat(srv->srvconf.changeroot->ptr, &st1)) {
-			log_error_write(srv, __FILE__, __LINE__, "sb",
-					"server.chroot doesn't exist:", srv->srvconf.changeroot);
+			log_error(srv->errh, __FILE__, __LINE__,
+			  "server.chroot doesn't exist: %s",
+			  srv->srvconf.changeroot->ptr);
 			return -1;
 		}
 		if (!S_ISDIR(st1.st_mode)) {
-			log_error_write(srv, __FILE__, __LINE__, "sb",
-					"server.chroot isn't a directory:", srv->srvconf.changeroot);
+			log_error(srv->errh, __FILE__, __LINE__,
+			  "server.chroot isn't a directory: %s",
+			  srv->srvconf.changeroot->ptr);
 			return -1;
 		}
 	}
@@ -1793,11 +1802,11 @@ int config_set_defaults(server *srv) {
 			buffer_string_set_length(b, len); /*(truncate)*/
 			buffer_append_string_buffer(b, &ds->value);
 			if (-1 == stat(b->ptr, &st1)) {
-				log_error_write(srv, __FILE__, __LINE__, "sb",
-					"server.upload-dirs doesn't exist:", b);
+				log_error(srv->errh, __FILE__, __LINE__,
+				  "server.upload-dirs doesn't exist: %s", b->ptr);
 			} else if (!S_ISDIR(st1.st_mode)) {
-				log_error_write(srv, __FILE__, __LINE__, "sb",
-					"server.upload-dirs isn't a directory:", b);
+				log_error(srv->errh, __FILE__, __LINE__,
+				  "server.upload-dirs isn't a directory: %s", b->ptr);
 			}
 		}
 	}
@@ -1807,8 +1816,7 @@ int config_set_defaults(server *srv) {
 		srv->srvconf.upload_temp_file_size);
 
 	if (buffer_string_is_empty(s->document_root)) {
-		log_error_write(srv, __FILE__, __LINE__, "s",
-				"document-root is not set");
+		log_error(srv->errh, __FILE__, __LINE__, "document-root is not set");
 		return -1;
 	}
 

src/connections-glue.c

@@ -8,7 +8,6 @@
 #include "log.h"
 #include "response.h"
 
-#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -109,9 +108,7 @@ static int connection_handle_read_post_chunked_crlf(chunkqueue *cq) {
     return 0;
 }
 
-handler_t connection_handle_read_post_error(server *srv, connection *con, int http_status) {
-    UNUSED(srv);
-
+handler_t connection_handle_read_post_error(connection *con, int http_status) {
     con->keep_alive = 0;
 
     /*(do not change status if response headers already set and possibly sent)*/
@@ -123,7 +120,7 @@ handler_t connection_handle_read_post_error(server *srv, connection *con, int ht
     return HANDLER_FINISHED;
 }
 
-static handler_t connection_handle_read_post_chunked(server *srv, connection *con, chunkqueue *cq, chunkqueue *dst_cq) {
+static handler_t connection_handle_read_post_chunked(connection *con, chunkqueue *cq, chunkqueue *dst_cq) {
 
     /* con->conf.max_request_size is in kBytes */
     const off_t max_request_size = (off_t)con->conf.max_request_size << 10;
@@ -142,29 +139,29 @@ static handler_t connection_handle_read_post_chunked(server *srv, connection *co
                 unsigned char *s = (unsigned char *)c->mem->ptr+c->offset;
                 for (unsigned char u;(u=(unsigned char)hex2int(*s))!=0xFF;++s) {
                     if (te_chunked > (off_t)(1uLL<<(8*sizeof(off_t)-5))-1) {
-                        log_error_write(srv, __FILE__, __LINE__, "s",
-                                        "chunked data size too large -> 400");
+                        log_error(con->conf.errh, __FILE__, __LINE__,
+                          "chunked data size too large -> 400");
                         /* 400 Bad Request */
-                        return connection_handle_read_post_error(srv, con, 400);
+                        return connection_handle_read_post_error(con, 400);
                     }
                     te_chunked <<= 4;
                     te_chunked |= u;
                 }
                 while (*s == ' ' || *s == '\t') ++s;
                 if (*s != '\r' && *s != ';') {
-                    log_error_write(srv, __FILE__, __LINE__, "s",
-                                    "chunked header invalid chars -> 400");
+                    log_error(con->conf.errh, __FILE__, __LINE__,
+                      "chunked header invalid chars -> 400");
                     /* 400 Bad Request */
-                    return connection_handle_read_post_error(srv, con, 400);
+                    return connection_handle_read_post_error(con, 400);
                 }
 
                 if (hsz >= 1024) {
                     /* prevent theoretical integer overflow
                      * casting to (size_t) and adding 2 (for "\r\n") */
-                    log_error_write(srv, __FILE__, __LINE__, "s",
-                                    "chunked header line too long -> 400");
+                    log_error(con->conf.errh, __FILE__, __LINE__,
+                      "chunked header line too long -> 400");
                     /* 400 Bad Request */
-                    return connection_handle_read_post_error(srv, con, 400);
+                    return connection_handle_read_post_error(con, 400);
                 }
 
                 if (0 == te_chunked) {
@@ -188,7 +185,7 @@ static handler_t connection_handle_read_post_chunked(server *srv, connection *co
                              * potentially received by backend, if in the future
                              * these trailers are added to request headers)*/
                             if ((off_t)buffer_string_length(c->mem) - c->offset
-                                < srv->srvconf.max_request_field_size) {
+                                < con->srv->srvconf.max_request_field_size) {
                                 break;
                             }
                             else {
@@ -216,11 +213,11 @@ static handler_t connection_handle_read_post_chunked(server *srv, connection *co
                 if (0 !=max_request_size
                     && (max_request_size < te_chunked
                      || max_request_size - te_chunked < dst_cq->bytes_in)) {
-                    log_error_write(srv, __FILE__, __LINE__, "sos",
-                                    "request-size too long:",
-                                    dst_cq->bytes_in + te_chunked, "-> 413");
+                    log_error(con->conf.errh, __FILE__, __LINE__,
+                      "request-size too long: %lld -> 413",
+                      (long long)(dst_cq->bytes_in + te_chunked));
                     /* 413 Payload Too Large */
-                    return connection_handle_read_post_error(srv, con, 413);
+                    return connection_handle_read_post_error(con, 413);
                 }
 
                 te_chunked += 2; /*(for trailing "\r\n" after chunked data)*/
@@ -231,10 +228,10 @@ static handler_t connection_handle_read_post_chunked(server *srv, connection *co
             /*(likely better ways to handle chunked header crossing chunkqueue
              * chunks, but this situation is not expected to occur frequently)*/
             if ((off_t)buffer_string_length(c->mem) - c->offset >= 1024) {
-                log_error_write(srv, __FILE__, __LINE__, "s",
-                                "chunked header line too long -> 400");
+                log_error(con->conf.errh, __FILE__, __LINE__,
+                  "chunked header line too long -> 400");
                 /* 400 Bad Request */
-                return connection_handle_read_post_error(srv, con, 400);
+                return connection_handle_read_post_error(con, 400);
             }
             else if (!connection_handle_read_post_cq_compact(cq)) {
                 break;
@@ -248,9 +245,10 @@ static handler_t connection_handle_read_post_chunked(server *srv, connection *co
                 /* avoid buffering request bodies <= 64k on disk */
                 chunkqueue_steal(dst_cq, cq, len);
             }
-            else if (0 != chunkqueue_steal_with_tempfiles(srv,dst_cq,cq,len)) {
+            else if (0 != chunkqueue_steal_with_tempfiles(dst_cq, cq, len,
+                                                          con->conf.errh)) {
                 /* 500 Internal Server Error */
-                return connection_handle_read_post_error(srv, con, 500);
+                return connection_handle_read_post_error(con, 500);
             }
             te_chunked -= len;
             len = cq->bytes_in - cq->bytes_out;
@@ -260,10 +258,10 @@ static handler_t connection_handle_read_post_chunked(server *srv, connection *co
 
         if (2 == te_chunked) {
             if (-1 == connection_handle_read_post_chunked_crlf(cq)) {
-                log_error_write(srv, __FILE__, __LINE__, "s",
-                                "chunked data missing end CRLF -> 400");
+                log_error(con->conf.errh, __FILE__, __LINE__,
+                  "chunked data missing end CRLF -> 400");
                 /* 400 Bad Request */
-                return connection_handle_read_post_error(srv, con, 400);
+                return connection_handle_read_post_error(con, 400);
             }
             chunkqueue_mark_written(cq, 2);/*consume \r\n at end of chunk data*/
             te_chunked -= 2;
@@ -275,21 +273,20 @@ static handler_t connection_handle_read_post_chunked(server *srv, connection *co
     return HANDLER_GO_ON;
 }
 
-static handler_t connection_handle_read_body_unknown(server *srv, connection *con, chunkqueue *cq, chunkqueue *dst_cq) {
+static handler_t connection_handle_read_body_unknown(connection *con, chunkqueue *cq, chunkqueue *dst_cq) {
     /* con->conf.max_request_size is in kBytes */
     const off_t max_request_size = (off_t)con->conf.max_request_size << 10;
     chunkqueue_append_chunkqueue(dst_cq, cq);
     if (0 != max_request_size && dst_cq->bytes_in > max_request_size) {
-        log_error_write(srv, __FILE__, __LINE__, "sos",
-                        "request-size too long:", dst_cq->bytes_in, "-> 413");
+        log_error(con->conf.errh, __FILE__, __LINE__,
+          "request-size too long: %lld -> 413", (long long)dst_cq->bytes_in);
         /* 413 Payload Too Large */
-        return connection_handle_read_post_error(srv, con, 413);
+        return connection_handle_read_post_error(con, 413);
     }
     return HANDLER_GO_ON;
 }
 
-static off_t connection_write_throttle(server *srv, connection *con, off_t max_bytes) {
-	UNUSED(srv);
+static off_t connection_write_throttle(connection *con, off_t max_bytes) {
 	if (con->conf.global_bytes_per_second) {
 		off_t limit = (off_t)con->conf.global_bytes_per_second - *(con->conf.global_bytes_per_second_cnt_ptr);
 		if (limit <= 0) {
@@ -317,14 +314,14 @@ static off_t connection_write_throttle(server *srv, connection *con, off_t max_b
 	return max_bytes;
 }
 
-int connection_write_chunkqueue(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
+int connection_write_chunkqueue(connection *con, chunkqueue *cq, off_t max_bytes) {
 	int ret = -1;
 	off_t written = 0;
       #ifdef TCP_CORK
 	int corked = 0;
       #endif
 
-	max_bytes = connection_write_throttle(srv, con, max_bytes);
+	max_bytes = connection_write_throttle(con, max_bytes);
 	if (0 == max_bytes) return 1;
 
 	written = cq->bytes_out;
@@ -347,7 +344,7 @@ int connection_write_chunkqueue(server *srv, connection *con, chunkqueue *cq, of
 	}
       #endif
 
-	ret = con->network_write(srv, con, cq, max_bytes);
+	ret = con->network_write(con, cq, max_bytes);
 	if (ret >= 0) {
 		ret = chunkqueue_is_empty(cq) ? 0 : 1;
 	}
@@ -368,7 +365,7 @@ int connection_write_chunkqueue(server *srv, connection *con, chunkqueue *cq, of
 	return ret;
 }
 
-static int connection_write_100_continue(server *srv, connection *con) {
+static int connection_write_100_continue(connection *con) {
 	/* Make best effort to send all or none of "HTTP/1.1 100 Continue" */
 	/* (Note: also choosing not to update con->write_request_ts
 	 *  which differs from connections.c:connection_handle_write()) */
@@ -378,7 +375,7 @@ static int connection_write_100_continue(server *srv, connection *con) {
 	int rc;
 
 	off_t max_bytes =
-	  connection_write_throttle(srv, con, sizeof(http_100_continue)-1);
+	  connection_write_throttle(con, sizeof(http_100_continue)-1);
 	if (max_bytes < (off_t)sizeof(http_100_continue)-1) {
 		return 1; /* success; skip sending if throttled to partial */
 	}
@@ -387,7 +384,7 @@ static int connection_write_100_continue(server *srv, connection *con) {
 	written = cq->bytes_out;
 
 	chunkqueue_append_mem(cq,http_100_continue,sizeof(http_100_continue)-1);
-	rc = con->network_write(srv, con, cq, sizeof(http_100_continue)-1);
+	rc = con->network_write(con, cq, sizeof(http_100_continue)-1);
 
 	written = cq->bytes_out - written;
 	con->bytes_written += written;
@@ -423,7 +420,7 @@ handler_t connection_handle_read_post_state(server *srv, connection *con) {
 	if (con->is_readable) {
 		con->read_idle_ts = srv->cur_ts;
 
-		switch(con->network_read(srv, con, con->read_queue, MAX_READ_LIMIT)) {
+		switch(con->network_read(con, con->read_queue, MAX_READ_LIMIT)) {
 		case -1:
 			con->state = CON_STATE_ERROR;
 			return HANDLER_ERROR;
@@ -445,7 +442,7 @@ handler_t connection_handle_read_post_state(server *srv, connection *con) {
 		const buffer *vb = http_header_request_get(con, HTTP_HEADER_EXPECT, CONST_STR_LEN("Expect"));
 		if (NULL != vb && buffer_eq_icase_slen(vb, CONST_STR_LEN("100-continue"))) {
 			http_header_request_unset(con, HTTP_HEADER_EXPECT, CONST_STR_LEN("Expect"));
-			if (!connection_write_100_continue(srv, con)) {
+			if (!connection_write_100_continue(con)) {
 				return HANDLER_ERROR;
 			}
 		}
@@ -454,17 +451,17 @@ handler_t connection_handle_read_post_state(server *srv, connection *con) {
 	if (con->request.content_length < 0) {
 		/*(-1: Transfer-Encoding: chunked, -2: unspecified length)*/
 		handler_t rc = (-1 == con->request.content_length)
-                  ? connection_handle_read_post_chunked(srv, con, cq, dst_cq)
-                  : connection_handle_read_body_unknown(srv, con, cq, dst_cq);
+                  ? connection_handle_read_post_chunked(con, cq, dst_cq)
+                  : connection_handle_read_body_unknown(con, cq, dst_cq);
 		if (HANDLER_GO_ON != rc) return rc;
 	}
 	else if (con->request.content_length <= 64*1024) {
 		/* don't buffer request bodies <= 64k on disk */
 		chunkqueue_steal(dst_cq, cq, (off_t)con->request.content_length - dst_cq->bytes_in);
 	}
-	else if (0 != chunkqueue_steal_with_tempfiles(srv, dst_cq, cq, (off_t)con->request.content_length - dst_cq->bytes_in)) {
+	else if (0 != chunkqueue_steal_with_tempfiles(dst_cq, cq, (off_t)con->request.content_length - dst_cq->bytes_in, con->conf.errh)) {
 		/* writing to temp file failed */
-		return connection_handle_read_post_error(srv, con, 500); /* Internal Server Error */
+		return connection_handle_read_post_error(con, 500); /* Internal Server Error */
 	}
 
 	chunkqueue_remove_finished_chunks(cq);
@@ -478,7 +475,7 @@ handler_t connection_handle_read_post_state(server *srv, connection *con) {
 		return HANDLER_GO_ON;
 	} else if (is_closed) {
 	      #if 0
-		return connection_handle_read_post_error(srv, con, 400); /* Bad Request */
+		return connection_handle_read_post_error(con, 400); /* Bad Request */
 	      #endif
 		return HANDLER_ERROR;
 	} else {

src/connections.c

@@ -108,8 +108,8 @@ static void connection_plugin_ctx_check(server *srv, connection *con) {
 		plugin *p = ((plugin **)(srv->plugins.ptr))[i];
 		plugin_data_base *pd = p->data;
 		if (!pd || NULL == con->plugin_ctx[pd->id]) continue;
-		log_error_write(srv, __FILE__, __LINE__, "ss",
-				"missing cleanup in", p->name);
+		log_error(con->conf.errh, __FILE__, __LINE__,
+		  "missing cleanup in %s", p->name);
 		con->plugin_ctx[pd->id] = NULL;
 	}
 }
@@ -126,23 +126,18 @@ static int connection_close(server *srv, connection *con) {
 	fdevent_unregister(srv->ev, con->fd);
 	con->fdn = NULL;
 #ifdef __WIN32
-	if (closesocket(con->fd)) {
-		log_error_write(srv, __FILE__, __LINE__, "sds",
-				"(warning) close:", con->fd, strerror(errno));
-	}
+	if (0 == closesocket(con->fd))
 #else
-	if (close(con->fd)) {
-		log_error_write(srv, __FILE__, __LINE__, "sds",
-				"(warning) close:", con->fd, strerror(errno));
-	}
+	if (0 == close(con->fd))
 #endif
-	else {
-		srv->cur_fds--;
-	}
+		--srv->cur_fds;
+	else
+		log_perror(con->conf.errh, __FILE__, __LINE__,
+		  "(warning) close: %d", con->fd);
 
 	if (srv->srvconf.log_state_handling) {
-		log_error_write(srv, __FILE__, __LINE__, "sd",
-				"connection closed for fd", con->fd);
+		log_error(con->conf.errh, __FILE__, __LINE__,
+		  "connection closed for fd %d", con->fd);
 	}
 	con->fd = -1;
 	con->is_ssl_sock = 0;
@@ -185,7 +180,7 @@ static void connection_read_for_eos_plain(server *srv, connection *con) {
 }
 
 static void connection_read_for_eos_ssl(server *srv, connection *con) {
-	if (con->network_read(srv, con, con->read_queue, MAX_READ_LIMIT) < 0)
+	if (con->network_read(con, con->read_queue, MAX_READ_LIMIT) < 0)
 		con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
 	chunkqueue_reset(con->read_queue);
 }
@@ -217,8 +212,8 @@ static void connection_handle_shutdown(server *srv, connection *con) {
 		connection_set_state(con, CON_STATE_CLOSE);
 
 		if (srv->srvconf.log_state_handling) {
-			log_error_write(srv, __FILE__, __LINE__, "sd",
-					"shutdown for fd", con->fd);
+			log_error(con->conf.errh, __FILE__, __LINE__,
+			  "shutdown for fd %d", con->fd);
 		}
 	} else {
 		connection_close(srv, con);
@@ -226,8 +221,8 @@ static void connection_handle_shutdown(server *srv, connection *con) {
 }
 
 __attribute_cold__
-static void connection_fdwaitqueue_append(server *srv, connection *con) {
-    connection_list_append(&srv->fdwaitqueue, con);
+static void connection_fdwaitqueue_append(connection *con) {
+    connection_list_append(&con->srv->fdwaitqueue, con);
 }
 
 static void connection_handle_response_end_state(server *srv, connection *con) {
@@ -296,7 +291,7 @@ static void connection_handle_errdoc(connection *con) {
         buffer_copy_buffer(con->physical.path, con->conf.errorfile_prefix);
         buffer_append_int(con->physical.path, con->http_status);
         buffer_append_string_len(con->physical.path, CONST_STR_LEN(".html"));
-        if (0 == http_chunk_append_file(srv, con, con->physical.path)) {
+        if (0 == http_chunk_append_file(con, con->physical.path)) {
             stat_cache_entry *sce = NULL;
             if (stat_cache_get_entry(srv, con, con->physical.path, &sce)
                 != HANDLER_ERROR) {
@@ -330,7 +325,7 @@ static void connection_handle_errdoc(connection *con) {
       "</h1>\n"
       " </body>\n"
       "</html>\n"));
-    (void)http_chunk_append_mem(srv, con, CONST_BUF_LEN(b));
+    (void)http_chunk_append_mem(con, CONST_BUF_LEN(b));
 
     http_header_response_set(con, HTTP_HEADER_CONTENT_TYPE,
                              CONST_STR_LEN("Content-Type"),
@@ -393,7 +388,7 @@ static int connection_handle_write_prepare(server *srv, connection *con) {
 	case HANDLER_FINISHED:
 		break;
 	default:
-		log_error_write(srv, __FILE__, __LINE__, "s", "response_start plugin failed");
+		log_error(con->conf.errh,__FILE__,__LINE__,"response_start plugin failed");
 		return -1;
 	}
 
@@ -420,8 +415,11 @@ static int connection_handle_write_prepare(server *srv, connection *con) {
 				/* qlen = 0 is important for Redirects (301, ...) as they MAY have
 				 * a content. Browsers are waiting for a Content otherwise
 				 */
-				buffer_copy_int(srv->tmp_buf, qlen);
-				http_header_response_set(con, HTTP_HEADER_CONTENT_LENGTH, CONST_STR_LEN("Content-Length"), CONST_BUF_LEN(srv->tmp_buf));
+				buffer * const tb = con->srv->tmp_buf;
+				buffer_copy_int(tb, qlen);
+				http_header_response_set(con, HTTP_HEADER_CONTENT_LENGTH,
+				                         CONST_STR_LEN("Content-Length"),
+				                         CONST_BUF_LEN(tb));
 			}
 		}
 	} else {
@@ -465,34 +463,33 @@ static int connection_handle_write_prepare(server *srv, connection *con) {
 		con->file_finished = 1;
 	}
 
-	http_response_write_header(srv, con);
+	http_response_write_header(con);
 
 	return 0;
 }
 
 static void connection_handle_write(server *srv, connection *con) {
-	switch(connection_write_chunkqueue(srv, con, con->write_queue, MAX_WRITE_LIMIT)) {
+	switch(connection_write_chunkqueue(con, con->write_queue, MAX_WRITE_LIMIT)) {
 	case 0:
-		con->write_request_ts = srv->cur_ts;
 		if (con->file_finished) {
 			connection_set_state(con, CON_STATE_RESPONSE_END);
 		}
 		break;
 	case -1: /* error on our side */
-		log_error_write(srv, __FILE__, __LINE__, "sd",
-				"connection closed: write failed on fd", con->fd);
+		log_error(con->conf.errh, __FILE__, __LINE__,
+		  "connection closed: write failed on fd %d", con->fd);
 		connection_set_state(con, CON_STATE_ERROR);
 		break;
 	case -2: /* remote close */
 		connection_set_state(con, CON_STATE_ERROR);
 		break;
 	case 1:
-		con->write_request_ts = srv->cur_ts;
 		con->is_writable = 0;
 
 		/* not finished yet -> WRITE */
 		break;
 	}
+	con->write_request_ts = srv->cur_ts;
 }
 
 static void connection_handle_write_state(server *srv, connection *con) {
@@ -516,13 +513,13 @@ static void connection_handle_write_state(server *srv, connection *con) {
             case HANDLER_GO_ON:
                 break;
             case HANDLER_WAIT_FOR_FD:
-                connection_fdwaitqueue_append(srv, con);
+                connection_fdwaitqueue_append(con);
                 break;
             case HANDLER_COMEBACK:
             default:
-                log_error_write(srv, __FILE__, __LINE__, "sdd",
-                                "unexpected subrequest handler ret-value:",
-                                con->fd, r);
+                log_error(con->conf.errh, __FILE__, __LINE__,
+                  "unexpected subrequest handler ret-value: %d %d",
+                  con->fd, r);
                 /* fall through */
             case HANDLER_ERROR:
                 connection_set_state(con, CON_STATE_ERROR);
@@ -700,7 +697,7 @@ static int connection_reset(server *srv, connection *con) {
 	chunkqueue_reset(con->request_content_queue);
 
 	/* The cond_cache gets reset in response.c */
-	/* config_cond_cache_reset(srv, con); */
+	/* config_cond_cache_reset(con); */
 
 	con->async_callback = 0;
 	con->error_handler_saved_status = 0;
@@ -726,7 +723,7 @@ static chunk * connection_read_header_more(connection *con, chunkqueue *cq, chun
     if ((NULL == c || NULL == c->next) && con->is_readable) {
         server * const srv = con->srv;
         con->read_idle_ts = srv->cur_ts;
-        if (0 != con->network_read(srv, con, cq, MAX_READ_LIMIT))
+        if (0 != con->network_read(con, cq, MAX_READ_LIMIT))
             connection_set_state(con, CON_STATE_ERROR);
     }
 
@@ -808,7 +805,7 @@ static int connection_handle_read_state(server * const srv, connection * const c
           srv->srvconf.max_request_field_size;
         if ((con->header_len ? con->header_len : clen) > max_request_field_size
             || hoff[0] >= sizeof(hoff)/sizeof(hoff[0])-1) {
-            log_error(con->errh, __FILE__, __LINE__, "%s",
+            log_error(con->conf.errh, __FILE__, __LINE__, "%s",
                       "oversized request-header -> sending Status 431");
             con->http_status = 431; /* Request Header Fields Too Large */
             con->keep_alive = 0;
@@ -853,7 +850,7 @@ static int connection_handle_read_state(server * const srv, connection * const c
     }
 
     if (con->conf.log_request_header) {
-        log_error(con->errh, __FILE__, __LINE__,
+        log_error(con->conf.errh, __FILE__, __LINE__,
                   "fd: %d request-len: %d\n%.*s", con->fd, (int)con->header_len,
                   (int)con->header_len, hdrs);
     }
@@ -866,7 +863,7 @@ static int connection_handle_read_state(server * const srv, connection * const c
         if (srv->srvconf.log_request_header_on_error) {
             /*(http_request_parse() modifies hdrs only to
              * undo line-wrapping in-place using spaces)*/
-            log_error(con->errh, __FILE__, __LINE__, "request-header:\n%.*s",
+            log_error(con->conf.errh, __FILE__, __LINE__, "request-header:\n%.*s",
                       (int)con->header_len, hdrs);
         }
     }
@@ -954,8 +951,8 @@ static handler_t connection_handle_fdevent(server *srv, void *context, int reven
 		} else if (revents & FDEVENT_ERR) { /* error, connection reset */
 			connection_set_state(con, CON_STATE_ERROR);
 		} else {
-			log_error_write(srv, __FILE__, __LINE__, "sd",
-					"connection closed: poll() -> ???", revents);
+			log_error(con->conf.errh, __FILE__, __LINE__,
+			  "connection closed: poll() -> ??? %d", revents);
 		}
 	}
 
@@ -994,7 +991,7 @@ connection *connection_accept(server *srv, server_socket *srv_socket) {
 			/* out of fds */
 			break;
 		default:
-			log_error_write(srv, __FILE__, __LINE__, "ssd", "accept failed:", strerror(errno), errno);
+			log_perror(srv->errh, __FILE__, __LINE__, "accept failed");
 		}
 		return NULL;
 	} else {
@@ -1007,7 +1004,7 @@ connection *connection_accept(server *srv, server_socket *srv_socket) {
 
 
 /* 0: everything ok, -1: error, -2: con closed */
-static int connection_read_cq(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
+static int connection_read_cq(connection *con, chunkqueue *cq, off_t max_bytes) {
 	ssize_t len;
 	char *mem = NULL;
 	size_t mem_len = 0;
@@ -1051,7 +1048,7 @@ static int connection_read_cq(server *srv, connection *con, chunkqueue *cq, off_
 				/* suppress logging for this error, expected for keep-alive */
 				break;
 			default:
-				log_error_write(srv, __FILE__, __LINE__, "sd", "connection closed - recv failed: ", lastError);
+				log_error(con->conf.errh, __FILE__, __LINE__, "connection closed - recv failed: %d", lastError);
 				break;
 			}
 		}
@@ -1067,7 +1064,7 @@ static int connection_read_cq(server *srv, connection *con, chunkqueue *cq, off_
 			/* suppress logging for this error, expected for keep-alive */
 			break;
 		default:
-			log_error_write(srv, __FILE__, __LINE__, "ssd", "connection closed - read failed: ", strerror(errno), errno);
+			log_perror(con->conf.errh, __FILE__, __LINE__, "connection closed - read failed");
 			break;
 		}
 #endif /* __WIN32 */
@@ -1093,8 +1090,9 @@ static int connection_read_cq(server *srv, connection *con, chunkqueue *cq, off_
 }
 
 
-static int connection_write_cq(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
-	return srv->network_backend_write(srv, con->fd, cq, max_bytes);
+static int connection_write_cq(connection *con, chunkqueue *cq, off_t max_bytes) {
+	server * const srv = con->srv;
+	return srv->network_backend_write(con->fd, cq, max_bytes, con->conf.errh);
 }
 
 
@@ -1105,13 +1103,12 @@ connection *connection_accepted(server *srv, server_socket *srv_socket, sock_add
 
 		/* ok, we have the connection, register it */
 #if 0
-		log_error_write(srv, __FILE__, __LINE__, "sd",
-				"appected()", cnt);
+		log_error(srv->errh, __FILE__, __LINE__, "accepted() %d", cnt);
 #endif
 		srv->con_opened++;
 
 		con = connections_get_new_connection(srv);
-		con->errh = srv->errh;
+		con->conf.errh = srv->errh;
 		con->srv  = srv;
 
 		con->fd = cnt;
@@ -1127,7 +1124,7 @@ connection *connection_accepted(server *srv, server_socket *srv_socket, sock_add
 		con->srv_socket = srv_socket;
 		con->is_ssl_sock = srv_socket->is_ssl;
 
-		config_cond_cache_reset(srv, con);
+		config_cond_cache_reset(con);
 		con->conditional_is_valid |= (1 << COMP_SERVER_SOCKET)
 					  |  (1 << COMP_HTTP_REMOTE_IP);
 
@@ -1229,7 +1226,7 @@ static int connection_handle_request(server *srv, connection *con) {
 				connection_set_state(con, CON_STATE_RESPONSE_START);
 				break;
 			case HANDLER_WAIT_FOR_FD:
-				connection_fdwaitqueue_append(srv, con);
+				connection_fdwaitqueue_append(con);
 				break;
 			case HANDLER_COMEBACK:
 				if (con->mode == DIRECT && buffer_is_empty(con->physical.path)) {
@@ -1241,7 +1238,7 @@ static int connection_handle_request(server *srv, connection *con) {
 				connection_set_state(con, CON_STATE_ERROR);
 				break;
 			default:
-				log_error_write(srv, __FILE__, __LINE__, "sdd", "unknown ret-value: ", con->fd, r);
+				log_error(con->conf.errh, __FILE__, __LINE__, "unknown ret-value: %d %d", con->fd, r);
 				break;
 			}
 
@@ -1255,16 +1252,14 @@ int connection_state_machine(server *srv, connection *con) {
 	const int log_state_handling = srv->srvconf.log_state_handling;
 
 	if (log_state_handling) {
-		log_error_write(srv, __FILE__, __LINE__, "sds",
-				"state at enter",
-				con->fd,
-				connection_get_state(con->state));
+		log_error(con->conf.errh, __FILE__, __LINE__,
+		  "state at enter %d %s", con->fd, connection_get_state(con->state));
 	}
 
 	do {
 		if (log_state_handling) {
-			log_error_write(srv, __FILE__, __LINE__, "sds",
-					"state for fd", con->fd, <