aboutsummaryrefslogtreecommitdiff
path: root/src/http/modules
diff options
context:
space:
mode:
Diffstat (limited to 'src/http/modules')
-rw-r--r--src/http/modules/ngx_http_access_handler.c2
-rw-r--r--src/http/modules/ngx_http_fastcgi_handler.c99
-rw-r--r--src/http/modules/ngx_http_geo_module.c252
-rw-r--r--src/http/modules/ngx_http_gzip_filter.c3
-rw-r--r--src/http/modules/ngx_http_rewrite_handler.c1347
-rw-r--r--src/http/modules/ngx_http_ssl_module.c2
-rw-r--r--src/http/modules/proxy/ngx_http_proxy_handler.c59
-rw-r--r--src/http/modules/proxy/ngx_http_proxy_handler.h2
-rw-r--r--src/http/modules/proxy/ngx_http_proxy_upstream.c122
9 files changed, 1565 insertions, 323 deletions
diff --git a/src/http/modules/ngx_http_access_handler.c b/src/http/modules/ngx_http_access_handler.c
index 01796897f..832f9c2ed 100644
--- a/src/http/modules/ngx_http_access_handler.c
+++ b/src/http/modules/ngx_http_access_handler.c
@@ -158,7 +158,7 @@ static char *ngx_http_access_rule(ngx_conf_t *cf, ngx_command_t *cmd,
}
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 9f5016a45..828f7accc 100644
--- a/src/http/modules/ngx_http_fastcgi_handler.c
+++ b/src/http/modules/ngx_http_fastcgi_handler.c
@@ -20,6 +20,8 @@ typedef struct {
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 void ngx_http_fastcgi_finalize_request(ngx_http_request_t *r,
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 @@ static ngx_command_t ngx_http_fastcgi_commands[] = {
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 @@ static ngx_int_t ngx_http_fastcgi_create_request(ngx_http_request_t *r)
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 @@ static ngx_int_t ngx_http_fastcgi_create_request(ngx_http_request_t *r)
}
+ 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 @@ static ngx_int_t ngx_http_fastcgi_create_request(ngx_http_request_t *r)
}
+ 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 @@ static char *ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd,
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_pass(ngx_conf_t *cf, ngx_command_t *cmd,
}
+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 000000000..cd774894c
--- /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 cda9ca31e..ccf5dc4be 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_conf_bitmask_t ngx_http_gzip_proxied_mask[] = {
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 636331bc4..b1f591c97 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;
+ ngx_flag_t no_referer;
+} ngx_http_rewrite_loc_conf_t;
typedef struct {
- ngx_array_t rules;
- ngx_flag_t log;
-} ngx_http_rewrite_srv_conf_t;
+ 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_str_t redirect;
-} ngx_http_rewrite_loc_conf_t;
+ ngx_http_rewrite_code_pt code;
+ uintptr_t uri:1;
-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);
-static ngx_int_t ngx_http_rewrite_init(ngx_cycle_t *cycle);
+ /* 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;
-static ngx_conf_post_handler_pt ngx_http_redirect_p = ngx_http_redirect;
+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 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,217 +185,468 @@ ngx_http_module_t ngx_http_rewrite_module_ctx = {
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);
+ if (cf->codes == NULL) {
+ return NGX_DECLINED;
+ }
- rule = scf->rules.elts;
- for (i = 0; i < scf->rules.nelts; i++) {
+ if (!(e = ngx_palloc(r->pool, sizeof(ngx_http_rewrite_engine_t)))) {
+ return NGX_HTTP_INTERNAL_SERVER_ERROR;
+ }
- if (rule[i].ncaptures) {
- captures = ngx_palloc(r->pool, rule[i].ncaptures * sizeof(int));
- if (captures == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
+ e->sp = ngx_palloc(r->pool, cf->stack_size * sizeof(ngx_int_t));
+ if (e->sp == NULL) {
+ return NGX_HTTP_INTERNAL_SERVER_ERROR;
+ }
- } else {
- captures = NULL;
+ 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;
}
- rc = ngx_regex_exec(rule[i].regex, &r->uri,
- captures, rule[i].ncaptures);
+ } else {
+ e->captures = NULL;
+ }
- 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);
- }
+ 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);
+ }
- continue;
- }
+ return e->status;
+}
- 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) {
+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\" matches \"%V\"",
- &rule[i].re_name, &r->uri);
+ "\"%V\" does not match \"%V\"", &code->name, e->line);
}
- if (rule[i].status) {
- return rule[i].status;
- }
+ 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);
+ }
- uri.len = rule[i].size;
+ if (code->status) {
+ e->status = code->status;
- for (n = 1; n < (ngx_uint_t) rc; n++) {
- uri.len += captures[2 * n + 1] - captures[2 * n];
+ if (!code->redirect) {
+ e->ip = ngx_http_rewrite_exit;
+ return;
}
+ }
- if (!(uri.data = ngx_palloc(r->pool, uri.len))) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
+ 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);
}
+ }
- args.data = NULL;
- p = uri.data;
+ for (n = 1; n < (ngx_uint_t) rc; n++) {
+ e->buf.len += e->captures[2 * n + 1] - e->captures[2 * n];
+ }
- 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;
- }
+ if (code->args && r->args.len) {
+ e->buf.len += r->args.len + 1;
+ }
- } else if (op[n].op == NGX_HTTP_REWRITE_COPY_LONG) {
- p = ngx_cpymem(p, (void *) op[n].data, op[n].len);
+ 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;
+ }
- } else if (op[n].op == NGX_HTTP_REWRITE_START_ARGS) {
- args.data = p;
+ e->quote = code->redirect;
- } 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]);
- }
+ 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);
}
- if (args.data) {
- uri.len = args.data - uri.data;
- args.len = p - args.data;
+ r->args.len = e->pos - e->args;
+ r->args.data = e->args;
- r->args = args;
+ e->args = NULL;
- } else {
- uri.len = p - uri.data;
- args.len = 0;
+ } else {
+ if (code->args && r->args.len) {
+ *e->pos++ = '&';
+ e->pos = ngx_cpymem(e->pos, r->args.data, r->args.len);
}
- r->uri = uri;
+ e->buf.len = e->pos - e->buf.data;
+ }
- if (scf->log) {
+ if (!code->redirect) {
+ if (e->conf->log) {
ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
- "rewritten uri: \"%V\", args: \"%V\"", &uri, &args);
+ "rewritten data: \"%V\", args: \"%V\"",
+ &e->buf, &r->args);
}
- if (ngx_http_set_exten(r) != NGX_OK) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
+ if (code->uri) {
+ r->uri = e->buf;
- if (rule[i].last) {
- return NGX_DECLINED;
+ 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;
}
- return NGX_DECLINED;
+ 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 = e->buf;
+
+ e->ip += sizeof(ngx_http_rewrite_regex_end_code_t);
}
-static ngx_int_t ngx_http_redirect_handler(ngx_http_request_t *r)
+static void ngx_http_rewrite_copy_capture_code(ngx_http_rewrite_engine_t *e)
{
- u_char *p;
- ngx_http_rewrite_loc_conf_t *rlcf;
+ 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]);
+ }
- ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
- "http redirect handler");
+ ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+ "http rewrite capture: \"%V\"", &e->buf);
+}
- 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) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
+static void ngx_http_rewrite_copy_code(ngx_http_rewrite_engine_t *e)
+{
+ ngx_http_rewrite_copy_code_t *code;
- if (rlcf->redirect.data[0] != '/') {
- r->headers_out.location->key.len = sizeof("Location") - 1;
- r->headers_out.location->key.data = (u_char *) "Location";
+ 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;
}
- 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);
+ ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+ "http rewrite if false");
- if (r->headers_out.location->value.data == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
+ e->ip += code->next;
+}
+
+
+static void ngx_http_rewrite_var_code(ngx_http_rewrite_engine_t *e)
+{
+ ngx_http_variable_value_t *value;
+ ngx_http_rewrite_var_code_t *code;
+
+ ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+ "http rewrite var");
+
+ 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;
}
- 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);
+ ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
+ "http rewrite var: %p", value->value);
- return NGX_HTTP_MOVED_TEMPORARILY;
+ *e->sp = value->value;
}
-static void *ngx_http_rewrite_create_srv_conf(ngx_conf_t *cf)
+static void ngx_http_rewrite_invalid_referer_code(ngx_http_rewrite_engine_t *e)
{
- ngx_http_rewrite_srv_conf_t *conf;
+ 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;
- if (!(conf = ngx_palloc(cf->pool, sizeof(ngx_http_rewrite_srv_conf_t)))) {
- return NGX_CONF_ERROR;
+ 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;
+ }
}
- ngx_init_array(conf->rules, cf->pool, 5, sizeof(ngx_http_rewrite_rule_t),
- NGX_CONF_ERROR);
+ len = r->headers_in.referer->value.len;
+ ref = r->headers_in.referer->value.data;
- conf->log = NGX_CONF_UNSET;
+ if (len < sizeof("http://i.ru") - 1
+ || (ngx_strncasecmp(ref, "http://", 7) != 0))
+ {
+ *e->sp = (uintptr_t) 1;
+ return;
+ }
- return conf;
+ 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 char *ngx_http_rewrite_merge_srv_conf(ngx_conf_t *cf,
- void *parent, void *child)
+static void ngx_http_rewrite_nop_code(ngx_http_rewrite_engine_t *e)
{
- ngx_http_rewrite_srv_conf_t *prev = parent;
- ngx_http_rewrite_srv_conf_t *conf = child;
+ e->ip += sizeof(uintptr_t);
+}
- ngx_conf_merge_value(conf->log, prev->log, 0);
- return NGX_CONF_OK;
-}
+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)
@@ -315,198 +657,643 @@ static void *ngx_http_rewrite_create_loc_conf(ngx_conf_t *cf)
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))) {
- return NGX_CONF_ERROR;
+ 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);
}
- ngx_init_array(rule->ops, cf->pool, 5, sizeof(ngx_http_rewrite_op_t),
- NGX_CONF_ERROR);
+ if (conf->codes == NULL) {
+ return NGX_CONF_OK;
+ }
- rule->ncaptures = 0;
- rule->size = 0;
- rule->status = 0;
- rule->last = 0;
+ if (conf->codes == prev->codes) {
+ return NGX_CONF_OK;
+ }
- value = cf->args->elts;
+ code = conf->codes->elts;
+ last = (uintptr_t *) ((u_char *) code + conf->codes->nelts);
- /* STUB */ {
- err.len = NGX_MAX_CONF_ERRSTR;
- err.data = errstr;
+ while (code < last) {
+ if (*code == (uintptr_t) NULL) {
+ return NGX_CONF_OK;
+ }
- 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;
+ 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;
+ }
+
+ *code = (uintptr_t) NULL;
+
+ 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;
- rule->re_name = value[1];
- rule->s_name = value[2];
+ 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;
+ }
- if (ngx_strcasecmp(value[2].data, "forbidden:") == 0) {
+ value = cf->args->elts;
- if (cf->args->nelts == 3) {
- rule->status = NGX_HTTP_FORBIDDEN;
- rule->last = 1;
- return NGX_CONF_OK;
- }
+ err.len = NGX_MAX_CONF_ERRSTR;
+ err.data = errstr;
+
+ /* TODO: NGX_REGEX_CASELESS */
+
+ regex->regex = ngx_regex_compile(&value[1], 0, cf->pool, &err);
+
+ 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;
+
+ while (i < value[2].len) {
+
+ data = &value[2].data[i];
- i = 0;
+ if (value[2].data[i] == '$' && i < value[2].len
+ && value[2].data[i + 1] >= '1' && value[2].data[i + 1] <= '9')
+ {
- while (i < value[2].len) {
+ /* the "$1" - "$9" captures */
- if (!(op = ngx_push_array(&rule->ops))) {
+ 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];
+ 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';
+ 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;
+ }
+
+ copy_capture->n *= 2;
+
+ i++;
- if (rule->ncaptures < op->data) {
- rule->ncaptures = op->data;
+ continue;
+ }
+
+ if (value[2].data[i] == '?') {
+
+ /* the arguments */
+
+ if (i == value[2].len - 1) {
+ /* the last "?" drops the original arguments */
+ regex->args = 0;
+ break;
+ }
+
+ 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;
}
+ }
+
+ i++;
+
+ /* the substituion strings */
+
+ while (i < value[2].len && value[2].data[i] != '$') {
if (value[2].data[i] == '?') {
- op->op = NGX_HTTP_REWRITE_START_ARGS;
- op->len = 0;
- op->data = 0;
- 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;
+ }
- continue;
+ if (!regex->redirect) {
+ break;
+ }
}
i++;
+ }
- while (i < value[2].len
- && value[2].data[i] != '$'
- && value[2].data[i] != '?')
- {
- i++;
- }
+ len = &value[2].data[i] - data;
- len = &value[2].data[i] - data;
- rule->size += len;
+ if (len == 0) {
+ continue;
+ }
- if (len) {
+ regex->size += len;
- op->len = len;
+ size = (len + sizeof(uintptr_t) - 1) & ~(sizeof(uintptr_t) - 1);
- if (len <= sizeof(uintptr_t)) {
- op->op = NGX_HTTP_REWRITE_COPY_SHORT;
- op->data = 0;
+ 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;
+ }
- while (len--) {
- op->data <<= 8;
- op->data |= data[len];
- }
+ copy->code = ngx_http_rewrite_copy_code;
+ copy->len = len;
- } else {
- op->op = NGX_HTTP_REWRITE_COPY_LONG;
+ ngx_memcpy((u_char *) copy + sizeof(ngx_http_rewrite_copy_code_t),
+ data, len);
+ }
- if (!(p = ngx_palloc(cf->pool, len))) {
- return NGX_CONF_ERROR;
- }
+ n = ngx_regex_capture_count(regex->regex);
- ngx_memcpy(p, data, len);
- op->data = (uintptr_t) p;
- }
+ 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;
+ }
+
+ *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;
+ }
+
+ module = ngx_modules[i]->ctx;
+
+ if (module->create_loc_conf) {
+
+ if (!(mconf = module->create_loc_conf(cf))) {
+ return NGX_CONF_ERROR;
}
+
+ ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
}
+ }
- n = ngx_regex_capture_count(rule->regex);
+ pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];
- 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]);
+ 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 (rule->ncaptures < n) {
- rule->ncaptures = n;
- }
+ if (!(clcfp = ngx_push_array(&pclcf->locations))) {
+ return NGX_CONF_ERROR;
+ }
+
+ *clcfp = clcf;
- if (rule->ncaptures) {
- rule->ncaptures = (rule->ncaptures + 1) * 3;
+
+ /* 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;
}
- if (cf->args->nelts > 3) {
- if (ngx_strcmp(value[3].data, "last") == 0) {
- rule->last = 1;
+ *code = ngx_http_rewrite_invalid_referer_code;
- } else {
- ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
- "invalid parameter \"%V\"", &value[3]);
- return NGX_CONF_ERROR;
+ } 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_redirect(ngx_conf_t *cf, void *post, void *data)
+static char *ngx_http_rewrite_valid_referers(ngx_conf_t *cf, ngx_command_t *cmd,
+ void *conf)
{
- ngx_http_core_loc_conf_t *clcf;
+ 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;
+ }
- clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
- clcf->handler = ngx_http_redirect_handler;
+ 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 ngx_int_t ngx_http_rewrite_init(ngx_cycle_t *cycle)
+static void *ngx_http_rewrite_start_code(ngx_pool_t *pool,
+ ngx_array_t **codes, size_t size)
{
- ngx_http_handler_pt *h;
- ngx_http_core_main_conf_t *cmcf;
+ if (*codes == NULL) {
+ if (!(*codes = ngx_array_create(pool, 256, 1))) {
+ return NULL;
+ }
+ }
- cmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_core_module);
+ return ngx_array_push_n(*codes, size);
+}
- h = ngx_push_array(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers);
- if (h == NULL) {
- return NGX_ERROR;
+
+static void *ngx_http_rewrite_add_code(ngx_array_t *codes, size_t size,
+ u_char **main)
+{
+ u_char *elts;
+ void *new;
+
+ elts = codes->elts;
+
+ 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 9cb6e171d..883e44fbc 100644
--- a/src/http/modules/ngx_http_ssl_module.c
+++ b/src/http/modules/ngx_http_ssl_module.c
@@ -73,7 +73,7 @@ static ngx_http_module_t ngx_http_ssl_module_ctx = {
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 ea3a0ca43..a195b45e4 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_set_pass(ngx_conf_t *cf, ngx_command_t *cmd,
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 @@ static ngx_command_t ngx_http_proxy_commands[] = {
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 @@ static void *ngx_http_proxy_create_loc_conf(ngx_conf_t *cf)
{
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 @@ static void *ngx_http_proxy_create_loc_conf(ngx_conf_t *cf)
* conf->peers = NULL;
* conf->cache_path = NULL;
* conf->temp_path = NULL;
+ * conf->x_vars;
* conf->busy_lock = NULL;
*/
@@ -1305,6 +1315,8 @@ static char *ngx_http_proxy_set_pass(ngx_conf_t *cf, ngx_command_t *cmd,
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_pass(ngx_conf_t *cf, ngx_command_t *cmd,
}
+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 4dd97c22c..28d7971df 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 @@ typedef struct {
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 4dfd4e6d1..cf5195368 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 @@ int ngx_http_proxy_request_upstream(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
}
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
#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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
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 @@ static ngx_chain_t *ngx_http_proxy_create_request(ngx_http_proxy_ctx_t *p)
}
/* 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
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-15 18:04:05 +0000