diff --git a/src/http/modules/ngx_http_access_handler.c b/src/http/modules/ngx_http_access_handler.c
index 0179689..832f9c2 100644
--- a/src/http/modules/ngx_http_access_handler.c
+++ b/src/http/modules/ngx_http_access_handler.c
@@ -158,7 +158,7 @@
     }
 
     if (ngx_ptocidr(&value[1], &in_cidr) == NGX_ERROR) {
-        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid paramter \"%V\"",
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%V\"",
                            &value[1]);
         return NGX_CONF_ERROR;
     }
diff --git a/src/http/modules/ngx_http_fastcgi_handler.c b/src/http/modules/ngx_http_fastcgi_handler.c
index 9f5016a..828f7ac 100644
--- a/src/http/modules/ngx_http_fastcgi_handler.c
+++ b/src/http/modules/ngx_http_fastcgi_handler.c
@@ -20,6 +20,8 @@
     ngx_str_t                       root;
     ngx_str_t                       index;
 
+    ngx_array_t                     vars;
+
     ngx_str_t                      *location;
 } ngx_http_fastcgi_loc_conf_t;
 
@@ -130,6 +132,8 @@
 
 static char *ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd,
                                    void *conf);
+static char *ngx_http_fastcgi_set_var(ngx_conf_t *cf, ngx_command_t *cmd,
+                                      void *conf);
 static char *ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post,
                                           void *data);
 static void *ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf);
@@ -306,6 +310,13 @@
       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.next_upstream),
       &ngx_http_fastcgi_next_upstream_masks },
 
+    { ngx_string("fastcgi_set_var"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_http_fastcgi_set_var,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      0,
+      NULL },
+
     { ngx_string("fastcgi_params"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_ANY,
       ngx_conf_set_bitmask_slot,
@@ -405,14 +416,18 @@
     ngx_buf_t                         *b;
     socklen_t                          slen;
     ngx_chain_t                       *cl, *body;
-    ngx_uint_t                         i, n, next;
+    ngx_uint_t                         i, n, next, *vindex;
     ngx_list_part_t                   *part;
     ngx_table_elt_t                   *header;
     struct sockaddr_in                 sin;
+    ngx_http_variable_t               *var;
+    ngx_http_variable_value_t         *value;
+    ngx_http_core_main_conf_t         *cmcf;
     ngx_http_fastcgi_header_t         *h;
     ngx_http_fastcgi_loc_conf_t       *flcf;
     ngx_http_fastcgi_begin_request_t  *br;
 
+
     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);
 
     if ((flcf->params & NGX_HTTP_FASTCGI_SERVER_ADDR) && r->in_addr == 0) {
@@ -518,6 +533,23 @@
     }
 
 
+    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
+
+    var = cmcf->variables.elts;
+    vindex = flcf->vars.elts;
+
+    for (i = 0; i < flcf->vars.nelts; i++) {
+
+        if (!(value = ngx_http_get_variable(r, vindex[i]))) {
+            continue;
+        }
+
+        if (value->text.len) {
+            len += 1 + 1 + var[vindex[i]].name.len + value->text.len;
+        }
+    }
+
+
     part = &r->headers_in.headers.part;
     header = part->elts;
 
@@ -850,6 +882,26 @@
     }
 
 
+    for (i = 0; i < flcf->vars.nelts; i++) {
+
+        if (!(value = ngx_http_get_variable(r, vindex[i]))) {
+            continue;
+        }
+
+        if (value->text.len == 0) {
+            continue;
+        }
+
+        *b->last++ = (u_char) var[vindex[i]].name.len;
+        *b->last++ = (u_char) value->text.len;
+
+        b->last = ngx_cpymem(b->last, var[vindex[i]].name.data,
+                             var[vindex[i]].name.len);
+
+        b->last = ngx_cpymem(b->last, value->text.data, value->text.len);
+    }
+
+
     part = &r->headers_in.headers.part;
     header = part->elts;
 
@@ -1763,7 +1815,11 @@
 
     clcf->handler = ngx_http_fastcgi_handler;
 
+#if (NGX_PCRE)
     lcf->location = clcf->regex ? &ngx_http_fastcgi_uri: &clcf->name;
+#else
+    lcf->location = &clcf->name;
+#endif
 
     if (clcf->name.data[clcf->name.len - 1] == '/') {
         clcf->auto_redirect = 1;
@@ -1773,6 +1829,47 @@
 }
 
 
+static char *ngx_http_fastcgi_set_var(ngx_conf_t *cf, ngx_command_t *cmd,
+                                      void *conf)
+{
+    ngx_http_fastcgi_loc_conf_t *lcf = conf;
+
+    ngx_uint_t                  i, *index;
+    ngx_str_t                  *value;
+    ngx_http_variable_t        *var;
+    ngx_http_core_main_conf_t  *cmcf;
+
+    if (lcf->vars.elts == NULL) {
+        if (ngx_array_init(&lcf->vars, cf->pool, 4,
+                           sizeof(ngx_http_variable_t *)) == NGX_ERROR)
+        {
+            return NGX_CONF_ERROR;
+        }
+    }
+
+    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
+
+    value = cf->args->elts;
+
+    var = cmcf->variables.elts;
+    for (i = 0; i < cmcf->variables.nelts; i++) {
+        if (ngx_strcasecmp(var[i].name.data, value[1].data) == 0) {
+
+            if (!(index = ngx_array_push(&lcf->vars))) {
+                return NGX_CONF_ERROR;
+            }
+
+            *index = var[i].index;
+            return NGX_CONF_OK;
+        }
+    }
+
+    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                       "unknown variable name \"%V\"", &value[1]);
+    return NGX_CONF_ERROR;
+}
+
+
 static char *ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post,
                                           void *data)
 {
diff --git a/src/http/modules/ngx_http_geo_module.c b/src/http/modules/ngx_http_geo_module.c
new file mode 100644
index 0000000..cd77489
--- /dev/null
+++ b/src/http/modules/ngx_http_geo_module.c
@@ -0,0 +1,252 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_http.h>
+
+
+typedef struct {
+    ngx_radix_tree_t           *tree;
+    ngx_pool_t                 *pool;
+    ngx_array_t                 values;
+} ngx_http_geo_conf_t;
+
+
+static char *ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
+static char *ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf);
+
+
+static ngx_command_t  ngx_http_geo_commands[] = {
+
+    { ngx_string("geo"),
+      NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
+      ngx_http_geo_block,
+      NGX_HTTP_MAIN_CONF_OFFSET,
+      0,
+      NULL },
+
+      ngx_null_command
+};
+
+
+static ngx_http_module_t  ngx_http_geo_module_ctx = {
+    NULL,                                  /* pre conf */
+
+    NULL,                                  /* create main configuration */
+    NULL,                                  /* init main configuration */
+
+    NULL,                                  /* create server configuration */
+    NULL,                                  /* merge server configuration */
+
+    NULL,                                  /* create location configuration */
+    NULL                                   /* merge location configuration */
+};
+
+
+ngx_module_t  ngx_http_geo_module = {
+    NGX_MODULE,
+    &ngx_http_geo_module_ctx,              /* module context */
+    ngx_http_geo_commands,                 /* module directives */
+    NGX_HTTP_MODULE,                       /* module type */
+    NULL,                                  /* init module */
+    NULL                                   /* init process */
+};
+
+
+static ngx_http_variable_value_t  ngx_http_geo_null_value =
+                                                        { 0, ngx_string("0") };
+
+
+/* AF_INET only */
+
+static ngx_http_variable_value_t *ngx_http_geo_variable(ngx_http_request_t *r,
+                                                        void *data)
+{
+    ngx_radix_tree_t *tree = data;
+
+    struct sockaddr_in  *sin;
+
+    sin = (struct sockaddr_in *) r->connection->sockaddr;
+
+    return (ngx_http_variable_value_t *)
+                       ngx_radix32tree_find(tree, ntohl(sin->sin_addr.s_addr));
+}
+
+
+static char *ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char                 *rv;
+    ngx_str_t            *value;
+    ngx_conf_t            save;
+    ngx_pool_t           *pool;
+    ngx_radix_tree_t     *tree;
+    ngx_http_geo_conf_t   geo;
+    ngx_http_variable_t  *var;
+
+    if (!(var = ngx_http_add_variable(cf))) {
+        return NGX_CONF_ERROR;
+    }
+
+    if (!(tree = ngx_radix_tree_create(cf->pool))) {
+        return NGX_CONF_ERROR;
+    }
+
+    value = cf->args->elts;
+
+    var->name = value[1];
+    var->handler = ngx_http_geo_variable;
+    var->data = tree;
+
+    /*
+     * create the temporary pool of a huge initial size
+     * to process quickly a large number of geo lines
+     */
+
+    if (!(pool = ngx_create_pool(512 * 1024, cf->log))) {
+        return NGX_CONF_ERROR;
+    }
+
+    if (ngx_array_init(&geo.values, pool, 512,
+                       sizeof(ngx_http_variable_value_t *)) == NGX_ERROR)
+    {
+        ngx_destroy_pool(pool);
+        return NGX_CONF_ERROR;
+    }
+
+    geo.tree = tree;
+    geo.pool = cf->pool;
+
+    save = *cf;
+    cf->pool = pool;
+    cf->ctx = &geo;
+    cf->handler = ngx_http_geo;
+    cf->handler_conf = conf;
+
+    rv = ngx_conf_parse(cf, NULL);
+
+    *cf = save;
+
+    ngx_destroy_pool(pool);
+
+    if (ngx_radix32tree_find(tree, 0) != NGX_RADIX_NO_VALUE) {
+        return rv;
+    }
+
+    if (ngx_radix32tree_insert(tree, 0, 0,
+                            (uintptr_t) &ngx_http_geo_null_value) == NGX_ERROR)
+    {
+        return NGX_CONF_ERROR;
+    }
+
+    return rv;
+}
+
+
+/* AF_INET only */
+
+static char *ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
+{
+    ngx_int_t                   rc, n;
+    ngx_uint_t                  i;
+    ngx_str_t                  *value, file;
+    ngx_inet_cidr_t             cidrin;
+    ngx_http_geo_conf_t        *geo;
+    ngx_http_variable_value_t  *var, **v;
+
+    geo = cf->ctx;
+
+    if (cf->args->nelts != 2) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "invalid number of the geo parameters");
+        return NGX_CONF_ERROR;
+    }
+
+    value = cf->args->elts;
+
+    if (ngx_strcmp(value[0].data, "include") == 0) {
+        file = value[1];
+
+        if (ngx_conf_full_name(cf->cycle, &file) == NGX_ERROR){
+            return NGX_CONF_ERROR;
+        }
+
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
+
+        return ngx_conf_parse(cf, &file);
+    }
+
+    if (ngx_strcmp(value[0].data, "default") == 0) {
+        cidrin.addr = 0;
+        cidrin.mask = 0;
+
+    } else {
+        if (ngx_ptocidr(&value[0], &cidrin) == NGX_ERROR) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "invalid parameter \"%V\"", &value[0]);
+            return NGX_CONF_ERROR;
+        }
+
+        cidrin.addr = ntohl(cidrin.addr);
+        cidrin.mask = ntohl(cidrin.mask);
+    }
+
+    n = ngx_atoi(value[1].data, value[1].len);
+
+    var = NULL;
+    v = geo->values.elts;
+
+    if (n == NGX_ERROR) {
+        for (i = 0; i < geo->values.nelts; i++) {
+            if (ngx_strcmp(value[1].data, v[i]->text.data) == 0) {
+                var = v[i];
+                break;
+            }
+        }
+
+    } else {
+        for (i = 0; i < geo->values.nelts; i++) {
+            if (v[i]->value == (ngx_uint_t) n) {
+                var = v[i];
+                break;
+            }
+        }
+    }
+
+    if (i == geo->values.nelts) {
+        var = ngx_palloc(geo->pool, sizeof(ngx_http_variable_value_t));
+        if (var == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        var->text.len = value[1].len;
+        if (!(var->text.data = ngx_pstrdup(geo->pool, &value[1]))) {
+            return NGX_CONF_ERROR;
+        }
+
+        var->value = (n == NGX_ERROR) ? 0 : n;
+
+        if (!(v = ngx_array_push(&geo->values))) {
+            return NGX_CONF_ERROR;
+        }
+
+        *v = var;
+    }
+
+    rc = ngx_radix32tree_insert(geo->tree, cidrin.addr, cidrin.mask,
+                                (uintptr_t) var);
+    if (rc == NGX_ERROR) {
+        return NGX_CONF_ERROR;
+    }
+
+    if (rc == NGX_BUSY) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "duplicate parameter \"%V\"",
+                           &value[0]);
+        return NGX_CONF_ERROR;
+    }
+
+    return NGX_CONF_OK;
+}
diff --git a/src/http/modules/ngx_http_gzip_filter.c b/src/http/modules/ngx_http_gzip_filter.c
index cda9ca3..ccf5dc4 100644
--- a/src/http/modules/ngx_http_gzip_filter.c
+++ b/src/http/modules/ngx_http_gzip_filter.c
@@ -132,7 +132,8 @@
 static ngx_command_t  ngx_http_gzip_filter_commands[] = {
 
     { ngx_string("gzip"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
+                        |NGX_CONF_FLAG,
       ngx_conf_set_flag_slot,
       NGX_HTTP_LOC_CONF_OFFSET,
       offsetof(ngx_http_gzip_conf_t, enable),
diff --git a/src/http/modules/ngx_http_rewrite_handler.c b/src/http/modules/ngx_http_rewrite_handler.c
index 636331b..b1f591c 100644
--- a/src/http/modules/ngx_http_rewrite_handler.c
+++ b/src/http/modules/ngx_http_rewrite_handler.c
@@ -9,79 +9,170 @@
 #include <ngx_http.h>
 
 
-#define NGX_HTTP_REWRITE_COPY_CAPTURE  0
-#define NGX_HTTP_REWRITE_COPY_SHORT    1
-#define NGX_HTTP_REWRITE_COPY_LONG     2
-#define NGX_HTTP_REWRITE_START_ARGS    3
+typedef struct ngx_http_rewrite_engine_s  ngx_http_rewrite_engine_t;
+
+typedef void (*ngx_http_rewrite_code_pt) (ngx_http_rewrite_engine_t *e);
 
 
 typedef struct {
-    ngx_int_t    op;
-    size_t       len;
-    uintptr_t    data;
-} ngx_http_rewrite_op_t;
+    ngx_str_t                     name;
+    ngx_uint_t                    wildcard;
+} ngx_http_rewrite_referer_t;
 
 
 typedef struct {
-    ngx_regex_t  *regex;
-    ngx_uint_t    ncaptures;
+    ngx_array_t                  *codes;        /* uintptr_t */
+    ngx_array_t                  *referers;     /* ngx_http_rewrite_referer_t */
 
-    ngx_array_t   ops;
-    ngx_uint_t    size;
+    ngx_uint_t                    max_captures;
+    ngx_uint_t                    stack_size;
 
-    ngx_str_t     re_name;
-    ngx_str_t     s_name;
+    ngx_flag_t                    log;
 
-    ngx_uint_t    status;
-    unsigned      last:1;
-} ngx_http_rewrite_rule_t;
-
-
-typedef struct {
-    ngx_array_t   rules;
-    ngx_flag_t    log;
-} ngx_http_rewrite_srv_conf_t;
-
-
-typedef struct {
-    ngx_str_t     redirect;
+    ngx_flag_t                    no_referer;
 } ngx_http_rewrite_loc_conf_t;
 
 
-static void *ngx_http_rewrite_create_srv_conf(ngx_conf_t *cf);
-static char *ngx_http_rewrite_merge_srv_conf(ngx_conf_t *cf,
-                                             void *parent, void *child);
-static void *ngx_http_rewrite_create_loc_conf(ngx_conf_t *cf);
-static char *ngx_http_rewrite_rule(ngx_conf_t *cf, ngx_command_t *cmd,
-                                   void *conf);
-static char *ngx_http_redirect(ngx_conf_t *cf, void *post, void *data);
+typedef struct {
+    ngx_http_rewrite_code_pt      code;
+    ngx_regex_t                  *regex;
+    uintptr_t                     size;
+    uintptr_t                     ncaptures;
+    uintptr_t                     status;
+    uintptr_t                     next;
+
+    uintptr_t                     uri:1;
+
+    /* add the r->args to the new arguments */
+    uintptr_t                     args:1;
+
+    uintptr_t                     redirect:1;
+
+    ngx_str_t                     name;
+} ngx_http_rewrite_regex_code_t;
+
+
+typedef struct {
+    ngx_http_rewrite_code_pt      code;
+
+    uintptr_t                     uri:1;
+
+    /* add the r->args to the new arguments */
+    uintptr_t                     args:1;
+
+    uintptr_t                     redirect:1;
+} ngx_http_rewrite_regex_end_code_t;
+
+typedef struct {
+    ngx_http_rewrite_code_pt      code;
+    uintptr_t                     n;
+} ngx_http_rewrite_copy_capture_code_t;
+
+
+typedef struct {
+    ngx_http_rewrite_code_pt      code;
+    uintptr_t                     len;
+} ngx_http_rewrite_copy_code_t;
+
+
+typedef struct {
+    ngx_http_rewrite_code_pt      code;
+    uintptr_t                     status;
+    uintptr_t                     null;
+} ngx_http_rewrite_return_code_t;
+
+
+typedef struct {
+    ngx_http_rewrite_code_pt      code;
+    uintptr_t                     next;
+    void                        **loc_conf;
+} ngx_http_rewrite_if_code_t;
+
+
+typedef struct {
+    ngx_http_rewrite_code_pt      code;
+    uintptr_t                     index;
+} ngx_http_rewrite_var_code_t;
+
+
+struct ngx_http_rewrite_engine_s {
+    u_char                       *ip;
+    uintptr_t                    *sp;
+
+    ngx_str_t                     buf;
+    ngx_str_t                    *line;
+
+    u_char                       *pos;
+
+    /* the start of the rewritten arguments */
+    u_char                       *args;
+
+    unsigned                      quote:1;
+
+    ngx_int_t                     status;
+
+    int                          *captures;
+
+    ngx_http_request_t           *request;
+    ngx_http_rewrite_loc_conf_t  *conf;
+};
+
+
 static ngx_int_t ngx_http_rewrite_init(ngx_cycle_t *cycle);
-
-
-static ngx_conf_post_handler_pt  ngx_http_redirect_p = ngx_http_redirect;
+static void *ngx_http_rewrite_create_loc_conf(ngx_conf_t *cf);
+static char *ngx_http_rewrite_merge_loc_conf(ngx_conf_t *cf,
+                                             void *parent, void *child);
+static char *ngx_http_rewrite(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
+static char *ngx_http_rewrite_return(ngx_conf_t *cf, ngx_command_t *cmd,
+                                     void *conf);
+static char *ngx_http_rewrite_if(ngx_conf_t *cf, ngx_command_t *cmd,
+                                 void *conf);
+static char *ngx_http_rewrite_valid_referers(ngx_conf_t *cf, ngx_command_t *cmd,
+                                             void *conf);
+static void *ngx_http_rewrite_start_code(ngx_pool_t *pool,
+                                         ngx_array_t **codes, size_t size);
+static void *ngx_http_rewrite_add_code(ngx_array_t *codes, size_t size,
+                                       u_char **main);
 
 
 static ngx_command_t  ngx_http_rewrite_commands[] = {
 
     { ngx_string("rewrite"),
-      NGX_HTTP_SRV_CONF|NGX_CONF_TAKE23,
-      ngx_http_rewrite_rule,
-      NGX_HTTP_SRV_CONF_OFFSET,
+      NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
+                       |NGX_CONF_TAKE23,
+      ngx_http_rewrite,
+      NGX_HTTP_LOC_CONF_OFFSET,
       0,
       NULL },
 
-    { ngx_string("redirect"),
-      NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_conf_set_str_slot,
+    { ngx_string("return"),
+      NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
+                       |NGX_CONF_TAKE1,
+      ngx_http_rewrite_return,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
-      &ngx_http_redirect_p },
+      NULL },
+
+    { ngx_string("if"),
+      NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_1MORE,
+      ngx_http_rewrite_if,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      0,
+      NULL },
+
+    { ngx_string("valid_referers"),
+      NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
+      ngx_http_rewrite_valid_referers,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      0,
+      NULL },
 
     { ngx_string("rewrite_log"),
-      NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
+      NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
+                       |NGX_CONF_TAKE1,
       ngx_conf_set_flag_slot,
-      NGX_HTTP_SRV_CONF_OFFSET,
-      offsetof(ngx_http_rewrite_srv_conf_t, log),
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_rewrite_loc_conf_t, log),
       NULL },
 
       ngx_null_command
@@ -94,219 +185,470 @@
     NULL,                                  /* create main configuration */
     NULL,                                  /* init main configuration */
 
-    ngx_http_rewrite_create_srv_conf,      /* create server configuration */
-    ngx_http_rewrite_merge_srv_conf,       /* merge server configuration */
+    NULL,                                  /* create server configuration */
+    NULL,                                  /* merge server configuration */
 
     ngx_http_rewrite_create_loc_conf,      /* create location configration */
-    NULL,                                  /* merge location configration */
+    ngx_http_rewrite_merge_loc_conf        /* merge location configration */
 };
 
 
 ngx_module_t  ngx_http_rewrite_module = {
     NGX_MODULE,
-    &ngx_http_rewrite_module_ctx,          /* module context */
+    &ngx_http_rewrite_module_ctx,          /* module context */ 
     ngx_http_rewrite_commands,             /* module directives */
     NGX_HTTP_MODULE,                       /* module type */
     ngx_http_rewrite_init,                 /* init module */
-    NULL                                   /* init child */
+    NULL                                   /* init process */
 };
 
 
+#define ngx_http_rewrite_exit  (u_char *) &ngx_http_rewrite_exit_code
+
+uintptr_t ngx_http_rewrite_exit_code = (uintptr_t) NULL;
+
+
 static ngx_int_t ngx_http_rewrite_handler(ngx_http_request_t *r)
 {
-    int                          *captures;
-    u_char                       *p;
-    size_t                        len;
-    uintptr_t                     data;
-    ngx_int_t                     rc;
-    ngx_uint_t                    i, m, n;
-    ngx_str_t                     uri, args;
-    ngx_http_rewrite_op_t        *op;
-    ngx_http_rewrite_rule_t      *rule;
-    ngx_http_rewrite_srv_conf_t  *scf;
+    ngx_http_rewrite_code_pt      code;
+    ngx_http_rewrite_engine_t    *e;
+    ngx_http_rewrite_loc_conf_t  *cf;
 
-    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-                   "http rewrite handler");
+    cf = ngx_http_get_module_loc_conf(r, ngx_http_rewrite_module);
 
-    scf = ngx_http_get_module_srv_conf(r, ngx_http_rewrite_module);
-
-    rule = scf->rules.elts;
-    for (i = 0; i < scf->rules.nelts; i++) {
-
-        if (rule[i].ncaptures) {
-            captures = ngx_palloc(r->pool, rule[i].ncaptures * sizeof(int));
-            if (captures == NULL) {
-                return NGX_HTTP_INTERNAL_SERVER_ERROR;
-            }
-
-        } else {
-            captures = NULL;
-        }
-
-        rc = ngx_regex_exec(rule[i].regex, &r->uri,
-                            captures, rule[i].ncaptures);
-
-        if (rc == NGX_REGEX_NO_MATCHED) {
-            if (scf->log) {
-                ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
-                              "\"%V\" does not match \"%V\"",
-                              &rule[i].re_name, &r->uri);
-            }
-
-            continue;
-        }
-
-        if (rc < 0) {
-            ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
-                          ngx_regex_exec_n
-                          " failed: %d on \"%V\" using \"%V\"",
-                          rc, &r->uri, &rule[i].re_name);
-            return NGX_HTTP_INTERNAL_SERVER_ERROR;
-        }
-
-        if (scf->log) {
-            ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
-                          "\"%V\" matches \"%V\"",
-                          &rule[i].re_name, &r->uri);
-        }
-
-        if (rule[i].status) {
-            return rule[i].status;
-        }
-
-        uri.len = rule[i].size;
-
-        for (n = 1; n < (ngx_uint_t) rc; n++) {
-            uri.len += captures[2 * n + 1] - captures[2 * n];
-        }
-
-        if (!(uri.data = ngx_palloc(r->pool, uri.len))) {
-            return NGX_HTTP_INTERNAL_SERVER_ERROR;
-        }
-
-        args.data = NULL;
-        p = uri.data;
-
-        op = rule[i].ops.elts;
-        for (n = 0; n < rule[i].ops.nelts; n++) {
-            if (op[n].op == NGX_HTTP_REWRITE_COPY_SHORT) {
-                len = op[n].len;
-                data = op[n].data;
-                while (len--) {
-                    *p++ = (char) (data & 0xff);
-                    data >>= 8;
-                }
-
-            } else if (op[n].op == NGX_HTTP_REWRITE_COPY_LONG) {
-                p = ngx_cpymem(p, (void *) op[n].data, op[n].len);
-
-            } else if (op[n].op == NGX_HTTP_REWRITE_START_ARGS) {
-                args.data = p;
-
-            } else { /* NGX_HTTP_REWRITE_COPY_CAPTURE */
-                m = 2 * op[n].data;
-                p = ngx_cpymem(p, &r->uri.data[captures[m]],
-                               captures[m + 1] - captures[m]);
-            }
-        }
-
-        if (args.data) {
-            uri.len = args.data - uri.data;
-            args.len = p - args.data;
-
-            r->args = args;
-
-        } else {
-            uri.len = p - uri.data;
-            args.len = 0;
-        }
-
-        r->uri = uri;
-
-        if (scf->log) {
-            ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
-                          "rewritten uri: \"%V\", args: \"%V\"", &uri, &args);
-        }
-
-        if (ngx_http_set_exten(r) != NGX_OK) {
-            return NGX_HTTP_INTERNAL_SERVER_ERROR;
-        }
-
-        if (rule[i].last) {
-            return NGX_DECLINED;
-        }
+    if (cf->codes == NULL) {
+        return NGX_DECLINED;
     }
 
