new file mode 100644
--- /dev/null
+++ b/src/http/modules/ngx_http_proxy_module.c
@@ -0,0 +1,1209 @@
+
+/*  
+ * Copyright (C) Igor Sysoev
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_event.h>
+#include <ngx_http.h>
+
+
+typedef struct {
+    ngx_http_upstream_conf_t   upstream;
+
+    ngx_peers_t               *peers;
+
+    ngx_array_t               *headers_set_len;
+    ngx_array_t               *headers_set;
+    ngx_hash_t                *headers_set_hash;
+
+    ngx_flag_t                 preserve_host;
+    ngx_flag_t                 set_x_url;
+    ngx_flag_t                 set_x_real_ip;
+    ngx_flag_t                 add_x_forwarded_for;
+    ngx_flag_t                 pass_server;
+    ngx_flag_t                 pass_x_accel_expires;
+
+    ngx_str_t                 *location0;
+
+    ngx_str_t                  host_header;
+    ngx_str_t                  uri0;
+
+    ngx_array_t               *headers_sources;
+    ngx_array_t               *headers_names;
+} ngx_http_proxy_loc_conf_t;
+
+
+typedef struct {
+    ngx_list_t                 headers;
+    
+    ngx_table_elt_t           *date;
+    ngx_table_elt_t           *server;
+
+    ngx_table_elt_t           *expires;
+    ngx_table_elt_t           *cache_control;
+    ngx_table_elt_t           *etag;
+    ngx_table_elt_t           *x_accel_expires;
+
+    ngx_table_elt_t           *connection;
+    ngx_table_elt_t           *content_type;
+    ngx_table_elt_t           *content_length;
+    
+#if (NGX_HTTP_GZIP)
+    ngx_table_elt_t           *content_encoding;
+#endif
+    
+    ngx_table_elt_t           *last_modified;
+    ngx_table_elt_t           *location;
+    ngx_table_elt_t           *accept_ranges;
+    ngx_table_elt_t           *x_pad;
+
+    off_t                      content_length_n;
+} ngx_http_proxy_headers_in_t;
+
+
+static ngx_int_t ngx_http_proxy_create_request(ngx_http_request_t *r);
+static ngx_int_t ngx_http_proxy_reinit_request(ngx_http_request_t *r);
+static ngx_int_t ngx_http_proxy_process_header(ngx_http_request_t *r);
+static ngx_int_t ngx_http_proxy_send_header(ngx_http_request_t *r);
+static void ngx_http_proxy_abort_request(ngx_http_request_t *r);
+static void ngx_http_proxy_finalize_request(ngx_http_request_t *r,
+    ngx_int_t rc);
+
+static ngx_int_t ngx_http_proxy_compile_header_start(ngx_table_elt_t *h,
+    ngx_array_t *lengths, ngx_array_t *values, ngx_uint_t value);
+static ngx_int_t ngx_http_proxy_compile_header_end(ngx_array_t *lengths,
+    ngx_array_t *values);
+
+static ngx_int_t ngx_http_proxy_init(ngx_cycle_t *cycle);
+static ngx_http_variable_value_t *ngx_http_proxy_host_variable
+    (ngx_http_request_t *r, uintptr_t data);
+static void *ngx_http_proxy_create_loc_conf(ngx_conf_t *cf);
+static char *ngx_http_proxy_merge_loc_conf(ngx_conf_t *cf,
+    void *parent, void *child);
+
+static char *ngx_http_proxy_pass(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+
+static char *ngx_http_proxy_set_x_var(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_proxy_lowat_check(ngx_conf_t *cf, void *post, void *data);
+
+static ngx_conf_post_t  ngx_http_proxy_lowat_post =
+                                                { ngx_http_proxy_lowat_check };
+
+static ngx_conf_bitmask_t  ngx_http_proxy_next_upstream_masks[] = {
+    { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR },
+    { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT },
+    { ngx_string("invalid_header"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER },
+    { ngx_string("http_500"), NGX_HTTP_UPSTREAM_FT_HTTP_500 },
+    { ngx_string("http_404"), NGX_HTTP_UPSTREAM_FT_HTTP_404 },
+    { ngx_null_string, 0 }
+};
+
+
+static ngx_command_t  ngx_http_proxy_commands[] = {
+
+    { ngx_string("proxy_pass"),
+      NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_http_proxy_pass,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      0,
+      NULL },
+
+    { ngx_string("proxy_connect_timeout"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_msec_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.connect_timeout),
+      NULL },
+
+    { ngx_string("proxy_send_timeout"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_msec_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.send_timeout),
+      NULL },
+
+    { ngx_string("proxy_send_lowat"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_size_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.send_lowat),
+      &ngx_http_proxy_lowat_post },
+
+    { ngx_string("proxy_pass_unparsed_uri"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.pass_unparsed_uri),
+      NULL },
+
+    { ngx_string("proxy_preserve_host"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, preserve_host),
+      NULL },
+
+    { ngx_string("proxy_set_x_url"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, set_x_url),
+      NULL },
+
+    { ngx_string("proxy_set_x_real_ip"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, set_x_real_ip),
+      NULL },
+
+    { ngx_string("proxy_set_x_var"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_http_proxy_set_x_var,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      0,
+      NULL },
+
+    { ngx_string("proxy_add_x_forwarded_for"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, add_x_forwarded_for),
+      NULL },
+
+    { ngx_string("proxy_header_buffer_size"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_size_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.header_buffer_size),
+      NULL },
+
+    { ngx_string("proxy_read_timeout"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_msec_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.read_timeout),
+      NULL },
+
+    { ngx_string("proxy_buffers"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
+      ngx_conf_set_bufs_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.bufs),
+      NULL },
+
+    { ngx_string("proxy_busy_buffers_size"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_size_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.busy_buffers_size),
+      NULL },
+
+    { ngx_string("proxy_temp_path"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
+      ngx_conf_set_path_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.temp_path),
+      (void *) ngx_garbage_collector_temp_handler },
+
+    { ngx_string("proxy_max_temp_file_size"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_size_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.max_temp_file_size),
+      NULL },
+
+    { ngx_string("proxy_temp_file_write_size"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_size_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.temp_file_write_size),
+      NULL },
+
+    { ngx_string("proxy_next_upstream"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_ANY,
+      ngx_conf_set_bitmask_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, upstream.next_upstream),
+      &ngx_http_proxy_next_upstream_masks },
+
+    { ngx_string("proxy_pass_server"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, pass_server),
+      NULL },
+
+    { ngx_string("proxy_pass_x_accel_expires"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      ngx_conf_set_flag_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_proxy_loc_conf_t, pass_x_accel_expires),
+      NULL },
+
+      ngx_null_command
+};
+
+
+ngx_http_module_t  ngx_http_proxy_module_ctx = {
+    NULL,                                  /* pre conf */
+
+    NULL,                                  /* create main configuration */
+    NULL,                                  /* init main configuration */
+
+    NULL,                                  /* create server configuration */
+    NULL,                                  /* merge server configuration */
+
+    ngx_http_proxy_create_loc_conf,        /* create location configration */
+    ngx_http_proxy_merge_loc_conf          /* merge location configration */
+};
+
+
+ngx_module_t  ngx_http_proxy_module = {
+    NGX_MODULE,
+    &ngx_http_proxy_module_ctx,            /* module context */
+    ngx_http_proxy_commands,               /* module directives */
+    NGX_HTTP_MODULE,                       /* module type */
+    ngx_http_proxy_init,                   /* init module */
+    NULL                                   /* init process */
+};
+
+
+static ngx_str_t ngx_http_proxy_methods[] = {
+    ngx_string("GET"),
+    ngx_string("HEAD"),
+    ngx_string("POST")
+};
+
+
+static char  ngx_http_proxy_version[] = " HTTP/1.0" CRLF;
+
+static ngx_str_t  ngx_http_proxy_host = ngx_string("PROXY_HOST");
+
+
+#if (NGX_PCRE)
+static ngx_str_t ngx_http_proxy_uri = ngx_string("/");
+#endif
+
+
+#if 0
+
+ngx_http_header_t ngx_http_proxy_headers_in[] = {
+    { ngx_string("Date"), offsetof(ngx_http_proxy_headers_in_t, date) },
+    { ngx_string("Server"), offsetof(ngx_http_proxy_headers_in_t, server) },
+
+    { ngx_string("Expires"), offsetof(ngx_http_proxy_headers_in_t, expires) },
+    { ngx_string("Cache-Control"),
+                 offsetof(ngx_http_proxy_headers_in_t, cache_control) },
+    { ngx_string("ETag"), offsetof(ngx_http_proxy_headers_in_t, etag) },
+    { ngx_string("X-Accel-Expires"),
+                 offsetof(ngx_http_proxy_headers_in_t, x_accel_expires) },
+
+    { ngx_string("Connection"),
+                 offsetof(ngx_http_proxy_headers_in_t, connection) },
+    { ngx_string("Content-Type"),
+                 offsetof(ngx_http_proxy_headers_in_t, content_type) },
+    { ngx_string("Content-Length"),
+                 offsetof(ngx_http_proxy_headers_in_t, content_length) },
+
+#if (NGX_HTTP_GZIP)
+    { ngx_string("Content-Encoding"),
+                 offsetof(ngx_http_proxy_headers_in_t, content_encoding) },
+#endif
+
+    { ngx_string("Last-Modified"),
+                 offsetof(ngx_http_proxy_headers_in_t, last_modified) },
+    { ngx_string("Location"),
+                 offsetof(ngx_http_proxy_headers_in_t, location) },
+    { ngx_string("Accept-Ranges"),
+                 offsetof(ngx_http_proxy_headers_in_t, accept_ranges) },
+    { ngx_string("X-Pad"), offsetof(ngx_http_proxy_headers_in_t, x_pad) },
+
+    { ngx_null_string, 0 }
+};
+
+#endif
+
+
+static ngx_int_t
+ngx_http_proxy_handler(ngx_http_request_t *r)
+{   
+    ngx_int_t                   rc;
+    ngx_http_upstream_t        *u;
+    ngx_http_proxy_loc_conf_t  *plcf;
+    
+    plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);
+    
+    u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t));
+    if (u == NULL) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+    
+    u->peer.log = r->connection->log;
+    u->peer.log_error = NGX_ERROR_ERR;
+    u->peer.peers = plcf->peers;
+    u->peer.tries = plcf->peers->number;
+#if (NGX_THREADS)
+    u->peer.lock = &r->connection->lock;
+#endif
+
+    u->output.tag = (ngx_buf_tag_t) &ngx_http_proxy_module;
+
+    u->conf = &plcf->upstream;
+
+    u->create_request = ngx_http_proxy_create_request;
+    u->reinit_request = ngx_http_proxy_reinit_request;
+    u->process_header = ngx_http_proxy_process_header;
+    u->send_header = ngx_http_proxy_send_header;
+    u->abort_request = ngx_http_proxy_abort_request;
+    u->finalize_request = ngx_http_proxy_finalize_request;
+
+    u->pipe.input_filter = ngx_event_pipe_copy_input_filter;
+
+    u->log_ctx = r->connection->log->data;
+    u->log_handler = ngx_http_upstream_log_error;
+
+    u->schema0.len = sizeof("http://") - 1;
+    u->schema0.data = (u_char *) "http://";
+    u->uri0 = plcf->uri0;
+    u->location0 = plcf->location0;
+    
+    r->upstream = u;
+
+    rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);
+
+    if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
+        return rc;
+    }
+
+    return NGX_DONE;
+}
+
+
+static ngx_int_t
+ngx_http_proxy_create_request(ngx_http_request_t *r)
+{
+    size_t                          len;
+    ngx_uint_t                      i, key;
+    uintptr_t                       escape;
+    ngx_buf_t                      *b;
+    ngx_str_t                      *hh;
+    ngx_chain_t                    *cl;
+    ngx_list_part_t                *part;
+    ngx_table_elt_t                *header;
+    ngx_http_upstream_t            *u;
+    ngx_http_proxy_loc_conf_t      *plcf;
+    ngx_http_script_code_pt         code;
+    ngx_http_script_len_code_pt     lcode;
+    ngx_http_script_lite_engine_t   e;
+
+    u = r->upstream;
+
+    plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);
+
+    len = sizeof(ngx_http_proxy_version) - 1 + sizeof(CRLF) - 1;
+
+    if (u->method) {
+        len += ngx_http_proxy_methods[u->method - 1].len + u->uri0.len;
+    } else {
+        len += r->method_name.len + u->uri0.len;
+    }
+
+    escape = 0;
+    
+    if (plcf->upstream.pass_unparsed_uri && r->valid_unparsed_uri) {
+        len += r->unparsed_uri.len - 1;
+
+    } else {
+        if (r->quoted_uri) {
+            escape = 2 * ngx_escape_uri(NULL, r->uri.data + u->location0->len,
+                                        r->uri.len - u->location0->len,
+                                        NGX_ESCAPE_URI);
+        }
+
+        len += r->uri.len - u->location0->len + escape
+            + sizeof("?") - 1 + r->args.len;
+    }
+
+
+    e.ip = plcf->headers_set_len->elts;
+    e.request = r;
+
+    while (*(uintptr_t *) e.ip) {
+        lcode = *(ngx_http_script_len_code_pt *) e.ip;
+        len += lcode(&e);
+    }
+
+
+    part = &r->headers_in.headers.part;
+    header = part->elts;
+    hh = (ngx_str_t *) plcf->headers_set_hash->buckets;
+
+    for (i = 0; /* void */; i++) {
+
+        if (i >= part->nelts) {
+            if (part->next == NULL) {
+                break;
+            }
+
+            part = part->next;
+            header = part->elts;
+            i = 0; 
+        }
+
+        key = header[i].hash % plcf->headers_set_hash->hash_size;
+
+        if (hh[key].len == header[i].key.len
+            && ngx_strcasecmp(hh[key].data, header[i].key.data) == 0)
+        {
+            continue;
+        }
+
+        len += header[i].key.len + sizeof(": ") - 1
+            + header[i].value.len + sizeof(CRLF) - 1;
+    }
+
+    b = ngx_create_temp_buf(r->pool, len);
+    if (b == NULL) {
+        return NGX_ERROR;
+    }
+
+    cl = ngx_alloc_chain_link(r->pool);
+    if (cl == NULL) {
+        return NGX_ERROR;
+    }
+
+    cl->buf = b;
+    cl->next = NULL;
+
+    r->request_body->bufs = cl;
+
+
+    /* the request line */
+
+    if (u->method) {
+        b->last = ngx_cpymem(b->last,
+                             ngx_http_proxy_methods[u->method - 1].data,
+                             ngx_http_proxy_methods[u->method - 1].len);
+    } else {
+        b->last = ngx_cpymem(b->last, r->method_name.data, r->method_name.len);
+    }
+
+    b->last = ngx_cpymem(b->last, u->uri0.data, u->uri0.len);
+
+    if (plcf->upstream.pass_unparsed_uri && r->valid_unparsed_uri) {
+        b->last = ngx_cpymem(b->last, r->unparsed_uri.data + 1,
+                             r->unparsed_uri.len - 1);
+    } else {
+        if (escape) {
+            ngx_escape_uri(b->last, r->uri.data + u->location0->len,
+                           r->uri.len - u->location0->len, NGX_ESCAPE_URI);
+            b->last += r->uri.len - u->location0->len + escape;
+
+        } else { 
+            b->last = ngx_cpymem(b->last, r->uri.data + u->location0->len,
+                                 r->uri.len - u->location0->len);
+        }
+
+        if (r->args.len > 0) {
+            *b->last++ = '?';
+            b->last = ngx_cpymem(b->last, r->args.data, r->args.len);
+        }
+    }
+
+    b->last = ngx_cpymem(b->last, ngx_http_proxy_version,
+                         sizeof(ngx_http_proxy_version) - 1);
+
+
+    e.ip = plcf->headers_set->elts;
+    e.pos = b->last;
+
+    while (*(uintptr_t *) e.ip) {
+        code = *(ngx_http_script_code_pt *) e.ip;
+        code((ngx_http_script_engine_t *) &e);
+    }
+
+    b->last = e.pos;
+
+
+    part = &r->headers_in.headers.part;
+    header = part->elts;
+    
+    for (i = 0; /* void */; i++) {
+
+        if (i >= part->nelts) {
+            if (part->next == NULL) {
+                break;
+            }
+
+            part = part->next;
+            header = part->elts;
+            i = 0; 
+        }
+
+        key = header[i].hash % plcf->headers_set_hash->hash_size;
+
+        if (hh[key].len == header[i].key.len
+            && ngx_strcasecmp(hh[key].data, header[i].key.data) == 0)
+        {
+            continue;
+        }
+
+        b->last = ngx_cpymem(b->last, header[i].key.data, header[i].key.len);
+
+        *b->last++ = ':'; *b->last++ = ' ';
+
+        b->last = ngx_cpymem(b->last, header[i].value.data,
+                             header[i].value.len);
+
+        *b->last++ = CR; *b->last++ = LF;
+
+        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "http proxy header: \"%V: %V\"",
+                       &header[i].key, &header[i].value);
+    }
+
+    /* add "\r\n" at the header end */
+    *b->last++ = CR; *b->last++ = LF;
+
+#if (NGX_DEBUG)
+    {
+    ngx_str_t  s;
+
+    s.len = b->last - b->pos;
+    s.data = b->pos;
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "http proxy header:\n\"%V\"", &s);
+    }
+#endif
+
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_http_proxy_reinit_request(ngx_http_request_t *r)
+{
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_http_proxy_process_header(ngx_http_request_t *r)
+{
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_http_proxy_send_header(ngx_http_request_t *r)
+{
+    return NGX_OK;
+}
+
+
+static void
+ngx_http_proxy_abort_request(ngx_http_request_t *r)
+{
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "abort http proxy request");
+    
+    return;
+}
+
+
+static void
+ngx_http_proxy_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
+{   
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "finalize http proxy request");
+
+    return;
+}
+
+
+static ngx_int_t
+ngx_http_proxy_init(ngx_cycle_t *cycle)
+{
+#if 0
+    ngx_http_variable_t  *var;
+
+    var = ngx_http_add_variable(cf, &ngx_http_proxy_host, 1);
+    if (var == NULL) {
+        return NGX_ERROR;
+    }
+
+    var->handler = ngx_http_proxy_host_variable;
+#endif
+
+    return NGX_OK;
+
+#if 0
+    ngx_http_log_op_name_t  *op;
+
+    for (op = ngx_http_proxy_log_fmt_ops; op->name.len; op++) { /* void */ }
+    op->run = NULL;
+
+    for (op = ngx_http_log_fmt_ops; op->run; op++) {
+        if (op->name.len == 0) {
+            op = (ngx_http_log_op_name_t *) op->run;
+        }
+    }
+
+    op->run = (ngx_http_log_op_run_pt) ngx_http_proxy_log_fmt_ops;
+
+#endif
+}
+
+
+static ngx_http_variable_value_t *
+ngx_http_proxy_host_variable(ngx_http_request_t *r, uintptr_t data)
+{
+    ngx_http_variable_value_t  *var;
+    ngx_http_proxy_loc_conf_t  *plcf;
+
+    var = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
+    if (var == NULL) {
+        return NULL;
+    }
+
+    plcf = ngx_http_get_module_loc_conf(r, ngx_http_proxy_module);
+
+    var->value = 0;
+    var->text = plcf->host_header;
+
+    return var;
+}
+
+
+static void *
+ngx_http_proxy_create_loc_conf(ngx_conf_t *cf)
+{
+    ngx_http_proxy_loc_conf_t  *conf;
+
+    conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_proxy_loc_conf_t));
+    if (conf == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+    /*
+     * set by ngx_pcalloc():
+     *
+     *     conf->upstream.bufs.num = 0;
+     *     conf->upstream.path = NULL;
+     *     conf->upstream.next_upstream = 0;
+     *     conf->upstream.temp_path = NULL;
+     */
+    
+    conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
+    conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
+    conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
+
+    conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
+    conf->upstream.header_buffer_size = NGX_CONF_UNSET_SIZE;
+    conf->upstream.busy_buffers_size = NGX_CONF_UNSET_SIZE;
+    conf->upstream.max_temp_file_size = NGX_CONF_UNSET_SIZE;  
+    conf->upstream.temp_file_write_size = NGX_CONF_UNSET_SIZE;
+    
+    conf->upstream.redirect_errors = NGX_CONF_UNSET;
+    conf->upstream.pass_unparsed_uri = NGX_CONF_UNSET;
+    conf->upstream.x_powered_by = NGX_CONF_UNSET;
+
+    /* "proxy_cyclic_temp_file" is disabled */
+    conf->upstream.cyclic_temp_file = 0;
+
+    conf->preserve_host = NGX_CONF_UNSET;
+    conf->set_x_url = NGX_CONF_UNSET;
+    conf->set_x_real_ip = NGX_CONF_UNSET;
+    conf->add_x_forwarded_for = NGX_CONF_UNSET;
+
+    conf->pass_server = NGX_CONF_UNSET;
+    conf->pass_x_accel_expires = NGX_CONF_UNSET;
+
+    return conf;
+}
+
+
+static char *
+ngx_http_proxy_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
+{
+    ngx_http_proxy_loc_conf_t *prev = parent;
+    ngx_http_proxy_loc_conf_t *conf = child;
+
+    size_t            size;
+    ngx_str_t        *name;
+    ngx_table_elt_t  *src;
+    ngx_http_variable_t  *var;
+    
+    ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
+                              prev->upstream.connect_timeout, 60000);
+
+    ngx_conf_merge_msec_value(conf->upstream.send_timeout,
+                              prev->upstream.send_timeout, 60000);
+
+    ngx_conf_merge_msec_value(conf->upstream.read_timeout,
+                              prev->upstream.read_timeout, 60000);
+
+    ngx_conf_merge_size_value(conf->upstream.send_lowat,
+                              prev->upstream.send_lowat, 0);
+
+    ngx_conf_merge_size_value(conf->upstream.header_buffer_size,
+                              prev->upstream.header_buffer_size,
+                              (size_t) ngx_pagesize);
+
+    ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
+                              8, ngx_pagesize);
+
+    if (conf->upstream.bufs.num < 2) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, 
+                           "there must be at least 2 \"proxy_buffers\"");
+        return NGX_CONF_ERROR;
+    }
+    
+
+    size = conf->upstream.header_buffer_size;
+    if (size < conf->upstream.bufs.size) { 
+        size = conf->upstream.bufs.size;
+    }
+
+
+    ngx_conf_merge_size_value(conf->upstream.busy_buffers_size,
+                              prev->upstream.busy_buffers_size,
+                              NGX_CONF_UNSET_SIZE);
+
+    if (conf->upstream.busy_buffers_size == NGX_CONF_UNSET_SIZE) {
+        conf->upstream.busy_buffers_size = 2 * size;
+
+    } else if (conf->upstream.busy_buffers_size < size) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+             "\"proxy_busy_buffers_size\" must be equal or bigger than "
+             "maximum of the value of \"proxy_header_buffer_size\" and "
+             "one of the \"proxy_buffers\"");
+
+        return NGX_CONF_ERROR;
+
+    } else if (conf->upstream.busy_buffers_size
+               > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
+    {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+             "\"proxy_busy_buffers_size\" must be less than "
+             "the size of all \"proxy_buffers\" minus one buffer");
+
+        return NGX_CONF_ERROR;
+    }
+    
+
+    ngx_conf_merge_size_value(conf->upstream.temp_file_write_size,
+                              prev->upstream.temp_file_write_size,
+                              NGX_CONF_UNSET_SIZE);
+
+    if (conf->upstream.temp_file_write_size == NGX_CONF_UNSET_SIZE) {
+        conf->upstream.temp_file_write_size = 2 * size;
+
+    } else if (conf->upstream.temp_file_write_size < size) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+             "\"proxy_temp_file_write_size\" must be equal or bigger than "
+             "maximum of the value of \"proxy_header_buffer_size\" and "
+             "one of the \"proxy_buffers\"");
+
+        return NGX_CONF_ERROR;
+    }
+
+
+    ngx_conf_merge_size_value(conf->upstream.max_temp_file_size,
+                              prev->upstream.max_temp_file_size,
+                              NGX_CONF_UNSET_SIZE);
+
+    if (conf->upstream.max_temp_file_size == NGX_CONF_UNSET_SIZE) {
+
+        conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
+
+    } else if (conf->upstream.max_temp_file_size != 0
+               && conf->upstream.max_temp_file_size < size)
+    {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+             "\"fastcgi_max_temp_file_size\" must be equal to zero to disable "
+             "the temporary files usage or must be equal or bigger than "
+             "maximum of the value of \"fastcgi_header_buffer_size\" and "
+             "one of the \"fastcgi_buffers\"");
+
+        return NGX_CONF_ERROR;
+    }
+
+    ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
+                              prev->upstream.next_upstream,
+                              (NGX_CONF_BITMASK_SET
+                               |NGX_HTTP_UPSTREAM_FT_ERROR
+                               |NGX_HTTP_UPSTREAM_FT_TIMEOUT));
+
+    ngx_conf_merge_msec_value(conf->upstream.redirect_errors,
+                              prev->upstream.redirect_errors, 0);
+
+    ngx_conf_merge_msec_value(conf->upstream.pass_unparsed_uri,
+                              prev->upstream.pass_unparsed_uri, 0);
+
+    if (conf->upstream.pass_unparsed_uri && conf->location0->len > 1) {
+        ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
+                      "\"proxy_pass_unparsed_uri\" can be set for "
+                      "location \"/\" or given by regular expression.");
+        return NGX_CONF_ERROR;
+    }
+
+    ngx_conf_merge_msec_value(conf->upstream.x_powered_by,
+                              prev->upstream.x_powered_by, 1);
+
+    ngx_conf_merge_value(conf->preserve_host, prev->preserve_host, 0);
+    ngx_conf_merge_value(conf->set_x_url, prev->set_x_url, 0);
+    ngx_conf_merge_value(conf->set_x_real_ip, prev->set_x_real_ip, 0);
+    ngx_conf_merge_value(conf->add_x_forwarded_for,
+                              prev->add_x_forwarded_for, 0);
+
+    if (conf->peers == NULL) {
+        conf->peers = prev->peers;
+        conf->upstream = prev->upstream;
+    }
+
+    if (conf->headers_set_hash == NULL) {
+        conf->headers_set_len = prev->headers_set_len;
+        conf->headers_set = prev->headers_set;
+        conf->headers_set_hash = prev->headers_set_hash;
+    }
+
+    if (conf->headers_set_hash == NULL) {
+
+        if (conf->headers_names == NULL) {
+            conf->headers_names = ngx_array_create(cf->pool, 4,
+                                                   sizeof(ngx_str_t));
+            if (conf->headers_names == NULL) {
+                return NGX_CONF_ERROR;
+            }
+        }
+
+        if (conf->headers_sources == NULL) {
+            conf->headers_sources = ngx_array_create(cf->pool, 4,
+                                                     sizeof(ngx_table_elt_t));
+            if (conf->headers_sources == NULL) {
+                return NGX_CONF_ERROR;
+            }
+        }
+
+        /* STUB */
+        var = ngx_http_add_variable(cf, &ngx_http_proxy_host, 0);
+        if (var == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        var->handler = ngx_http_proxy_host_variable;
+        /**/
+
+
+        name = ngx_array_push(conf->headers_names);
+        if (name == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        name->len = sizeof("Host") - 1;
+        name->data = (u_char *) "Host";
+
+        src = ngx_array_push(conf->headers_sources);
+        if (src == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        src->hash = 0;
+        src->key.len = sizeof("Host") - 1;
+        src->key.data = (u_char *) "Host";
+        src->value.len = sizeof("$PROXY_HOST") - 1;
+        src->value.data = (u_char *) "$PROXY_HOST";
+
+
+        name = ngx_array_push(conf->headers_names);
+        if (name == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        name->len = sizeof("Connection") - 1;
+        name->data = (u_char *) "Connection";
+
+        src = ngx_array_push(conf->headers_sources);
+        if (src == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        src->hash = 0;
+        src->key.len = sizeof("Connection") - 1;
+        src->key.data = (u_char *) "Connection";
+        src->value.len = sizeof("close") - 1;
+        src->value.data = (u_char *) "close";
+
+
+        name = ngx_array_push(conf->headers_names);
+        if (name == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        name->len = 0;
+        name->data = NULL;
+
+
+        if (ngx_http_script_compile_lite(cf, conf->headers_sources,
+                &conf->headers_set_len, &conf->headers_set,
+                ngx_http_proxy_compile_header_start,
+                ngx_http_proxy_compile_header_end) != NGX_OK)
+        {
+            return NGX_CONF_ERROR;
+        }
+
+
+        conf->headers_set_hash = ngx_pcalloc(cf->pool, sizeof(ngx_hash_t));
+        if (conf->headers_set_hash == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        conf->headers_set_hash->max_size = 100;
+        conf->headers_set_hash->bucket_limit = 1;
+        conf->headers_set_hash->bucket_size = sizeof(ngx_str_t);
+        conf->headers_set_hash->name = "proxy_headers";
+
+        if (ngx_hash_init(conf->headers_set_hash, cf->pool,
+                          conf->headers_names->elts) != NGX_OK)
+        {
+            return NGX_CONF_ERROR;
+        }
+
+#if 0
+        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0,
+#endif
+        ngx_log_error(NGX_LOG_NOTICE, cf->log, 0,
+                       "proxy_headers hash size: %ui, "
+                       "max buckets per entry: %ui",
+                       conf->headers_set_hash->hash_size,
+                       conf->headers_set_hash->min_buckets);
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+static ngx_int_t
+ngx_http_proxy_compile_header_start(ngx_table_elt_t *h,
+    ngx_array_t *lengths, ngx_array_t *values, ngx_uint_t value)
+{
+    u_char                       *p;
+    size_t                        size;
+    ngx_http_script_copy_code_t  *copy;
+
+    copy = ngx_array_push_n(lengths, sizeof(ngx_http_script_copy_code_t));
+    if (copy == NULL) {
+        return NGX_ERROR;
+    }
+
+    copy->code = (ngx_http_script_code_pt) ngx_http_script_copy_len;
+    copy->len = h->key.len + sizeof(": ") - 1;
+
+    if (value) {
+        copy->len += h->value.len + sizeof(CRLF) - 1;
+    }
+
+    size = (copy->len + sizeof(uintptr_t) - 1) & ~(sizeof(uintptr_t) - 1);
+
+    copy = ngx_array_push_n(values,
+                            sizeof(ngx_http_script_copy_code_t) + size);
+    if (copy == NULL) {
+        return NGX_ERROR;
+    }
+
+    copy->code = ngx_http_script_copy;
+    copy->len = h->key.len + sizeof(": ") - 1;
+
+    if (value) {
+        copy->len += h->value.len + sizeof(CRLF) - 1;
+    }
+
+    p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
+
+    p = ngx_cpymem(p, h->key.data, h->key.len);
+    p = ngx_cpymem(p, ": ", sizeof(": ") - 1);
+
+    if (value) {
+        p = ngx_cpymem(p, h->value.data, h->value.len);
+        ngx_memcpy(p, CRLF, sizeof(CRLF) - 1);
+    }
+
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_http_proxy_compile_header_end(ngx_array_t *lengths, ngx_array_t *values)
+{
+    size_t                        size;
+    ngx_http_script_copy_code_t  *copy;
+
+    copy = ngx_array_push_n(lengths, sizeof(ngx_http_script_copy_code_t));
+    if (copy == NULL) {
+        return NGX_ERROR;
+    }
+
+    copy->code = (ngx_http_script_code_pt) ngx_http_script_copy_len;
+    copy->len = sizeof(CRLF) - 1;
+
+    size = (sizeof(CRLF) - 1 + sizeof(uintptr_t) - 1)
+            & ~(sizeof(uintptr_t) - 1);
+
+    copy = ngx_array_push_n(values,
+                            sizeof(ngx_http_script_copy_code_t) + size);
+    if (copy == NULL) {
+        return NGX_ERROR;
+    }
+
+    copy->code = ngx_http_script_copy;
+    copy->len = sizeof(CRLF) - 1;
+
+    ngx_memcpy((u_char *) copy + sizeof(ngx_http_script_copy_code_t),
+               CRLF, sizeof(CRLF) - 1);
+
+    return NGX_OK;
+}
+
+
+static char *
+ngx_http_proxy_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_http_proxy_loc_conf_t *lcf = conf;
+
+    ngx_uint_t                   i;
+    ngx_str_t                   *value, *url;
+    ngx_inet_upstream_t          inet_upstream;
+    ngx_http_core_loc_conf_t    *clcf;
+#if (NGX_HAVE_UNIX_DOMAIN)
+    ngx_unix_domain_upstream_t   unix_upstream;
+#endif
+
+    value = cf->args->elts;
+
+    url = &value[1];
+
+    if (ngx_strncasecmp(url->data, "http://", 7) != 0) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid URL prefix");
+        return NGX_CONF_ERROR;
+    }
+
+    if (ngx_strncasecmp(url->data + 7, "unix:", 5) == 0) {
+
+#if (NGX_HAVE_UNIX_DOMAIN)
+
+        ngx_memzero(&unix_upstream, sizeof(ngx_unix_domain_upstream_t));
+
+        unix_upstream.name = *url;
+        unix_upstream.url.len = url->len - 7;
+        unix_upstream.url.data = url->data + 7;
+        unix_upstream.uri_part = 1;
+
+        lcf->peers = ngx_unix_upstream_parse(cf, &unix_upstream);
+        if (lcf->peers == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        lcf->peers->peer[0].uri_separator = ":";
+
+        lcf->host_header.len = sizeof("localhost") - 1;
+        lcf->host_header.data = (u_char *) "localhost";
+        lcf->uri0 = unix_upstream.uri;
+#if 0
+	STUB
+        lcf->upstream->default_port = 1;
+#endif
+
+#else
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "the unix domain sockets are not supported "
+                           "on this platform");
+        return NGX_CONF_ERROR;
+
+#endif
+
+    } else {
+        ngx_memzero(&inet_upstream, sizeof(ngx_inet_upstream_t));
+
+        inet_upstream.name = *url;
+        inet_upstream.url.len = url->len - 7;
+        inet_upstream.url.data = url->data + 7;
+        inet_upstream.default_port_value = 80;
+        inet_upstream.uri_part = 1;
+
+        lcf->peers = ngx_inet_upstream_parse(cf, &inet_upstream);
+        if (lcf->peers == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        for (i = 0; i < lcf->peers->number; i++) {
+            lcf->peers->peer[i].uri_separator = ":";
+        }
+
+        lcf->host_header = inet_upstream.host_header;
+        lcf->uri0 = inet_upstream.uri;
+#if 0
+	STUB
+        lcf->port_text = inet_upstream.port_text;
+        lcf->upstream->default_port = inet_upstream.default_port;
+#endif
+    }
+
+    clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+
+    clcf->handler = ngx_http_proxy_handler;
+
+#if (NGX_PCRE)
+    lcf->location0 = clcf->regex ? &ngx_http_proxy_uri : &clcf->name;
+#else
+    lcf->location0 = &clcf->name;
+#endif
+
+    if (clcf->name.data[clcf->name.len - 1] == '/') {
+        clcf->auto_redirect = 1;
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+static char *
+ngx_http_proxy_set_x_var(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    return NGX_CONF_OK;
+}
+
+
+static char *
+ngx_http_proxy_lowat_check(ngx_conf_t *cf, void *post, void *data)
+{
+#if (NGX_FREEBSD)
+    ssize_t *np = data;
+
+    if (*np >= ngx_freebsd_net_inet_tcp_sendspace) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "\"proxy_send_lowat\" must be less than %d "
+                           "(sysctl net.inet.tcp.sendspace)",
+                           ngx_freebsd_net_inet_tcp_sendspace);
+
+        return NGX_CONF_ERROR;
+    }
+
+#elif !(NGX_HAVE_SO_SNDLOWAT)
+    ssize_t *np = data;
+
+    ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+                       "\"proxy_send_lowat\" is not supported, ignored");
+
+    *np = 0;
+
+#endif
+
+    return NGX_CONF_OK;
+}