|
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 {
|
|
|
279 return v[key].handler(r, v[key].data);
|
|
499
|
280 }
|
|
|
281
|
|
509
|
282 if (ngx_strncmp(name->data, "http_", 5) == 0) {
|
|
501
|
283 return ngx_http_variable_unknown_header(r, (uintptr_t) name);
|
|
499
|
284 }
|
|
|
285
|
|
501
|
286 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
|
|
|
287 "unknown \"%V\" variable", name);
|
|
|
288
|
|
509
|
289 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
290 }
|
|
|
291
|
|
|
292
|
|
|
293 static ngx_http_variable_value_t *
|
|
|
294 ngx_http_variable_request(ngx_http_request_t *r, uintptr_t data)
|
|
|
295 {
|
|
|
296 ngx_str_t *s;
|
|
|
297 ngx_http_variable_value_t *vv;
|
|
|
298
|
|
|
299 s = (ngx_str_t *) ((char *) r + data);
|
|
|
300
|
|
|
301 if (s->data == NULL) {
|
|
|
302 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
303 }
|
|
|
304
|
|
|
305 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
306 if (vv == NULL) {
|
|
|
307 return NULL;
|
|
|
308 }
|
|
|
309
|
|
|
310 vv->value = 0;
|
|
|
311 vv->text = *s;
|
|
|
312
|
|
|
313 return vv;
|
|
499
|
314 }
|
|
|
315
|
|
|
316
|
|
|
317 static ngx_http_variable_value_t *
|
|
|
318 ngx_http_variable_header(ngx_http_request_t *r, uintptr_t data)
|
|
|
319 {
|
|
|
320 ngx_table_elt_t *h;
|
|
501
|
321 ngx_http_variable_value_t *vv;
|
|
499
|
322
|
|
509
|
323 h = *(ngx_table_elt_t **) ((char *) r + data);
|
|
499
|
324
|
|
|
325 if (h == NULL) {
|
|
509
|
326 return NGX_HTTP_VAR_NOT_FOUND;
|
|
499
|
327 }
|
|
|
328
|
|
501
|
329 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
330 if (vv == NULL) {
|
|
499
|
331 return NULL;
|
|
|
332 }
|
|
|
333
|
|
501
|
334 vv->value = 0;
|
|
|
335 vv->text = h->value;
|
|
499
|
336
|
|
501
|
337 return vv;
|
|
499
|
338 }
|
|
|
339
|
|
|
340
|
|
|
341 static ngx_http_variable_value_t *
|
|
515
|
342 ngx_http_variable_headers(ngx_http_request_t *r, uintptr_t data)
|
|
|
343 {
|
|
|
344 u_char *p;
|
|
|
345 ngx_uint_t i;
|
|
|
346 ngx_array_t *a;
|
|
|
347 ngx_table_elt_t **h;
|
|
|
348 ngx_http_variable_value_t *vv;
|
|
|
349
|
|
|
350 a = (ngx_array_t *) ((char *) r + data);
|
|
|
351
|
|
|
352 if (a->nelts == 0) {
|
|
|
353 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
354 }
|
|
|
355
|
|
|
356 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
357 if (vv == NULL) {
|
|
|
358 return NULL;
|
|
|
359 }
|
|
|
360
|
|
|
361 vv->value = 0;
|
|
|
362
|
|
|
363 h = a->elts;
|
|
|
364
|
|
|
365 if (a->nelts == 1) {
|
|
|
366 vv->text = (*h)->value;
|
|
|
367 return vv;
|
|
|
368 }
|
|
|
369
|
|
|
370 vv->text.len = (size_t) - (ssize_t) (sizeof("; ") - 1);
|
|
|
371
|
|
|
372 for (i = 0; i < a->nelts; i++) {
|
|
|
373 vv->text.len += h[i]->value.len + sizeof("; ") - 1;
|
|
|
374 }
|
|
|
375
|
|
|
376 vv->text.data = ngx_palloc(r->pool, vv->text.len);
|
|
|
377 if (vv->text.data == NULL) {
|
|
|
378 return NULL;
|
|
|
379 }
|
|
|
380
|
|
|
381 p = vv->text.data;
|
|
|
382
|
|
|
383 for (i = 0; /* void */ ; i++) {
|
|
|
384 p = ngx_cpymem(p, h[i]->value.data, h[i]->value.len);
|
|
|
385
|
|
|
386 if (i == a->nelts - 1) {
|
|
|
387 break;
|
|
|
388 }
|
|
|
389
|
|
|
390 *p++ = ';'; *p++ = ' ';
|
|
|
391 }
|
|
|
392
|
|
|
393 return vv;
|
|
|
394 }
|
|
|
395
|
|
|
396
|
|
|
397 static ngx_http_variable_value_t *
|
|
501
|
398 ngx_http_variable_unknown_header(ngx_http_request_t *r, uintptr_t data)
|
|
499
|
399 {
|
|
501
|
400 ngx_str_t *var = (ngx_str_t *) data;
|
|
|
401
|
|
499
|
402 u_char ch;
|
|
|
403 ngx_uint_t i, n;
|
|
|
404 ngx_list_part_t *part;
|
|
|
405 ngx_table_elt_t *header;
|
|
501
|
406 ngx_http_variable_value_t *vv;
|
|
499
|
407
|
|
|
408 part = &r->headers_in.headers.part;
|
|
|
409 header = part->elts;
|
|
|
410
|
|
|
411 for (i = 0; /* void */ ; i++) {
|
|
|
412
|
|
|
413 if (i >= part->nelts) {
|
|
|
414 if (part->next == NULL) {
|
|
|
415 break;
|
|
|
416 }
|
|
|
417
|
|
|
418 part = part->next;
|
|
|
419 header = part->elts;
|
|
|
420 i = 0;
|
|
|
421 }
|
|
|
422
|
|
509
|
423 for (n = 0; n + 5 < var->len && n < header[i].key.len; n++) {
|
|
499
|
424 ch = header[i].key.data[n];
|
|
|
425
|
|
509
|
426 if (ch >= 'A' && ch <= 'Z') {
|
|
|
427 ch |= 0x20;
|
|
499
|
428
|
|
|
429 } else if (ch == '-') {
|
|
|
430 ch = '_';
|
|
|
431 }
|
|
|
432
|
|
|
433 if (var->data[n + 5] != ch) {
|
|
|
434 break;
|
|
|
435 }
|
|
|
436 }
|
|
|
437
|
|
|
438 if (n + 5 == var->len) {
|
|
501
|
439 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
440 if (vv == NULL) {
|
|
499
|
441 return NULL;
|
|
|
442 }
|
|
|
443
|
|
501
|
444 vv->value = 0;
|
|
|
445 vv->text = header[i].value;
|
|
|
446 return vv;
|
|
499
|
447 }
|
|
|
448 }
|
|
|
449
|
|
509
|
450 return NGX_HTTP_VAR_NOT_FOUND;
|
|
|
451 }
|
|
|
452
|
|
|
453
|
|
|
454 static ngx_http_variable_value_t *
|
|
|
455 ngx_http_variable_host(ngx_http_request_t *r, uintptr_t data)
|
|
|
456 {
|
|
|
457 ngx_http_variable_value_t *vv;
|
|
|
458
|
|
|
459 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
460 if (vv == NULL) {
|
|
|
461 return NULL;
|
|
|
462 }
|
|
|
463
|
|
|
464 vv->value = 0;
|
|
|
465
|
|
|
466 if (r->headers_in.host) {
|
|
|
467 vv->text.len = r->headers_in.host_name_len;
|
|
|
468 vv->text.data = r->headers_in.host->value.data;
|
|
|
469
|
|
|
470 } else {
|
|
|
471 vv->text = r->server_name;
|
|
|
472 }
|
|
|
473
|
|
|
474 return vv;
|
|
499
|
475 }
|
|
|
476
|
|
|
477
|
|
|
478 static ngx_http_variable_value_t *
|
|
|
479 ngx_http_variable_remote_addr(ngx_http_request_t *r, uintptr_t data)
|
|
|
480 {
|
|
501
|
481 ngx_http_variable_value_t *vv;
|
|
499
|
482
|
|
501
|
483 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
484 if (vv == NULL) {
|
|
499
|
485 return NULL;
|
|
|
486 }
|
|
|
487
|
|
501
|
488 vv->value = 0;
|
|
|
489 vv->text = r->connection->addr_text;
|
|
499
|
490
|
|
501
|
491 return vv;
|
|
499
|
492 }
|
|
|
493
|
|
|
494
|
|
|
495 static ngx_http_variable_value_t *
|
|
509
|
496 ngx_http_variable_remote_port(ngx_http_request_t *r, uintptr_t data)
|
|
499
|
497 {
|
|
509
|
498 ngx_uint_t port;
|
|
|
499 struct sockaddr_in *sin;
|
|
|
500 ngx_http_variable_value_t *vv;
|
|
|
501
|
|
|
502 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
503 if (vv == NULL) {
|
|
|
504 return NULL;
|
|
|
505 }
|
|
|
506
|
|
|
507 vv->value = 0;
|
|
|
508 vv->text.len = 0;
|
|
|
509
|
|
|
510 vv->text.data = ngx_palloc(r->pool, sizeof("65535") - 1);
|
|
|
511 if (vv->text.data == NULL) {
|
|
|
512 return NULL;
|
|
|
513 }
|
|
|
514
|
|
|
515 /* AF_INET only */
|
|
|
516
|
|
|
517 if (r->connection->sockaddr->sa_family == AF_INET) {
|
|
|
518 sin = (struct sockaddr_in *) r->connection->sockaddr;
|
|
|
519
|
|
|
520 port = ntohs(sin->sin_port);
|
|
|
521
|
|
|
522 if (port > 0 && port < 65536) {
|
|
|
523 vv->value = port;
|
|
|
524 vv->text.len = ngx_sprintf(vv->text.data, "%ui", port)
|
|
|
525 - vv->text.data;
|
|
|
526 }
|
|
|
527 }
|
|
|
528
|
|
|
529 return vv;
|
|
|
530 }
|
|
|
531
|
|
|
532
|
|
|
533 static ngx_http_variable_value_t *
|
|
|
534 ngx_http_variable_server_addr(ngx_http_request_t *r, uintptr_t data)
|
|
|
535 {
|
|
|
536 socklen_t len;
|
|
|
537 ngx_connection_t *c;
|
|
|
538 struct sockaddr_in sin;
|
|
501
|
539 ngx_http_variable_value_t *vv;
|
|
499
|
540
|
|
501
|
541 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
542 if (vv == NULL) {
|
|
499
|
543 return NULL;
|
|
|
544 }
|
|
|
545
|
|
501
|
546 vv->value = 0;
|
|
509
|
547
|
|
|
548 vv->text.data = ngx_palloc(r->pool, INET_ADDRSTRLEN);
|
|
|
549 if (vv->text.data == NULL) {
|
|
|
550 return NULL;
|
|
|
551 }
|
|
|
552
|
|
|
553 c = r->connection;
|
|
|
554
|
|
|
555 if (r->in_addr == 0) {
|
|
|
556 len = sizeof(struct sockaddr_in);
|
|
|
557 if (getsockname(c->fd, (struct sockaddr *) &sin, &len) == -1) {
|
|
|
558 ngx_log_error(NGX_LOG_CRIT, c->log,
|
|
|
559 ngx_socket_errno, "getsockname() failed");
|
|
|
560 return NULL;
|
|
|
561 }
|
|
|
562
|
|
|
563 r->in_addr = sin.sin_addr.s_addr;
|
|
|
564 }
|
|
|
565
|
|
|
566 vv->text.len = ngx_inet_ntop(c->listening->family, &r->in_addr,
|
|
|
567 vv->text.data, INET_ADDRSTRLEN);
|
|
499
|
568
|
|
501
|
569 return vv;
|
|
499
|
570 }
|
|
|
571
|
|
|
572
|
|
|
573 static ngx_http_variable_value_t *
|
|
509
|
574 ngx_http_variable_server_port(ngx_http_request_t *r, uintptr_t data)
|
|
|
575 {
|
|
|
576 ngx_http_variable_value_t *vv;
|
|
|
577
|
|
|
578 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
579 if (vv == NULL) {
|
|
|
580 return NULL;
|
|
|
581 }
|
|
|
582
|
|
|
583 vv->value = r->port;
|
|
|
584 vv->text.len = r->port_text->len - 1;
|
|
|
585 vv->text.data = r->port_text->data + 1;
|
|
|
586
|
|
|
587 return vv;
|
|
|
588 }
|
|
|
589
|
|
|
590
|
|
|
591 static ngx_http_variable_value_t *
|
|
|
592 ngx_http_variable_document_root(ngx_http_request_t *r, uintptr_t data)
|
|
499
|
593 {
|
|
509
|
594 ngx_http_core_loc_conf_t *clcf;
|
|
|
595 ngx_http_variable_value_t *vv;
|
|
|
596
|
|
|
597 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
598 if (vv == NULL) {
|
|
|
599 return NULL;
|
|
|
600 }
|
|
|
601
|
|
|
602 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
|
|
|
603
|
|
|
604 vv->value = 0;
|
|
|
605 vv->text = clcf->root;
|
|
|
606
|
|
|
607 return vv;
|
|
|
608 }
|
|
|
609
|
|
|
610
|
|
|
611 static ngx_http_variable_value_t *
|
|
|
612 ngx_http_variable_request_filename(ngx_http_request_t *r, uintptr_t data)
|
|
|
613 {
|
|
|
614 u_char *p;
|
|
|
615 ngx_http_core_loc_conf_t *clcf;
|
|
501
|
616 ngx_http_variable_value_t *vv;
|
|
499
|
617
|
|
501
|
618 vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
|
|
|
619 if (vv == NULL) {
|
|
499
|
620 return NULL;
|
|
|
621 }
|
|
|
622
|
|
501
|
623 vv->value = 0;
|
|
509
|
624
|
|
|
625 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
|
|
|
626
|
|
|
627 if (!clcf->alias) {
|
|
|
628 vv->text.len = clcf->root.len + r->uri.len;
|
|
|
629 vv->text.data = ngx_palloc(r->pool, vv->text.len);
|
|
|
630 if (vv->text.data == NULL) {
|
|
|
631 return NULL;
|
|
|
632 }
|
|
|
633
|
|
|
634 p = ngx_cpymem(vv->text.data, clcf->root.data, clcf->root.len);
|
|
|
635 ngx_memcpy(p, r->uri.data, r->uri.len + 1);
|
|
|
636
|
|
|
637 } else {
|
|
|
638 vv->text.len = clcf->root.len + r->uri.len + 2 - clcf->name.len;
|
|
|
639 vv->text.data = ngx_palloc(r->pool, vv->text.len);
|
|
|
640 if (vv->text.data == NULL) {
|
|
|
641 return NULL;
|
|
|
642 }
|
|
|
643
|
|
|
644 p = ngx_cpymem(vv->text.data, clcf->root.data, clcf->root.len);
|
|
|
645 ngx_memcpy(p, r->uri.data + clcf->name.len,
|
|
|
646 r->uri.len + 1 - clcf->name.len);
|
|
|
647 }
|
|
499
|
648
|
|
501
|
649 return vv;
|
|
499
|
650 }
|
|
|
651
|
|
|
652
|
|
|
653 ngx_int_t
|
|
509
|
654 ngx_http_variables_add_core_vars(ngx_conf_t *cf)
|
|
499
|
655 {
|
|
509
|
656 ngx_http_variable_t *v, *cv;
|
|
501
|
657 ngx_http_core_main_conf_t *cmcf;
|
|
499
|
658
|
|
509
|
659 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
|
|
|
660
|
|
|
661 if (ngx_array_init(&cmcf->all_variables, cf->pool, 32,
|
|
|
662 sizeof(ngx_http_variable_t)) == NGX_ERROR)
|
|
|
663 {
|
|
499
|
664 return NGX_ERROR;
|
|
|
665 }
|
|
|
666
|
|
501
|
667 for (cv = ngx_http_core_variables; cv->name.len; cv++) {
|
|
509
|
668 v = ngx_array_push(&cmcf->all_variables);
|
|
|
669 if (v == NULL) {
|
|
499
|
670 return NGX_ERROR;
|
|
|
671 }
|
|
|
672
|
|
509
|
673 *v = *cv;
|
|
499
|
674 }
|
|
|
675
|
|
|
676 return NGX_OK;
|
|
|
677 }
|
|
509
|
678
|
|
|
679
|
|
|
680 ngx_int_t
|
|
|
681 ngx_http_variables_init_vars(ngx_conf_t *cf)
|
|
|
682 {
|
|
|
683 ngx_uint_t i, n;
|
|
|
684 ngx_http_variable_t *v, *av;
|
|
|
685 ngx_http_core_main_conf_t *cmcf;
|
|
|
686
|
|
|
687 /* set the handlers for the indexed http variables */
|
|
|
688
|
|
|
689 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
|
|
|
690
|
|
|
691 v = cmcf->variables.elts;
|
|
|
692 av = cmcf->all_variables.elts;
|
|
|
693
|
|
|
694 for (i = 0; i < cmcf->variables.nelts; i++) {
|
|
|
695
|
|
|
696 for (n = 0; n < cmcf->all_variables.nelts; n++) {
|
|
|
697
|
|
|
698 if (v[i].name.len == av[n].name.len
|
|
|
699 && ngx_strncmp(v[i].name.data, av[n].name.data, v[i].name.len)
|
|
|
700 == 0)
|
|
|
701 {
|
|
|
702 v[i].handler = av[n].handler;
|
|
|
703 v[i].data = av[n].data;
|
|
|
704 v[i].flags = av[n].flags;
|
|
|
705
|
|
|
706 goto next;
|
|
|
707 }
|
|
|
708 }
|
|
|
709
|
|
|
710 if (ngx_strncmp(v[i].name.data, "http_", 5) == 0) {
|
|
|
711 v[i].handler = ngx_http_variable_unknown_header;
|
|
|
712 v[i].data = (uintptr_t) &v[i].name;
|
|
|
713
|
|
|
714 continue;
|
|
|
715 }
|
|
|
716
|
|
|
717 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
|
|
|
718 "unknown \"%V\" variable", &v[i].name);
|
|
|
719
|
|
|
720 return NGX_ERROR;
|
|
|
721
|
|
|
722 next:
|
|
|
723 continue;
|
|
|
724 }
|
|
|
725
|
|
|
726 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
|
727 "http variables: %ui", cmcf->variables.nelts);
|
|
|
728
|
|
|
729
|
|
|
730 /* init the all http variables hash */
|
|
|
731
|
|
|
732 cmcf->variables_hash.max_size = 500;
|
|
|
733 cmcf->variables_hash.bucket_limit = 1;
|
|
|
734 cmcf->variables_hash.bucket_size = sizeof(ngx_http_variable_t);
|
|
|
735 cmcf->variables_hash.name = "http variables";
|
|
|
736
|
|
|
737 if (ngx_hash_init(&cmcf->variables_hash, cf->pool,
|
|
|
738 cmcf->all_variables.elts, cmcf->all_variables.nelts) != NGX_OK)
|
|
|
739 {
|
|
|
740 return NGX_ERROR;
|
|
|
741 }
|
|
|
742
|
|
|
743 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
|
744 "http variables hash size: %ui for %ui values, "
|
|
|
745 "max buckets per entry: %ui",
|
|
|
746 cmcf->variables_hash.hash_size, cmcf->all_variables.nelts,
|
|
|
747 cmcf->variables_hash.min_buckets);
|
|
|
748
|
|
|
749 return NGX_OK;
|
|
|
750 }
|