-    return NGX_DECLINED;
-}
-
-
-static ngx_int_t ngx_http_redirect_handler(ngx_http_request_t *r)
-{
-    u_char                       *p;
-    ngx_http_rewrite_loc_conf_t  *rlcf;
-
-    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-                   "http redirect handler");
-
-    rlcf = ngx_http_get_module_loc_conf(r, ngx_http_rewrite_module);
-
-    r->headers_out.location = ngx_list_push(&r->headers_out.headers);
-    if (r->headers_out.location == NULL) {
+    if (!(e = ngx_palloc(r->pool, sizeof(ngx_http_rewrite_engine_t)))) {
         return NGX_HTTP_INTERNAL_SERVER_ERROR;
     }
 
-    if (rlcf->redirect.data[0] != '/') {
+    e->sp = ngx_palloc(r->pool, cf->stack_size * sizeof(ngx_int_t));
+    if (e->sp == NULL) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    if (cf->max_captures) {
+        e->captures = ngx_palloc(r->pool, cf->max_captures * sizeof(int));
+        if (e->captures == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+    } else {
+        e->captures = NULL;
+    }
+
+    e->ip = cf->codes->elts;
+    e->buf.len = 0;
+    e->buf.data = NULL;
+    e->line = NULL;
+    e->pos = NULL;
+    e->args = NULL;
+    e->quote = 1;
+    e->status = NGX_DECLINED;
+    e->request = r;
+    e->conf = cf;
+
+    while (*(uintptr_t *) e->ip) {
+        code = *(ngx_http_rewrite_code_pt *) e->ip;
+        code(e);
+    }
+
+    return e->status;
+}
+
+
+static void ngx_http_rewrite_regex_start_code(ngx_http_rewrite_engine_t *e)
+{
+    ngx_int_t                       rc;
+    ngx_uint_t                      n;
+    ngx_http_request_t             *r;
+    ngx_http_rewrite_regex_code_t  *code;
+
+    code = (ngx_http_rewrite_regex_code_t *) e->ip;
+
+    r = e->request;
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "http rewrite start: \"%V\"", &code->name);
+
+    if (code->uri) {
+        e->line = &r->uri;
+    } else {
+        e->line = *(ngx_str_t **) e->sp--;
+    }
+
+    rc = ngx_regex_exec(code->regex, e->line, e->captures, code->ncaptures);
+
+    if (rc == NGX_REGEX_NO_MATCHED) {
+        if (e->conf->log) {
+            ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
+                          "\"%V\" does not match \"%V\"", &code->name, e->line);
+        }
+
+        e->ip += code->next;
+        return;
+    }
+
+    if (rc < 0) {
+        ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
+                      ngx_regex_exec_n " failed: %d on \"%V\" using \"%V\"",
+                      rc, e->line, &code->name);
+
+        e->ip = ngx_http_rewrite_exit;
+        e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
+        return;
+    }
+
+    if (e->conf->log) {
+        ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
+                      "\"%V\" matches \"%V\"", &code->name, e->line);
+    }
+
+    if (code->status) {
+        e->status = code->status;
+
+        if (!code->redirect) {
+            e->ip = ngx_http_rewrite_exit;
+            return;
+        }
+    }
+
+    e->buf.len = code->size;
+
+    if (code->uri) {
+        r->uri_changed = 1;
+
+        if (rc && (r->quoted_uri || r->plus_in_uri)) {
+            e->buf.len += 2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len,
+                                             NGX_ESCAPE_ARGS);
+        }
+    }
+
+    for (n = 1; n < (ngx_uint_t) rc; n++) {
+        e->buf.len += e->captures[2 * n + 1] - e->captures[2 * n];
+    }
+
+    if (code->args && r->args.len) {
+        e->buf.len += r->args.len + 1;
+    }
+
+    if (!(e->buf.data = ngx_palloc(r->pool, e->buf.len))) {
+        e->ip = ngx_http_rewrite_exit;
+        e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
+        return;
+    }
+
+    e->quote = code->redirect;
+
+    e->pos = e->buf.data;
+
+    e->ip += sizeof(ngx_http_rewrite_regex_code_t);
+}
+
+
+static void ngx_http_rewrite_regex_end_code(ngx_http_rewrite_engine_t *e)
+{
+    ngx_http_request_t                 *r;
+    ngx_http_rewrite_regex_end_code_t  *code;
+
+    code = (ngx_http_rewrite_regex_end_code_t *) e->ip;
+
+    r = e->request;
+
+    e->quote = 0;
+
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "http rewrite end");
+
+    if (e->args) {
+        e->buf.len = e->args - e->buf.data;
+
+        if (code->args && r->args.len) {
+            *e->pos++ = '&';
+            e->pos = ngx_cpymem(e->pos, r->args.data, r->args.len);
+        }
+
+        r->args.len = e->pos - e->args;
+        r->args.data = e->args;
+
+        e->args = NULL;
+
+    } else {
+        if (code->args && r->args.len) {
+            *e->pos++ = '&';
+            e->pos = ngx_cpymem(e->pos, r->args.data, r->args.len);
+        }
+
+        e->buf.len = e->pos - e->buf.data;
+    }
+
+    if (!code->redirect) {
+        if (e->conf->log) {
+            ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
+                          "rewritten data: \"%V\", args: \"%V\"",
+                          &e->buf, &r->args);
+        }
+
+        if (code->uri) {
+            r->uri = e->buf;
+
+            if (ngx_http_set_exten(r) != NGX_OK) {
+                e->ip = ngx_http_rewrite_exit;
+                e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
+                return;
+            }
+        }
+
+        e->ip += sizeof(ngx_http_rewrite_regex_end_code_t);
+        return;
+    }
+
+    ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
+                  "rewritten redirect: \"%V\"", &e->buf);
+
+    if (!(r->headers_out.location = ngx_list_push(&r->headers_out.headers))) {
+        e->ip = ngx_http_rewrite_exit;
+        e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
+        return;
+    }
+
+    if (e->buf.data[0] != '/') {
         r->headers_out.location->key.len = sizeof("Location") - 1;
         r->headers_out.location->key.data = (u_char *) "Location";
     }
 
