--- a/src/http/ngx_http_core_module.c
+++ b/src/http/ngx_http_core_module.c
@@ -873,9 +873,9 @@ static ngx_int_t ngx_http_core_init_proc
 
     ngx_http_handler_pt         *h;
 
-    ngx_test_null(h, ngx_push_array(
-                             &cmcf->phases[NGX_HTTP_TRANSLATE_PHASE].handlers),
-                  NGX_ERROR);
+    if (!(h = ngx_array_push(&cmcf->phases[NGX_HTTP_TRANSLATE_PHASE].handlers)))
+        return NGX_ERROR;
+    }
     *h = ngx_http_delay_handler;
 #endif
 
@@ -904,24 +904,26 @@ static char *ngx_server_block(ngx_conf_t
     ngx_http_core_main_conf_t   *cmcf;
     ngx_http_core_srv_conf_t    *cscf, **cscfp;
 
-    ngx_test_null(ctx,
-                  ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)),
-                  NGX_CONF_ERROR);
+    if (!(ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)))) {
+        return NGX_CONF_ERROR;
+    }
 
     http_ctx = cf->ctx;
     ctx->main_conf = http_ctx->main_conf;
 
     /* the server{}'s srv_conf */
 
-    ngx_test_null(ctx->srv_conf,
-                  ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
-                  NGX_CONF_ERROR);
+    ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
+    if (ctx->srv_conf == NULL) {
+        return NGX_CONF_ERROR;
+    }
 
     /* the server{}'s loc_conf */
 
-    ngx_test_null(ctx->loc_conf,
-                  ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
-                  NGX_CONF_ERROR);
+    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
+    if (ctx->loc_conf == NULL) {
+        return NGX_CONF_ERROR;
+    }
 
     for (m = 0; ngx_modules[m]; m++) {
         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
@@ -1325,11 +1327,11 @@ static char *ngx_http_core_merge_srv_con
     }
 
     ngx_conf_merge_size_value(conf->connection_pool_size,
-                              prev->connection_pool_size, 2048);
+                              prev->connection_pool_size, 256);
     ngx_conf_merge_msec_value(conf->post_accept_timeout,
-                              prev->post_accept_timeout, 30000);
+                              prev->post_accept_timeout, 60000);
     ngx_conf_merge_size_value(conf->request_pool_size,
-                              prev->request_pool_size, 16384);
+                              prev->request_pool_size, (size_t) ngx_pagesize);
     ngx_conf_merge_msec_value(conf->client_header_timeout,
                               prev->client_header_timeout, 60000);
     ngx_conf_merge_size_value(conf->client_header_buffer_size,
@@ -1462,7 +1464,8 @@ static char *ngx_http_core_merge_loc_con
     ngx_conf_merge_size_value(conf->client_max_body_size,
                               prev->client_max_body_size, 10 * 1024 * 1024);
     ngx_conf_merge_size_value(conf->client_body_buffer_size,
-                              prev->client_body_buffer_size, 8192);
+                              prev->client_body_buffer_size,
+                              (size_t) 4 * ngx_pagesize);
     ngx_conf_merge_msec_value(conf->client_body_timeout,
                               prev->client_body_timeout, 60000);
     ngx_conf_merge_value(conf->sendfile, prev->sendfile, 0);

