|
499
|
1
|
|
|
2 /*
|
|
|
3 * Copyright (C) Igor Sysoev
|
|
|
4 */
|
|
|
5
|
|
|
6
|
|
|
7 #include <ngx_config.h>
|
|
|
8 #include <ngx_core.h>
|
|
|
9 #include <ngx_event.h>
|
|
|
10 #include <ngx_http.h>
|
|
|
11
|
|
|
12
|
|
509
|
13 static ngx_http_variable_value_t *
|
|
|
14 ngx_http_variable_request(ngx_http_request_t *r, uintptr_t data);
|
|
499
|
15 static ngx_http_variable_value_t *
|
|
|
16 ngx_http_variable_header(ngx_http_request_t *r, uintptr_t data);
|
|
|
17 static ngx_http_variable_value_t *
|
|
515
|
18 ngx_http_variable_headers(ngx_http_request_t *r, uintptr_t data);
|
|
|
19 static ngx_http_variable_value_t *
|
|
501
|
20 ngx_http_variable_unknown_header(ngx_http_request_t *r, uintptr_t data);
|
|
499
|
21 static ngx_http_variable_value_t *
|
|
509
|
22 ngx_http_variable_host(ngx_http_request_t *r, uintptr_t data);
|
|
|
23 static ngx_http_variable_value_t *
|
|
499
|
24 ngx_http_variable_remote_addr(ngx_http_request_t *r, uintptr_t data);
|
|
|
25 static ngx_http_variable_value_t *
|
|
509
|
26 ngx_http_variable_remote_port(ngx_http_request_t *r, uintptr_t data);
|
|
|
27 static ngx_http_variable_value_t *
|
|
|
28 ngx_http_variable_server_addr(ngx_http_request_t *r, uintptr_t data);
|
|
499
|
29 static ngx_http_variable_value_t *
|
|
509
|
30 ngx_http_variable_server_port(ngx_http_request_t *r, uintptr_t data);
|
|
|
31 static ngx_http_variable_value_t *
|
|
|
32 ngx_http_variable_document_root(ngx_http_request_t *r, uintptr_t data);
|
|
|
33 static ngx_http_variable_value_t *
|
|
|
34 ngx_http_variable_request_filename(ngx_http_request_t *r, uintptr_t data);
|
|
499
|
35
|
|
|
36
|
|
509
|
37 /*
|
|
|
38 * TODO:
|
|
|
39 * Apache CGI: AUTH_TYPE, PATH_INFO (null), PATH_TRANSLATED
|
|
|
40 * REMOTE_HOST (null), REMOTE_IDENT (null),
|
|
|
41 * SERVER_SOFTWARE
|
|
|
42 *
|
|
|
43 * Apache SSI: DATE_GMT, DOCUMENT_NAME, LAST_MODIFIED,
|
|
|
44 * USER_NAME (file owner)
|
|
|
45 */
|
|
499
|
46
|
|
509
|
47 static ngx_http_variable_t ngx_http_core_variables[] = {
|
|
|
48
|
|
|
49 { ngx_string("http_host"), ngx_http_variable_header,
|
|
|
50 offsetof(ngx_http_request_t, headers_in.host), 0 },
|
|
499
|
51
|
|
509
|
52 { ngx_string("http_user_agent"), ngx_http_variable_header,
|
|
|
53 offsetof(ngx_http_request_t, headers_in.user_agent), 0 },
|
|
|
54
|
|
|
55 { ngx_string("http_referer"), ngx_http_variable_header,
|
|
|
56 offsetof(ngx_http_request_t, headers_in.referer), 0 },
|
|
499
|
57
|
|
|
58 #if (NGX_HTTP_GZIP)
|
|
509
|
59 { ngx_string("http_via"), ngx_http_variable_header,
|
|
|
60 offsetof(ngx_http_request_t, headers_in.via), 0 },
|
|
499
|
61 #endif
|
|
|
62
|
|
|
63 #if (NGX_HTTP_PROXY)
|
|
509
|
64 { ngx_string("http_x_forwarded_for"), ngx_http_variable_header,
|
|
|
65 offsetof(ngx_http_request_t, headers_in.x_forwarded_for), 0 },
|
|
499
|
66 #endif
|
|
|
67
|
|
515
|
68 { ngx_string("http_cookie"), ngx_http_variable_headers,
|
|
|
69 offsetof(ngx_http_request_t, headers_in.cookies), 0 },
|
|
|
70
|
|
509
|
71 { ngx_string("content_length"), ngx_http_variable_header,
|
|
|
72 offsetof(ngx_http_request_t, headers_in.content_length), 0 },
|
|
|
73
|
|
|
74 { ngx_string("content_type"), ngx_http_variable_header,
|
|
|
75 offsetof(ngx_http_request_t, headers_in.content_type), 0 },
|
|
|
76
|
|
|
77 { ngx_string("host"), ngx_http_variable_host, 0, 0 },
|
|
|
78
|
|
|
79 { ngx_string("remote_addr"), ngx_http_variable_remote_addr, 0, 0 },
|
|
499
|
80
|
|
509
|
81 { ngx_string("remote_port"), ngx_http_variable_remote_port, 0, 0 },
|
|
|
82
|
|
|
83 { ngx_string("server_addr"), ngx_http_variable_server_addr, 0, 0 },
|
|
|
84
|
|
|
85 { ngx_string("server_port"), ngx_http_variable_server_port, 0, 0 },
|
|
|
86
|
|
|
87 { ngx_string("server_protocol"), ngx_http_variable_request,
|
|
|
88 offsetof(ngx_http_request_t, http_protocol), 0 },
|
|
|
89
|
|
|
90 { ngx_string("request_uri"), ngx_http_variable_request,
|
|
|
91 offsetof(ngx_http_request_t, unparsed_uri), 0 },
|
|
499
|
92
|
|
509
|
93 { ngx_string("document_uri"), ngx_http_variable_request,
|
|
|
94 offsetof(ngx_http_request_t, uri), 0 },
|
|
|
95
|
|
|
96 { ngx_string("document_root"), ngx_http_variable_document_root, 0, 0 },
|
|
|
97
|
|
|
98 { ngx_string("query_string"), ngx_http_variable_request,
|
|
|
99 offsetof(ngx_http_request_t, args),
|
|
|
100 NGX_HTTP_VAR_NOCACHABLE },
|
|
499
|
101
|
|
509
|
102 { ngx_string("request_filename"), ngx_http_variable_request_filename, 0,
|
|
|
103 NGX_HTTP_VAR_NOCACHABLE },
|
|
|
104
|
|
|
105 { ngx_string("server_name"), ngx_http_variable_request,
|
|
|
106 offsetof(ngx_http_request_t, server_name), 0 },
|
|
|
107
|
|
|
108 { ngx_string("request_method"), ngx_http_variable_request,
|
|
|
109 offsetof(ngx_http_request_t, method_name), 0 },
|
|
|
110
|
|
|
111 { ngx_string("remote_user"), ngx_http_variable_request,
|
|
|
112 offsetof(ngx_http_request_t, headers_in.user), 0 },
|
|
|
113
|
|
|
114 { ngx_null_string, NULL, 0, 0 }
|
|
499
|
115 };
|
|
|
116
|
|
|
117
|
|
|
118 ngx_http_variable_t *
|
|
509
|
119 ngx_http_add_variable(ngx_conf_t *cf, ngx_str_t *name, ngx_uint_t flags)
|
|
|
120 {
|
|
|
121 ngx_uint_t i;
|
|
|
122 ngx_http_variable_t *v;
|
|
|
123 ngx_http_core_main_conf_t *cmcf;
|
|
|
124
|
|
|
125 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
|
|
|
126
|
|
|
127 v = cmcf->all_variables.elts;
|
|
|
128 for (i = 0; i < cmcf->all_variables.nelts; i++) {
|
|
|
129 if (name->len != v[i].name.len
|
|
|
130 || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
|
|
|
131 {
|
|
|
132 continue;
|
|
|
133 }
|
|
|
134
|
|
|
135 if (!(v[i].flags & NGX_HTTP_VAR_CHANGABLE)) {
|
|
|
136 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
137 "the duplicate \"%V\" variable", name);
|
|
|
138 return NULL;
|
|
|
139 }
|
|
|
140
|
|
|
141 return &v[i];
|
|
|
142 }
|
|
|
143
|
|
|
144 v = ngx_array_push(&cmcf->all_variables);
|
|
|
145 if (v == NULL) {
|
|
|
146 return NULL;
|
|
|
147 }
|
|
|
148
|
|
|
149 v->name.len = name->len;
|
|
|
150 v->name.data = ngx_palloc(cf->pool, name->len);
|
|
|
151 if (v->name.data == NULL) {
|
|
|
152 return NULL;
|
|
|
153 }
|
|
|
154
|
|
|
155 for (i = 0; i < name->len; i++) {
|
|
|
156 v->name.data[i] = ngx_tolower(name->data[i]);
|
|
|
157 }
|
|
|
158
|
|
|
159 v->handler = NULL;
|
|
|
160 v->data = 0;
|
|
|
161 v->flags = flags;
|
|
|
162
|
|
|
163 return v;
|
|
|
164 }
|
|
|
165
|
|
|
166
|
|
|
167 ngx_int_t
|
|
|
168 ngx_http_get_variable_index(ngx_conf_t *cf, ngx_str_t *name)
|
|
499
|
169 {
|
|
501
|
170 ngx_uint_t i;
|
|
|
171 ngx_http_variable_t *v;
|
|
499
|
172 ngx_http_core_main_conf_t *cmcf;
|
|
|
173
|
|
|
174 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
|
|
|
175
|
|
501
|
176 v = cmcf->variables.elts;
|
|
|
177
|
|
|
178 if (v == NULL) {
|
|
499
|
179 if (ngx_array_init(&cmcf->variables, cf->pool, 4,
|
|
|
180 sizeof(ngx_http_variable_t)) == NGX_ERROR)
|
|
|
181 {
|
|
509
|
182 return NGX_ERROR;
|
|
499
|
183 }
|
|
501
|
184
|
|
|
185 } else {
|
|
|
186 for (i = 0; i < cmcf->variables.nelts; i++) {
|
|
|
187 if (name->len != v[i].name.len
|
|
|
188 || ngx_strncasecmp(name->data, v[i].name.data, name->len) != 0)
|
|
|
189 {
|
|
|
190 continue;
|
|
|
191 }
|
|
|
192
|
|
509
|
193 return i;
|
|
501
|
194 }
|
|
499
|
195 }
|
|
|
196
|
|
501
|
197 v = ngx_array_push(&cmcf->variables);
|
|
|
198 if (v == NULL) {
|
|
509
|
199 return NGX_ERROR;
|
|
499
|
200 }
|
|
|
201
|
|
501
|
202 v->name.len = name->len;
|
|
|
203 v->name.data = ngx_palloc(cf->pool, name->len);
|
|
|
204 if (v->name.data == NULL) {
|
|
509
|
205 return NGX_ERROR;
|
|
501
|
206 }
|
|
499
|
207
|
|
501
|
208 for (i = 0; i < name->len; i++) {
|
|
509
|
209 v->name.data[i] = ngx_tolower(name->data[i]);
|
|
501
|
210 }
|
|
|
211
|
|
|
212 v->handler = NULL;
|
|
|
213 v->data = 0;
|
|
509
|
214 v->flags = 0;
|
|
501
|
215
|
|
509
|
216 return cmcf->variables.nelts - 1;
|
|
499
|
217 }
|
|
|
218
|
|
|
219
|
|
|
220 ngx_http_variable_value_t *
|
|
|
221 ngx_http_get_indexed_variable(ngx_http_request_t *r, ngx_uint_t index)
|
|
|
222 {
|
|
501
|
223 ngx_http_variable_t *v;
|
|
|
224 ngx_http_variable_value_t *vv;
|
|
499
|
225 ngx_http_core_main_conf_t *cmcf;
|
|
|
226
|
|
|
227 cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
|
|
|
228
|
|
|
229 if (cmcf->variables.elts == NULL || cmcf->variables.nelts <= index) {
|
|
|
230 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
|
|
|
231 "unknown variable index: %d", index);
|
|
|
232 return NULL;
|
|
|
233 }
|
|
|
234
|
|
501
|
235 if (r->variables && r->variables[index]) {
|
|
|
236 return r->variables[index];
|
|
|
237 }
|
|
499
|
238
|
|
501
|
239 v = cmcf->variables.elts;
|
|
499
|
240
|
|
501
|
241 vv = v[index].handler(r, v[index].data);
|
|
499
|
242
|
|
501
|
243 if (r->variables == NULL) {
|
|
|
244 r->variables = ngx_pcalloc(r->pool, cmcf->variables.nelts
|
|
|
245 * sizeof(ngx_http_variable_value_t *));
|
|
|
246 if (r->variables == NULL) {
|
|
|
247 return NULL;
|
|
499
|
248 }
|
|
|
249 }
|
|
|
250
|
|
509
|
251 if (!(v[index].flags & NGX_HTTP_VAR_NOCACHABLE)) {
|
|
|
252 r->variables[index] = vv;
|
|
|
253 }
|
|
501
|
254
|
|
|
255 return vv;
|
|
499
|
256 }
|
|
|
257
|
|
|
258
|
|
|
259 ngx_http_variable_value_t *
|
|
|
260 ngx_http_get_variable(ngx_http_request_t *r, ngx_str_t *name)
|
|
|
261 {
|
|
|
262 ngx_uint_t i, key;
|
|
501
|
263 ngx_http_variable_t *v;
|
|
499
|
264 ngx_http_core_main_conf_t *cmcf;
|
|
|
265
|
|
|
266 cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
|
|
|
267
|
|
509
|
268 key = 0;
|
|
|
269 for (i = 0; i < name->len; i++) {
|
|
|
270 key += name->data[i];
|
|
499
|
271 }
|
|
|
272
|
|
509
|
273 key %= cmcf->variables_hash.hash_size;
|
|
|
274 v = (ngx_http_variable_t *) cmcf->variables_hash.buckets;
|
|
499
|
275
|
|
509
|
276 if (v[key].name.len == name->len
|
|
|
277 && ngx_strncmp(v[key].name.data, name->data, name->len) == 0)
|
|
|
278 {
|
|
519
|
279 if (v[key].flags & NGX_HTTP_VAR_INDEXED) {
|
|
|
280 return ngx_http_get_indexed_variable(r, v[key].data);
|
|
|
281
|
|
|
282 } else {
|
|
|
283 return v[key].handler(r, v[key].data);
|
|
|
284 }
|
|
499
|
285 }
|
|
|
286
|
|
509
|
287 if (ngx_strncmp(name->data, "http_", 5) == 0) {
|
|
501
|
288 return ngx_http_variable_unknown_header(r, (uintptr_t) name);
|
|
499
|
289 }
|
|
|
290
|
|
501
|
291 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
|
|
|
292 "unknown \"%V\" variable", name);
|
|
|
293
|
|
509
|
294 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
295 }
|
|
|
296
|
|
|
297
|
|
|
298 static ngx_http_variable_value_t *
|
|
|
299 ngx_http_variable_request(ngx_http_request_t *r, uintptr_t data)
|
|
|
300 {
|
|
|
301 ngx_str_t *s;
|
|
|
302 ngx_http_variable_value_t *vv;
|
|
|
303
|
|
|
304 s = (ngx_str_t *) ((char *) r + data);
|
|
|
305
|
|
|
306 if (s->data == NULL) {
|
|
|
307 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
308 }
|
|
|
309
|
|
|
310 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
311 if (vv == NULL) {
|
|
|
312 return NULL;
|
|
|
313 }
|
|
|
314
|
|
|
315 vv->value = 0;
|
|
|
316 vv->text = *s;
|
|
|
317
|
|
|
318 return vv;
|
|
499
|
319 }
|
|
|
320
|
|
|
321
|
|
|
322 static ngx_http_variable_value_t *
|
|
|
323 ngx_http_variable_header(ngx_http_request_t *r, uintptr_t data)
|
|
|
324 {
|
|
|
325 ngx_table_elt_t *h;
|
|
501
|
326 ngx_http_variable_value_t *vv;
|
|
499
|
327
|
|
509
|
328 h = *(ngx_table_elt_t **) ((char *) r + data);
|
|
499
|
329
|
|
|
330 if (h == NULL) {
|
|
509
|
331 return NGX_HTTP_VAR_NOT_FOUND;
|
|
499
|
332 }
|
|
|
333
|
|
501
|
334 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
335 if (vv == NULL) {
|
|
499
|
336 return NULL;
|
|
|
337 }
|
|
|
338
|
|
501
|
339 vv->value = 0;
|
|
|
340 vv->text = h->value;
|
|
499
|
341
|
|
501
|
342 return vv;
|
|
499
|
343 }
|
|
|
344
|
|
|
345
|
|
|
346 static ngx_http_variable_value_t *
|
|
515
|
347 ngx_http_variable_headers(ngx_http_request_t *r, uintptr_t data)
|
|
|
348 {
|
|
|
349 u_char *p;
|
|
|
350 ngx_uint_t i;
|
|
|
351 ngx_array_t *a;
|
|
|
352 ngx_table_elt_t **h;
|
|
|
353 ngx_http_variable_value_t *vv;
|
|
|
354
|
|
|
355 a = (ngx_array_t *) ((char *) r + data);
|
|
|
356
|
|
|
357 if (a->nelts == 0) {
|
|
|
358 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
359 }
|
|
|
360
|
|
|
361 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
362 if (vv == NULL) {
|
|
|
363 return NULL;
|
|
|
364 }
|
|
|
365
|
|
|
366 vv->value = 0;
|
|
|
367
|
|
|
368 h = a->elts;
|
|
|
369
|
|
|
370 if (a->nelts == 1) {
|
|
|
371 vv->text = (*h)->value;
|
|
|
372 return vv;
|
|
|
373 }
|
|
|
374
|
|
|
375 vv->text.len = (size_t) - (ssize_t) (sizeof("; ") - 1);
|
|
|
376
|
|
|
377 for (i = 0; i < a->nelts; i++) {
|
|
|
378 vv->text.len += h[i]->value.len + sizeof("; ") - 1;
|
|
|
379 }
|
|
|
380
|
|
|
381 vv->text.data = ngx_palloc(r->pool, vv->text.len);
|
|
|
382 if (vv->text.data == NULL) {
|
|
|
383 return NULL;
|
|
|
384 }
|
|
|
385
|
|
|
386 p = vv->text.data;
|
|
|
387
|
|
|
388 for (i = 0; /* void */ ; i++) {
|
|
|
389 p = ngx_cpymem(p, h[i]->value.data, h[i]->value.len);
|
|
|
390
|
|
|
391 if (i == a->nelts - 1) {
|
|
|
392 break;
|
|
|
393 }
|
|
|
394
|
|
|
395 *p++ = ';'; *p++ = ' ';
|
|
|
396 }
|
|
|
397
|
|
|
398 return vv;
|
|
|
399 }
|
|
|
400
|
|
|
401
|
|
|
402 static ngx_http_variable_value_t *
|
|
501
|
403 ngx_http_variable_unknown_header(ngx_http_request_t *r, uintptr_t data)
|
|
499
|
404 {
|
|
501
|
405 ngx_str_t *var = (ngx_str_t *) data;
|
|
|
406
|
|
499
|
407 u_char ch;
|
|
|
408 ngx_uint_t i, n;
|
|
|
409 ngx_list_part_t *part;
|
|
|
410 ngx_table_elt_t *header;
|
|
501
|
411 ngx_http_variable_value_t *vv;
|
|
499
|
412
|
|
|
413 part = &r->headers_in.headers.part;
|
|
|
414 header = part->elts;
|
|
|
415
|
|
|
416 for (i = 0; /* void */ ; i++) {
|
|
|
417
|
|
|
418 if (i >= part->nelts) {
|
|
|
419 if (part->next == NULL) {
|
|
|
420 break;
|
|
|
421 }
|
|
|
422
|
|
|
423 part = part->next;
|
|
|
424 header = part->elts;
|
|
|
425 i = 0;
|
|
|
426 }
|
|
|
427
|
|
509
|
428 for (n = 0; n + 5 < var->len && n < header[i].key.len; n++) {
|
|
499
|
429 ch = header[i].key.data[n];
|
|
|
430
|
|
509
|
431 if (ch >= 'A' && ch <= 'Z') {
|
|
|
432 ch |= 0x20;
|
|
499
|
433
|
|
|
434 } else if (ch == '-') {
|
|
|
435 ch = '_';
|
|
|
436 }
|
|
|
437
|
|
|
438 if (var->data[n + 5] != ch) {
|
|
|
439 break;
|
|
|
440 }
|
|
|
441 }
|
|
|
442
|
|
|
443 if (n + 5 == var->len) {
|
|
501
|
444 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
445 if (vv == NULL) {
|
|
499
|
446 return NULL;
|
|
|
447 }
|
|
|
448
|
|
501
|
449 vv->value = 0;
|
|
|
450 vv->text = header[i].value;
|
|
|
451 return vv;
|
|
499
|
452 }
|
|
|
453 }
|
|
|
454
|
|
509
|
455 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
456 }
|
|
|
457
|
|
|
458
|
|
|
459 static ngx_http_variable_value_t *
|
|
|
460 ngx_http_variable_host(ngx_http_request_t *r, uintptr_t data)
|
|
|
461 {
|
|
|
462 ngx_http_variable_value_t *vv;
|
|
|
463
|
|
|
464 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
465 if (vv == NULL) {
|
|
|
466 return NULL;
|
|
|
467 }
|
|
|
468
|
|
|
469 vv->value = 0;
|
|
|
470
|
|
|
471 if (r->headers_in.host) {
|
|
|
472 vv->text.len = r->headers_in.host_name_len;
|
|
|
473 vv->text.data = r->headers_in.host->value.data;
|
|
|
474
|
|
|
475 } else {
|
|
|
476 vv->text = r->server_name;
|
|
|
477 }
|
|
|
478
|
|
|
479 return vv;
|
|
499
|
480 }
|
|
|
481
|
|
|
482
|
|
|
483 static ngx_http_variable_value_t *
|
|
|
484 ngx_http_variable_remote_addr(ngx_http_request_t *r, uintptr_t data)
|
|
|
485 {
|
|
501
|
486 ngx_http_variable_value_t *vv;
|
|
499
|
487
|
|
501
|
488 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
489 if (vv == NULL) {
|
|
499
|
490 return NULL;
|
|
|
491 }
|
|
|
492
|
|
501
|
493 vv->value = 0;
|
|
|
494 vv->text = r->connection->addr_text;
|
|
499
|
495
|
|
501
|
496 return vv;
|
|
499
|
497 }
|
|
|
498
|
|
|
499
|
|
|
500 static ngx_http_variable_value_t *
|
|
509
|
501 ngx_http_variable_remote_port(ngx_http_request_t *r, uintptr_t data)
|
|
499
|
502 {
|
|
509
|
503 ngx_uint_t port;
|
|
|
504 struct sockaddr_in *sin;
|
|
|
505 ngx_http_variable_value_t *vv;
|
|
|
506
|
|
|
507 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
508 if (vv == NULL) {
|
|
|
509 return NULL;
|
|
|
510 }
|
|
|
511
|
|
|
512 vv->value = 0;
|
|
|
513 vv->text.len = 0;
|
|
|
514
|
|
|
515 vv->text.data = ngx_palloc(r->pool, sizeof("65535") - 1);
|
|
|
516 if (vv->text.data == NULL) {
|
|
|
517 return NULL;
|
|
|
518 }
|
|
|
519
|
|
|
520 /* AF_INET only */
|
|
|
521
|
|
|
522 if (r->connection->sockaddr->sa_family == AF_INET) {
|
|
|
523 sin = (struct sockaddr_in *) r->connection->sockaddr;
|
|
|
524
|
|
|
525 port = ntohs(sin->sin_port);
|
|
|
526
|
|
|
527 if (port > 0 && port < 65536) {
|
|
|
528 vv->value = port;
|
|
|
529 vv->text.len = ngx_sprintf(vv->text.data, "%ui", port)
|
|
|
530 - vv->text.data;
|
|
|
531 }
|
|
|
532 }
|
|
|
533
|
|
|
534 return vv;
|
|
|
535 }
|
|
|
536
|
|
|
537
|
|
|
538 static ngx_http_variable_value_t *
|
|
|
539 ngx_http_variable_server_addr(ngx_http_request_t *r, uintptr_t data)
|
|
|
540 {
|
|
|
541 socklen_t len;
|
|
|
542 ngx_connection_t *c;
|
|
|
543 struct sockaddr_in sin;
|
|
501
|
544 ngx_http_variable_value_t *vv;
|
|
499
|
545
|
|
501
|
546 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
547 if (vv == NULL) {
|
|
499
|
548 return NULL;
|
|
|
549 }
|
|
|
550
|
|
501
|
551 vv->value = 0;
|
|
509
|
552
|
|
|
553 vv->text.data = ngx_palloc(r->pool, INET_ADDRSTRLEN);
|
|
|
554 if (vv->text.data == NULL) {
|
|
|
555 return NULL;
|
|
|
556 }
|
|
|
557
|
|
|
558 c = r->connection;
|
|
|
559
|
|
|
560 if (r->in_addr == 0) {
|
|
|
561 len = sizeof(struct sockaddr_in);
|
|
|
562 if (getsockname(c->fd, (struct sockaddr *) &sin, &len) == -1) {
|
|
|
563 ngx_log_error(NGX_LOG_CRIT, c->log,
|
|
|
564 ngx_socket_errno, "getsockname() failed");
|
|
|
565 return NULL;
|
|
|
566 }
|
|
|
567
|
|
|
568 r->in_addr = sin.sin_addr.s_addr;
|
|
|
569 }
|
|
|
570
|
|
|
571 vv->text.len = ngx_inet_ntop(c->listening->family, &r->in_addr,
|
|
|
572 vv->text.data, INET_ADDRSTRLEN);
|
|
499
|
573
|
|
501
|
574 return vv;
|
|
499
|
575 }
|
|
|
576
|
|
|
577
|
|
|
578 static ngx_http_variable_value_t *
|
|
509
|
579 ngx_http_variable_server_port(ngx_http_request_t *r, uintptr_t data)
|
|
|
580 {
|
|
|
581 ngx_http_variable_value_t *vv;
|
|
|
582
|
|
|
583 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
584 if (vv == NULL) {
|
|
|
585 return NULL;
|
|
|
586 }
|
|
|
587
|
|
|
588 vv->value = r->port;
|
|
|
589 vv->text.len = r->port_text->len - 1;
|
|
|
590 vv->text.data = r->port_text->data + 1;
|
|
|
591
|
|
|
592 return vv;
|
|
|
593 }
|
|
|
594
|
|
|
595
|
|
|
596 static ngx_http_variable_value_t *
|
|
|
597 ngx_http_variable_document_root(ngx_http_request_t *r, uintptr_t data)
|
|
499
|
598 {
|
|
509
|
599 ngx_http_core_loc_conf_t *clcf;
|
|
|
600 ngx_http_variable_value_t *vv;
|
|
|
601
|
|
|
602 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
603 if (vv == NULL) {
|
|
|
604 return NULL;
|
|
|
605 }
|
|
|
606
|
|
|
607 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
|
|
|
608
|
|
|
609 vv->value = 0;
|
|
|
610 vv->text = clcf->root;
|
|
|
611
|
|
|
612 return vv;
|
|
|
613 }
|
|
|
614
|
|
|
615
|
|
|
616 static ngx_http_variable_value_t *
|
|
|
617 ngx_http_variable_request_filename(ngx_http_request_t *r, uintptr_t data)
|
|
|
618 {
|
|
|
619 u_char *p;
|
|
|
620 ngx_http_core_loc_conf_t *clcf;
|
|
501
|
621 ngx_http_variable_value_t *vv;
|
|
499
|
622
|
|
501
|
623 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
624 if (vv == NULL) {
|
|
499
|
625 return NULL;
|
|
|
626 }
|
|
|
627
|
|
501
|
628 vv->value = 0;
|
|
509
|
629
|
|
|
630 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
|
|
|
631
|
|
|
632 if (!clcf->alias) {
|
|
|
633 vv->text.len = clcf->root.len + r->uri.len;
|
|
|
634 vv->text.data = ngx_palloc(r->pool, vv->text.len);
|
|
|
635 if (vv->text.data == NULL) {
|
|
|
636 return NULL;
|
|
|
637 }
|
|
|
638
|
|
|
639 p = ngx_cpymem(vv->text.data, clcf->root.data, clcf->root.len);
|
|
|
640 ngx_memcpy(p, r->uri.data, r->uri.len + 1);
|
|
|
641
|
|
|
642 } else {
|
|
|
643 vv->text.len = clcf->root.len + r->uri.len + 2 - clcf->name.len;
|
|
|
644 vv->text.data = ngx_palloc(r->pool, vv->text.len);
|
|
|
645 if (vv->text.data == NULL) {
|
|
|
646 return NULL;
|
|
|
647 }
|
|
|
648
|
|
|
649 p = ngx_cpymem(vv->text.data, clcf->root.data, clcf->root.len);
|
|
|
650 ngx_memcpy(p, r->uri.data + clcf->name.len,
|
|
|
651 r->uri.len + 1 - clcf->name.len);
|
|
|
652 }
|
|
499
|
653
|
|
501
|
654 return vv;
|
|
499
|
655 }
|
|
|
656
|
|
|
657
|
|
|
658 ngx_int_t
|
|
509
|
659 ngx_http_variables_add_core_vars(ngx_conf_t *cf)
|
|
499
|
660 {
|
|
509
|
661 ngx_http_variable_t *v, *cv;
|
|
501
|
662 ngx_http_core_main_conf_t *cmcf;
|
|
499
|
663
|
|
509
|
664 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
|
|
|
665
|
|
|
666 if (ngx_array_init(&cmcf->all_variables, cf->pool, 32,
|
|
|
667 sizeof(ngx_http_variable_t)) == NGX_ERROR)
|
|
|
668 {
|
|
499
|
669 return NGX_ERROR;
|
|
|
670 }
|
|
|
671
|
|
501
|
672 for (cv = ngx_http_core_variables; cv->name.len; cv++) {
|
|
509
|
673 v = ngx_array_push(&cmcf->all_variables);
|
|
|
674 if (v == NULL) {
|
|
499
|
675 return NGX_ERROR;
|
|
|
676 }
|
|
|
677
|
|
509
|
678 *v = *cv;
|
|
499
|
679 }
|
|
|
680
|
|
|
681 return NGX_OK;
|
|
|
682 }
|
|
509
|
683
|
|
|
684
|
|
|
685 ngx_int_t
|
|
|
686 ngx_http_variables_init_vars(ngx_conf_t *cf)
|
|
|
687 {
|
|
|
688 ngx_uint_t i, n;
|
|
|
689 ngx_http_variable_t *v, *av;
|
|
|
690 ngx_http_core_main_conf_t *cmcf;
|
|
|
691
|
|
|
692 /* set the handlers for the indexed http variables */
|
|
|
693
|
|
|
694 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
|
|
|
695
|
|
|
696 v = cmcf->variables.elts;
|
|
|
697 av = cmcf->all_variables.elts;
|
|
|
698
|
|
|
699 for (i = 0; i < cmcf->variables.nelts; i++) {
|
|
|
700
|
|
|
701 for (n = 0; n < cmcf->all_variables.nelts; n++) {
|
|
|
702
|
|
|
703 if (v[i].name.len == av[n].name.len
|
|
|
704 && ngx_strncmp(v[i].name.data, av[n].name.data, v[i].name.len)
|
|
|
705 == 0)
|
|
|
706 {
|
|
|
707 v[i].handler = av[n].handler;
|
|
|
708 v[i].data = av[n].data;
|
|
519
|
709 v[i].flags = av[n].flags | NGX_HTTP_VAR_INDEXED;
|
|
509
|
710
|
|
|
711 goto next;
|
|
|
712 }
|
|
|
713 }
|
|
|
714
|
|
|
715 if (ngx_strncmp(v[i].name.data, "http_", 5) == 0) {
|
|
|
716 v[i].handler = ngx_http_variable_unknown_header;
|
|
|
717 v[i].data = (uintptr_t) &v[i].name;
|
|
|
718
|
|
|
719 continue;
|
|
|
720 }
|
|
|
721
|
|
|
722 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
|
|
|
723 "unknown \"%V\" variable", &v[i].name);
|
|
|
724
|
|
|
725 return NGX_ERROR;
|
|
|
726
|
|
|
727 next:
|
|
|
728 continue;
|
|
|
729 }
|
|
|
730
|
|
|
731 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
|
732 "http variables: %ui", cmcf->variables.nelts);
|
|
|
733
|
|
|
734
|
|
|
735 /* init the all http variables hash */
|
|
|
736
|
|
|
737 cmcf->variables_hash.max_size = 500;
|
|
|
738 cmcf->variables_hash.bucket_limit = 1;
|
|
|
739 cmcf->variables_hash.bucket_size = sizeof(ngx_http_variable_t);
|
|
|
740 cmcf->variables_hash.name = "http variables";
|
|
|
741
|
|
|
742 if (ngx_hash_init(&cmcf->variables_hash, cf->pool,
|
|
|
743 cmcf->all_variables.elts, cmcf->all_variables.nelts) != NGX_OK)
|
|
|
744 {
|
|
|
745 return NGX_ERROR;
|
|
|
746 }
|
|
|
747
|
|
|
748 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
|
749 "http variables hash size: %ui for %ui values, "
|
|
|
750 "max buckets per entry: %ui",
|
|
|
751 cmcf->variables_hash.hash_size, cmcf->all_variables.nelts,
|
|
|
752 cmcf->variables_hash.min_buckets);
|
|
|
753
|
|
|
754 return NGX_OK;
|
|
|
755 }
|