-    r->headers_out.location->value.len =  rlcf->redirect.len
-                                          + r->unparsed_uri.len;
-    r->headers_out.location->value.data = ngx_palloc(r->pool,
-                                           r->headers_out.location->value.len);
+    r->headers_out.location->value = e->buf;
 
-    if (r->headers_out.location->value.data == NULL) {
-        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    e->ip += sizeof(ngx_http_rewrite_regex_end_code_t);
+}
+
+
+static void ngx_http_rewrite_copy_capture_code(ngx_http_rewrite_engine_t *e)
+{
+    ngx_http_rewrite_copy_capture_code_t  *code;
+
+    code = (ngx_http_rewrite_copy_capture_code_t *) e->ip;
+
+    e->ip += sizeof(ngx_http_rewrite_copy_capture_code_t);
+
+    if ((e->args || e->quote)
+        && (e->request->quoted_uri || e->request->plus_in_uri))
+    {
+        e->pos = (u_char *) ngx_escape_uri(e->pos,
+                                &e->line->data[e->captures[code->n]],
+                                e->captures[code->n + 1] - e->captures[code->n],
+                                NGX_ESCAPE_ARGS);
+    } else {
+        e->pos = ngx_cpymem(e->pos, &e->line->data[e->captures[code->n]],
+                        e->captures[code->n + 1] - e->captures[code->n]);
     }
 
-    p = ngx_cpymem(r->headers_out.location->value.data, rlcf->redirect.data,
-                   rlcf->redirect.len);
-    p = ngx_cpystrn(p, r->unparsed_uri.data + 1, r->unparsed_uri.len);
-
-    return NGX_HTTP_MOVED_TEMPORARILY;
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+                   "http rewrite capture: \"%V\"", &e->buf);
 }
 
 
-static void *ngx_http_rewrite_create_srv_conf(ngx_conf_t *cf)
+static void ngx_http_rewrite_copy_code(ngx_http_rewrite_engine_t *e)
 {
-    ngx_http_rewrite_srv_conf_t  *conf;
+    ngx_http_rewrite_copy_code_t  *code;
 
-    if (!(conf = ngx_palloc(cf->pool, sizeof(ngx_http_rewrite_srv_conf_t)))) {
-        return NGX_CONF_ERROR;
+    code = (ngx_http_rewrite_copy_code_t *) e->ip;
+
+    e->pos = ngx_cpymem(e->pos, e->ip + sizeof(ngx_http_rewrite_copy_code_t),
+                        code->len);
+
+    e->ip += sizeof(ngx_http_rewrite_copy_code_t)
+             + ((code->len + sizeof(uintptr_t) - 1) & ~(sizeof(uintptr_t) - 1));
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+                   "http rewrite copy: \"%V\"", &e->buf);
+}
+
+
+static void ngx_http_rewrite_start_args_code(ngx_http_rewrite_engine_t *e)
+{
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+                   "http rewrite args");
+
+    e->args = e->pos;
+    e->ip += sizeof(uintptr_t);
+}
+
+
+static void ngx_http_rewrite_return_code(ngx_http_rewrite_engine_t *e)
+{
+    ngx_http_rewrite_return_code_t  *code;
+
+    code = (ngx_http_rewrite_return_code_t *) e->ip;
+
+    e->status = code->status;
+
+    e->ip += sizeof(ngx_http_rewrite_return_code_t) - sizeof(uintptr_t);
+}
+
+
+static void ngx_http_rewrite_if_code(ngx_http_rewrite_engine_t *e)
+{
+    ngx_http_rewrite_if_code_t  *code;
+
+    code = (ngx_http_rewrite_if_code_t *) e->ip;
+
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+                   "http rewrite if");
+
+    if (*e->sp--) {
+        if (code->loc_conf) {
+            e->request->loc_conf = code->loc_conf;
+        }
+
+        e->ip += sizeof(ngx_http_rewrite_if_code_t);
+        return;
     }
 
-    ngx_init_array(conf->rules, cf->pool, 5, sizeof(ngx_http_rewrite_rule_t),
-                   NGX_CONF_ERROR);
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+                   "http rewrite if false");
 
-    conf->log = NGX_CONF_UNSET;
-
-    return conf;
+    e->ip += code->next;
 }
 
 
-static char *ngx_http_rewrite_merge_srv_conf(ngx_conf_t *cf,
-                                             void *parent, void *child)
+static void ngx_http_rewrite_var_code(ngx_http_rewrite_engine_t *e)
 {
-    ngx_http_rewrite_srv_conf_t *prev = parent;
-    ngx_http_rewrite_srv_conf_t *conf = child;
+    ngx_http_variable_value_t    *value;
+    ngx_http_rewrite_var_code_t  *code;
 
-    ngx_conf_merge_value(conf->log, prev->log, 0);
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+                   "http rewrite var");
 
-    return NGX_CONF_OK;
+    code = (ngx_http_rewrite_var_code_t *) e->ip;
+
+    e->sp++;
+
+    e->ip += sizeof(ngx_http_rewrite_var_code_t);
+
+    if (!(value = ngx_http_get_variable(e->request, code->index))) {
+        *e->sp = (uintptr_t) 0;
+        return;
+    }
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+                   "http rewrite var: %p", value->value);
+
+    *e->sp = value->value;
 }
 
 
+static void ngx_http_rewrite_invalid_referer_code(ngx_http_rewrite_engine_t *e)
+{
+    u_char                       *ref;
+    size_t                        len;
+    ngx_uint_t                    i, n;
+    ngx_http_request_t           *r;
+    ngx_http_rewrite_referer_t   *refs;
+    ngx_http_rewrite_loc_conf_t  *cf;
+
+    r = e->request;
+
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "http rewrite invalid referer");
+
+    cf = ngx_http_get_module_loc_conf(r, ngx_http_rewrite_module);
+
+    e->sp++;
+    e->ip += sizeof(uintptr_t);
+
+    if (cf->referers == NULL) {
+        *e->sp = (uintptr_t) 0;
+        return;
+    }
+
+    if (r->headers_in.referer == NULL) {
+        if (cf->no_referer) {
+            *e->sp = (uintptr_t) 0;
+            return;
+        } else {
+            *e->sp = (uintptr_t) 1;
+            return;
+        }
+    }
+
+    len = r->headers_in.referer->value.len;
+    ref = r->headers_in.referer->value.data;
+
+    if (len < sizeof("http://i.ru") - 1
+        || (ngx_strncasecmp(ref, "http://", 7) != 0))
+    {
+        *e->sp = (uintptr_t) 1;
+        return;
+    }
+
+    len -= 7;
+    ref += 7;
+
+    refs = cf->referers->elts;
+    for (i = 0; i < cf->referers->nelts; i++ ){
+
+        if (refs[i].name.len > len) {
+            continue;
+        }
+
+        if (refs[i].wildcard) {
+            for (n = 0; n < len; n++) {
+                if (ref[n] == '/' || ref[n] == ':') {
+                    break;
+                }
+
+                if (ref[n] != '.') {
+                    continue;
+                }
+
+                if (ngx_strncmp(&ref[n], refs[i].name.data,
+                                refs[i].name.len) == 0)
+                {
+                    *e->sp = (uintptr_t) 0;
+                    return;
+                }
+            }
+
+        } else {
+            if (ngx_strncasecmp(refs[i].name.data, ref, refs[i].name.len) == 0)
+            {
+                *e->sp = (uintptr_t) 0;
+                return;
+            }
+        }
+    }
+
+    *e->sp = (uintptr_t) 1;
+}
+
+
+static void ngx_http_rewrite_nop_code(ngx_http_rewrite_engine_t *e)
+{
+    e->ip += sizeof(uintptr_t);
+}
+
+
+static ngx_int_t ngx_http_rewrite_init(ngx_cycle_t *cycle)
+{   
+    ngx_http_handler_pt        *h;
+    ngx_http_core_main_conf_t  *cmcf;
+    
+    cmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_core_module);
+
+    h = ngx_push_array(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers);
+    if (h == NULL) {
+        return NGX_ERROR;
+    }
+    
+    *h = ngx_http_rewrite_handler;
+    
+    return NGX_OK;
+}   
+
+
 static void *ngx_http_rewrite_create_loc_conf(ngx_conf_t *cf)
 {
     ngx_http_rewrite_loc_conf_t  *conf;
@@ -315,198 +657,643 @@
         return NGX_CONF_ERROR;
     }
 
+    conf->stack_size = NGX_CONF_UNSET_UINT;
+    conf->log = NGX_CONF_UNSET;
+    conf->no_referer = NGX_CONF_UNSET;
+
     return conf;
 }
 
 
