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