--- a/src/http/ngx_http_header_filter.c
+++ b/src/http/ngx_http_header_filter.c
@@ -246,9 +246,7 @@ static ngx_int_t ngx_http_header_filter(
          * Konqueror keeps the connection alive for about N seconds.
          */
 
-        if (clcf->keepalive_header
-            && (r->headers_in.gecko || r->headers_in.konqueror))
-        {
+        if (clcf->keepalive_header) {
             len += sizeof("Keep-Alive: timeout=") - 1 + TIME_T_LEN + 2;
         }
 
@@ -380,9 +378,7 @@ static ngx_int_t ngx_http_header_filter(
         b->last = ngx_cpymem(b->last, "Connection: keep-alive" CRLF,
                              sizeof("Connection: keep-alive" CRLF) - 1);
 
-        if (clcf->keepalive_header
-            && (r->headers_in.gecko || r->headers_in.konqueror))
-        {
+        if (clcf->keepalive_header) {
             b->last += ngx_snprintf((char *) b->last,
                             sizeof("Keep-Alive: timeout=") + TIME_T_LEN + 2,
                             "Keep-Alive: timeout=" TIME_T_FMT CRLF,

--- a/src/http/ngx_http_request.c
+++ b/src/http/ngx_http_request.c
@@ -484,7 +484,7 @@ static void ngx_http_process_request_lin
 {
     u_char              *p;
     ssize_t              n;
-    ngx_int_t            rc, rv, offset;
+    ngx_int_t            rc, rv;
     ngx_connection_t    *c;
     ngx_http_request_t  *r;
     ngx_http_log_ctx_t  *ctx;
@@ -708,7 +708,7 @@ static void ngx_http_process_request_lin
 static void ngx_http_process_request_headers(ngx_event_t *rev)
 {
     ssize_t              n;
-    ngx_int_t            rc, rv, i, offset;
+    ngx_int_t            rc, rv, i;
     ngx_table_elt_t     *h, **cookie;
     ngx_connection_t    *c;
     ngx_http_request_t  *r;
@@ -939,7 +939,6 @@ static ngx_int_t ngx_http_alloc_large_he
                                                     ngx_uint_t request_line)
 {
     u_char                    *old, *new;
-    ngx_int_t                  offset;
     ngx_buf_t                 *b;
     ngx_http_connection_t     *hc;
     ngx_http_core_srv_conf_t  *cscf;
@@ -1545,7 +1544,6 @@ static ngx_int_t ngx_http_read_discarded
 static void ngx_http_set_keepalive(ngx_http_request_t *r)
 {
     ngx_int_t                  i;
-    size_t                     len;
     ngx_buf_t                 *b, *f;
     ngx_event_t               *rev, *wev;
     ngx_connection_t          *c;
@@ -1571,7 +1569,13 @@ static void ngx_http_set_keepalive(ngx_h
 
         if (b != c->buffer) {
 
-            /* move the large header buffers to the free list */
+            /*
+             * If the large header buffers were allocated while the previous
+             * request processing then we do not use c->buffer for
+             * the pipelined request (see ngx_http_init_request()).
+             * 
+             * Now we would move the large header buffers to the free list.
+             */
 
             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
 
@@ -1623,6 +1627,15 @@ static void ngx_http_set_keepalive(ngx_h
 
     hc->pipeline = 0;
 
+
+    /*
+     * To keep a memory footprint as small as possible for an idle
+     * keepalive connection we try to free the ngx_http_request_t and
+     * c->buffer's memory if they were allocated outside the c->pool.
+     * The large header buffers are always allocated outside the c->pool and
+     * are freed too.
+     */
+
     if (ngx_pfree(c->pool, r) == NGX_OK) {
         hc->request = NULL;
     }
@@ -1630,6 +1643,12 @@ static void ngx_http_set_keepalive(ngx_h
     b = c->buffer;
 
     if (ngx_pfree(c->pool, b->start) == NGX_OK) {
+
+        /*
+         * the special note for ngx_http_keepalive_handler() that
+         * c->buffer's memory was freed
+         */
+
         b->pos = NULL;
 
     } else {
@@ -1692,7 +1711,7 @@ static void ngx_http_set_keepalive(ngx_h
     }
 
 #if 0
-    /* if "keepalive_buffers off" then we need some other place */
+    /* if ngx_http_request_t was freed then we need some other place */
     r->http_state = NGX_HTTP_KEEPALIVE_STATE;
 #endif
 
@@ -1741,6 +1760,13 @@ static void ngx_http_keepalive_handler(n
     size = b->end - b->start;
 
     if (b->pos == NULL) {
+
+        /*
+         * The c->buffer's memory was freed by ngx_http_set_keepalive().
+         * However, the c->buffer->start and c->buffer->end were not changed
+         * to keep the buffer size.
+         */
+
         if (!(b->pos = ngx_palloc(c->pool, size))) {
             ngx_http_close_connection(c);
             return;