-static char *ngx_http_rewrite_rule(ngx_conf_t *cf, ngx_command_t *cmd,
-                                   void *conf)
+static char *ngx_http_rewrite_merge_loc_conf(ngx_conf_t *cf,
+                                             void *parent, void *child)
 {
-    ngx_http_rewrite_srv_conf_t *scf = conf;
+    ngx_http_rewrite_loc_conf_t *prev = parent;
+    ngx_http_rewrite_loc_conf_t *conf = child;
 
-    u_char                   *data, *p;
-    size_t                    len;
-    ngx_str_t                *value, err;
-    ngx_uint_t                i, n;
-    ngx_http_rewrite_op_t    *op;
-    ngx_http_rewrite_rule_t  *rule;
-    u_char                    errstr[NGX_MAX_CONF_ERRSTR];
+    uintptr_t                      *code, *last;
+    ngx_http_rewrite_regex_code_t  *regex;
 
-    if (!(rule = ngx_push_array(&scf->rules))) {
+    ngx_conf_merge_value(conf->log, prev->log, 0);
+    ngx_conf_merge_unsigned_value(conf->stack_size, prev->stack_size, 10);
+
+    if (conf->referers == NULL) {
+        conf->referers = prev->referers;
+        ngx_conf_merge_value(conf->no_referer, prev->no_referer, 0);
+    }
+
+    if (conf->codes == NULL) {
+        return NGX_CONF_OK;
+    }
+
+    if (conf->codes == prev->codes) {
+        return NGX_CONF_OK;
+    }
+
+    code = conf->codes->elts;
+    last = (uintptr_t *) ((u_char *) code + conf->codes->nelts);
+
+    while (code < last) {
+        if (*code == (uintptr_t) NULL) {
+            return NGX_CONF_OK;
+        }
+
+        if (*code == (uintptr_t) &ngx_http_rewrite_regex_start_code) {
+            regex = (ngx_http_rewrite_regex_code_t *) code;
+            if (conf->max_captures < regex->ncaptures) {
+                conf->max_captures = regex->ncaptures;
+            }
+            code = (uintptr_t *) ((u_char *) code + regex->next);
+        }
+
+        if (*code == (uintptr_t) &ngx_http_rewrite_if_code) {
+            code += sizeof(ngx_http_rewrite_if_code_t) / sizeof(uintptr_t);
+        }
+
+        if (*code == (uintptr_t) &ngx_http_rewrite_return_code) {
+            code += sizeof(ngx_http_rewrite_return_code_t) / sizeof(uintptr_t);
+        }
+
+        if (*code == (uintptr_t) &ngx_http_rewrite_var_code) {
+            code += sizeof(ngx_http_rewrite_var_code_t) / sizeof(uintptr_t);
+        }
+
+        if (*code == (uintptr_t) &ngx_http_rewrite_invalid_referer_code) {
+            code++;
+        }
+
+        if (*code == (uintptr_t) &ngx_http_rewrite_nop_code) {
+            code++;
+        }
+    }
+
+    if (!(code = ngx_array_push_n(conf->codes, sizeof(uintptr_t)))) {
         return NGX_CONF_ERROR;
     }
 
-    ngx_init_array(rule->ops, cf->pool, 5, sizeof(ngx_http_rewrite_op_t),
-                   NGX_CONF_ERROR);
+    *code = (uintptr_t) NULL;
 
-    rule->ncaptures = 0;
-    rule->size = 0;
-    rule->status = 0;
-    rule->last = 0;
+    return NGX_CONF_OK;
+}
+
+
+static char *ngx_http_rewrite(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_http_rewrite_loc_conf_t *lcf = conf;
+    
+    u_char                                *data;
+    size_t                                 len, size;
+    ngx_str_t                             *value, err;
+    ngx_uint_t                             i, n, last;
+    ngx_http_rewrite_code_pt              *code;
+    ngx_http_rewrite_copy_code_t          *copy;
+    ngx_http_rewrite_regex_code_t         *regex;
+    ngx_http_rewrite_regex_end_code_t     *regex_end;
+    ngx_http_rewrite_copy_capture_code_t  *copy_capture;
+    u_char                                 errstr[NGX_MAX_CONF_ERRSTR];
+
+    regex = ngx_http_rewrite_start_code(cf->pool, &lcf->codes,
+                                        sizeof(ngx_http_rewrite_regex_code_t));
+    if (regex == NULL) {
+        return NGX_CONF_ERROR;
+    }
 
     value = cf->args->elts;
 
-    /* STUB */ {
-        err.len = NGX_MAX_CONF_ERRSTR;
-        err.data = errstr;
+    err.len = NGX_MAX_CONF_ERRSTR;
+    err.data = errstr;
 
-        rule->regex = ngx_regex_compile(&value[1], 0, cf->pool, &err);
-    
-        if (rule->regex == NULL) {
-            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%s", err.data);
-            return NGX_CONF_ERROR;
-        }
-    
-        rule->re_name = value[1];
-        rule->s_name = value[2];
+    /* TODO: NGX_REGEX_CASELESS */
 
-        if (ngx_strcasecmp(value[2].data, "forbidden:") == 0) {
+    regex->regex = ngx_regex_compile(&value[1], 0, cf->pool, &err);
 
-            if (cf->args->nelts == 3) {
-                rule->status = NGX_HTTP_FORBIDDEN;
-                rule->last = 1;
-                return NGX_CONF_OK;
-            }
+    if (regex->regex == NULL) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%s", err.data);
+        return NGX_CONF_ERROR;
+    }
 
+    regex->code = ngx_http_rewrite_regex_start_code;
+    regex->size = 0;
+    regex->ncaptures = 0;
+    regex->status = 0;
+    regex->uri = 1;
+    regex->args = 1;
+    regex->redirect = 0;
+    regex->name = value[1];
+
+    last = 0;
+
+    if (ngx_strncmp(value[2].data, "http://", sizeof("http://") - 1) == 0) {
+        regex->status = NGX_HTTP_MOVED_TEMPORARILY;
+        regex->redirect = 1;
+        last = 1;
+    }
+
+    if (cf->args->nelts == 4) {
+        if (ngx_strcmp(value[3].data, "last") == 0) {
+            last = 1;
+
+        } else if (ngx_strcmp(value[3].data, "redirect") == 0) {
+            regex->status = NGX_HTTP_MOVED_TEMPORARILY;
+            regex->redirect = 1;
+            last = 1;
+
+        } else if (ngx_strcmp(value[3].data, "permanent") == 0) {
+            regex->status = NGX_HTTP_MOVED_PERMANENTLY;
+            regex->redirect = 1;
+            last = 1;
+
+        } else {
             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                "invalid parameter \"%V\"", &value[3]);
             return NGX_CONF_ERROR;
         }
+    }
 
-        i = 0;
+    i = 0;
 
-        while (i < value[2].len) {
+    while (i < value[2].len) {
 
-            if (!(op = ngx_push_array(&rule->ops))) {
+        data = &value[2].data[i];
+
+        if (value[2].data[i] == '$' && i < value[2].len
+            && value[2].data[i + 1] >= '1' && value[2].data[i + 1] <= '9')
+        {
+
+            /* the "$1" - "$9" captures */
+
+            copy_capture = ngx_http_rewrite_add_code(lcf->codes,
+                                  sizeof(ngx_http_rewrite_copy_capture_code_t),
+                                  (u_char **) &regex);
+            if (copy_capture == NULL) {
                 return NGX_CONF_ERROR;
             }
 
-            data = &value[2].data[i];
-
-            if (value[2].data[i] == '$'
-                && i < value[2].len
-                && value[2].data[i + 1] >= '1'
-                && value[2].data[i + 1] <= '9')
-            {
-                op->op = NGX_HTTP_REWRITE_COPY_CAPTURE; 
-                op->len = 0;
-                op->data = value[2].data[++i] - '0';
-
-                if (rule->ncaptures < op->data) {
-                    rule->ncaptures = op->data;
-                }
-
-                i++;
-
-                continue;
-            }
-
-            if (value[2].data[i] == '?') {
-                op->op = NGX_HTTP_REWRITE_START_ARGS; 
-                op->len = 0;
-                op->data = 0;
-
-                i++;
-
-                continue;
-            }
-
             i++;
 
-            while (i < value[2].len
-                   && value[2].data[i] != '$'
-                   && value[2].data[i] != '?')
-            {
-                i++;
+            copy_capture->code = ngx_http_rewrite_copy_capture_code;
+            copy_capture->n = value[2].data[i] - '0';
+
+            if (regex->ncaptures < copy_capture->n) {
+                regex->ncaptures = copy_capture->n;
             }
 
-            len = &value[2].data[i] - data;
-            rule->size += len;
+            copy_capture->n *= 2;
 
-            if (len) {
+            i++;
 
-                op->len = len;
+            continue;
+        }
 
-                if (len <= sizeof(uintptr_t)) {
-                    op->op = NGX_HTTP_REWRITE_COPY_SHORT; 
-                    op->data = 0;
+        if (value[2].data[i] == '?') {
 
-                    while (len--) {
-                        op->data <<= 8;
-                        op->data |= data[len];
-                    }
+            /* the arguments */
 
-                } else {
-                    op->op = NGX_HTTP_REWRITE_COPY_LONG;
+            if (i == value[2].len - 1) {
+                /* the last "?" drops the original arguments */
+                regex->args = 0;
+                break;
+            }
 
-                    if (!(p = ngx_palloc(cf->pool, len))) {
-                        return NGX_CONF_ERROR;
-                    }
-
-                    ngx_memcpy(p, data, len);
-                    op->data = (uintptr_t) p;
+            if (!regex->redirect) {
+                code = ngx_http_rewrite_add_code(lcf->codes, sizeof(uintptr_t),
+                                                 (u_char **) &regex);
+                if (code == NULL) {
+                    return NGX_CONF_ERROR;
                 }
+
+                *code = ngx_http_rewrite_start_args_code;
+
+                i++;
+
+                continue;
             }
         }
 
-        n = ngx_regex_capture_count(rule->regex);
+        i++;
 
-        if (rule->ncaptures > n) {
-            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-                               "pattern \"%V\" has less captures "
-                               "than referrenced in substitution \"%V\"",
-                               &value[1], &value[2]);
+        /* the substituion strings */
+
+        while (i < value[2].len && value[2].data[i] != '$') {
+
+            if (value[2].data[i] == '?') {
+
+                if (i == value[2].len - 1) {
+                    /*
+                     * the last "?" drops the original arguments,
+                     * and it should not be copied to a substituion
+                     */
+                    regex->args = 0;
+                    break;
+                }
+
+                if (!regex->redirect) {
+                    break;
+                }
+            }
+
+            i++;
+        }
+
+        len = &value[2].data[i] - data;
+
+        if (len == 0) {
+            continue;
+        }
+
+        regex->size += len;
+
+        size = (len + sizeof(uintptr_t) - 1) & ~(sizeof(uintptr_t) - 1);
+
+        copy = ngx_http_rewrite_add_code(lcf->codes,
+                                   sizeof(ngx_http_rewrite_copy_code_t) + size,
+                                   (u_char **) &regex);
+        if (copy == NULL) {
             return NGX_CONF_ERROR;
         }
 
-        if (rule->ncaptures < n) {
-            rule->ncaptures = n;
+        copy->code = ngx_http_rewrite_copy_code;
+        copy->len = len;
+
+        ngx_memcpy((u_char *) copy + sizeof(ngx_http_rewrite_copy_code_t),
+                   data, len);
+    }
+
+    n = ngx_regex_capture_count(regex->regex);
+
+    if (regex->ncaptures > n) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "pattern \"%V\" has less captures "
+                           "than referrenced in substitution \"%V\"",
+                           &value[1], &value[2]);
+        return NGX_CONF_ERROR;
+    }
+
+    if (regex->ncaptures < n) {
+        regex->ncaptures = n;
+    }
+
+    if (regex->ncaptures) {
+        regex->ncaptures = (regex->ncaptures + 1) * 3;
+    }
+
+    regex_end = ngx_http_rewrite_add_code(lcf->codes,
+                                     sizeof(ngx_http_rewrite_regex_end_code_t),
+                                     (u_char **) &regex);
+    if (regex_end == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+    regex_end->code = ngx_http_rewrite_regex_end_code;
+    regex_end->uri = regex->uri;
+    regex_end->args = regex->args;
+    regex_end->redirect = regex->redirect;
+
+    if (last) {
+        code = ngx_http_rewrite_add_code(lcf->codes, sizeof(uintptr_t),
+                                         (u_char **) &regex);
+        if (code == NULL) {
+            return NGX_CONF_ERROR;
         }
 
-        if (rule->ncaptures) {
-            rule->ncaptures = (rule->ncaptures + 1) * 3;
+        *code = (uintptr_t) NULL;
+    }
+
+    regex->next = (u_char *) lcf->codes->elts + lcf->codes->nelts
+                                              - (u_char *) regex;
+
+    return NGX_CONF_OK;
+}
+
+
+
+static char *ngx_http_rewrite_return(ngx_conf_t *cf, ngx_command_t *cmd,
+                                     void *conf)
+{
+    ngx_http_rewrite_loc_conf_t *lcf = conf;
+
+    ngx_str_t                       *value;
+    ngx_http_rewrite_return_code_t  *ret;
+
+    ret = ngx_http_rewrite_start_code(cf->pool, &lcf->codes,
+                                      sizeof(ngx_http_rewrite_return_code_t));
+    if (ret == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+    value = cf->args->elts;
+
+    ret->code = ngx_http_rewrite_return_code;
+    ret->null = (uintptr_t) NULL;
+
+    ret->status = ngx_atoi(value[1].data, value[1].len);
+
+    if (ret->status == (uintptr_t) NGX_ERROR) {
+        return NGX_CONF_ERROR;
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+static char *ngx_http_rewrite_if(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_http_rewrite_loc_conf_t *lcf = conf;
+
+    void                         *mconf;
+    char                         *rv;
+    u_char                       *elts;
+    ngx_str_t                    *value;
+    ngx_uint_t                    i;
+    ngx_conf_t                    save;
+    ngx_http_rewrite_code_pt     *code;
+    ngx_http_module_t            *module;
+    ngx_http_conf_ctx_t          *ctx, *pctx;
+    ngx_http_variable_t          *var;
+    ngx_http_core_loc_conf_t     *clcf, *pclcf, **clcfp;
+    ngx_http_core_main_conf_t    *cmcf;
+    ngx_http_rewrite_if_code_t   *if_code;
+    ngx_http_rewrite_var_code_t  *var_code;
+    ngx_http_rewrite_loc_conf_t  *nlcf;
+
+    if (!(ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)))) {
+        return NGX_CONF_ERROR;
+    }
+
+    pctx = cf->ctx;
+    ctx->main_conf = pctx->main_conf;
+    ctx->srv_conf = pctx->srv_conf; 
+
+    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
+    if (ctx->loc_conf == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+    for (i = 0; ngx_modules[i]; i++) {
+        if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
+            continue;
         }
 
-        if (cf->args->nelts > 3) {
-            if (ngx_strcmp(value[3].data, "last") == 0) {
-                rule->last = 1;
+        module = ngx_modules[i]->ctx;
+    
+        if (module->create_loc_conf) {
 
-            } else {
-                ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-                                   "invalid parameter \"%V\"", &value[3]);
-                return NGX_CONF_ERROR;
+            if (!(mconf = module->create_loc_conf(cf))) {
+                 return NGX_CONF_ERROR;
+            }
+
+            ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
+        }
+    }
+
+    pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];
+
+    clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
+    clcf->loc_conf = ctx->loc_conf;
+    clcf->name = pclcf->name;
+    clcf->noname = 1;
+
+    if (pclcf->locations.elts == NULL) {
+        if (ngx_array_init(&pclcf->locations, cf->pool, 4, sizeof(void *))
+                                                                  == NGX_ERROR)
+        {
+            return NGX_CONF_ERROR;
+        }
+    }
+
+    if (!(clcfp = ngx_push_array(&pclcf->locations))) {
+        return NGX_CONF_ERROR;
+    }
+
+    *clcfp = clcf;
+
+
+    /* STUB: "if ($var)" */
+
+    value = cf->args->elts;
+
+    if (value[1].len < 2
+        || value[1].data[0] != '('
+        || value[1].data[1] != '$'
+        || value[1].data[value[1].len - 1] != ')')
+    {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "invalid condition \"%V\"", &value[1]);
+        return NGX_CONF_ERROR;
+    }
+
+    value[1].len -= 3;
+    value[1].data += 2;
+
+    if (value[1].len == sizeof("invalid_referer") - 1
+        && ngx_strncmp(value[1].data, "invalid_referer",
+                       sizeof("invalid_referer") - 1) == 0)
+    {
+        code = ngx_http_rewrite_start_code(cf->pool, &lcf->codes,
+                                           sizeof(ngx_http_rewrite_code_pt));
+        if (code == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        *code = ngx_http_rewrite_invalid_referer_code;
+
+    } else {
+
+        cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
+
+        var = cmcf->variables.elts;
+        for (i = 0; i < cmcf->variables.nelts; i++) {
+            if (var[i].name.len != value[1].len) {
+                continue;
+            }
+
+            if (ngx_strncasecmp(var[i].name.data, value[1].data,
+                                var[i].name.len) == 0)
+            {
+                break;
             }
         }
+
+        if (i == cmcf->variables.nelts) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "unknown variable name \"%V\"", &value[1]);
+            return NGX_CONF_ERROR;
+        }
+
+        var_code = ngx_http_rewrite_start_code(cf->pool, &lcf->codes,
+                                           sizeof(ngx_http_rewrite_var_code_t));
+        if (var_code == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        var_code->code = ngx_http_rewrite_var_code;
+        var_code->index = var[i].index;
+    }
+
+    if_code = ngx_array_push_n(lcf->codes, sizeof(ngx_http_rewrite_if_code_t));
+    if (if_code == NULL) {
+        return NULL;
+    }
+
+    if_code->code = ngx_http_rewrite_if_code;
+
+    elts = lcf->codes->elts;
+
+
+    /* the inside directives must compile to the same code array */
+
+    nlcf = ctx->loc_conf[ngx_http_rewrite_module.ctx_index];
+    nlcf->codes = lcf->codes;
+
+
+    save = *cf;
+    cf->ctx = ctx;
+
+    if (pclcf->name.len == 0) {
+        if_code->loc_conf = NULL;
+        cf->cmd_type = NGX_HTTP_SIF_CONF;
+
+    } else {
+        if_code->loc_conf = ctx->loc_conf;
+        cf->cmd_type = NGX_HTTP_LIF_CONF;
+    }
+
+    rv = ngx_conf_parse(cf, NULL);
+
+    *cf = save;
+
+    if (rv != NGX_CONF_OK) {
+        return rv;
+    }
+
+
+    if (elts != lcf->codes->elts) {
+        if_code = (ngx_http_rewrite_if_code_t *)
+                   ((u_char *) if_code + ((u_char *) lcf->codes->elts - elts));
+    }
+
+    if_code->next = (u_char *) lcf->codes->elts + lcf->codes->nelts
+                                                - (u_char *) if_code;
+
+    return NGX_CONF_OK;
+}
+
+
+static char *ngx_http_rewrite_valid_referers(ngx_conf_t *cf, ngx_command_t *cmd,
+                                             void *conf)
+{
+    ngx_http_rewrite_loc_conf_t *lcf = conf;
+
+    ngx_uint_t                   i, server_names;
+    ngx_str_t                   *value;
+    ngx_http_server_name_t      *sn;
+    ngx_http_core_srv_conf_t    *cscf;
+    ngx_http_rewrite_referer_t  *ref;
+
+    cscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_core_module);
+
+    if (lcf->referers == NULL) {
+        lcf->referers = ngx_array_create(cf->pool,
+                                    cf->args->nelts + cscf->server_names.nelts,
+                                    sizeof(ngx_http_rewrite_referer_t));
+        if (lcf->referers == NULL) {
+            return NGX_CONF_ERROR;
+        }
+    }
+
+    value = cf->args->elts;
+    server_names = 0;
+
+    for (i = 1; i < cf->args->nelts; i++) {
+        if (value[i].len == 0) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "invalid referer \"%V\"", &value[i]);
+            return NGX_CONF_ERROR;
+        }
+
+        if (ngx_strcmp(value[i].data, "none") == 0) {
+            lcf->no_referer = 1;
+            continue;
+        }
+
+        if (ngx_strcmp(value[i].data, "server_names") == 0) {
+            server_names = 1;
+            continue;
+        }
+
+        if (!(ref = ngx_array_push(lcf->referers))) {
+            return NGX_CONF_ERROR;
+        }
+
+        if (value[i].data[0] != '*') {
+            ref->name = value[i];
+            ref->wildcard = 0;
+            continue;
+        }
+
+        if (value[i].data[1] != '.') {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "invalid wildcard referer \"%V\"", &value[i]);
+            return NGX_CONF_ERROR;
+        }
+
+        ref->name.len = value[i].len - 1;
+        ref->name.data = value[i].data + 1;
+        ref->wildcard = 1;
+    }
+
+    if (!server_names) {
+        return NGX_CONF_OK;
+    }
+
+    sn = cscf->server_names.elts;
+    for (i = 0; i < cscf->server_names.nelts; i++) {
+        if (!(ref = ngx_array_push(lcf->referers))) {
+            return NGX_CONF_ERROR;
+        }
+
+        ref->name.len = sn[i].name.len + 1;
+        if (!(ref->name.data = ngx_palloc(cf->pool, ref->name.len))) {
+            return NGX_CONF_ERROR;
+        }
+
+        ngx_memcpy(ref->name.data, sn[i].name.data, sn[i].name.len);
+        ref->name.data[sn[i].name.len] = '/';
+        ref->wildcard = sn[i].wildcard;
     }
 
     return NGX_CONF_OK;
 }
 
 
-static char *ngx_http_redirect(ngx_conf_t *cf, void *post, void *data)
+static void *ngx_http_rewrite_start_code(ngx_pool_t *pool,
+                                         ngx_array_t **codes, size_t size)
 {
-    ngx_http_core_loc_conf_t  *clcf;
+    if (*codes == NULL) {
+        if (!(*codes = ngx_array_create(pool, 256, 1))) {
+            return NULL;
+        }
+    }
 
-    clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
-    clcf->handler = ngx_http_redirect_handler;
-
-    return NGX_CONF_OK;
+    return ngx_array_push_n(*codes, size);
 }
 
 
-static ngx_int_t ngx_http_rewrite_init(ngx_cycle_t *cycle)
+static void *ngx_http_rewrite_add_code(ngx_array_t *codes, size_t size,
+                                       u_char **main)
 {
-    ngx_http_handler_pt        *h;
-    ngx_http_core_main_conf_t  *cmcf;
+    u_char  *elts;
+    void    *new;
 
-    cmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_core_module);
+    elts = codes->elts;
 
-    h = ngx_push_array(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers);
-    if (h == NULL) {
-        return NGX_ERROR;
+    if (!(new = ngx_array_push_n(codes, size))) {
+        return NGX_CONF_ERROR;
     }
 
-    *h = ngx_http_rewrite_handler;
+    if (elts != codes->elts) {
+        *main += (u_char *) codes->elts - elts;
+    }
 
-    return NGX_OK;
+    return new;
 }
diff --git a/src/http/modules/ngx_http_ssl_module.c b/src/http/modules/ngx_http_ssl_module.c
index 9cb6e17..883e44f 100644
--- a/src/http/modules/ngx_http_ssl_module.c
+++ b/src/http/modules/ngx_http_ssl_module.c
@@ -73,7 +73,7 @@
     ngx_http_ssl_merge_srv_conf,           /* merge server configuration */
 
     NULL,                                  /* create location configuration */
-    NULL,                                  /* merge location configuration */
+    NULL                                   /* merge location configuration */
 };
 
 
diff --git a/src/http/modules/proxy/ngx_http_proxy_handler.c b/src/http/modules/proxy/ngx_http_proxy_handler.c
index ea3a0ca..a195b45 100644
--- a/src/http/modules/proxy/ngx_http_proxy_handler.c
+++ b/src/http/modules/proxy/ngx_http_proxy_handler.c
@@ -36,6 +36,8 @@
 static char *ngx_http_proxy_parse_upstream(ngx_str_t *url,
                                            ngx_http_proxy_upstream_conf_t *u);
 
+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 =
@@ -119,6 +121,13 @@
       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,
@@ -1063,9 +1072,9 @@
 {
     ngx_http_proxy_loc_conf_t  *conf;
 
-    ngx_test_null(conf,
-                  ngx_pcalloc(cf->pool, sizeof(ngx_http_proxy_loc_conf_t)),
-                  NGX_CONF_ERROR);
+    if (!(conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_proxy_loc_conf_t)))) {
+        return NGX_CONF_ERROR;
+    }
 
     /*
      * set by ngx_pcalloc():
@@ -1078,6 +1087,7 @@
      *    conf->peers = NULL;
      *    conf->cache_path = NULL;
      *    conf->temp_path = NULL;
+     *    conf->x_vars;
      *    conf->busy_lock = NULL;
      */
 
@@ -1305,6 +1315,8 @@
         return NGX_CONF_ERROR;
     }
 
