One Level Up Top Level

src/http/modules/ngx_http_geo_module.c - nginx

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  13. ‌typedef struct {
  14.     ngx_http_variable_value_t       *value;
  15.     u_short                          start;
  16.     u_short                          end;
  17. ‌} ngx_http_geo_range_t;


  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;


  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;


  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;


  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;

  55.     size_t                           data_size;

  57.     ngx_str_t                        include_name;
  58.     ngx_uint_t                       includes;
  59.     ngx_uint_t                       entries;

  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.     unsigned                         no_cacheable:1;
  67. ‌} ngx_http_geo_conf_ctx_t;


  70. ‌typedef struct {
  71. ‌    union {
  72.         ngx_http_geo_trees_t         trees;
  73.         ngx_http_geo_high_ranges_t   high;
  74.     } u;

  76.     ngx_array_t                     *proxies;
  77.     unsigned                         proxy_recursive:1;

  79.     ngx_int_t                        index;
  80. ‌} ngx_http_geo_ctx_t;


  83. static ngx_int_t ngx_http_geo_addr(ngx_http_request_t *r,
  84.     ngx_http_geo_ctx_t *ctx, ngx_addr_t *addr);
  85. static ngx_int_t ngx_http_geo_real_addr(ngx_http_request_t *r,
  86.     ngx_http_geo_ctx_t *ctx, ngx_addr_t *addr);
  87. static char *ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  88. static char *ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf);
  89. static char *ngx_http_geo_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  90.     ngx_str_t *value);
  91. static char *ngx_http_geo_add_range(ngx_conf_t *cf,
  92.     ngx_http_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
  93. static ngx_uint_t ngx_http_geo_delete_range(ngx_conf_t *cf,
  94.     ngx_http_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
  95. static char *ngx_http_geo_cidr(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  96.     ngx_str_t *value);
  97. static char *ngx_http_geo_cidr_add(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  98.     ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net);
  99. static ngx_http_variable_value_t *ngx_http_geo_value(ngx_conf_t *cf,
  100.     ngx_http_geo_conf_ctx_t *ctx, ngx_str_t *value);
  101. static char *ngx_http_geo_add_proxy(ngx_conf_t *cf,
  102.     ngx_http_geo_conf_ctx_t *ctx, ngx_cidr_t *cidr);
  103. static ngx_int_t ngx_http_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net,
  104.     ngx_cidr_t *cidr);
  105. static char *ngx_http_geo_include(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  106.     ngx_str_t *name);
  107. static ngx_int_t ngx_http_geo_include_binary_base(ngx_conf_t *cf,
  108.     ngx_http_geo_conf_ctx_t *ctx, ngx_str_t *name);
  109. static void ngx_http_geo_create_binary_base(ngx_http_geo_conf_ctx_t *ctx);
  110. static u_char *ngx_http_geo_copy_values(u_char *base, u_char *p,
  111.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);


  114. ‌static ngx_command_t  ngx_http_geo_commands[] = {

  116.     { ngx_string("geo"),
  117.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
  118.       ngx_http_geo_block,
  119.       NGX_HTTP_MAIN_CONF_OFFSET,
  120.       0,
  121.       NULL },

  123.       ngx_null_command
  124. };


  127. ‌static ngx_http_module_t  ngx_http_geo_module_ctx = {
  128.     NULL,                                  /* preconfiguration */
  129.     NULL,                                  /* postconfiguration */

  131.     NULL,                                  /* create main configuration */
  132.     NULL,                                  /* init main configuration */

  134.     NULL,                                  /* create server configuration */
  135.     NULL,                                  /* merge server configuration */

  137.     NULL,                                  /* create location configuration */
  138.     NULL                                   /* merge location configuration */
  139. };


  142. ‌ngx_module_t  ngx_http_geo_module = {
  143.     NGX_MODULE_V1,
  144.     &ngx_http_geo_module_ctx,              /* module context */
  145.     ngx_http_geo_commands,                 /* module directives */
  146.     NGX_HTTP_MODULE,                       /* module type */
  147.     NULL,                                  /* init master */
  148.     NULL,                                  /* init module */
  149.     NULL,                                  /* init process */
  150.     NULL,                                  /* init thread */
  151.     NULL,                                  /* exit thread */
  152.     NULL,                                  /* exit process */
  153.     NULL,                                  /* exit master */
  154.     NGX_MODULE_V1_PADDING
  155. };


  158. ‌typedef struct {
  159.     u_char    GEORNG[6];
  160.     u_char    version;
  161.     u_char    ptr_size;
  162.     uint32_t  endianness;
  163.     uint32_t  crc32;
  164. ‌} ngx_http_geo_header_t;


  167. ‌static ngx_http_geo_header_t  ngx_http_geo_header = {
  168.     { 'G', 'E', 'O', 'R', 'N', 'G' }, 0, sizeof(void *), 0x12345678, 0
  169. };


  172. /* geo range is AF_INET only */

  174. static ngx_int_t
  175. ‌ngx_http_geo_cidr_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  176.     uintptr_t data)
  177. {
  178.     ngx_http_geo_ctx_t *ctx = (ngx_http_geo_ctx_t *) data;

  180.     in_addr_t                   inaddr;
  181.     ngx_addr_t                  addr;
  182.     struct sockaddr_in         *sin;
  183.     ngx_http_variable_value_t  *vv;
  184. #if (NGX_HAVE_INET6)
  185.     u_char                     *p;
  186.     struct in6_addr            *inaddr6;
  187. #endif

  189.     if (ngx_http_geo_addr(r, ctx, &addr) != NGX_OK) {
  190.         vv = (ngx_http_variable_value_t *)
  191.                   ngx_radix32tree_find(ctx->u.trees.tree, INADDR_NONE);
  192.         goto done;
  193.     }

  195.     switch (addr.sockaddr->sa_family) {

  197. #if (NGX_HAVE_INET6)
  198.     case AF_INET6:
  199.         inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;
  200.         p = inaddr6->s6_addr;

  202.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  203.             inaddr = (in_addr_t) p[12] << 24;
  204.             inaddr += p[13] << 16;
  205.             inaddr += p[14] << 8;
  206.             inaddr += p[15];

  208.             vv = (ngx_http_variable_value_t *)
  209.                       ngx_radix32tree_find(ctx->u.trees.tree, inaddr);

  211.         } else {
  212.             vv = (ngx_http_variable_value_t *)
  213.                       ngx_radix128tree_find(ctx->u.trees.tree6, p);
  214.         }

  216.         break;
  217. #endif

  219. #if (NGX_HAVE_UNIX_DOMAIN)
  220.     case AF_UNIX:
  221.         vv = (ngx_http_variable_value_t *)
  222.                   ngx_radix32tree_find(ctx->u.trees.tree, INADDR_NONE);
  223.         break;
  224. #endif

  226.     default: /* AF_INET */
  227.         sin = (struct sockaddr_in *) addr.sockaddr;
  228.         inaddr = ntohl(sin->sin_addr.s_addr);

  230.         vv = (ngx_http_variable_value_t *)
  231.                   ngx_radix32tree_find(ctx->u.trees.tree, inaddr);

  233.         break;
  234.     }

  236. done:

  238.     *v = *vv;

  240.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  241.                    "http geo: %v", v);

  243.     return NGX_OK;
  244. }


  247. static ngx_int_t
  248. ‌ngx_http_geo_range_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  249.     uintptr_t data)
  250. {
  251.     ngx_http_geo_ctx_t *ctx = (ngx_http_geo_ctx_t *) data;

  253.     in_addr_t              inaddr;
  254.     ngx_addr_t             addr;
  255.     ngx_uint_t             n;
  256.     struct sockaddr_in    *sin;
  257.     ngx_http_geo_range_t  *range;
  258. #if (NGX_HAVE_INET6)
  259.     u_char                *p;
  260.     struct in6_addr       *inaddr6;
  261. #endif

  263.     *v = *ctx->u.high.default_value;

  265.     if (ngx_http_geo_addr(r, ctx, &addr) == NGX_OK) {

  267.         switch (addr.sockaddr->sa_family) {

  269. #if (NGX_HAVE_INET6)
  270.         case AF_INET6:
  271.             inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;

  273.             if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  274.                 p = inaddr6->s6_addr;

  276.                 inaddr = (in_addr_t) p[12] << 24;
  277.                 inaddr += p[13] << 16;
  278.                 inaddr += p[14] << 8;
  279.                 inaddr += p[15];

  281.             } else {
  282.                 inaddr = INADDR_NONE;
  283.             }

  285.             break;
  286. #endif

  288. #if (NGX_HAVE_UNIX_DOMAIN)
  289.         case AF_UNIX:
  290.             inaddr = INADDR_NONE;
  291.             break;
  292. #endif

  294.         default: /* AF_INET */
  295.             sin = (struct sockaddr_in *) addr.sockaddr;
  296.             inaddr = ntohl(sin->sin_addr.s_addr);
  297.             break;
  298.         }

  300.     } else {
  301.         inaddr = INADDR_NONE;
  302.     }

  304.     if (ctx->u.high.low) {
  305.         range = ctx->u.high.low[inaddr >> 16];

  307.         if (range) {
  308.             n = inaddr & 0xffff;
  309.             do {
  310.                 if (n >= (ngx_uint_t) range->start
  311.                     && n <= (ngx_uint_t) range->end)
  312.                 {
  313.                     *v = *range->value;
  314.                     break;
  315.                 }
  316.             } while ((++range)->value);
  317.         }
  318.     }

  320.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  321.                    "http geo: %v", v);

  323.     return NGX_OK;
  324. }


  327. static ngx_int_t
  328. ‌ngx_http_geo_addr(ngx_http_request_t *r, ngx_http_geo_ctx_t *ctx,
  329.     ngx_addr_t *addr)
  330. {
  331.     ngx_table_elt_t  *xfwd;

  333.     if (ngx_http_geo_real_addr(r, ctx, addr) != NGX_OK) {
  334.         return NGX_ERROR;
  335.     }

  337.     xfwd = r->headers_in.x_forwarded_for;

  339.     if (xfwd != NULL && ctx->proxies != NULL) {
  340.         (void) ngx_http_get_forwarded_addr(r, addr, xfwd, NULL,
  341.                                            ctx->proxies, ctx->proxy_recursive);
  342.     }

  344.     return NGX_OK;
  345. }


  348. static ngx_int_t
  349. ‌ngx_http_geo_real_addr(ngx_http_request_t *r, ngx_http_geo_ctx_t *ctx,
  350.     ngx_addr_t *addr)
  351. {
  352.     ngx_http_variable_value_t  *v;

  354.     if (ctx->index == -1) {
  355.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  356.                        "http geo started: %V", &r->connection->addr_text);

  358.         addr->sockaddr = r->connection->sockaddr;
  359.         addr->socklen = r->connection->socklen;
  360.         /* addr->name = r->connection->addr_text; */

  362.         return NGX_OK;
  363.     }

  365.     v = ngx_http_get_flushed_variable(r, ctx->index);

  367.     if (v == NULL || v->not_found) {
  368.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  369.                        "http geo not found");

  371.         return NGX_ERROR;
  372.     }

  374.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  375.                    "http geo started: %v", v);

  377.     if (ngx_parse_addr(r->pool, addr, v->data, v->len) == NGX_OK) {
  378.         return NGX_OK;
  379.     }

  381.     return NGX_ERROR;
  382. }


  385. static char *
  386. ‌ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  387. {
  388.     char                     *rv;
  389.     size_t                    len;
  390.     ngx_str_t                *value, name;
  391.     ngx_uint_t                i;
  392.     ngx_conf_t                save;
  393.     ngx_pool_t               *pool;
  394.     ngx_array_t              *a;
  395.     ngx_http_variable_t      *var;
  396.     ngx_http_geo_ctx_t       *geo;
  397.     ngx_http_geo_conf_ctx_t   ctx;
  398. #if (NGX_HAVE_INET6)
  399.     static struct in6_addr    zero;
  400. #endif

  402.     value = cf->args->elts;

  404.     geo = ngx_palloc(cf->pool, sizeof(ngx_http_geo_ctx_t));
  405.     if (geo == NULL) {
  406.         return NGX_CONF_ERROR;
  407.     }

  409.     name = value[1];

  411.     if (name.data[0] != '$') {
  412.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  413.                            "invalid variable name \"%V\"", &name);
  414.         return NGX_CONF_ERROR;
  415.     }

  417.     name.len--;
  418.     name.data++;

  420.     if (cf->args->nelts == 3) {

  422.         geo->index = ngx_http_get_variable_index(cf, &name);
  423.         if (geo->index == NGX_ERROR) {
  424.             return NGX_CONF_ERROR;
  425.         }

  427.         name = value[2];

  429.         if (name.data[0] != '$') {
  430.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  431.                                "invalid variable name \"%V\"", &name);
  432.             return NGX_CONF_ERROR;
  433.         }

  435.         name.len--;
  436.         name.data++;

  438.     } else {
  439.         geo->index = -1;
  440.     }

  442.     var = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
  443.     if (var == NULL) {
  444.         return NGX_CONF_ERROR;
  445.     }

  447.     pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
  448.     if (pool == NULL) {
  449.         return NGX_CONF_ERROR;
  450.     }

  452.     ngx_memzero(&ctx, sizeof(ngx_http_geo_conf_ctx_t));

  454.     ctx.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
  455.     if (ctx.temp_pool == NULL) {
  456.         ngx_destroy_pool(pool);
  457.         return NGX_CONF_ERROR;
  458.     }

  460.     ngx_rbtree_init(&ctx.rbtree, &ctx.sentinel, ngx_str_rbtree_insert_value);

  462.     ctx.pool = cf->pool;
  463.     ctx.data_size = sizeof(ngx_http_geo_header_t)
  464.                   + sizeof(ngx_http_variable_value_t)
  465.                   + 0x10000 * sizeof(ngx_http_geo_range_t *);
  466.     ctx.allow_binary_include = 1;
  467.     ctx.no_cacheable = 0;

  469.     save = *cf;
  470.     cf->pool = pool;
  471.     cf->ctx = &ctx;
  472.     cf->handler = ngx_http_geo;
  473.     cf->handler_conf = conf;

  475.     rv = ngx_conf_parse(cf, NULL);

  477.     *cf = save;

  479.     if (rv != NGX_CONF_OK) {
  480.         goto failed;
  481.     }

  483.     if (ctx.no_cacheable) {
  484.         var->flags |= NGX_HTTP_VAR_NOCACHEABLE;
  485.     }

  487.     geo->proxies = ctx.proxies;
  488.     geo->proxy_recursive = ctx.proxy_recursive;

  490.     if (ctx.ranges) {

  492.         if (ctx.high.low && !ctx.binary_include) {
  493.             for (i = 0; i < 0x10000; i++) {
  494.                 a = (ngx_array_t *) ctx.high.low[i];

  496.                 if (a == NULL) {
  497.                     continue;
  498.                 }

  500.                 if (a->nelts == 0) {
  501.                     ctx.high.low[i] = NULL;
  502.                     continue;
  503.                 }

  505.                 len = a->nelts * sizeof(ngx_http_geo_range_t);

  507.                 ctx.high.low[i] = ngx_palloc(cf->pool, len + sizeof(void *));
  508.                 if (ctx.high.low[i] == NULL) {
  509.                     goto failed;
  510.                 }

  512.                 ngx_memcpy(ctx.high.low[i], a->elts, len);
  513.                 ctx.high.low[i][a->nelts].value = NULL;
  514.                 ctx.data_size += len + sizeof(void *);
  515.             }

  517.             if (ctx.allow_binary_include
  518.                 && !ctx.outside_entries
  519.                 && ctx.entries > 100000
  520.                 && ctx.includes == 1)
  521.             {
  522.                 ngx_http_geo_create_binary_base(&ctx);
  523.             }
  524.         }

  526.         if (ctx.high.default_value == NULL) {
  527.             ctx.high.default_value = &ngx_http_variable_null_value;
  528.         }

  530.         geo->u.high = ctx.high;

  532.         var->get_handler = ngx_http_geo_range_variable;
  533.         var->data = (uintptr_t) geo;

  535.     } else {
  536.         if (ctx.tree == NULL) {
  537.             ctx.tree = ngx_radix_tree_create(cf->pool, -1);
  538.             if (ctx.tree == NULL) {
  539.                 goto failed;
  540.             }
  541.         }

  543.         geo->u.trees.tree = ctx.tree;

  545. #if (NGX_HAVE_INET6)
  546.         if (ctx.tree6 == NULL) {
  547.             ctx.tree6 = ngx_radix_tree_create(cf->pool, -1);
  548.             if (ctx.tree6 == NULL) {
  549.                 goto failed;
  550.             }
  551.         }

  553.         geo->u.trees.tree6 = ctx.tree6;
  554. #endif

  556.         var->get_handler = ngx_http_geo_cidr_variable;
  557.         var->data = (uintptr_t) geo;

  559.         if (ngx_radix32tree_insert(ctx.tree, 0, 0,
  560.                                    (uintptr_t) &ngx_http_variable_null_value)
  561.             == NGX_ERROR)
  562.         {
  563.             goto failed;
  564.         }

  566.         /* NGX_BUSY is okay (default was set explicitly) */

  568. #if (NGX_HAVE_INET6)
  569.         if (ngx_radix128tree_insert(ctx.tree6, zero.s6_addr, zero.s6_addr,
  570.                                     (uintptr_t) &ngx_http_variable_null_value)
  571.             == NGX_ERROR)
  572.         {
  573.             goto failed;
  574.         }
  575. #endif
  576.     }

  578.     ngx_destroy_pool(ctx.temp_pool);
  579.     ngx_destroy_pool(pool);

  581.     return NGX_CONF_OK;

  583. failed:

  585.     ngx_destroy_pool(ctx.temp_pool);
  586.     ngx_destroy_pool(pool);

  588.     return NGX_CONF_ERROR;
  589. }


  592. static char *
  593. ‌ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  594. {
  595.     char                     *rv;
  596.     ngx_str_t                *value;
  597.     ngx_cidr_t                cidr;
  598.     ngx_http_geo_conf_ctx_t  *ctx;

  600.     ctx = cf->ctx;

  602.     value = cf->args->elts;

  604.     if (cf->args->nelts == 1) {

  606.         if (ngx_strcmp(value[0].data, "ranges") == 0) {

  608.             if (ctx->tree
  609. #if (NGX_HAVE_INET6)
  610.                 || ctx->tree6
  611. #endif
  612.                )
  613.             {
  614.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  615.                                    "the \"ranges\" directive must be "
  616.                                    "the first directive inside \"geo\" block");
  617.                 goto failed;
  618.             }

  620.             ctx->ranges = 1;

  622.             rv = NGX_CONF_OK;

  624.             goto done;
  625.         }

  627.         else if (ngx_strcmp(value[0].data, "proxy_recursive") == 0) {
  628.             ctx->proxy_recursive = 1;
  629.             rv = NGX_CONF_OK;
  630.             goto done;
  631.         }

  633.         else if (ngx_strcmp(value[0].data, "volatile") == 0) {
  634.             ctx->no_cacheable = 1;
  635.             rv = NGX_CONF_OK;
  636.             goto done;
  637.         }
  638.     }

  640.     if (cf->args->nelts != 2) {
  641.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  642.                            "invalid number of the geo parameters");
  643.         goto failed;
  644.     }

  646.     if (ngx_strcmp(value[0].data, "include") == 0) {

  648.         if (strpbrk((char *) value[1].data, "*?[") == NULL) {
  649.             rv = ngx_http_geo_include(cf, ctx, &value[1]);

  651.         } else {
  652.             rv = ngx_conf_include(cf, dummy, conf);
  653.         }

  655.         goto done;

  657.     } else if (ngx_strcmp(value[0].data, "proxy") == 0) {

  659.         if (ngx_http_geo_cidr_value(cf, &value[1], &cidr) != NGX_OK) {
  660.             goto failed;
  661.         }

  663.         rv = ngx_http_geo_add_proxy(cf, ctx, &cidr);

  665.         goto done;
  666.     }

  668.     if (ctx->ranges) {
  669.         rv = ngx_http_geo_range(cf, ctx, value);

  671.     } else {
  672.         rv = ngx_http_geo_cidr(cf, ctx, value);
  673.     }

  675. done:

  677.     ngx_reset_pool(cf->pool);

  679.     return rv;

  681. failed:

  683.     ngx_reset_pool(cf->pool);

  685.     return NGX_CONF_ERROR;
  686. }


  689. static char *
  690. ‌ngx_http_geo_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  691.     ngx_str_t *value)
  692. {
  693.     u_char      *p, *last;
  694.     in_addr_t    start, end;
  695.     ngx_str_t   *net;
  696.     ngx_uint_t   del;

  698.     if (ngx_strcmp(value[0].data, "default") == 0) {

  700.         if (ctx->high.default_value) {
  701.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  702.                 "duplicate default geo range value: \"%V\", old value: \"%v\"",
  703.                 &value[1], ctx->high.default_value);
  704.         }

  706.         ctx->high.default_value = ngx_http_geo_value(cf, ctx, &value[1]);
  707.         if (ctx->high.default_value == NULL) {
  708.             return NGX_CONF_ERROR;
  709.         }

  711.         return NGX_CONF_OK;
  712.     }

  714.     if (ctx->binary_include) {
  715.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  716.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  717.             ctx->include_name.data);
  718.         return NGX_CONF_ERROR;
  719.     }

  721.     if (ctx->high.low == NULL) {
  722.         ctx->high.low = ngx_pcalloc(ctx->pool,
  723.                                     0x10000 * sizeof(ngx_http_geo_range_t *));
  724.         if (ctx->high.low == NULL) {
  725.             return NGX_CONF_ERROR;
  726.         }
  727.     }

  729.     ctx->entries++;
  730.     ctx->outside_entries = 1;

  732.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  733.         net = &value[1];
  734.         del = 1;

  736.     } else {
  737.         net = &value[0];
  738.         del = 0;
  739.     }

  741.     last = net->data + net->len;

  743.     p = ngx_strlchr(net->data, last, '-');

  745.     if (p == NULL) {
  746.         goto invalid;
  747.     }

  749.     start = ngx_inet_addr(net->data, p - net->data);

  751.     if (start == INADDR_NONE) {
  752.         goto invalid;
  753.     }

  755.     start = ntohl(start);

  757.     p++;

  759.     end = ngx_inet_addr(p, last - p);

  761.     if (end == INADDR_NONE) {
  762.         goto invalid;
  763.     }

  765.     end = ntohl(end);

  767.     if (start > end) {
  768.         goto invalid;
  769.     }

  771.     if (del) {
  772.         if (ngx_http_geo_delete_range(cf, ctx, start, end)) {
  773.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  774.                                "no address range \"%V\" to delete", net);
  775.         }

  777.         return NGX_CONF_OK;
  778.     }

  780.     ctx->value = ngx_http_geo_value(cf, ctx, &value[1]);

  782.     if (ctx->value == NULL) {
  783.         return NGX_CONF_ERROR;
  784.     }

  786.     ctx->net = net;

  788.     return ngx_http_geo_add_range(cf, ctx, start, end);

  790. invalid:

  792.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid range \"%V\"", net);

  794.     return NGX_CONF_ERROR;
  795. }


  798. /* the add procedure is optimized to add a growing up sequence */

  800. static char *
  801. ‌ngx_http_geo_add_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  802.     in_addr_t start, in_addr_t end)
  803. {
  804.     in_addr_t              n;
  805.     ngx_uint_t             h, i, s, e;
  806.     ngx_array_t           *a;
  807.     ngx_http_geo_range_t  *range;

  809.     for (n = start; n <= end; n = (n + 0x10000) & 0xffff0000) {

  811.         h = n >> 16;

  813.         if (n == start) {
  814.             s = n & 0xffff;
  815.         } else {
  816.             s = 0;
  817.         }

  819.         if ((n | 0xffff) > end) {
  820.             e = end & 0xffff;

  822.         } else {
  823.             e = 0xffff;
  824.         }

  826.         a = (ngx_array_t *) ctx->high.low[h];

  828.         if (a == NULL) {
  829.             a = ngx_array_create(ctx->temp_pool, 64,
  830.                                  sizeof(ngx_http_geo_range_t));
  831.             if (a == NULL) {
  832.                 return NGX_CONF_ERROR;
  833.             }

  835.             ctx->high.low[h] = (ngx_http_geo_range_t *) a;
  836.         }

  838.         i = a->nelts;
  839.         range = a->elts;

  841.         while (i) {

  843.             i--;

  845.             if (e < (ngx_uint_t) range[i].start) {
  846.                 continue;
  847.             }

  849.             if (s > (ngx_uint_t) range[i].end) {

  851.                 /* add after the range */

  853.                 range = ngx_array_push(a);
  854.                 if (range == NULL) {
  855.                     return NGX_CONF_ERROR;
  856.                 }

  858.                 range = a->elts;

  860.                 ngx_memmove(&range[i + 2], &range[i + 1],
  861.                             (a->nelts - 2 - i) * sizeof(ngx_http_geo_range_t));

  863.                 range[i + 1].start = (u_short) s;
  864.                 range[i + 1].end = (u_short) e;
  865.                 range[i + 1].value = ctx->value;

  867.                 goto next;
  868.             }

  870.             if (s == (ngx_uint_t) range[i].start
  871.                 && e == (ngx_uint_t) range[i].end)
  872.             {
  873.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  874.                     "duplicate range \"%V\", value: \"%v\", old value: \"%v\"",
  875.                     ctx->net, ctx->value, range[i].value);

  877.                 range[i].value = ctx->value;

  879.                 goto next;
  880.             }

  882.             if (s > (ngx_uint_t) range[i].start
  883.                 && e < (ngx_uint_t) range[i].end)
  884.             {
  885.                 /* split the range and insert the new one */

  887.                 range = ngx_array_push(a);
  888.                 if (range == NULL) {
  889.                     return NGX_CONF_ERROR;
  890.                 }

  892.                 range = ngx_array_push(a);
  893.                 if (range == NULL) {
  894.                     return NGX_CONF_ERROR;
  895.                 }

  897.                 range = a->elts;

  899.                 ngx_memmove(&range[i + 3], &range[i + 1],
  900.                             (a->nelts - 3 - i) * sizeof(ngx_http_geo_range_t));

  902.                 range[i + 2].start = (u_short) (e + 1);
  903.                 range[i + 2].end = range[i].end;
  904.                 range[i + 2].value = range[i].value;

  906.                 range[i + 1].start = (u_short) s;
  907.                 range[i + 1].end = (u_short) e;
  908.                 range[i + 1].value = ctx->value;

  910.                 range[i].end = (u_short) (s - 1);

  912.                 goto next;
  913.             }

  915.             if (s == (ngx_uint_t) range[i].start
  916.                 && e < (ngx_uint_t) range[i].end)
  917.             {
  918.                 /* shift the range start and insert the new range */

  920.                 range = ngx_array_push(a);
  921.                 if (range == NULL) {
  922.                     return NGX_CONF_ERROR;
  923.                 }

  925.                 range = a->elts;

  927.                 ngx_memmove(&range[i + 1], &range[i],
  928.                             (a->nelts - 1 - i) * sizeof(ngx_http_geo_range_t));

  930.                 range[i + 1].start = (u_short) (e + 1);

  932.                 range[i].start = (u_short) s;
  933.                 range[i].end = (u_short) e;
  934.                 range[i].value = ctx->value;

  936.                 goto next;
  937.             }

  939.             if (s > (ngx_uint_t) range[i].start
  940.                 && e == (ngx_uint_t) range[i].end)
  941.             {
  942.                 /* shift the range end and insert the new range */

  944.                 range = ngx_array_push(a);
  945.                 if (range == NULL) {
  946.                     return NGX_CONF_ERROR;
  947.                 }

  949.                 range = a->elts;

  951.                 ngx_memmove(&range[i + 2], &range[i + 1],
  952.                             (a->nelts - 2 - i) * sizeof(ngx_http_geo_range_t));

  954.                 range[i + 1].start = (u_short) s;
  955.                 range[i + 1].end = (u_short) e;
  956.                 range[i + 1].value = ctx->value;

  958.                 range[i].end = (u_short) (s - 1);

  960.                 goto next;
  961.             }

  963.             s = (ngx_uint_t) range[i].start;
  964.             e = (ngx_uint_t) range[i].end;

  966.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  967.                          "range \"%V\" overlaps \"%d.%d.%d.%d-%d.%d.%d.%d\"",
  968.                          ctx->net,
  969.                          h >> 8, h & 0xff, s >> 8, s & 0xff,
  970.                          h >> 8, h & 0xff, e >> 8, e & 0xff);

  972.             return NGX_CONF_ERROR;
  973.         }

  975.         /* add the first range */

  977.         range = ngx_array_push(a);
  978.         if (range == NULL) {
  979.             return NGX_CONF_ERROR;
  980.         }

  982.         range = a->elts;

  984.         ngx_memmove(&range[1], &range[0],
  985.                     (a->nelts - 1) * sizeof(ngx_http_geo_range_t));

  987.         range[0].start = (u_short) s;
  988.         range[0].end = (u_short) e;
  989.         range[0].value = ctx->value;

  991.     next:

  993.         if (h == 0xffff) {
  994.             break;
  995.         }
  996.     }

  998.     return NGX_CONF_OK;
  999. }


  1002. static ngx_uint_t
  1003. ‌ngx_http_geo_delete_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1004.     in_addr_t start, in_addr_t end)
  1005. {
  1006.     in_addr_t              n;
  1007.     ngx_uint_t             h, i, s, e, warn;
  1008.     ngx_array_t           *a;
  1009.     ngx_http_geo_range_t  *range;

  1011.     warn = 0;

  1013.     for (n = start; n <= end; n = (n + 0x10000) & 0xffff0000) {

  1015.         h = n >> 16;

  1017.         if (n == start) {
  1018.             s = n & 0xffff;
  1019.         } else {
  1020.             s = 0;
  1021.         }

  1023.         if ((n | 0xffff) > end) {
  1024.             e = end & 0xffff;

  1026.         } else {
  1027.             e = 0xffff;
  1028.         }

  1030.         a = (ngx_array_t *) ctx->high.low[h];

  1032.         if (a == NULL || a->nelts == 0) {
  1033.             warn = 1;
  1034.             goto next;
  1035.         }

  1037.         range = a->elts;
  1038.         for (i = 0; i < a->nelts; i++) {

  1040.             if (s == (ngx_uint_t) range[i].start
  1041.                 && e == (ngx_uint_t) range[i].end)
  1042.             {
  1043.                 ngx_memmove(&range[i], &range[i + 1],
  1044.                             (a->nelts - 1 - i) * sizeof(ngx_http_geo_range_t));

  1046.                 a->nelts--;

  1048.                 break;
  1049.             }

  1051.             if (i == a->nelts - 1) {
  1052.                 warn = 1;
  1053.             }
  1054.         }

  1056.     next:

  1058.         if (h == 0xffff) {
  1059.             break;
  1060.         }
  1061.     }

  1063.     return warn;
  1064. }


  1067. static char *
  1068. ‌ngx_http_geo_cidr(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1069.     ngx_str_t *value)
  1070. {
  1071.     char        *rv;
  1072.     ngx_int_t    rc, del;
  1073.     ngx_str_t   *net;
  1074.     ngx_cidr_t   cidr;

  1076.     if (ctx->tree == NULL) {
  1077.         ctx->tree = ngx_radix_tree_create(ctx->pool, -1);
  1078.         if (ctx->tree == NULL) {
  1079.             return NGX_CONF_ERROR;
  1080.         }
  1081.     }

  1083. #if (NGX_HAVE_INET6)
  1084.     if (ctx->tree6 == NULL) {
  1085.         ctx->tree6 = ngx_radix_tree_create(ctx->pool, -1);
  1086.         if (ctx->tree6 == NULL) {
  1087.             return NGX_CONF_ERROR;
  1088.         }
  1089.     }
  1090. #endif

  1092.     if (ngx_strcmp(value[0].data, "default") == 0) {
  1093.         cidr.family = AF_INET;
  1094.         cidr.u.in.addr = 0;
  1095.         cidr.u.in.mask = 0;

  1097.         rv = ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], &value[0]);

  1099.         if (rv != NGX_CONF_OK) {
  1100.             return rv;
  1101.         }

  1103. #if (NGX_HAVE_INET6)
  1104.         cidr.family = AF_INET6;
  1105.         ngx_memzero(&cidr.u.in6, sizeof(ngx_in6_cidr_t));

  1107.         rv = ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], &value[0]);

  1109.         if (rv != NGX_CONF_OK) {
  1110.             return rv;
  1111.         }
  1112. #endif

  1114.         return NGX_CONF_OK;
  1115.     }

  1117.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  1118.         net = &value[1];
  1119.         del = 1;

  1121.     } else {
  1122.         net = &value[0];
  1123.         del = 0;
  1124.     }

  1126.     if (ngx_http_geo_cidr_value(cf, net, &cidr) != NGX_OK) {
  1127.         return NGX_CONF_ERROR;
  1128.     }

  1130.     if (cidr.family == AF_INET) {
  1131.         cidr.u.in.addr = ntohl(cidr.u.in.addr);
  1132.         cidr.u.in.mask = ntohl(cidr.u.in.mask);
  1133.     }

  1135.     if (del) {
  1136.         switch (cidr.family) {

  1138. #if (NGX_HAVE_INET6)
  1139.         case AF_INET6:
  1140.             rc = ngx_radix128tree_delete(ctx->tree6,
  1141.                                          cidr.u.in6.addr.s6_addr,
  1142.                                          cidr.u.in6.mask.s6_addr);
  1143.             break;
  1144. #endif

  1146.         default: /* AF_INET */
  1147.             rc = ngx_radix32tree_delete(ctx->tree, cidr.u.in.addr,
  1148.                                         cidr.u.in.mask);
  1149.             break;
  1150.         }

  1152.         if (rc != NGX_OK) {
  1153.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1154.                                "no network \"%V\" to delete", net);
  1155.         }

  1157.         return NGX_CONF_OK;
  1158.     }

  1160.     return ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], net);
  1161. }


  1164. static char *
  1165. ‌ngx_http_geo_cidr_add(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1166.     ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net)
  1167. {
  1168.     ngx_int_t                   rc;
  1169.     ngx_http_variable_value_t  *val, *old;

  1171.     val = ngx_http_geo_value(cf, ctx, value);

  1173.     if (val == NULL) {
  1174.         return NGX_CONF_ERROR;
  1175.     }

  1177.     switch (cidr->family) {

  1179. #if (NGX_HAVE_INET6)
  1180.     case AF_INET6:
  1181.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1182.                                      cidr->u.in6.mask.s6_addr,
  1183.                                      (uintptr_t) val);

  1185.         if (rc == NGX_OK) {
  1186.             return NGX_CONF_OK;
  1187.         }

  1189.         if (rc == NGX_ERROR) {
  1190.             return NGX_CONF_ERROR;
  1191.         }

  1193.         /* rc == NGX_BUSY */

  1195.         old = (ngx_http_variable_value_t *)
  1196.                    ngx_radix128tree_find(ctx->tree6,
  1197.                                          cidr->u.in6.addr.s6_addr);

  1199.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1200.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1201.               net, val, old);

  1203.         rc = ngx_radix128tree_delete(ctx->tree6,
  1204.                                      cidr->u.in6.addr.s6_addr,
  1205.                                      cidr->u.in6.mask.s6_addr);

  1207.         if (rc == NGX_ERROR) {
  1208.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1209.             return NGX_CONF_ERROR;
  1210.         }

  1212.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1213.                                      cidr->u.in6.mask.s6_addr,
  1214.                                      (uintptr_t) val);

  1216.         break;
  1217. #endif

  1219.     default: /* AF_INET */
  1220.         rc = ngx_radix32tree_insert(ctx->tree, cidr->u.in.addr,
  1221.                                     cidr->u.in.mask, (uintptr_t) val);

  1223.         if (rc == NGX_OK) {
  1224.             return NGX_CONF_OK;
  1225.         }

  1227.         if (rc == NGX_ERROR) {
  1228.             return NGX_CONF_ERROR;
  1229.         }

  1231.         /* rc == NGX_BUSY */

  1233.         old = (ngx_http_variable_value_t *)
  1234.                    ngx_radix32tree_find(ctx->tree, cidr->u.in.addr);

  1236.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1237.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1238.               net, val, old);

  1240.         rc = ngx_radix32tree_delete(ctx->tree,
  1241.                                     cidr->u.in.addr, cidr->u.in.mask);

  1243.         if (rc == NGX_ERROR) {
  1244.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1245.             return NGX_CONF_ERROR;
  1246.         }

  1248.         rc = ngx_radix32tree_insert(ctx->tree, cidr->u.in.addr,
  1249.                                     cidr->u.in.mask, (uintptr_t) val);

  1251.         break;
  1252.     }

  1254.     if (rc == NGX_OK) {
  1255.         return NGX_CONF_OK;
  1256.     }

  1258.     return NGX_CONF_ERROR;
  1259. }


  1262. static ngx_http_variable_value_t *
  1263. ‌ngx_http_geo_value(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1264.     ngx_str_t *value)
  1265. {
  1266.     uint32_t                             hash;
  1267.     ngx_http_variable_value_t           *val;
  1268.     ngx_http_geo_variable_value_node_t  *gvvn;

  1270.     hash = ngx_crc32_long(value->data, value->len);

  1272.     gvvn = (ngx_http_geo_variable_value_node_t *)
  1273.                ngx_str_rbtree_lookup(&ctx->rbtree, value, hash);

  1275.     if (gvvn) {
  1276.         return gvvn->value;
  1277.     }

  1279.     val = ngx_pcalloc(ctx->pool, sizeof(ngx_http_variable_value_t));
  1280.     if (val == NULL) {
  1281.         return NULL;
  1282.     }

  1284.     val->len = value->len;
  1285.     val->data = ngx_pstrdup(ctx->pool, value);
  1286.     if (val->data == NULL) {
  1287.         return NULL;
  1288.     }

  1290.     val->valid = 1;

  1292.     gvvn = ngx_palloc(ctx->temp_pool,
  1293.                       sizeof(ngx_http_geo_variable_value_node_t));
  1294.     if (gvvn == NULL) {
  1295.         return NULL;
  1296.     }

  1298.     gvvn->sn.node.key = hash;
  1299.     gvvn->sn.str.len = val->len;
  1300.     gvvn->sn.str.data = val->data;
  1301.     gvvn->value = val;
  1302.     gvvn->offset = 0;

  1304.     ngx_rbtree_insert(&ctx->rbtree, &gvvn->sn.node);

  1306.     ctx->data_size += ngx_align(sizeof(ngx_http_variable_value_t) + value->len,
  1307.                                 sizeof(void *));

  1309.     return val;
  1310. }


  1313. static char *
  1314. ‌ngx_http_geo_add_proxy(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1315.     ngx_cidr_t *cidr)
  1316. {
  1317.     ngx_cidr_t  *c;

  1319.     if (ctx->proxies == NULL) {
  1320.         ctx->proxies = ngx_array_create(ctx->pool, 4, sizeof(ngx_cidr_t));
  1321.         if (ctx->proxies == NULL) {
  1322.             return NGX_CONF_ERROR;
  1323.         }
  1324.     }

  1326.     c = ngx_array_push(ctx->proxies);
  1327.     if (c == NULL) {
  1328.         return NGX_CONF_ERROR;
  1329.     }

  1331.     *c = *cidr;

  1333.     return NGX_CONF_OK;
  1334. }


  1337. static ngx_int_t
  1338. ‌ngx_http_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net, ngx_cidr_t *cidr)
  1339. {
  1340.     ngx_int_t  rc;

  1342.     if (ngx_strcmp(net->data, "255.255.255.255") == 0) {
  1343.         cidr->family = AF_INET;
  1344.         cidr->u.in.addr = 0xffffffff;
  1345.         cidr->u.in.mask = 0xffffffff;

  1347.         return NGX_OK;
  1348.     }

  1350.     rc = ngx_ptocidr(net, cidr);

  1352.     if (rc == NGX_ERROR) {
  1353.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid network \"%V\"", net);
  1354.         return NGX_ERROR;
  1355.     }

  1357.     if (rc == NGX_DONE) {
  1358.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1359.                            "low address bits of %V are meaningless", net);
  1360.     }

  1362.     return NGX_OK;
  1363. }


  1366. static char *
  1367. ‌ngx_http_geo_include(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1368.     ngx_str_t *name)
  1369. {
  1370.     char       *rv;
  1371.     ngx_str_t   file;

  1373.     file.len = name->len + 4;
  1374.     file.data = ngx_pnalloc(ctx->temp_pool, name->len + 5);
  1375.     if (file.data == NULL) {
  1376.         return NGX_CONF_ERROR;
  1377.     }

  1379.     ngx_sprintf(file.data, "%V.bin%Z", name);

  1381.     if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
  1382.         return NGX_CONF_ERROR;
  1383.     }

  1385.     if (ctx->ranges) {
  1386.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);

  1388.         switch (ngx_http_geo_include_binary_base(cf, ctx, &file)) {
  1389.         case NGX_OK:
  1390.             return NGX_CONF_OK;
  1391.         case NGX_ERROR:
  1392.             return NGX_CONF_ERROR;
  1393.         default:
  1394.             break;
  1395.         }
  1396.     }

  1398.     file.len -= 4;
  1399.     file.data[file.len] = '\0';

  1401.     ctx->include_name = file;

  1403.     if (ctx->outside_entries) {
  1404.         ctx->allow_binary_include = 0;
  1405.     }

  1407.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);

  1409.     rv = ngx_conf_parse(cf, &file);

  1411.     ctx->includes++;
  1412.     ctx->outside_entries = 0;

  1414.     return rv;
  1415. }


  1418. static ngx_int_t
  1419. ‌ngx_http_geo_include_binary_base(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1420.     ngx_str_t *name)
  1421. {
  1422.     u_char                     *base, ch;
  1423.     time_t                      mtime;
  1424.     size_t                      size, len;
  1425.     ssize_t                     n;
  1426.     uint32_t                    crc32;
  1427.     ngx_err_t                   err;
  1428.     ngx_int_t                   rc;
  1429.     ngx_uint_t                  i;
  1430.     ngx_file_t                  file;
  1431.     ngx_file_info_t             fi;
  1432.     ngx_http_geo_range_t       *range, **ranges;
  1433.     ngx_http_geo_header_t      *header;
  1434.     ngx_http_variable_value_t  *vv;

  1436.     ngx_memzero(&file, sizeof(ngx_file_t));
  1437.     file.name = *name;
  1438.     file.log = cf->log;

  1440.     file.fd = ngx_open_file(name->data, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);

  1442.     if (file.fd == NGX_INVALID_FILE) {
  1443.         err = ngx_errno;
  1444.         if (err != NGX_ENOENT) {
  1445.             ngx_conf_log_error(NGX_LOG_CRIT, cf, err,
  1446.                                ngx_open_file_n " \"%s\" failed", name->data);
  1447.         }
  1448.         return NGX_DECLINED;
  1449.     }

  1451.     if (ctx->outside_entries) {
  1452.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1453.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  1454.             name->data);
  1455.         rc = NGX_ERROR;
  1456.         goto done;
  1457.     }

  1459.     if (ctx->binary_include) {
  1460.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1461.             "second binary geo range base \"%s\" cannot be mixed with \"%s\"",
  1462.             name->data, ctx->include_name.data);
  1463.         rc = NGX_ERROR;
  1464.         goto done;
  1465.     }

  1467.     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  1468.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1469.                            ngx_fd_info_n " \"%s\" failed", name->data);
  1470.         goto failed;
  1471.     }

  1473.     size = (size_t) ngx_file_size(&fi);
  1474.     mtime = ngx_file_mtime(&fi);

  1476.     ch = name->data[name->len - 4];
  1477.     name->data[name->len - 4] = '\0';

  1479.     if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
  1480.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1481.                            ngx_file_info_n " \"%s\" failed", name->data);
  1482.         goto failed;
  1483.     }

  1485.     name->data[name->len - 4] = ch;

  1487.     if (mtime < ngx_file_mtime(&fi)) {
  1488.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1489.                            "stale binary geo range base \"%s\"", name->data);
  1490.         goto failed;
  1491.     }

  1493.     base = ngx_palloc(ctx->pool, size);
  1494.     if (base == NULL) {
  1495.         goto failed;
  1496.     }

  1498.     n = ngx_read_file(&file, base, size, 0);

  1500.     if (n == NGX_ERROR) {
  1501.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1502.                            ngx_read_file_n " \"%s\" failed", name->data);
  1503.         goto failed;
  1504.     }

  1506.     if ((size_t) n != size) {
  1507.         ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  1508.             ngx_read_file_n " \"%s\" returned only %z bytes instead of %z",
  1509.             name->data, n, size);
  1510.         goto failed;
  1511.     }

  1513.     header = (ngx_http_geo_header_t *) base;

  1515.     if (size < 16 || ngx_memcmp(&ngx_http_geo_header, header, 12) != 0) {
  1516.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1517.              "incompatible binary geo range base \"%s\"", name->data);
  1518.         goto failed;
  1519.     }

  1521.     ngx_crc32_init(crc32);

  1523.     vv = (ngx_http_variable_value_t *) (base + sizeof(ngx_http_geo_header_t));

  1525.     while (vv->data) {
  1526.         len = ngx_align(sizeof(ngx_http_variable_value_t) + vv->len,
  1527.                         sizeof(void *));
  1528.         ngx_crc32_update(&crc32, (u_char *) vv, len);
  1529.         vv->data += (size_t) base;
  1530.         vv = (ngx_http_variable_value_t *) ((u_char *) vv + len);
  1531.     }
  1532.     ngx_crc32_update(&crc32, (u_char *) vv, sizeof(ngx_http_variable_value_t));
  1533.     vv++;

  1535.     ranges = (ngx_http_geo_range_t **) vv;

  1537.     for (i = 0; i < 0x10000; i++) {
  1538.         ngx_crc32_update(&crc32, (u_char *) &ranges[i], sizeof(void *));
  1539.         if (ranges[i]) {
  1540.             ranges[i] = (ngx_http_geo_range_t *)
  1541.                             ((u_char *) ranges[i] + (size_t) base);
  1542.         }
  1543.     }

  1545.     range = (ngx_http_geo_range_t *) &ranges[0x10000];

  1547.     while ((u_char *) range < base + size) {
  1548.         while (range->value) {
  1549.             ngx_crc32_update(&crc32, (u_char *) range,
  1550.                              sizeof(ngx_http_geo_range_t));
  1551.             range->value = (ngx_http_variable_value_t *)
  1552.                                ((u_char *) range->value + (size_t) base);
  1553.             range++;
  1554.         }
  1555.         ngx_crc32_update(&crc32, (u_char *) range, sizeof(void *));
  1556.         range = (ngx_http_geo_range_t *) ((u_char *) range + sizeof(void *));
  1557.     }

  1559.     ngx_crc32_final(crc32);

  1561.     if (crc32 != header->crc32) {
  1562.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1563.                   "CRC32 mismatch in binary geo range base \"%s\"", name->data);
  1564.         goto failed;
  1565.     }

  1567.     ngx_conf_log_error(NGX_LOG_NOTICE, cf, 0,
  1568.                        "using binary geo range base \"%s\"", name->data);

  1570.     ctx->include_name = *name;
  1571.     ctx->binary_include = 1;
  1572.     ctx->high.low = ranges;
  1573.     rc = NGX_OK;

  1575.     goto done;

  1577. failed:

  1579.     rc = NGX_DECLINED;

  1581. done:

  1583.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  1584.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  1585.                       ngx_close_file_n " \"%s\" failed", name->data);
  1586.     }

  1588.     return rc;
  1589. }


  1592. static void
  1593. ‌ngx_http_geo_create_binary_base(ngx_http_geo_conf_ctx_t *ctx)
  1594. {
  1595.     u_char                              *p;
  1596.     uint32_t                             hash;
  1597.     ngx_str_t                            s;
  1598.     ngx_uint_t                           i;
  1599.     ngx_file_mapping_t                   fm;
  1600.     ngx_http_geo_range_t                *r, *range, **ranges;
  1601.     ngx_http_geo_header_t               *header;
  1602.     ngx_http_geo_variable_value_node_t  *gvvn;

  1604.     fm.name = ngx_pnalloc(ctx->temp_pool, ctx->include_name.len + 5);
  1605.     if (fm.name == NULL) {
  1606.         return;
  1607.     }

  1609.     ngx_sprintf(fm.name, "%V.bin%Z", &ctx->include_name);

  1611.     fm.size = ctx->data_size;
  1612.     fm.log = ctx->pool->log;

  1614.     ngx_log_error(NGX_LOG_NOTICE, fm.log, 0,
  1615.                   "creating binary geo range base \"%s\"", fm.name);

  1617.     if (ngx_create_file_mapping(&fm) != NGX_OK) {
  1618.         return;
  1619.     }

  1621.     p = ngx_cpymem(fm.addr, &ngx_http_geo_header,
  1622.                    sizeof(ngx_http_geo_header_t));

  1624.     p = ngx_http_geo_copy_values(fm.addr, p, ctx->rbtree.root,
  1625.                                  ctx->rbtree.sentinel);

  1627.     p += sizeof(ngx_http_variable_value_t);

  1629.     ranges = (ngx_http_geo_range_t **) p;

  1631.     p += 0x10000 * sizeof(ngx_http_geo_range_t *);

  1633.     for (i = 0; i < 0x10000; i++) {
  1634.         r = ctx->high.low[i];
  1635.         if (r == NULL) {
  1636.             continue;
  1637.         }

  1639.         range = (ngx_http_geo_range_t *) p;
  1640.         ranges[i] = (ngx_http_geo_range_t *) (p - (u_char *) fm.addr);

  1642.         do {
  1643.             s.len = r->value->len;
  1644.             s.data = r->value->data;
  1645.             hash = ngx_crc32_long(s.data, s.len);
  1646.             gvvn = (ngx_http_geo_variable_value_node_t *)
  1647.                         ngx_str_rbtree_lookup(&ctx->rbtree, &s, hash);

  1649.             range->value = (ngx_http_variable_value_t *) gvvn->offset;
  1650.             range->start = r->start;
  1651.             range->end = r->end;
  1652.             range++;

  1654.         } while ((++r)->value);

  1656.         range->value = NULL;

  1658.         p = (u_char *) range + sizeof(void *);
  1659.     }

  1661.     header = fm.addr;
  1662.     header->crc32 = ngx_crc32_long((u_char *) fm.addr
  1663.                                        + sizeof(ngx_http_geo_header_t),
  1664.                                    fm.size - sizeof(ngx_http_geo_header_t));

  1666.     ngx_close_file_mapping(&fm);
  1667. }


  1670. static u_char *
  1671. ‌ngx_http_geo_copy_values(u_char *base, u_char *p, ngx_rbtree_node_t *node,
  1672.     ngx_rbtree_node_t *sentinel)
  1673. {
  1674.     ngx_http_variable_value_t           *vv;
  1675.     ngx_http_geo_variable_value_node_t  *gvvn;

  1677.     if (node == sentinel) {
  1678.         return p;
  1679.     }

  1681.     gvvn = (ngx_http_geo_variable_value_node_t *) node;
  1682.     gvvn->offset = p - base;

  1684.     vv = (ngx_http_variable_value_t *) p;
  1685.     *vv = *gvvn->value;
  1686.     p += sizeof(ngx_http_variable_value_t);
  1687.     vv->data = (u_char *) (p - base);

  1689.     p = ngx_cpymem(p, gvvn->sn.str.data, gvvn->sn.str.len);

  1691.     p = ngx_align_ptr(p, sizeof(void *));

  1693.     p = ngx_http_geo_copy_values(base, p, node->left, sentinel);

  1695.     return ngx_http_geo_copy_values(base, p, node->right, sentinel);
  1696. }

One Level Up Top Level