Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_http_geo_module.c
Go to the documentation of this file.
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) Nginx, Inc.
5  */
6 
7 
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10 #include <ngx_http.h>
11 
12 
13 typedef struct {
14  ngx_http_variable_value_t *value;
15  u_short start;
16  u_short end;
17 } ngx_http_geo_range_t;
18 
19 
20 typedef struct {
21  ngx_radix_tree_t *tree;
22 #if (NGX_HAVE_INET6)
23  ngx_radix_tree_t *tree6;
24 #endif
25 } ngx_http_geo_trees_t;
26 
27 
28 typedef struct {
29  ngx_http_geo_range_t **low;
30  ngx_http_variable_value_t *default_value;
31 } ngx_http_geo_high_ranges_t;
32 
33 
34 typedef struct {
35  ngx_str_node_t sn;
36  ngx_http_variable_value_t *value;
37  size_t offset;
38 } ngx_http_geo_variable_value_node_t;
39 
40 
41 typedef struct {
42  ngx_http_variable_value_t *value;
43  ngx_str_t *net;
44  ngx_http_geo_high_ranges_t high;
45  ngx_radix_tree_t *tree;
46 #if (NGX_HAVE_INET6)
47  ngx_radix_tree_t *tree6;
48 #endif
49  ngx_rbtree_t rbtree;
50  ngx_rbtree_node_t sentinel;
51  ngx_array_t *proxies;
52  ngx_pool_t *pool;
53  ngx_pool_t *temp_pool;
54 
55  size_t data_size;
56 
57  ngx_str_t include_name;
58  ngx_uint_t includes;
59  ngx_uint_t entries;
60 
61  unsigned ranges:1;
62  unsigned outside_entries:1;
63  unsigned allow_binary_include:1;
64  unsigned binary_include:1;
65  unsigned proxy_recursive:1;
66 } ngx_http_geo_conf_ctx_t;
67 
68 
69 typedef struct {
70  union {
71  ngx_http_geo_trees_t trees;
72  ngx_http_geo_high_ranges_t high;
73  } u;
74 
75  ngx_array_t *proxies;
76  unsigned proxy_recursive:1;
77 
78  ngx_int_t index;
79 } ngx_http_geo_ctx_t;
80 
81 
82 static ngx_int_t ngx_http_geo_addr(ngx_http_request_t *r,
83  ngx_http_geo_ctx_t *ctx, ngx_addr_t *addr);
84 static ngx_int_t ngx_http_geo_real_addr(ngx_http_request_t *r,
85  ngx_http_geo_ctx_t *ctx, ngx_addr_t *addr);
86 static char *ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
87 static char *ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf);
88 static char *ngx_http_geo_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
89  ngx_str_t *value);
90 static char *ngx_http_geo_add_range(ngx_conf_t *cf,
91  ngx_http_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
92 static ngx_uint_t ngx_http_geo_delete_range(ngx_conf_t *cf,
93  ngx_http_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
94 static char *ngx_http_geo_cidr(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
95  ngx_str_t *value);
96 static char *ngx_http_geo_cidr_add(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
97  ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net);
98 static ngx_http_variable_value_t *ngx_http_geo_value(ngx_conf_t *cf,
99  ngx_http_geo_conf_ctx_t *ctx, ngx_str_t *value);
100 static char *ngx_http_geo_add_proxy(ngx_conf_t *cf,
101  ngx_http_geo_conf_ctx_t *ctx, ngx_cidr_t *cidr);
102 static ngx_int_t ngx_http_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net,
103  ngx_cidr_t *cidr);
104 static char *ngx_http_geo_include(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
105  ngx_str_t *name);
106 static ngx_int_t ngx_http_geo_include_binary_base(ngx_conf_t *cf,
107  ngx_http_geo_conf_ctx_t *ctx, ngx_str_t *name);
108 static void ngx_http_geo_create_binary_base(ngx_http_geo_conf_ctx_t *ctx);
109 static u_char *ngx_http_geo_copy_values(u_char *base, u_char *p,
110  ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
111 
112 
113 static ngx_command_t ngx_http_geo_commands[] = {
114 
115  { ngx_string("geo"),
116  NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
117  ngx_http_geo_block,
118  NGX_HTTP_MAIN_CONF_OFFSET,
119  0,
120  NULL },
121 
122  ngx_null_command
123 };
124 
125 
126 static ngx_http_module_t ngx_http_geo_module_ctx = {
127  NULL, /* preconfiguration */
128  NULL, /* postconfiguration */
129 
130  NULL, /* create main configuration */
131  NULL, /* init main configuration */
132 
133  NULL, /* create server configuration */
134  NULL, /* merge server configuration */
135 
136  NULL, /* create location configuration */
137  NULL /* merge location configuration */
138 };
139 
140 
141 ngx_module_t ngx_http_geo_module = {
142  NGX_MODULE_V1,
143  &ngx_http_geo_module_ctx, /* module context */
144  ngx_http_geo_commands, /* module directives */
145  NGX_HTTP_MODULE, /* module type */
146  NULL, /* init master */
147  NULL, /* init module */
148  NULL, /* init process */
149  NULL, /* init thread */
150  NULL, /* exit thread */
151  NULL, /* exit process */
152  NULL, /* exit master */
153  NGX_MODULE_V1_PADDING
154 };
155 
156 
157 typedef struct {
158  u_char GEORNG[6];
159  u_char version;
160  u_char ptr_size;
161  uint32_t endianness;
162  uint32_t crc32;
163 } ngx_http_geo_header_t;
164 
165 
166 static ngx_http_geo_header_t ngx_http_geo_header = {
167  { 'G', 'E', 'O', 'R', 'N', 'G' }, 0, sizeof(void *), 0x12345678, 0
168 };
169 
170 
171 /* geo range is AF_INET only */
172 
173 static ngx_int_t
174 ngx_http_geo_cidr_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
175  uintptr_t data)
176 {
177  ngx_http_geo_ctx_t *ctx = (ngx_http_geo_ctx_t *) data;
178 
179  in_addr_t inaddr;
180  ngx_addr_t addr;
181  struct sockaddr_in *sin;
182  ngx_http_variable_value_t *vv;
183 #if (NGX_HAVE_INET6)
184  u_char *p;
185  struct in6_addr *inaddr6;
186 #endif
187 
188  if (ngx_http_geo_addr(r, ctx, &addr) != NGX_OK) {
189  vv = (ngx_http_variable_value_t *)
190  ngx_radix32tree_find(ctx->u.trees.tree, INADDR_NONE);
191  goto done;
192  }
193 
194  switch (addr.sockaddr->sa_family) {
195 
196 #if (NGX_HAVE_INET6)
197  case AF_INET6:
198  inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;
199  p = inaddr6->s6_addr;
200 
201  if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
202  inaddr = p[12] << 24;
203  inaddr += p[13] << 16;
204  inaddr += p[14] << 8;
205  inaddr += p[15];
206 
207  vv = (ngx_http_variable_value_t *)
208  ngx_radix32tree_find(ctx->u.trees.tree, inaddr);
209 
210  } else {
211  vv = (ngx_http_variable_value_t *)
212  ngx_radix128tree_find(ctx->u.trees.tree6, p);
213  }
214 
215  break;
216 #endif
217 
218  default: /* AF_INET */
219  sin = (struct sockaddr_in *) addr.sockaddr;
220  inaddr = ntohl(sin->sin_addr.s_addr);
221 
222  vv = (ngx_http_variable_value_t *)
223  ngx_radix32tree_find(ctx->u.trees.tree, inaddr);
224 
225  break;
226  }
227 
228 done:
229 
230  *v = *vv;
231 
232  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
233  "http geo: %v", v);
234 
235  return NGX_OK;
236 }
237 
238 
239 static ngx_int_t
240 ngx_http_geo_range_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
241  uintptr_t data)
242 {
243  ngx_http_geo_ctx_t *ctx = (ngx_http_geo_ctx_t *) data;
244 
245  in_addr_t inaddr;
246  ngx_addr_t addr;
247  ngx_uint_t n;
248  struct sockaddr_in *sin;
249  ngx_http_geo_range_t *range;
250 #if (NGX_HAVE_INET6)
251  u_char *p;
252  struct in6_addr *inaddr6;
253 #endif
254 
255  *v = *ctx->u.high.default_value;
256 
257  if (ngx_http_geo_addr(r, ctx, &addr) == NGX_OK) {
258 
259  switch (addr.sockaddr->sa_family) {
260 
261 #if (NGX_HAVE_INET6)
262  case AF_INET6:
263  inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;
264 
265  if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
266  p = inaddr6->s6_addr;
267 
268  inaddr = p[12] << 24;
269  inaddr += p[13] << 16;
270  inaddr += p[14] << 8;
271  inaddr += p[15];
272 
273  } else {
274  inaddr = INADDR_NONE;
275  }
276 
277  break;
278 #endif
279 
280  default: /* AF_INET */
281  sin = (struct sockaddr_in *) addr.sockaddr;
282  inaddr = ntohl(sin->sin_addr.s_addr);
283  break;
284  }
285 
286  } else {
287  inaddr = INADDR_NONE;
288  }
289 
290  if (ctx->u.high.low) {
291  range = ctx->u.high.low[inaddr >> 16];
292 
293  if (range) {
294  n = inaddr & 0xffff;
295  do {
296  if (n >= (ngx_uint_t) range->start
297  && n <= (ngx_uint_t) range->end)
298  {
299  *v = *range->value;
300  break;
301  }
302  } while ((++range)->value);
303  }
304  }
305 
306  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
307  "http geo: %v", v);
308 
309  return NGX_OK;
310 }
311 
312 
313 static ngx_int_t
314 ngx_http_geo_addr(ngx_http_request_t *r, ngx_http_geo_ctx_t *ctx,
315  ngx_addr_t *addr)
316 {
317  ngx_array_t *xfwd;
318 
319  if (ngx_http_geo_real_addr(r, ctx, addr) != NGX_OK) {
320  return NGX_ERROR;
321  }
322 
323  xfwd = &r->headers_in.x_forwarded_for;
324 
325  if (xfwd->nelts > 0 && ctx->proxies != NULL) {
326  (void) ngx_http_get_forwarded_addr(r, addr, xfwd, NULL,
327  ctx->proxies, ctx->proxy_recursive);
328  }
329 
330  return NGX_OK;
331 }
332 
333 
334 static ngx_int_t
335 ngx_http_geo_real_addr(ngx_http_request_t *r, ngx_http_geo_ctx_t *ctx,
336  ngx_addr_t *addr)
337 {
338  ngx_http_variable_value_t *v;
339 
340  if (ctx->index == -1) {
341  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
342  "http geo started: %V", &r->connection->addr_text);
343 
344  addr->sockaddr = r->connection->sockaddr;
345  addr->socklen = r->connection->socklen;
346  /* addr->name = r->connection->addr_text; */
347 
348  return NGX_OK;
349  }
350 
351  v = ngx_http_get_flushed_variable(r, ctx->index);
352 
353  if (v == NULL || v->not_found) {
354  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
355  "http geo not found");
356 
357  return NGX_ERROR;
358  }
359 
360  ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
361  "http geo started: %v", v);
362 
363  if (ngx_parse_addr(r->pool, addr, v->data, v->len) == NGX_OK) {
364  return NGX_OK;
365  }
366 
367  return NGX_ERROR;
368 }
369 
370 
371 static char *
372 ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
373 {
374  char *rv;
375  size_t len;
376  ngx_str_t *value, name;
377  ngx_uint_t i;
378  ngx_conf_t save;
379  ngx_pool_t *pool;
380  ngx_array_t *a;
381  ngx_http_variable_t *var;
382  ngx_http_geo_ctx_t *geo;
383  ngx_http_geo_conf_ctx_t ctx;
384 #if (NGX_HAVE_INET6)
385  static struct in6_addr zero;
386 #endif
387 
388  value = cf->args->elts;
389 
390  geo = ngx_palloc(cf->pool, sizeof(ngx_http_geo_ctx_t));
391  if (geo == NULL) {
392  return NGX_CONF_ERROR;
393  }
394 
395  name = value[1];
396 
397  if (name.data[0] != '$') {
398  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
399  "invalid variable name \"%V\"", &name);
400  return NGX_CONF_ERROR;
401  }
402 
403  name.len--;
404  name.data++;
405 
406  if (cf->args->nelts == 3) {
407 
408  geo->index = ngx_http_get_variable_index(cf, &name);
409  if (geo->index == NGX_ERROR) {
410  return NGX_CONF_ERROR;
411  }
412 
413  name = value[2];
414 
415  if (name.data[0] != '$') {
416  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
417  "invalid variable name \"%V\"", &name);
418  return NGX_CONF_ERROR;
419  }
420 
421  name.len--;
422  name.data++;
423 
424  } else {
425  geo->index = -1;
426  }
427 
428  var = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
429  if (var == NULL) {
430  return NGX_CONF_ERROR;
431  }
432 
433  pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
434  if (pool == NULL) {
435  return NGX_CONF_ERROR;
436  }
437 
438  ngx_memzero(&ctx, sizeof(ngx_http_geo_conf_ctx_t));
439 
440  ctx.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
441  if (ctx.temp_pool == NULL) {
442  return NGX_CONF_ERROR;
443  }
444 
445  ngx_rbtree_init(&ctx.rbtree, &ctx.sentinel, ngx_str_rbtree_insert_value);
446 
447  ctx.pool = cf->pool;
448  ctx.data_size = sizeof(ngx_http_geo_header_t)
449  + sizeof(ngx_http_variable_value_t)
450  + 0x10000 * sizeof(ngx_http_geo_range_t *);
451  ctx.allow_binary_include = 1;
452 
453  save = *cf;
454  cf->pool = pool;
455  cf->ctx = &ctx;
456  cf->handler = ngx_http_geo;
457  cf->handler_conf = conf;
458 
459  rv = ngx_conf_parse(cf, NULL);
460 
461  *cf = save;
462 
463  geo->proxies = ctx.proxies;
464  geo->proxy_recursive = ctx.proxy_recursive;
465 
466  if (ctx.ranges) {
467 
468  if (ctx.high.low && !ctx.binary_include) {
469  for (i = 0; i < 0x10000; i++) {
470  a = (ngx_array_t *) ctx.high.low[i];
471 
472  if (a == NULL || a->nelts == 0) {
473  continue;
474  }
475 
476  len = a->nelts * sizeof(ngx_http_geo_range_t);
477 
478  ctx.high.low[i] = ngx_palloc(cf->pool, len + sizeof(void *));
479  if (ctx.high.low[i] == NULL) {
480  return NGX_CONF_ERROR;
481  }
482 
483  ngx_memcpy(ctx.high.low[i], a->elts, len);
484  ctx.high.low[i][a->nelts].value = NULL;
485  ctx.data_size += len + sizeof(void *);
486  }
487 
488  if (ctx.allow_binary_include
489  && !ctx.outside_entries
490  && ctx.entries > 100000
491  && ctx.includes == 1)
492  {
493  ngx_http_geo_create_binary_base(&ctx);
494  }
495  }
496 
497  if (ctx.high.default_value == NULL) {
498  ctx.high.default_value = &ngx_http_variable_null_value;
499  }
500 
501  geo->u.high = ctx.high;
502 
503  var->get_handler = ngx_http_geo_range_variable;
504  var->data = (uintptr_t) geo;
505 
506  ngx_destroy_pool(ctx.temp_pool);
507  ngx_destroy_pool(pool);
508 
509  } else {
510  if (ctx.tree == NULL) {
511  ctx.tree = ngx_radix_tree_create(cf->pool, -1);
512  if (ctx.tree == NULL) {
513  return NGX_CONF_ERROR;
514  }
515  }
516 
517  geo->u.trees.tree = ctx.tree;
518 
519 #if (NGX_HAVE_INET6)
520  if (ctx.tree6 == NULL) {
521  ctx.tree6 = ngx_radix_tree_create(cf->pool, -1);
522  if (ctx.tree6 == NULL) {
523  return NGX_CONF_ERROR;
524  }
525  }
526 
527  geo->u.trees.tree6 = ctx.tree6;
528 #endif
529 
530  var->get_handler = ngx_http_geo_cidr_variable;
531  var->data = (uintptr_t) geo;
532 
533  ngx_destroy_pool(ctx.temp_pool);
534  ngx_destroy_pool(pool);
535 
536  if (ngx_radix32tree_insert(ctx.tree, 0, 0,
537  (uintptr_t) &ngx_http_variable_null_value)
538  == NGX_ERROR)
539  {
540  return NGX_CONF_ERROR;
541  }
542 
543  /* NGX_BUSY is okay (default was set explicitly) */
544 
545 #if (NGX_HAVE_INET6)
546  if (ngx_radix128tree_insert(ctx.tree6, zero.s6_addr, zero.s6_addr,
547  (uintptr_t) &ngx_http_variable_null_value)
548  == NGX_ERROR)
549  {
550  return NGX_CONF_ERROR;
551  }
552 #endif
553  }
554 
555  return rv;
556 }
557 
558 
559 static char *
560 ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
561 {
562  char *rv;
563  ngx_str_t *value;
564  ngx_cidr_t cidr;
565  ngx_http_geo_conf_ctx_t *ctx;
566 
567  ctx = cf->ctx;
568 
569  value = cf->args->elts;
570 
571  if (cf->args->nelts == 1) {
572 
573  if (ngx_strcmp(value[0].data, "ranges") == 0) {
574 
575  if (ctx->tree
576 #if (NGX_HAVE_INET6)
577  || ctx->tree6
578 #endif
579  )
580  {
581  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
582  "the \"ranges\" directive must be "
583  "the first directive inside \"geo\" block");
584  goto failed;
585  }
586 
587  ctx->ranges = 1;
588 
589  rv = NGX_CONF_OK;
590 
591  goto done;
592  }
593 
594  else if (ngx_strcmp(value[0].data, "proxy_recursive") == 0) {
595  ctx->proxy_recursive = 1;
596  rv = NGX_CONF_OK;
597  goto done;
598  }
599  }
600 
601  if (cf->args->nelts != 2) {
602  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
603  "invalid number of the geo parameters");
604  goto failed;
605  }
606 
607  if (ngx_strcmp(value[0].data, "include") == 0) {
608 
609  rv = ngx_http_geo_include(cf, ctx, &value[1]);
610 
611  goto done;
612 
613  } else if (ngx_strcmp(value[0].data, "proxy") == 0) {
614 
615  if (ngx_http_geo_cidr_value(cf, &value[1], &cidr) != NGX_OK) {
616  goto failed;
617  }
618 
619  rv = ngx_http_geo_add_proxy(cf, ctx, &cidr);
620 
621  goto done;
622  }
623 
624  if (ctx->ranges) {
625  rv = ngx_http_geo_range(cf, ctx, value);
626 
627  } else {
628  rv = ngx_http_geo_cidr(cf, ctx, value);
629  }
630 
631 done:
632 
633  ngx_reset_pool(cf->pool);
634 
635  return rv;
636 
637 failed:
638 
639  ngx_reset_pool(cf->pool);
640 
641  return NGX_CONF_ERROR;
642 }
643 
644 
645 static char *
646 ngx_http_geo_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
647  ngx_str_t *value)
648 {
649  u_char *p, *last;
650  in_addr_t start, end;
651  ngx_str_t *net;
652  ngx_uint_t del;
653 
654  if (ngx_strcmp(value[0].data, "default") == 0) {
655 
656  if (ctx->high.default_value) {
657  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
658  "duplicate default geo range value: \"%V\", old value: \"%v\"",
659  &value[1], ctx->high.default_value);
660  }
661 
662  ctx->high.default_value = ngx_http_geo_value(cf, ctx, &value[1]);
663  if (ctx->high.default_value == NULL) {
664  return NGX_CONF_ERROR;
665  }
666 
667  return NGX_CONF_OK;
668  }
669 
670  if (ctx->binary_include) {
671  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
672  "binary geo range base \"%s\" cannot be mixed with usual entries",
673  ctx->include_name.data);
674  return NGX_CONF_ERROR;
675  }
676 
677  if (ctx->high.low == NULL) {
678  ctx->high.low = ngx_pcalloc(ctx->pool,
679  0x10000 * sizeof(ngx_http_geo_range_t *));
680  if (ctx->high.low == NULL) {
681  return NGX_CONF_ERROR;
682  }
683  }
684 
685  ctx->entries++;
686  ctx->outside_entries = 1;
687 
688  if (ngx_strcmp(value[0].data, "delete") == 0) {
689  net = &value[1];
690  del = 1;
691 
692  } else {
693  net = &value[0];
694  del = 0;
695  }
696 
697  last = net->data + net->len;
698 
699  p = ngx_strlchr(net->data, last, '-');
700 
701  if (p == NULL) {
702  goto invalid;
703  }
704 
705  start = ngx_inet_addr(net->data, p - net->data);
706 
707  if (start == INADDR_NONE) {
708  goto invalid;
709  }
710 
711  start = ntohl(start);
712 
713  p++;
714 
715  end = ngx_inet_addr(p, last - p);
716 
717  if (end == INADDR_NONE) {
718  goto invalid;
719  }
720 
721  end = ntohl(end);
722 
723  if (start > end) {
724  goto invalid;
725  }
726 
727  if (del) {
728  if (ngx_http_geo_delete_range(cf, ctx, start, end)) {
729  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
730  "no address range \"%V\" to delete", net);
731  }
732 
733  return NGX_CONF_OK;
734  }
735 
736  ctx->value = ngx_http_geo_value(cf, ctx, &value[1]);
737 
738  if (ctx->value == NULL) {
739  return NGX_CONF_ERROR;
740  }
741 
742  ctx->net = net;
743 
744  return ngx_http_geo_add_range(cf, ctx, start, end);
745 
746 invalid:
747 
748  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid range \"%V\"", net);
749 
750  return NGX_CONF_ERROR;
751 }
752 
753 
754 /* the add procedure is optimized to add a growing up sequence */
755 
756 static char *
757 ngx_http_geo_add_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
758  in_addr_t start, in_addr_t end)
759 {
760  in_addr_t n;
761  ngx_uint_t h, i, s, e;
762  ngx_array_t *a;
763  ngx_http_geo_range_t *range;
764 
765  for (n = start; n <= end; n = (n + 0x10000) & 0xffff0000) {
766 
767  h = n >> 16;
768 
769  if (n == start) {
770  s = n & 0xffff;
771  } else {
772  s = 0;
773  }
774 
775  if ((n | 0xffff) > end) {
776  e = end & 0xffff;
777 
778  } else {
779  e = 0xffff;
780  }
781 
782  a = (ngx_array_t *) ctx->high.low[h];
783 
784  if (a == NULL) {
785  a = ngx_array_create(ctx->temp_pool, 64,
786  sizeof(ngx_http_geo_range_t));
787  if (a == NULL) {
788  return NGX_CONF_ERROR;
789  }
790 
791  ctx->high.low[h] = (ngx_http_geo_range_t *) a;
792  }
793 
794  i = a->nelts;
795  range = a->elts;
796 
797  while (i) {
798 
799  i--;
800 
801  if (e < (ngx_uint_t) range[i].start) {
802  continue;
803  }
804 
805  if (s > (ngx_uint_t) range[i].end) {
806 
807  /* add after the range */
808 
809  range = ngx_array_push(a);
810  if (range == NULL) {
811  return NGX_CONF_ERROR;
812  }
813 
814  range = a->elts;
815 
816  ngx_memmove(&range[i + 2], &range[i + 1],
817  (a->nelts - 2 - i) * sizeof(ngx_http_geo_range_t));
818 
819  range[i + 1].start = (u_short) s;
820  range[i + 1].end = (u_short) e;
821  range[i + 1].value = ctx->value;
822 
823  goto next;
824  }
825 
826  if (s == (ngx_uint_t) range[i].start
827  && e == (ngx_uint_t) range[i].end)
828  {
829  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
830  "duplicate range \"%V\", value: \"%v\", old value: \"%v\"",
831  ctx->net, ctx->value, range[i].value);
832 
833  range[i].value = ctx->value;
834 
835  goto next;
836  }
837 
838  if (s > (ngx_uint_t) range[i].start
839  && e < (ngx_uint_t) range[i].end)
840  {
841  /* split the range and insert the new one */
842 
843  range = ngx_array_push(a);
844  if (range == NULL) {
845  return NGX_CONF_ERROR;
846  }
847 
848  range = ngx_array_push(a);
849  if (range == NULL) {
850  return NGX_CONF_ERROR;
851  }
852 
853  range = a->elts;
854 
855  ngx_memmove(&range[i + 3], &range[i + 1],
856  (a->nelts - 3 - i) * sizeof(ngx_http_geo_range_t));
857 
858  range[i + 2].start = (u_short) (e + 1);
859  range[i + 2].end = range[i].end;
860  range[i + 2].value = range[i].value;
861 
862  range[i + 1].start = (u_short) s;
863  range[i + 1].end = (u_short) e;
864  range[i + 1].value = ctx->value;
865 
866  range[i].end = (u_short) (s - 1);
867 
868  goto next;
869  }
870 
871  if (s == (ngx_uint_t) range[i].start
872  && e < (ngx_uint_t) range[i].end)
873  {
874  /* shift the range start and insert the new range */
875 
876  range = ngx_array_push(a);
877  if (range == NULL) {
878  return NGX_CONF_ERROR;
879  }
880 
881  range = a->elts;
882 
883  ngx_memmove(&range[i + 1], &range[i],
884  (a->nelts - 1 - i) * sizeof(ngx_http_geo_range_t));
885 
886  range[i + 1].start = (u_short) (e + 1);
887 
888  range[i].start = (u_short) s;
889  range[i].end = (u_short) e;
890  range[i].value = ctx->value;
891 
892  goto next;
893  }
894 
895  if (s > (ngx_uint_t) range[i].start
896  && e == (ngx_uint_t) range[i].end)
897  {
898  /* shift the range end and insert the new range */
899 
900  range = ngx_array_push(a);
901  if (range == NULL) {
902  return NGX_CONF_ERROR;
903  }
904 
905  range = a->elts;
906 
907  ngx_memmove(&range[i + 2], &range[i + 1],
908  (a->nelts - 2 - i) * sizeof(ngx_http_geo_range_t));
909 
910  range[i + 1].start = (u_short) s;
911  range[i + 1].end = (u_short) e;
912  range[i + 1].value = ctx->value;
913 
914  range[i].end = (u_short) (s - 1);
915 
916  goto next;
917  }
918 
919  s = (ngx_uint_t) range[i].start;
920  e = (ngx_uint_t) range[i].end;
921 
922  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
923  "range \"%V\" overlaps \"%d.%d.%d.%d-%d.%d.%d.%d\"",
924  ctx->net,
925  h >> 8, h & 0xff, s >> 8, s & 0xff,
926  h >> 8, h & 0xff, e >> 8, e & 0xff);
927 
928  return NGX_CONF_ERROR;
929  }
930 
931  /* add the first range */
932 
933  range = ngx_array_push(a);
934  if (range == NULL) {
935  return NGX_CONF_ERROR;
936  }
937 
938  range->start = (u_short) s;
939  range->end = (u_short) e;
940  range->value = ctx->value;
941 
942  next:
943 
944  continue;
945  }
946 
947  return NGX_CONF_OK;
948 }
949 
950 
951 static ngx_uint_t
952 ngx_http_geo_delete_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
953  in_addr_t start, in_addr_t end)
954 {
955  in_addr_t n;
956  ngx_uint_t h, i, s, e, warn;
957  ngx_array_t *a;
958  ngx_http_geo_range_t *range;
959 
960  warn = 0;
961 
962  for (n = start; n <= end; n += 0x10000) {
963 
964  h = n >> 16;
965 
966  if (n == start) {
967  s = n & 0xffff;
968  } else {
969  s = 0;
970  }
971 
972  if ((n | 0xffff) > end) {
973  e = end & 0xffff;
974 
975  } else {
976  e = 0xffff;
977  }
978 
979  a = (ngx_array_t *) ctx->high.low[h];
980 
981  if (a == NULL) {
982  warn = 1;
983  continue;
984  }
985 
986  range = a->elts;
987  for (i = 0; i < a->nelts; i++) {
988 
989  if (s == (ngx_uint_t) range[i].start
990  && e == (ngx_uint_t) range[i].end)
991  {
992  ngx_memmove(&range[i], &range[i + 1],
993  (a->nelts - 1 - i) * sizeof(ngx_http_geo_range_t));
994 
995  a->nelts--;
996 
997  break;
998  }
999 
1000  if (s != (ngx_uint_t) range[i].start
1001  && e != (ngx_uint_t) range[i].end)
1002  {
1003  continue;
1004  }
1005 
1006  warn = 1;
1007  }
1008  }
1009 
1010  return warn;
1011 }
1012 
1013 
1014 static char *
1015 ngx_http_geo_cidr(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1016  ngx_str_t *value)
1017 {
1018  char *rv;
1019  ngx_int_t rc, del;
1020  ngx_str_t *net;
1021  ngx_cidr_t cidr;
1022 
1023  if (ctx->tree == NULL) {
1024  ctx->tree = ngx_radix_tree_create(ctx->pool, -1);
1025  if (ctx->tree == NULL) {
1026  return NGX_CONF_ERROR;
1027  }
1028  }
1029 
1030 #if (NGX_HAVE_INET6)
1031  if (ctx->tree6 == NULL) {
1032  ctx->tree6 = ngx_radix_tree_create(ctx->pool, -1);
1033  if (ctx->tree6 == NULL) {
1034  return NGX_CONF_ERROR;
1035  }
1036  }
1037 #endif
1038 
1039  if (ngx_strcmp(value[0].data, "default") == 0) {
1040  cidr.family = AF_INET;
1041  cidr.u.in.addr = 0;
1042  cidr.u.in.mask = 0;
1043 
1044  rv = ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], &value[0]);
1045 
1046  if (rv != NGX_CONF_OK) {
1047  return rv;
1048  }
1049 
1050 #if (NGX_HAVE_INET6)
1051  cidr.family = AF_INET6;
1052  ngx_memzero(&cidr.u.in6, sizeof(ngx_in6_cidr_t));
1053 
1054  rv = ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], &value[0]);
1055 
1056  if (rv != NGX_CONF_OK) {
1057  return rv;
1058  }
1059 #endif
1060 
1061  return NGX_CONF_OK;
1062  }
1063 
1064  if (ngx_strcmp(value[0].data, "delete") == 0) {
1065  net = &value[1];
1066  del = 1;
1067 
1068  } else {
1069  net = &value[0];
1070  del = 0;
1071  }
1072 
1073  if (ngx_http_geo_cidr_value(cf, net, &cidr) != NGX_OK) {
1074  return NGX_CONF_ERROR;
1075  }
1076 
1077  if (cidr.family == AF_INET) {
1078  cidr.u.in.addr = ntohl(cidr.u.in.addr);
1079  cidr.u.in.mask = ntohl(cidr.u.in.mask);
1080  }
1081 
1082  if (del) {
1083  switch (cidr.family) {
1084 
1085 #if (NGX_HAVE_INET6)
1086  case AF_INET6:
1087  rc = ngx_radix128tree_delete(ctx->tree6,
1088  cidr.u.in6.addr.s6_addr,
1089  cidr.u.in6.mask.s6_addr);
1090  break;
1091 #endif
1092 
1093  default: /* AF_INET */
1094  rc = ngx_radix32tree_delete(ctx->tree, cidr.u.in.addr,
1095  cidr.u.in.mask);
1096  break;
1097  }
1098 
1099  if (rc != NGX_OK) {
1100  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1101  "no network \"%V\" to delete", net);
1102  }
1103 
1104  return NGX_CONF_OK;
1105  }
1106 
1107  return ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], net);
1108 }
1109 
1110 
1111 static char *
1112 ngx_http_geo_cidr_add(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1113  ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net)
1114 {
1115  ngx_int_t rc;
1116  ngx_http_variable_value_t *val, *old;
1117 
1118  val = ngx_http_geo_value(cf, ctx, value);
1119 
1120  if (val == NULL) {
1121  return NGX_CONF_ERROR;
1122  }
1123 
1124  switch (cidr->family) {
1125 
1126 #if (NGX_HAVE_INET6)
1127  case AF_INET6:
1128  rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
1129  cidr->u.in6.mask.s6_addr,
1130  (uintptr_t) val);
1131 
1132  if (rc == NGX_OK) {
1133  return NGX_CONF_OK;
1134  }
1135 
1136  if (rc == NGX_ERROR) {
1137  return NGX_CONF_ERROR;
1138  }
1139 
1140  /* rc == NGX_BUSY */
1141 
1142  old = (ngx_http_variable_value_t *)
1143  ngx_radix128tree_find(ctx->tree6,
1144  cidr->u.in6.addr.s6_addr);
1145 
1146  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1147  "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
1148  net, val, old);
1149 
1150  rc = ngx_radix128tree_delete(ctx->tree6,
1151  cidr->u.in6.addr.s6_addr,
1152  cidr->u.in6.mask.s6_addr);
1153 
1154  if (rc == NGX_ERROR) {
1155  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
1156  return NGX_CONF_ERROR;
1157  }
1158 
1159  rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
1160  cidr->u.in6.mask.s6_addr,
1161  (uintptr_t) val);
1162 
1163  break;
1164 #endif
1165 
1166  default: /* AF_INET */
1167  rc = ngx_radix32tree_insert(ctx->tree, cidr->u.in.addr,
1168  cidr->u.in.mask, (uintptr_t) val);
1169 
1170  if (rc == NGX_OK) {
1171  return NGX_CONF_OK;
1172  }
1173 
1174  if (rc == NGX_ERROR) {
1175  return NGX_CONF_ERROR;
1176  }
1177 
1178  /* rc == NGX_BUSY */
1179 
1180  old = (ngx_http_variable_value_t *)
1181  ngx_radix32tree_find(ctx->tree, cidr->u.in.addr);
1182 
1183  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1184  "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
1185  net, val, old);
1186 
1187  rc = ngx_radix32tree_delete(ctx->tree,
1188  cidr->u.in.addr, cidr->u.in.mask);
1189 
1190  if (rc == NGX_ERROR) {
1191  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
1192  return NGX_CONF_ERROR;
1193  }
1194 
1195  rc = ngx_radix32tree_insert(ctx->tree, cidr->u.in.addr,
1196  cidr->u.in.mask, (uintptr_t) val);
1197 
1198  break;
1199  }
1200 
1201  if (rc == NGX_OK) {
1202  return NGX_CONF_OK;
1203  }
1204 
1205  return NGX_CONF_ERROR;
1206 }
1207 
1208 
1209 static ngx_http_variable_value_t *
1210 ngx_http_geo_value(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1211  ngx_str_t *value)
1212 {
1213  uint32_t hash;
1214  ngx_http_variable_value_t *val;
1215  ngx_http_geo_variable_value_node_t *gvvn;
1216 
1217  hash = ngx_crc32_long(value->data, value->len);
1218 
1219  gvvn = (ngx_http_geo_variable_value_node_t *)
1220  ngx_str_rbtree_lookup(&ctx->rbtree, value, hash);
1221 
1222  if (gvvn) {
1223  return gvvn->value;
1224  }
1225 
1226  val = ngx_palloc(ctx->pool, sizeof(ngx_http_variable_value_t));
1227  if (val == NULL) {
1228  return NULL;
1229  }
1230 
1231  val->len = value->len;
1232  val->data = ngx_pstrdup(ctx->pool, value);
1233  if (val->data == NULL) {
1234  return NULL;
1235  }
1236 
1237  val->valid = 1;
1238  val->no_cacheable = 0;
1239  val->not_found = 0;
1240 
1241  gvvn = ngx_palloc(ctx->temp_pool,
1242  sizeof(ngx_http_geo_variable_value_node_t));
1243  if (gvvn == NULL) {
1244  return NULL;
1245  }
1246 
1247  gvvn->sn.node.key = hash;
1248  gvvn->sn.str.len = val->len;
1249  gvvn->sn.str.data = val->data;
1250  gvvn->value = val;
1251  gvvn->offset = 0;
1252 
1253  ngx_rbtree_insert(&ctx->rbtree, &gvvn->sn.node);
1254 
1255  ctx->data_size += ngx_align(sizeof(ngx_http_variable_value_t) + value->len,
1256  sizeof(void *));
1257 
1258  return val;
1259 }
1260 
1261 
1262 static char *
1263 ngx_http_geo_add_proxy(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1264  ngx_cidr_t *cidr)
1265 {
1266  ngx_cidr_t *c;
1267 
1268  if (ctx->proxies == NULL) {
1269  ctx->proxies = ngx_array_create(ctx->pool, 4, sizeof(ngx_cidr_t));
1270  if (ctx->proxies == NULL) {
1271  return NGX_CONF_ERROR;
1272  }
1273  }
1274 
1275  c = ngx_array_push(ctx->proxies);
1276  if (c == NULL) {
1277  return NGX_CONF_ERROR;
1278  }
1279 
1280  *c = *cidr;
1281 
1282  return NGX_CONF_OK;
1283 }
1284 
1285 
1286 static ngx_int_t
1287 ngx_http_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net, ngx_cidr_t *cidr)
1288 {
1289  ngx_int_t rc;
1290 
1291  if (ngx_strcmp(net->data, "255.255.255.255") == 0) {
1292  cidr->family = AF_INET;
1293  cidr->u.in.addr = 0xffffffff;
1294  cidr->u.in.mask = 0xffffffff;
1295 
1296  return NGX_OK;
1297  }
1298 
1299  rc = ngx_ptocidr(net, cidr);
1300 
1301  if (rc == NGX_ERROR) {
1302  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid network \"%V\"", net);
1303  return NGX_ERROR;
1304  }
1305 
1306  if (rc == NGX_DONE) {
1307  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1308  "low address bits of %V are meaningless", net);
1309  }
1310 
1311  return NGX_OK;
1312 }
1313 
1314 
1315 static char *
1316 ngx_http_geo_include(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1317  ngx_str_t *name)
1318 {
1319  char *rv;
1320  ngx_str_t file;
1321 
1322  file.len = name->len + 4;
1323  file.data = ngx_pnalloc(ctx->temp_pool, name->len + 5);
1324  if (file.data == NULL) {
1325  return NGX_CONF_ERROR;
1326  }
1327 
1328  ngx_sprintf(file.data, "%V.bin%Z", name);
1329 
1330  if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
1331  return NGX_CONF_ERROR;
1332  }
1333 
1334  if (ctx->ranges) {
1335  ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
1336 
1337  switch (ngx_http_geo_include_binary_base(cf, ctx, &file)) {
1338  case NGX_OK:
1339  return NGX_CONF_OK;
1340  case NGX_ERROR:
1341  return NGX_CONF_ERROR;
1342  default:
1343  break;
1344  }
1345  }
1346 
1347  file.len -= 4;
1348  file.data[file.len] = '\0';
1349 
1350  ctx->include_name = file;
1351 
1352  if (ctx->outside_entries) {
1353  ctx->allow_binary_include = 0;
1354  }
1355 
1356  ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
1357 
1358  rv = ngx_conf_parse(cf, &file);
1359 
1360  ctx->includes++;
1361  ctx->outside_entries = 0;
1362 
1363  return rv;
1364 }
1365 
1366 
1367 static ngx_int_t
1368 ngx_http_geo_include_binary_base(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1369  ngx_str_t *name)
1370 {
1371  u_char *base, ch;
1372  time_t mtime;
1373  size_t size, len;
1374  ssize_t n;
1375  uint32_t crc32;
1376  ngx_err_t err;
1377  ngx_int_t rc;
1378  ngx_uint_t i;
1379  ngx_file_t file;
1380  ngx_file_info_t fi;
1381  ngx_http_geo_range_t *range, **ranges;
1382  ngx_http_geo_header_t *header;
1383  ngx_http_variable_value_t *vv;
1384 
1385  ngx_memzero(&file, sizeof(ngx_file_t));
1386  file.name = *name;
1387  file.log = cf->log;
1388 
1389  file.fd = ngx_open_file(name->data, NGX_FILE_RDONLY, 0, 0);
1390  if (file.fd == NGX_INVALID_FILE) {
1391  err = ngx_errno;
1392  if (err != NGX_ENOENT) {
1393  ngx_conf_log_error(NGX_LOG_CRIT, cf, err,
1394  ngx_open_file_n " \"%s\" failed", name->data);
1395  }
1396  return NGX_DECLINED;
1397  }
1398 
1399  if (ctx->outside_entries) {
1400  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1401  "binary geo range base \"%s\" cannot be mixed with usual entries",
1402  name->data);
1403  rc = NGX_ERROR;
1404  goto done;
1405  }
1406 
1407  if (ctx->binary_include) {
1408  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1409  "second binary geo range base \"%s\" cannot be mixed with \"%s\"",
1410  name->data, ctx->include_name.data);
1411  rc = NGX_ERROR;
1412  goto done;
1413  }
1414 
1415  if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
1416  ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
1417  ngx_fd_info_n " \"%s\" failed", name->data);
1418  goto failed;
1419  }
1420 
1421  size = (size_t) ngx_file_size(&fi);
1422  mtime = ngx_file_mtime(&fi);
1423 
1424  ch = name->data[name->len - 4];
1425  name->data[name->len - 4] = '\0';
1426 
1427  if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
1428  ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
1429  ngx_file_info_n " \"%s\" failed", name->data);
1430  goto failed;
1431  }
1432 
1433  name->data[name->len - 4] = ch;
1434 
1435  if (mtime < ngx_file_mtime(&fi)) {
1436  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1437  "stale binary geo range base \"%s\"", name->data);
1438  goto failed;
1439  }
1440 
1441  base = ngx_palloc(ctx->pool, size);
1442  if (base == NULL) {
1443  goto failed;
1444  }
1445 
1446  n = ngx_read_file(&file, base, size, 0);
1447 
1448  if (n == NGX_ERROR) {
1449  ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
1450  ngx_read_file_n " \"%s\" failed", name->data);
1451  goto failed;
1452  }
1453 
1454  if ((size_t) n != size) {
1455  ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
1456  ngx_read_file_n " \"%s\" returned only %z bytes instead of %z",
1457  name->data, n, size);
1458  goto failed;
1459  }
1460 
1461  header = (ngx_http_geo_header_t *) base;
1462 
1463  if (size < 16 || ngx_memcmp(&ngx_http_geo_header, header, 12) != 0) {
1464  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1465  "incompatible binary geo range base \"%s\"", name->data);
1466  goto failed;
1467  }
1468 
1469  ngx_crc32_init(crc32);
1470 
1471  vv = (ngx_http_variable_value_t *) (base + sizeof(ngx_http_geo_header_t));
1472 
1473  while(vv->data) {
1474  len = ngx_align(sizeof(ngx_http_variable_value_t) + vv->len,
1475  sizeof(void *));
1476  ngx_crc32_update(&crc32, (u_char *) vv, len);
1477  vv->data += (size_t) base;
1478  vv = (ngx_http_variable_value_t *) ((u_char *) vv + len);
1479  }
1480  ngx_crc32_update(&crc32, (u_char *) vv, sizeof(ngx_http_variable_value_t));
1481  vv++;
1482 
1483  ranges = (ngx_http_geo_range_t **) vv;
1484 
1485  for (i = 0; i < 0x10000; i++) {
1486  ngx_crc32_update(&crc32, (u_char *) &ranges[i], sizeof(void *));
1487  if (ranges[i]) {
1488  ranges[i] = (ngx_http_geo_range_t *)
1489  ((u_char *) ranges[i] + (size_t) base);
1490  }
1491  }
1492 
1493  range = (ngx_http_geo_range_t *) &ranges[0x10000];
1494 
1495  while ((u_char *) range < base + size) {
1496  while (range->value) {
1497  ngx_crc32_update(&crc32, (u_char *) range,
1498  sizeof(ngx_http_geo_range_t));
1499  range->value = (ngx_http_variable_value_t *)
1500  ((u_char *) range->value + (size_t) base);
1501  range++;
1502  }
1503  ngx_crc32_update(&crc32, (u_char *) range, sizeof(void *));
1504  range = (ngx_http_geo_range_t *) ((u_char *) range + sizeof(void *));
1505  }
1506 
1507  ngx_crc32_final(crc32);
1508 
1509  if (crc32 != header->crc32) {
1510  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1511  "CRC32 mismatch in binary geo range base \"%s\"", name->data);
1512  goto failed;
1513  }
1514 
1515  ngx_conf_log_error(NGX_LOG_NOTICE, cf, 0,
1516  "using binary geo range base \"%s\"", name->data);
1517 
1518  ctx->include_name = *name;
1519  ctx->binary_include = 1;
1520  ctx->high.low = ranges;
1521  rc = NGX_OK;
1522 
1523  goto done;
1524 
1525 failed:
1526 
1527  rc = NGX_DECLINED;
1528 
1529 done:
1530 
1531  if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
1532  ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
1533  ngx_close_file_n " \"%s\" failed", name->data);
1534  }
1535 
1536  return rc;
1537 }
1538 
1539 
1540 static void
1541 ngx_http_geo_create_binary_base(ngx_http_geo_conf_ctx_t *ctx)
1542 {
1543  u_char *p;
1544  uint32_t hash;
1545  ngx_str_t s;
1546  ngx_uint_t i;
1547  ngx_file_mapping_t fm;
1548  ngx_http_geo_range_t *r, *range, **ranges;
1549  ngx_http_geo_header_t *header;
1550  ngx_http_geo_variable_value_node_t *gvvn;
1551 
1552  fm.name = ngx_pnalloc(ctx->temp_pool, ctx->include_name.len + 5);
1553  if (fm.name == NULL) {
1554  return;
1555  }
1556 
1557  ngx_sprintf(fm.name, "%V.bin%Z", &ctx->include_name);
1558 
1559  fm.size = ctx->data_size;
1560  fm.log = ctx->pool->log;
1561 
1562  ngx_log_error(NGX_LOG_NOTICE, fm.log, 0,
1563  "creating binary geo range base \"%s\"", fm.name);
1564 
1565  if (ngx_create_file_mapping(&fm) != NGX_OK) {
1566  return;
1567  }
1568 
1569  p = ngx_cpymem(fm.addr, &ngx_http_geo_header,
1570  sizeof(ngx_http_geo_header_t));
1571 
1572  p = ngx_http_geo_copy_values(fm.addr, p, ctx->rbtree.root,
1573  ctx->rbtree.sentinel);
1574 
1575  p += sizeof(ngx_http_variable_value_t);
1576 
1577  ranges = (ngx_http_geo_range_t **) p;
1578 
1579  p += 0x10000 * sizeof(ngx_http_geo_range_t *);
1580 
1581  for (i = 0; i < 0x10000; i++) {
1582  r = ctx->high.low[i];
1583  if (r == NULL) {
1584  continue;
1585  }
1586 
1587  range = (ngx_http_geo_range_t *) p;
1588  ranges[i] = (ngx_http_geo_range_t *) (p - (u_char *) fm.addr);
1589 
1590  do {
1591  s.len = r->value->len;
1592  s.data = r->value->data;
1593  hash = ngx_crc32_long(s.data, s.len);
1594  gvvn = (ngx_http_geo_variable_value_node_t *)
1595  ngx_str_rbtree_lookup(&ctx->rbtree, &s, hash);
1596 
1597  range->value = (ngx_http_variable_value_t *) gvvn->offset;
1598  range->start = r->start;
1599  range->end = r->end;
1600  range++;
1601 
1602  } while ((++r)->value);
1603 
1604  range->value = NULL;
1605 
1606  p = (u_char *) range + sizeof(void *);
1607  }
1608 
1609  header = fm.addr;
1610  header->crc32 = ngx_crc32_long((u_char *) fm.addr
1611  + sizeof(ngx_http_geo_header_t),
1612  fm.size - sizeof(ngx_http_geo_header_t));
1613 
1614  ngx_close_file_mapping(&fm);
1615 }
1616 
1617 
1618 static u_char *
1619 ngx_http_geo_copy_values(u_char *base, u_char *p, ngx_rbtree_node_t *node,
1620  ngx_rbtree_node_t *sentinel)
1621 {
1622  ngx_http_variable_value_t *vv;
1623  ngx_http_geo_variable_value_node_t *gvvn;
1624 
1625  if (node == sentinel) {
1626  return p;
1627  }
1628 
1629  gvvn = (ngx_http_geo_variable_value_node_t *) node;
1630  gvvn->offset = p - base;
1631 
1632  vv = (ngx_http_variable_value_t *) p;
1633  *vv = *gvvn->value;
1634  p += sizeof(ngx_http_variable_value_t);
1635  vv->data = (u_char *) (p - base);
1636 
1637  p = ngx_cpymem(p, gvvn->sn.str.data, gvvn->sn.str.len);
1638 
1639  p = ngx_align_ptr(p, sizeof(void *));
1640 
1641  p = ngx_http_geo_copy_values(base, p, node->left, sentinel);
1642 
1643  return ngx_http_geo_copy_values(base, p, node->right, sentinel);
1644 }
Generated on Sun Nov 10 2013 09:49:07 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2