+    lcf->upstream->url = *url;
+
     if (ngx_strncasecmp(url->data + 7, "unix:", 5) == 0) {
 
 #if (NGX_HAVE_UNIX_DOMAIN)
@@ -1367,6 +1379,47 @@
 }
 
 
+static char *ngx_http_proxy_set_x_var(ngx_conf_t *cf, ngx_command_t *cmd,
+                                      void *conf)
+{
+    ngx_http_proxy_loc_conf_t *lcf = conf;
+
+    ngx_uint_t                  i, *index;
+    ngx_str_t                  *value;
+    ngx_http_variable_t        *var;
+    ngx_http_core_main_conf_t  *cmcf;
+
+    if (lcf->x_vars.elts == NULL) {
+        if (ngx_array_init(&lcf->x_vars, cf->pool, 4,
+                           sizeof(ngx_http_variable_t *)) == NGX_ERROR)
+        {
+            return NGX_CONF_ERROR;
+        }
+    }
+
+    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
+
+    value = cf->args->elts;
+
+    var = cmcf->variables.elts;
+    for (i = 0; i < cmcf->variables.nelts; i++) {
+        if (ngx_strcasecmp(var[i].name.data, value[1].data) == 0) {
+
+            if (!(index = ngx_array_push(&lcf->x_vars))) {
+                return NGX_CONF_ERROR;
+            }
+
+            *index = var[i].index;
+            return NGX_CONF_OK;
+        }
+    }
+
+    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                       "unknown variable name \"%V\"", &value[1]);
+    return NGX_CONF_ERROR;
+}
+
+
 static char *ngx_http_proxy_lowat_check(ngx_conf_t *cf, void *post, void *data)
 {
 #if (NGX_FREEBSD)
diff --git a/src/http/modules/proxy/ngx_http_proxy_handler.h b/src/http/modules/proxy/ngx_http_proxy_handler.h
index 4dd97c2..28d7971 100644
--- a/src/http/modules/proxy/ngx_http_proxy_handler.h
+++ b/src/http/modules/proxy/ngx_http_proxy_handler.h
@@ -87,6 +87,8 @@
     ngx_path_t                      *cache_path;
     ngx_path_t                      *temp_path;
 
+    ngx_array_t                      x_vars;
+
     ngx_http_busy_lock_t            *busy_lock;
 
     ngx_http_proxy_upstream_conf_t  *upstream;
diff --git a/src/http/modules/proxy/ngx_http_proxy_upstream.c b/src/http/modules/proxy/ngx_http_proxy_upstream.c
index 4dfd4e6..cf51953 100644
--- a/src/http/modules/proxy/ngx_http_proxy_upstream.c
+++ b/src/http/modules/proxy/ngx_http_proxy_upstream.c
@@ -86,13 +86,15 @@
 static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
 {
     size_t                           len;
-    ngx_int_t                        escape;
-    ngx_uint_t                       i;
+    ngx_uint_t                       i, escape, *index;
     ngx_buf_t                       *b;
     ngx_chain_t                     *chain;
     ngx_list_part_t                 *part;
     ngx_table_elt_t                 *header;
     ngx_http_request_t              *r;
+    ngx_http_variable_t             *var;
+    ngx_http_variable_value_t       *value;
+    ngx_http_core_main_conf_t       *cmcf;
     ngx_http_proxy_upstream_conf_t  *uc;
 
     r = p->request;
@@ -115,18 +117,18 @@
 
     len += uc->uri.len
         + r->uri.len - uc->location->len + escape
-        + 1 + r->args.len                                   /* 1 is for "?" */
+        + sizeof("?") - 1 + r->args.len
         + sizeof(http_version) - 1
         + sizeof(connection_close_header) - 1
-        + 2;                           /* 2 is for "\r\n" at the header end */
+        + sizeof(CRLF) - 1;
 
 
     if (p->lcf->set_x_url) {
         len += sizeof(x_url_header) - 1
-            + 4                                          /* 4 is for "s://" */
+            + sizeof("s://") - 1
             + r->port_text->len
             + r->unparsed_uri.len
-            + 2;                        /* 2 is for "\r\n" at the header end */
+            + sizeof(CRLF) - 1;
 
         if (r->headers_in.host) {
             len += r->headers_in.host_name_len;
@@ -140,17 +142,17 @@
 
     if (p->lcf->preserve_host && r->headers_in.host) {
         len += sizeof(host_header) - 1
-            + r->headers_in.host_name_len
-            + 1                                              /* 1 is for ":" */
-            + uc->port_text.len
-            + 2;                                          /* 2 is for "\r\n" */
-    } else {                                              /* 2 is for "\r\n" */
-        len += sizeof(host_header) - 1 + uc->host_header.len + 2;
+            + r->headers_in.host_name_len + sizeof(":") - 1 + uc->port_text.len
+            + sizeof(CRLF) - 1;
+    } else {
+        len += sizeof(host_header) - 1 + uc->host_header.len
+            + sizeof(CRLF) - 1;
     }
 
 
-    if (p->lcf->set_x_real_ip) {                          /* 2 is for "\r\n" */
-        len += sizeof(x_real_ip_header) - 1 + INET_ADDRSTRLEN - 1 + 2;
+    if (p->lcf->set_x_real_ip) {
+        len += sizeof(x_real_ip_header) - 1 + INET_ADDRSTRLEN - 1
+            + sizeof(CRLF) - 1;
     }
 
 
@@ -158,12 +160,29 @@
         if (r->headers_in.x_forwarded_for) {
             len += sizeof(x_forwarded_for_header) - 1
                 + r->headers_in.x_forwarded_for->value.len
-                + 2                                         /* 2 is ofr ", " */
-                + INET_ADDRSTRLEN - 1
-                + 2;                                      /* 2 is for "\r\n" */
+                + sizeof(", ") - 1 + INET_ADDRSTRLEN - 1 + sizeof(CRLF) - 1;
+
         } else {
-            len += sizeof(x_forwarded_for_header) - 1 + INET_ADDRSTRLEN - 1 + 2;
-                                                          /* 2 is for "\r\n" */
+            len += sizeof(x_forwarded_for_header) - 1 + INET_ADDRSTRLEN - 1
+                + sizeof(CRLF) - 1;
+        }
+    }
+
+
+    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
+
+    var = cmcf->variables.elts;
+    index = p->lcf->x_vars.elts;
+
+    for (i = 0; i < p->lcf->x_vars.nelts; i++) {
+
+        if (!(value = ngx_http_get_variable(r, index[i]))) {
+            continue;
+        }
+
+        if (value->text.len) {
+            len += sizeof("X-") - 1 + var[index[i]].name.len + sizeof(": ") - 1
+                + value->text.len + sizeof(CRLF) - 1;
         }
     }
 
@@ -191,16 +210,24 @@
             continue;
         }
 
-        /* 2 is for ": " and 2 is for "\r\n" */
-        len += header[i].key.len + 2 + header[i].value.len + 2;
+        len += header[i].key.len + sizeof(": ") - 1
+            + header[i].value.len + sizeof(CRLF) - 1;
     }
 
 #if (NGX_DEBUG)
     len++;
 #endif
 
-    ngx_test_null(b, ngx_create_temp_buf(r->pool, len), NULL);
-    ngx_alloc_link_and_set_buf(chain, b, r->pool, NULL);
+    if (!(b = ngx_create_temp_buf(r->pool, len))) {
+        return NULL;
+    }
+
+    if (!(chain = ngx_alloc_chain_link(r->pool))) {
+        return NULL;
+    }
+
+    chain->buf = b;
+    chain->next = NULL;
 
 
     /* the request line */
@@ -227,7 +254,7 @@
     }
 
     if (r->args.len > 0) {
-        *(b->last++) = '?';
+        *b->last++ = '?';
         b->last = ngx_cpymem(b->last, r->args.data, r->args.len);
     }
 
@@ -249,7 +276,7 @@
                              r->headers_in.host_name_len);
 
         if (!uc->default_port) {
-            *(b->last++) = ':';
+            *b->last++ = ':';
             b->last = ngx_cpymem(b->last, uc->port_text.data,
                                  uc->port_text.len);
         }
@@ -258,7 +285,7 @@
         b->last = ngx_cpymem(b->last, uc->host_header.data,
                              uc->host_header.len);
     }
-    *(b->last++) = CR; *(b->last++) = LF;
+    *b->last++ = CR; *b->last++ = LF;
 
 
     /* the "X-URL" header */
@@ -271,12 +298,12 @@
 #if (NGX_OPENSSL)
 
         if (r->connection->ssl) {
-            *(b->last++) = 's';
+            *b->last++ = 's';
         }
 
 #endif
 
-        *(b->last++) = ':'; *(b->last++) = '/'; *(b->last++) = '/';
+        *b->last++ = ':'; *b->last++ = '/'; *b->last++ = '/';
 
         if (r->headers_in.host) {
             b->last = ngx_cpymem(b->last, r->headers_in.host->value.data,
@@ -290,7 +317,7 @@
         b->last = ngx_cpymem(b->last, r->unparsed_uri.data,
                              r->unparsed_uri.len);
 
-        *(b->last++) = CR; *(b->last++) = LF;
+        *b->last++ = CR; *b->last++ = LF;
     }
 
 
@@ -301,7 +328,7 @@
                              sizeof(x_real_ip_header) - 1);
         b->last = ngx_cpymem(b->last, r->connection->addr_text.data,
                              r->connection->addr_text.len);
-        *(b->last++) = CR; *(b->last++) = LF;
+        *b->last++ = CR; *b->last++ = LF;
     }
 
 
@@ -316,7 +343,7 @@
                                  r->headers_in.x_forwarded_for->value.data,
                                  r->headers_in.x_forwarded_for->value.len);
 
-            *(b->last++) = ','; *(b->last++) = ' ';
+            *b->last++ = ','; *b->last++ = ' ';
 
         } else {
             b->last = ngx_cpymem(b->last, x_forwarded_for_header,
@@ -325,7 +352,30 @@
 
         b->last = ngx_cpymem(b->last, r->connection->addr_text.data,
                              r->connection->addr_text.len);
-        *(b->last++) = CR; *(b->last++) = LF;
+        *b->last++ = CR; *b->last++ = LF;
+    }
+
+
+    for (i = 0; i < p->lcf->x_vars.nelts; i++) {
+
+        if (!(value = ngx_http_get_variable(r, index[i]))) {
+            continue;
+        }
+
+        if (value->text.len == 0) {
+            continue;
+        }
+
+        *b->last++ = 'X'; *b->last++ = '-';
+
+        b->last = ngx_cpymem(b->last, var[index[i]].name.data,
+                             var[index[i]].name.len);
+
+        *b->last++ = ':'; *b->last++ = ' ';
+
+        b->last = ngx_cpymem(b->last, value->text.data, value->text.len);
+
+        *b->last++ = CR; *b->last++ = LF;
     }
 
 
@@ -372,12 +422,12 @@
 
         b->last = ngx_cpymem(b->last, header[i].key.data, header[i].key.len);
 
-        *(b->last++) = ':'; *(b->last++) = ' ';
+        *b->last++ = ':'; *b->last++ = ' ';
 
         b->last = ngx_cpymem(b->last, header[i].value.data,
                              header[i].value.len);
 
-        *(b->last++) = CR; *(b->last++) = LF;
+        *b->last++ = CR; *b->last++ = LF;
 
         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                        "http proxy header: \"%V: %V\"",
@@ -385,10 +435,10 @@
     }
 
     /* add "\r\n" at the header end */
-    *(b->last++) = CR; *(b->last++) = LF;
+    *b->last++ = CR; *b->last++ = LF;
 
 #if (NGX_DEBUG)
-    *(b->last) = '\0';
+    *b->last = '\0';
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                    "http proxy header:\n\"%s\"", b->pos);
 #endif
diff --git a/src/http/ngx_http.c b/src/http/ngx_http.c
index 21d2e55..26f1cb4 100644
--- a/src/http/ngx_http.c
+++ b/src/http/ngx_http.c
@@ -26,7 +26,7 @@
                                       ngx_http_module_t *module,
                                       ngx_uint_t ctx_index);
 
-int         ngx_http_max_module;
+ngx_uint_t  ngx_http_max_module;
 
 ngx_uint_t  ngx_http_total_requests;
 uint64_t    ngx_http_total_sent;
@@ -89,19 +89,20 @@
 #endif
 
 #if (NGX_SUPPRESS_WARN)
-    /* MSVC thinks 'in_ports' may be used without having been initialized */
+    /* MSVC thinks "in_ports" may be used without having been initialized */
     ngx_memzero(&in_ports, sizeof(ngx_array_t));
 #endif
 
 
     /* the main http context */
 
-    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;
+    }
 
     *(ngx_http_conf_ctx_t **) conf = ctx;
 
+
     /* count the number of the http modules and set up their indices */
 
     ngx_http_max_module = 0;
@@ -113,24 +114,42 @@
         ngx_modules[m]->ctx_index = ngx_http_max_module++;
     }
 
-    /* the main http main_conf, it's the same in the all http contexts */
 
-    ngx_test_null(ctx->main_conf,
-                  ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
-                  NGX_CONF_ERROR);
+    /* the http main_conf context, it is the same in the all http contexts */
 
-    /* the http null srv_conf, it's used to merge the server{}s' srv_conf's */
-    ngx_test_null(ctx->srv_conf,
-                  ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
-                  NGX_CONF_ERROR);
-
-    /* the http null loc_conf, it's used to merge the server{}s' loc_conf's */
-    ngx_test_null(ctx->loc_conf,
-                  ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
-                  NGX_CONF_ERROR);
+    ctx->main_conf = ngx_pcalloc(cf->pool,
+                                 sizeof(void *) * ngx_http_max_module);
+    if (ctx->main_conf == NULL) {
+        return NGX_CONF_ERROR;
+    }
 
 
-    /* create the main_conf, srv_conf and loc_conf in all http modules */
+    /*
+     * the http null srv_conf context, it is used to merge
+     * the server{}s' srv_conf's
+     */
+
+    ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
+    if (ctx->srv_conf == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+
+    /*
+     * the http null loc_conf context, it is used to merge
+     * the server{}s' loc_conf's
+     */
+
+    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
+    if (ctx->loc_conf == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+
+    /*
+     * create the main_conf's, the null srv_conf's, and the null loc_conf's
+     * of the all http modules
+     */
 
     for (m = 0; ngx_modules[m]; m++) {
         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
@@ -147,21 +166,25 @@
         }
 
         if (module->create_main_conf) {
-            ngx_test_null(ctx->main_conf[mi], module->create_main_conf(cf),
-                          NGX_CONF_ERROR);
+            if (!(ctx->main_conf[mi] = module->create_main_conf(cf))) {
+                return NGX_CONF_ERROR;
+            }
         }
 
         if (module->create_srv_conf) {
-            ngx_test_null(ctx->srv_conf[mi], module->create_srv_conf(cf),
-                          NGX_CONF_ERROR);
+            if (!(ctx->srv_conf[mi] = module->create_srv_conf(cf))) {
+                return NGX_CONF_ERROR;
+            }
         }
 
         if (module->create_loc_conf) {
-            ngx_test_null(ctx->loc_conf[mi], module->create_loc_conf(cf),
-                          NGX_CONF_ERROR);
+            if (!(ctx->loc_conf[mi] = module->create_loc_conf(cf))) {
+                return NGX_CONF_ERROR;
+            }
         }
     }
 
+
     /* parse inside the http{} block */
 
     pcf = *cf;
@@ -236,57 +259,59 @@
                     *cf = pcf;
                     return rv;
                 }
-
-#if 0
-                clcfp = (ngx_http_core_loc_conf_t **) cscfp[s]->locations.elts;
-
-                for (l = 0; l < cscfp[s]->locations.nelts; l++) {
-                    rv = module->merge_loc_conf(cf,
-                                                cscfp[s]->ctx->loc_conf[mi],
-                                                clcfp[l]->loc_conf[mi]);
-                    if (rv != NGX_CONF_OK) {
-                        *cf = pcf;
-                        return rv;
-                    }
-                }
-#endif
             }
         }
     }
 
-    /* we needed "http"'s cf->ctx while merging configuration */
+
+    /* we needed http{}'s cf->ctx while the merging configuration */
     *cf = pcf;
 
+
     /* init lists of the handlers */
 
-    ngx_init_array(cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers,
-                   cf->cycle->pool, 10, sizeof(ngx_http_handler_pt),
-                   NGX_CONF_ERROR);
+    if (ngx_array_init(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers,
+                       cf->pool, 1, sizeof(ngx_http_handler_pt)) == NGX_ERROR)
+    {
+        return NGX_CONF_ERROR;
+    }
+
     cmcf->phases[NGX_HTTP_REWRITE_PHASE].type = NGX_OK;
 
 
-    /* the special find config phase for single handler */
+    /* the special find config phase for a single handler */
 
-    ngx_init_array(cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers,
-                   cf->cycle->pool, 1, sizeof(ngx_http_handler_pt),
-                   NGX_CONF_ERROR);
+    if (ngx_array_init(&cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers,
+                       cf->pool, 1, sizeof(ngx_http_handler_pt)) == NGX_ERROR)
+    {
+        return NGX_CONF_ERROR;
+    }
+
     cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].type = NGX_OK;
 
-    ngx_test_null(h, ngx_push_array(
-                           &cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers),
-                  NGX_CONF_ERROR);
+    h = ngx_push_array(&cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers);
+    if (h == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
     *h = ngx_http_find_location_config;
 
 
-    ngx_init_array(cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers,
-                   cf->cycle->pool, 10, sizeof(ngx_http_handler_pt),
-                   NGX_CONF_ERROR);
+    if (ngx_array_init(&cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers,
+                       cf->pool, 1, sizeof(ngx_http_handler_pt)) == NGX_ERROR)
+    {
+        return NGX_CONF_ERROR;
+    }
+
     cmcf->phases[NGX_HTTP_ACCESS_PHASE].type = NGX_DECLINED;
 
 
-    ngx_init_array(cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers,
-                   cf->cycle->pool, 10, sizeof(ngx_http_handler_pt),
-                   NGX_CONF_ERROR);
+    if (ngx_array_init(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers,
+                       cf->pool, 4, sizeof(ngx_http_handler_pt)) == NGX_ERROR)
+    {
+        return NGX_CONF_ERROR;
+    }
+
     cmcf->phases[NGX_HTTP_CONTENT_PHASE].type = NGX_OK;
 
 
diff --git a/src/http/ngx_http_config.h b/src/http/ngx_http_config.h
index be0052e..85be911 100644
--- a/src/http/ngx_http_config.h
+++ b/src/http/ngx_http_config.h
@@ -38,6 +38,9 @@
 #define NGX_HTTP_MAIN_CONF        0x02000000
 #define NGX_HTTP_SRV_CONF         0x04000000
 #define NGX_HTTP_LOC_CONF         0x08000000
+#define NGX_HTTP_UPS_CONF         0x10000000
+#define NGX_HTTP_SIF_CONF         0x20000000
+#define NGX_HTTP_LIF_CONF         0x80000000
 
 
 #define NGX_HTTP_MAIN_CONF_OFFSET  offsetof(ngx_http_conf_ctx_t, main_conf)
diff --git a/src/http/ngx_http_core_module.c b/src/http/ngx_http_core_module.c
index bf455d8..10fcb87 100644
--- a/src/http/ngx_http_core_module.c
+++ b/src/http/ngx_http_core_module.c
@@ -17,10 +17,10 @@
 #define NGX_HTTP_LOCATION_REGEX           4
 
 
-static void ngx_http_phase_event_handler(ngx_event_t *rev);
-static void ngx_http_run_phases(ngx_http_request_t *r);
-static ngx_int_t ngx_http_find_location(ngx_http_request_t *r,
-                                        ngx_array_t *locations, size_t len);
+static void ngx_http_core_phase_event_handler(ngx_event_t *rev);
+static void ngx_http_core_run_phases(ngx_http_request_t *r);
+static ngx_int_t ngx_http_core_find_location(ngx_http_request_t *r,
+                                            ngx_array_t *locations, size_t len);
 
 static void *ngx_http_core_create_main_conf(ngx_conf_t *cf);
 static char *ngx_http_core_init_main_conf(ngx_conf_t *cf, void *conf);
@@ -31,23 +31,33 @@
 static char *ngx_http_core_merge_loc_conf(ngx_conf_t *cf,
                                           void *parent, void *child);
 
-static char *ngx_server_block(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy);
-static int ngx_cmp_locations(const void *first, const void *second);
-static char *ngx_location_block(ngx_conf_t *cf, ngx_command_t *cmd,
-                                void *dummy);
-static char *ngx_types_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
-static char *ngx_set_type(ngx_conf_t *cf, ngx_command_t *dummy, void *conf);
-static char *ngx_http_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
-static char *ngx_set_server_name(ngx_conf_t *cf, ngx_command_t *cmd,
+static char *ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd,
+                                  void *dummy);
+static char *ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd,
+                                    void *dummy);
+static int ngx_http_core_cmp_locations(const void *first, const void *second);
+
+static char *ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd,
                                  void *conf);
-static char *ngx_set_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
-static char *ngx_set_error_page(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
-static char *ngx_set_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
-static char *ngx_set_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
+static char *ngx_http_core_type(ngx_conf_t *cf, ngx_command_t *dummy,
+                                void *conf);
 
-static char *ngx_http_lowat_check(ngx_conf_t *cf, void *post, void *data);
+static char *ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd,
+                                  void *conf);
+static char *ngx_http_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd,
+                                       void *conf);
+static char *ngx_http_core_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
+static char *ngx_http_core_error_page(ngx_conf_t *cf, ngx_command_t *cmd,
+                                      void *conf);
+static char *ngx_http_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd,
+                                     void *conf);
+static char *ngx_http_core_keepalive(ngx_conf_t *cf, ngx_command_t *cmd,
+                                     void *conf);
 
-static ngx_conf_post_t  ngx_http_lowat_post = { ngx_http_lowat_check } ;
+static char *ngx_http_core_lowat_check(ngx_conf_t *cf, void *post, void *data);
+
+static ngx_conf_post_t  ngx_http_core_lowat_post =
+                                                 { ngx_http_core_lowat_check };
 
 
 static ngx_conf_enum_t  ngx_http_restrict_host_names[] = {
@@ -76,7 +86,7 @@
 
     { ngx_string("server"),
       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
-      ngx_server_block,
+      ngx_http_core_server,
       0,
       0,
       NULL },
@@ -132,7 +142,7 @@
 
     { ngx_string("location"),
       NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
-      ngx_location_block,
+      ngx_http_core_location,
       NGX_HTTP_SRV_CONF_OFFSET,
       0,
       NULL },
@@ -143,14 +153,14 @@
 #else
       NGX_HTTP_SRV_CONF|NGX_CONF_TAKE12,
 #endif
-      ngx_http_listen,
+      ngx_http_core_listen,
       NGX_HTTP_SRV_CONF_OFFSET,
       0,
       NULL },
 
     { ngx_string("server_name"),
       NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
-      ngx_set_server_name,
+      ngx_http_core_server_name,
       NGX_HTTP_SRV_CONF_OFFSET,
       0,
       NULL },
@@ -158,7 +168,7 @@
     { ngx_string("types"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF
                                           |NGX_CONF_BLOCK|NGX_CONF_NOARGS,
-      ngx_types_block,
+      ngx_http_core_types,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
       NULL },
@@ -172,14 +182,14 @@
 
     { ngx_string("root"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_set_root,
+      ngx_http_core_root,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
       NULL },
 
     { ngx_string("alias"),
       NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-      ngx_set_root,
+      ngx_http_core_root,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
       NULL },
@@ -245,7 +255,7 @@
       ngx_conf_set_size_slot,
       NGX_HTTP_LOC_CONF_OFFSET,
       offsetof(ngx_http_core_loc_conf_t, send_lowat),
-      &ngx_http_lowat_post },
+      &ngx_http_core_lowat_post },
 
     { ngx_string("postpone_output"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
@@ -255,7 +265,8 @@
       NULL },
 
     { ngx_string("limit_rate"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
+                        |NGX_CONF_TAKE1,
       ngx_conf_set_size_slot,
       NGX_HTTP_LOC_CONF_OFFSET,
       offsetof(ngx_http_core_loc_conf_t, limit_rate),
@@ -263,7 +274,7 @@
 
     { ngx_string("keepalive_timeout"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
-      ngx_set_keepalive,
+      ngx_http_core_keepalive,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
       NULL },
@@ -298,14 +309,14 @@
 
     { ngx_string("error_page"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_2MORE,
-      ngx_set_error_page,
+      ngx_http_core_error_page,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
       NULL },
 
     { ngx_string("error_log"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
-      ngx_set_error_log,
+      ngx_http_core_error_log,
       NGX_HTTP_LOC_CONF_OFFSET,
       0,
       NULL },
@@ -399,15 +410,18 @@
     /* TEST STUB */ r->lingering_close = 1;
 #endif
 
-    r->connection->write->event_handler = ngx_http_phase_event_handler;
+    r->connection->write->event_handler = ngx_http_core_phase_event_handler;
 
-    ngx_http_run_phases(r);
+    r->uri_changed = 1;
+    r->uri_changes = 11;
+
+    ngx_http_core_run_phases(r);
 
     return;
 }
 
 
-static void ngx_http_phase_event_handler(ngx_event_t *ev)
+static void ngx_http_core_phase_event_handler(ngx_event_t *ev)
 {
     ngx_connection_t    *c;
     ngx_http_request_t  *r;
@@ -417,15 +431,14 @@
 
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0, "phase event handler");
 
-    ngx_http_run_phases(r);
+    ngx_http_core_run_phases(r);
 
     return;
 }
 
 
-static void ngx_http_run_phases(ngx_http_request_t *r)
+static void ngx_http_core_run_phases(ngx_http_request_t *r)
 {
-    char                       *path;
     ngx_int_t                   rc;
     ngx_http_handler_pt        *h;
     ngx_http_core_loc_conf_t   *clcf;
@@ -435,10 +448,38 @@
 
     for (/* void */; r->phase < NGX_HTTP_LAST_PHASE; r->phase++) {
 
+        if (r->phase == NGX_HTTP_FIND_CONFIG_PHASE && !r->uri_changed) {
+            continue;
+        }
+
+        if (r->phase == NGX_HTTP_FIND_CONFIG_PHASE + 1 && r->uri_changed) {
+
+            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                           "uri changes: %d", r->uri_changes);
+
+            /*
+             * gcc before 3.3 compiles the broken code for
+             *     if (r->uri_changes-- == 0)
+             * if the r->uri_changes is defined as
+             *     unsigned  uri_changes:4
+             */
+
+            r->uri_changes--;
+
+            if (r->uri_changes == 0) {
+                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                              "rewrite cycle");
+                ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
+                return;
+            }
+
+            r->uri_changed = 0;
+            r->phase = NGX_HTTP_REWRITE_PHASE;
+        }
+
         if (r->phase == NGX_HTTP_CONTENT_PHASE && r->content_handler) {
             r->connection->write->event_handler = ngx_http_empty_handler;
-            rc = r->content_handler(r);
-            ngx_http_finalize_request(r, rc);
+            ngx_http_finalize_request(r, r->content_handler(r));
             return;
         }
 
@@ -483,21 +524,15 @@
         }
     }
 
+    /* no content handler was found */
 
     if (r->uri.data[r->uri.len - 1] == '/') {
 
         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 
-        if (!(path = ngx_palloc(r->pool, clcf->root.len + r->uri.len))) {
-            ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
-            return;
-        }
-    
-        ngx_cpystrn(ngx_cpymem(path, clcf->root.data, clcf->root.len),
-                    r->uri.data, r->uri.len + 1);
-    
         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                      "directory index of \"%s\" is forbidden", path);
+                      "directory index of \"%V%V\" is forbidden",
+                      &clcf->root, &r->uri);
 
         ngx_http_finalize_request(r, NGX_HTTP_FORBIDDEN);
         return;
@@ -518,7 +553,7 @@
 
     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
 
-    rc = ngx_http_find_location(r, &cscf->locations, 0);
+    rc = ngx_http_core_find_location(r, &cscf->locations, 0);
 
     if (rc == NGX_HTTP_INTERNAL_SERVER_ERROR) {
         return rc;
@@ -583,8 +618,8 @@
 }
 
 
-static ngx_int_t ngx_http_find_location(ngx_http_request_t *r,
-                                        ngx_array_t *locations, size_t len)
+static ngx_int_t ngx_http_core_find_location(ngx_http_request_t *r,
+                                            ngx_array_t *locations, size_t len)
 {
     ngx_int_t                  n, rc;
     ngx_uint_t                 i, found, noregex;
@@ -604,6 +639,10 @@
         }
 #endif
 
+        if (clcfp[i]->noname) {
+            break;
+        }
+
         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                        "find location: %s\"%V\"",
                        clcfp[i]->exact_match ? "= " : "", &clcfp[i]->name);
@@ -632,9 +671,14 @@
         }
 
         if (n == 0) {
-            if (clcfp[i]->exact_match && r->uri.len == clcfp[i]->name.len) {
-                r->loc_conf = clcfp[i]->loc_conf;
-                return NGX_HTTP_LOCATION_EXACT;
+            if (clcfp[i]->exact_match) {
+
+                if (r->uri.len == clcfp[i]->name.len) {
+                    r->loc_conf = clcfp[i]->loc_conf;
+                    return NGX_HTTP_LOCATION_EXACT;
+                }
+
+                continue;
             }
 
             if (len > clcfp[i]->name.len) {
@@ -652,7 +696,7 @@
         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 
         if (clcf->locations.nelts) {
-            rc = ngx_http_find_location(r, &clcf->locations, len);
+            rc = ngx_http_core_find_location(r, &clcf->locations, len);
 
             if (rc != NGX_OK) {
                 return rc;
@@ -674,6 +718,10 @@
             continue;
         }
 
+        if (clcfp[i]->noname) {
+            break;
+        }
+
         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                        "find location: ~ \"%V\"", &clcfp[i]->name);
 
@@ -706,6 +754,7 @@
 
 ngx_int_t ngx_http_set_content_type(ngx_http_request_t *r)
 {
+    u_char                     c, *p, *exten;
     uint32_t                   key;
     ngx_uint_t                 i;
     ngx_http_type_t           *type;
@@ -724,6 +773,37 @@
     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 
     if (r->exten.len) {
+
+        if (!r->low_case_exten) {
+            for (i = 0; i < r->exten.len; i++) {
+                c = r->exten.data[i];
+                if (c >= 'A' && c <= 'Z') {
+                    break;
+                }
+            }
+
+            if (i < r->exten.len) {
+                if (!(p = ngx_palloc(r->pool, r->exten.len))) {
+                    return NGX_HTTP_INTERNAL_SERVER_ERROR;
+                }
+
+                exten = p;
+
+                for (i = 0; i < r->exten.len; i++) {
+                    c = r->exten.data[i];
+                    if (c >= 'A' && c <= 'Z') {
+                        *p++ = (u_char) (c | 0x20);
+                    } else {
+                        *p++ = c;
+                    }
+                }
+
+                r->exten.data = exten;
+            }
+
+            r->low_case_exten = 1;
+        }
+
 #if 0
         key = ngx_crc(r->exten.data, r->exten.key);
 #endif
@@ -826,6 +906,8 @@
         }
     }
 
+    r->low_case_exten = 0;
+
     return NGX_OK;
 }
 
@@ -864,6 +946,7 @@
 
     r->phase = 0;
     r->phase_handler = 0;
+    r->content_handler = NULL;
 
     ngx_http_handler(r);
 
@@ -893,48 +976,60 @@
 #endif
 
 
-#if 0
-
-static ngx_int_t ngx_http_core_init_process(ngx_cycle_t *cycle)
+ngx_http_variable_t *ngx_http_add_variable(ngx_conf_t *cf)
 {
-    ngx_uint_t                   i;
-    ngx_http_core_srv_conf_t   **cscfp;
-    ngx_http_core_main_conf_t   *cmcf;
+    ngx_http_variable_t        *var;
+    ngx_http_core_main_conf_t  *cmcf;
 
-    cmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_core_module);
+    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
 
-#if 0
-    ngx_http_core_init_module:
-
-    ngx_http_handler_pt         *h;
-
-    ngx_test_null(h, ngx_push_array(
-                             &cmcf->phases[NGX_HTTP_TRANSLATE_PHASE].handlers),
-                  NGX_ERROR);
-    *h = ngx_http_delay_handler;
-#endif
-
-    cscfp = cmcf->servers.elts;
-
-    for (i = 0; i < cmcf->servers.nelts; i++) {
-        if (cscfp[i]->recv == NULL) {
-            cscfp[i]->recv = ngx_io.recv;
-            cscfp[i]->send_chain = ngx_io.send_chain;
+    if (cmcf->variables.elts == NULL) {
+        if (ngx_array_init(&cmcf->variables, cf->pool, 5,
+                           sizeof(ngx_http_variable_t)) == NGX_ERROR)
+        {
+            return NULL;
         }
     }
 
-    return NGX_OK;
+    if (!(var = ngx_array_push(&cmcf->variables))) {
+        return NULL;
+    }
+
+    var->index = cmcf->variables.nelts - 1;
+
+    return var;
 }
 
-#endif
+
+ngx_http_variable_value_t *ngx_http_get_variable(ngx_http_request_t *r,
+                                                 ngx_uint_t index)
+{
+    ngx_http_variable_t        *v;
+    ngx_http_core_main_conf_t  *cmcf;
+
+    /* TODO: cached variables */
+
+    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
+
+    if (cmcf->variables.elts == NULL || cmcf->variables.nelts <= index) {
+        ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
+                      "unknown variable index: %d", index);
+        return NULL;
+    }
+
+    v = cmcf->variables.elts;    
+
+    return v[index].handler(r, v[index].data);
+}
 
 
-static char *ngx_server_block(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
+static char *ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd,
+                                  void *dummy)
 {
     int                          m;
     char                        *rv;
     ngx_http_module_t           *module;
-    ngx_conf_t                   pvcf;
+    ngx_conf_t                   save;
     ngx_http_conf_ctx_t         *ctx, *http_ctx;
     ngx_http_core_main_conf_t   *cmcf;
     ngx_http_core_srv_conf_t    *cscf, **cscfp;
@@ -989,67 +1084,32 @@
 
     /* parse inside server{} */
 
-    pvcf = *cf;
+    save = *cf;
     cf->ctx = ctx;
     cf->cmd_type = NGX_HTTP_SRV_CONF;
+
     rv = ngx_conf_parse(cf, NULL);
-    *cf = pvcf;
+
+    *cf = save;
 
     if (rv != NGX_CONF_OK) {
         return rv;
     }
 
     ngx_qsort(cscf->locations.elts, (size_t) cscf->locations.nelts,
-              sizeof(ngx_http_core_loc_conf_t *), ngx_cmp_locations);
+              sizeof(ngx_http_core_loc_conf_t *), ngx_http_core_cmp_locations);
 
     return rv;
 }
 
 
-static int ngx_cmp_locations(const void *one, const void *two)
-{
-    ngx_int_t                  rc;
-    ngx_http_core_loc_conf_t  *first, *second;
-
-    first = *(ngx_http_core_loc_conf_t **) one;
-    second = *(ngx_http_core_loc_conf_t **) two;
-
-#if (NGX_PCRE)
-
-    if (first->regex && !second->regex) {
-        /* shift the regex matches to the end */
-        return 1;
-    }
-
-    if (!first->regex && second->regex) {
-        /* shift the regex matches to the end */
-        return -1;
-    }
-
-    if (first->regex || second->regex) {
-        /* do not sort the regex matches */
-        return 0;
-    }
-
-#endif
-
-    rc = ngx_strcmp(first->name.data, second->name.data);
-
-    if (rc == 0 && second->exact_match) {
-        /* an exact match must be before the same inclusive one */
-        return 1;
-    }
-
-    return (int) rc;
-}
-
-
-static char *ngx_location_block(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
+static char *ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd,
+                                    void *dummy)
 {
     char                      *rv;
     ngx_int_t                  m;
     ngx_str_t                 *value;
-    ngx_conf_t                 pcf;
+    ngx_conf_t                 save;
     ngx_http_module_t         *module;
     ngx_http_conf_ctx_t       *ctx, *pctx;
     ngx_http_core_srv_conf_t  *cscf;
@@ -1150,7 +1210,9 @@
         }
 
     } else {
+#if 0
         clcf->prev_location = pclcf;
+#endif
 
         if (pclcf->exact_match) {
             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
@@ -1176,7 +1238,7 @@
         }
 
         if (pclcf->locations.elts == NULL) {
-            ngx_init_array(pclcf->locations, cf->pool, 5, sizeof(void *),
+            ngx_init_array(pclcf->locations, cf->pool, 4, sizeof(void *),
                            NGX_CONF_ERROR);
         }
 
@@ -1187,38 +1249,103 @@
 
     *clcfp = clcf;
 
-    pcf = *cf;
+    save = *cf;
     cf->ctx = ctx;
     cf->cmd_type = NGX_HTTP_LOC_CONF;
+
     rv = ngx_conf_parse(cf, NULL);
-    *cf = pcf;
+
+    *cf = save;
+
+    if (rv != NGX_CONF_OK) {
+        return rv;
+    }
+
+    ngx_qsort(clcf->locations.elts, (size_t) clcf->locations.nelts,
+              sizeof(ngx_http_core_loc_conf_t *), ngx_http_core_cmp_locations);
 
     return rv;
 }
 
 
-static char *ngx_types_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+static int ngx_http_core_cmp_locations(const void *one, const void *two)
+{
+    ngx_int_t                  rc;
+    ngx_http_core_loc_conf_t  *first, *second;
+
+    first = *(ngx_http_core_loc_conf_t **) one;
+    second = *(ngx_http_core_loc_conf_t **) two;
+
+    if (first->noname && !second->noname) {
+        /* shift no named locations to the end */
+        return 1;
+    }
+
+    if (!first->noname && second->noname) {
+        /* shift no named locations to the end */
+        return -1;
+    }
+
+    if (first->noname || second->noname) {
+        /* do not sort no named locations */
+        return 0;
+    }
+
+#if (NGX_PCRE)
+
+    if (first->regex && !second->regex) {
+        /* shift the regex matches to the end */
+        return 1;
+    }
+
+    if (!first->regex && second->regex) {
+        /* shift the regex matches to the end */
+        return -1;
+    }
+
+    if (first->regex || second->regex) {
+        /* do not sort the regex matches */
+        return 0;
+    }
+
+#endif
+
+    rc = ngx_strcmp(first->name.data, second->name.data);
+
+    if (rc == 0 && second->exact_match) {
+        /* an exact match must be before the same inclusive one */
+        return 1;
+    }
+
+    return (int) rc;
+}
+
+
+static char *ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 {
     char        *rv;
-    ngx_conf_t   pcf;
+    ngx_conf_t   save;
 
-    pcf = *cf;
-    cf->handler = ngx_set_type;
+    save = *cf;
+    cf->handler = ngx_http_core_type;
     cf->handler_conf = conf;
+
     rv = ngx_conf_parse(cf, NULL);
-    *cf = pcf;
+
+    *cf = save;
 
     return rv;
 }
 
 
-static char *ngx_set_type(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
+static char *ngx_http_core_type(ngx_conf_t *cf, ngx_command_t *dummy,
+                                void *conf)
 {
     ngx_http_core_loc_conf_t *lcf = conf;
 
     uint32_t          key;
     ngx_uint_t        i;
-    ngx_str_t        *args;
+    ngx_str_t        *value;
     ngx_http_type_t  *type;
 
     if (lcf->types == NULL) {
@@ -1237,17 +1364,17 @@
         }
     }
 
-    args = (ngx_str_t *) cf->args->elts;
+    value = cf->args->elts;
 
     for (i = 1; i < cf->args->nelts; i++) {
-        ngx_http_types_hash_key(key, args[i]);
+        ngx_http_types_hash_key(key, value[i]);
 
         if (!(type = ngx_array_push(&lcf->types[key]))) {
             return NGX_CONF_ERROR;
         }
 
-        type->exten = args[i];
-        type->type = args[0];
+        type->exten = value[i];
+        type->type = value[0];
     }
 
     return NGX_CONF_OK;
@@ -1256,15 +1383,17 @@
 
 static void *ngx_http_core_create_main_conf(ngx_conf_t *cf)
 {
-    ngx_http_core_main_conf_t *cmcf;
+    ngx_http_core_main_conf_t  *cmcf;
 
-    ngx_test_null(cmcf,
-                  ngx_pcalloc(cf->pool, sizeof(ngx_http_core_main_conf_t)),
-                  NGX_CONF_ERROR);
+    if (!(cmcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_core_main_conf_t)))) {
+        return NGX_CONF_ERROR;
+    }
 
-    ngx_init_array(cmcf->servers, cf->pool,
-                   5, sizeof(ngx_http_core_srv_conf_t *),
-                   NGX_CONF_ERROR);
+    if (ngx_array_init(&cmcf->servers, cf->pool, 5,
+                       sizeof(ngx_http_core_srv_conf_t *)) == NGX_ERROR)
+    {
+        return NGX_CONF_ERROR;
+    }
 
     cmcf->server_names_hash = NGX_CONF_UNSET_UINT;
     cmcf->server_names_hash_threshold = NGX_CONF_UNSET_UINT;
@@ -1396,7 +1525,7 @@
 
 static void *ngx_http_core_create_loc_conf(ngx_conf_t *cf)
 {
-    ngx_http_core_loc_conf_t *lcf;
+    ngx_http_core_loc_conf_t  *lcf;
 
     ngx_test_null(lcf,
                   ngx_pcalloc(cf->pool, sizeof(ngx_http_core_loc_conf_t)),
@@ -1547,7 +1676,8 @@
 }
 
 
-static char *ngx_http_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+static char *ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd,
+                                  void *conf)
 {
     ngx_http_core_srv_conf_t *scf = conf;
 
@@ -1633,7 +1763,8 @@
 }
 
 
-static char *ngx_set_server_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+static char *ngx_http_core_server_name(ngx_conf_t *cf, ngx_command_t *cmd,
+                                       void *conf)
 {
     ngx_http_core_srv_conf_t *scf = conf;
 
@@ -1683,7 +1814,7 @@
 }
 
 
-static char *ngx_set_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+static char *ngx_http_core_root(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 {
     ngx_http_core_loc_conf_t *lcf = conf;
 
@@ -1723,7 +1854,8 @@
 }
 
 
-static char *ngx_set_error_page(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+static char *ngx_http_core_error_page(ngx_conf_t *cf, ngx_command_t *cmd,
+                                      void *conf)
 {
     ngx_http_core_loc_conf_t *lcf = conf;
 
@@ -1793,7 +1925,8 @@
 }
 
 
-static char *ngx_set_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+static char *ngx_http_core_keepalive(ngx_conf_t *cf, ngx_command_t *cmd,
+                                     void *conf)
 {
     ngx_http_core_loc_conf_t *lcf = conf;
 
@@ -1831,7 +1964,8 @@
 }
 
 
-static char *ngx_set_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+static char *ngx_http_core_error_log(ngx_conf_t *cf, ngx_command_t *cmd,
+                                     void *conf)
 {
     ngx_http_core_loc_conf_t *lcf = conf;
 
@@ -1843,7 +1977,7 @@
 }
 
 
-static char *ngx_http_lowat_check(ngx_conf_t *cf, void *post, void *data)
+static char *ngx_http_core_lowat_check(ngx_conf_t *cf, void *post, void *data)
 {
 #if (NGX_FREEBSD)
     ssize_t *np = data;
diff --git a/src/http/ngx_http_core_module.h b/src/http/ngx_http_core_module.h
index eee43bc..1c60991 100644
--- a/src/http/ngx_http_core_module.h
+++ b/src/http/ngx_http_core_module.h
@@ -37,13 +37,34 @@
 
 
 typedef struct {
+    ngx_uint_t                 value;
+    ngx_str_t                  text;
+} ngx_http_variable_value_t;
+
+
+typedef struct ngx_http_variable_s  ngx_http_variable_t;
+
+typedef ngx_http_variable_value_t
+               *(*ngx_http_get_variable_pt) (ngx_http_request_t *r, void *var);
+
+
+struct ngx_http_variable_s {
+    ngx_str_t                  name;
+    ngx_uint_t                 index;
+    ngx_http_get_variable_pt   handler;
+    void                      *data;
+    ngx_uint_t                 uses;
+};
+
+
+typedef struct {
     ngx_array_t                handlers;
     ngx_int_t                  type;                /* NGX_OK, NGX_DECLINED */
 } ngx_http_phase_t;
 
 
 typedef struct {
-    ngx_array_t                servers; /* array of ngx_http_core_srv_conf_t */
+    ngx_array_t                servers;         /* ngx_http_core_srv_conf_t */
 
     ngx_http_phase_t           phases[NGX_HTTP_LAST_PHASE];
     ngx_array_t                index_handlers;
@@ -52,20 +73,22 @@
     ngx_uint_t                 server_names_hash_threshold;
 
     size_t                     max_server_name_len;
+
+    ngx_array_t                variables;        /* ngx_http_variable_t */
 } ngx_http_core_main_conf_t;
 
 
 typedef struct {
     /*
-     * array of ngx_http_core_loc_conf_t, used in the translation handler
-     * and in the merge phase
+     * array of the ngx_http_core_loc_conf_t,
+     * used in the translation handler and in the merge phase
      */
     ngx_array_t                locations;
 
-    /* "listen", array of ngx_http_listen_t */
+    /* array of the ngx_http_listen_t, "listen" directive */
     ngx_array_t                listen;
 
-    /* "server_name", array of ngx_http_server_name_t */
+    /* array of the ngx_http_server_name_t, "server_name" directive */
     ngx_array_t                server_names;
 
     /* server ctx */
@@ -158,6 +181,8 @@
     ngx_regex_t  *regex;
 #endif
 
+    unsigned      noname:1;   /* "if () {}" block */
+
     unsigned      exact_match:1;
     unsigned      noregex:1;
 
@@ -205,19 +230,21 @@
 
     ngx_log_t    *err_log;
 
+#if 0
     ngx_http_core_loc_conf_t  *prev_location;
+#endif
 };
 
 
+
 extern ngx_http_module_t  ngx_http_core_module_ctx;
 extern ngx_module_t  ngx_http_core_module;
 
-extern int ngx_http_max_module;
+extern ngx_uint_t ngx_http_max_module;
 
 
 
 ngx_int_t ngx_http_find_location_config(ngx_http_request_t *r);
-ngx_int_t ngx_http_core_translate_handler(ngx_http_request_t *r);
 
 ngx_int_t ngx_http_set_content_type(ngx_http_request_t *r);
 ngx_int_t ngx_http_set_exten(ngx_http_request_t *r);
@@ -225,6 +252,10 @@
 ngx_int_t ngx_http_internal_redirect(ngx_http_request_t *r,
                                      ngx_str_t *uri, ngx_str_t *args);
 
+ngx_http_variable_t *ngx_http_add_variable(ngx_conf_t *cf);
+ngx_http_variable_value_t *ngx_http_get_variable(ngx_http_request_t *r,
+                                                 ngx_uint_t index);
+
 
 typedef ngx_int_t (*ngx_http_output_header_filter_pt)(ngx_http_request_t *r);
 typedef ngx_int_t (*ngx_http_output_body_filter_pt)
diff --git a/src/http/ngx_http_log_handler.c b/src/http/ngx_http_log_handler.c
index 1420107..d4f906f 100644
--- a/src/http/ngx_http_log_handler.c
+++ b/src/http/ngx_http_log_handler.c
@@ -893,8 +893,8 @@
 
     fmt->name = value[1];
 
-    if (!(fmt->ops = ngx_create_array(cf->pool, 20,
-                                      sizeof(ngx_http_log_op_t)))) {
+    if (!(fmt->ops = ngx_array_create(cf->pool, 20, sizeof(ngx_http_log_op_t))))
+    {
         return NGX_CONF_ERROR;
     }
 
diff --git a/src/http/ngx_http_parse.c b/src/http/ngx_http_parse.c
index b17c200..f5912ac 100644
--- a/src/http/ngx_http_parse.c
+++ b/src/http/ngx_http_parse.c
@@ -229,6 +229,9 @@
             case '/':
                 r->complex_uri = 1;
                 break;
+            case '+':
+                r->plus_in_uri = 1;
+                break;
             case '?':
                 r->args_start = p + 1;
                 state = sw_uri;
@@ -268,6 +271,9 @@
                 r->uri_ext = NULL;
                 state = sw_after_slash_in_uri;
                 break;
+            case '+':
+                r->plus_in_uri = 1;
+                break;
             case '%':
                 r->quoted_uri = 1;
                 state = sw_uri;
@@ -291,6 +297,9 @@
                 r->uri_end = p;
                 r->http_minor = 9;
                 goto done;
+            case '+':
+                r->plus_in_uri = 1;
+                break;
             case ' ':
                 r->uri_end = p;
                 state = sw_http_09;
diff --git a/src/http/ngx_http_request.h b/src/http/ngx_http_request.h
index 14121d1..a4e3d0e 100644
--- a/src/http/ngx_http_request.h
+++ b/src/http/ngx_http_request.h
@@ -298,6 +298,9 @@
     ngx_int_t            phase_handler;
     ngx_http_handler_pt  content_handler;
 
+    ngx_uint_t           nvariables;
+    void               **variables;
+
     ngx_array_t          cleanup;
 
     /* used to learn the Apache compatible response length without a header */
@@ -313,14 +316,19 @@
 
     unsigned             http_state:4;
 
-#if 0
-    /* URI is not started with '/' - "GET http://" */
-    unsigned             unusual_uri:1;
-#endif
     /* URI with "/." and on Win32 with "//" */
     unsigned             complex_uri:1;
+
     /* URI with "%" */
     unsigned             quoted_uri:1;
+
+    /* URI with "+" */
+    unsigned             plus_in_uri:1;
+
+    unsigned             uri_changed:1;
+    unsigned             uri_changes:4;
+
+    unsigned             low_case_exten:1;
     unsigned             header_timeout_set:1;
 
     unsigned             proxy:1;
diff --git a/src/http/ngx_http_upstream.c b/src/http/ngx_http_upstream.c
index dae8269..11e0f31 100644
--- a/src/http/ngx_http_upstream.c
+++ b/src/http/ngx_http_upstream.c
@@ -664,13 +664,14 @@
 static void ngx_http_upstream_send_response(ngx_http_request_t *r,
                                             ngx_http_upstream_t *u)
 {
+    ngx_int_t                  rc;
     ngx_event_pipe_t          *p;
     ngx_http_core_loc_conf_t  *clcf;
 
+    rc = u->send_header(r);
 
-    if (u->send_header(r) == NGX_HTTP_INTERNAL_SERVER_ERROR) {
-        ngx_http_upstream_finalize_request(r, u,
-                                           NGX_HTTP_INTERNAL_SERVER_ERROR);
+    if (rc == NGX_ERROR || rc > NGX_OK) {
+        ngx_http_upstream_finalize_request(r, u, rc);
         return;
     }