One Level Up Top Level

src/http/modules/ngx_http_geo_module.c - nginx source code

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. ‌} ngx_http_geo_conf_ctx_t;


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

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

  78.     ngx_int_t                        index;
  79. ‌} ngx_http_geo_ctx_t;


  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);


  113. ‌static ngx_command_t  ngx_http_geo_commands[] = {

  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 },

  122.       ngx_null_command
  123. };


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

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

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

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


  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. };


  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;


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


  171. /* geo range is AF_INET only */

  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;

  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

  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.     }

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

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

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

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

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

  215.         break;
  216. #endif

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

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

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

  232.         break;
  233.     }

  235. done:

  237.     *v = *vv;

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

  242.     return NGX_OK;
  243. }


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

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

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

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

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

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

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

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

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

  284.             break;
  285. #endif

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

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

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

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

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

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

  322.     return NGX_OK;
  323. }


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

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

  336.     xfwd = r->headers_in.x_forwarded_for;

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

  343.     return NGX_OK;
  344. }


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

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

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

  361.         return NGX_OK;
  362.     }

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

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

  370.         return NGX_ERROR;
  371.     }

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

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

  380.     return NGX_ERROR;
  381. }


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

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

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

  408.     name = value[1];

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

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

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

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

  426.         name = value[2];

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

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

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

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

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

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

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

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

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

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

  473.     rv = ngx_conf_parse(cf, NULL);

  475.     *cf = save;

  477.     if (rv != NGX_CONF_OK) {
  478.         goto failed;
  479.     }

  481.     geo->proxies = ctx.proxies;
  482.     geo->proxy_recursive = ctx.proxy_recursive;

  484.     if (ctx.ranges) {

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

  490.                 if (a == NULL) {
  491.                     continue;
  492.                 }

  494.                 if (a->nelts == 0) {
  495.                     ctx.high.low[i] = NULL;
  496.                     continue;
  497.                 }

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

  501.                 ctx.high.low[i] = ngx_palloc(cf->pool, len + sizeof(void *));
  502.                 if (ctx.high.low[i] == NULL) {
  503.                     goto failed;
  504.                 }

  506.                 ngx_memcpy(ctx.high.low[i], a->elts, len);
  507.                 ctx.high.low[i][a->nelts].value = NULL;
  508.                 ctx.data_size += len + sizeof(void *);
  509.             }

  511.             if (ctx.allow_binary_include
  512.                 && !ctx.outside_entries
  513.                 && ctx.entries > 100000
  514.                 && ctx.includes == 1)
  515.             {
  516.                 ngx_http_geo_create_binary_base(&ctx);
  517.             }
  518.         }

  520.         if (ctx.high.default_value == NULL) {
  521.             ctx.high.default_value = &ngx_http_variable_null_value;
  522.         }

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

  526.         var->get_handler = ngx_http_geo_range_variable;
  527.         var->data = (uintptr_t) geo;

  529.     } else {
  530.         if (ctx.tree == NULL) {
  531.             ctx.tree = ngx_radix_tree_create(cf->pool, -1);
  532.             if (ctx.tree == NULL) {
  533.                 goto failed;
  534.             }
  535.         }

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

  539. #if (NGX_HAVE_INET6)
  540.         if (ctx.tree6 == NULL) {
  541.             ctx.tree6 = ngx_radix_tree_create(cf->pool, -1);
  542.             if (ctx.tree6 == NULL) {
  543.                 goto failed;
  544.             }
  545.         }

  547.         geo->u.trees.tree6 = ctx.tree6;
  548. #endif

  550.         var->get_handler = ngx_http_geo_cidr_variable;
  551.         var->data = (uintptr_t) geo;

  553.         if (ngx_radix32tree_insert(ctx.tree, 0, 0,
  554.                                    (uintptr_t) &ngx_http_variable_null_value)
  555.             == NGX_ERROR)
  556.         {
  557.             goto failed;
  558.         }

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

  562. #if (NGX_HAVE_INET6)
  563.         if (ngx_radix128tree_insert(ctx.tree6, zero.s6_addr, zero.s6_addr,
  564.                                     (uintptr_t) &ngx_http_variable_null_value)
  565.             == NGX_ERROR)
  566.         {
  567.             goto failed;
  568.         }
  569. #endif
  570.     }

  572.     ngx_destroy_pool(ctx.temp_pool);
  573.     ngx_destroy_pool(pool);

  575.     return NGX_CONF_OK;

  577. failed:

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

  582.     return NGX_CONF_ERROR;
  583. }


  586. static char *
  587. ‌ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  588. {
  589.     char                     *rv;
  590.     ngx_str_t                *value;
  591.     ngx_cidr_t                cidr;
  592.     ngx_http_geo_conf_ctx_t  *ctx;

  594.     ctx = cf->ctx;

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

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

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

  602.             if (ctx->tree
  603. #if (NGX_HAVE_INET6)
  604.                 || ctx->tree6
  605. #endif
  606.                )
  607.             {
  608.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  609.                                    "the \"ranges\" directive must be "
  610.                                    "the first directive inside \"geo\" block");
  611.                 goto failed;
  612.             }

  614.             ctx->ranges = 1;

  616.             rv = NGX_CONF_OK;

  618.             goto done;
  619.         }

  621.         else if (ngx_strcmp(value[0].data, "proxy_recursive") == 0) {
  622.             ctx->proxy_recursive = 1;
  623.             rv = NGX_CONF_OK;
  624.             goto done;
  625.         }
  626.     }

  628.     if (cf->args->nelts != 2) {
  629.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  630.                            "invalid number of the geo parameters");
  631.         goto failed;
  632.     }

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

  636.         rv = ngx_http_geo_include(cf, ctx, &value[1]);

  638.         goto done;

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

  642.         if (ngx_http_geo_cidr_value(cf, &value[1], &cidr) != NGX_OK) {
  643.             goto failed;
  644.         }

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

  648.         goto done;
  649.     }

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

  654.     } else {
  655.         rv = ngx_http_geo_cidr(cf, ctx, value);
  656.     }

  658. done:

  660.     ngx_reset_pool(cf->pool);

  662.     return rv;

  664. failed:

  666.     ngx_reset_pool(cf->pool);

  668.     return NGX_CONF_ERROR;
  669. }


  672. static char *
  673. ‌ngx_http_geo_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  674.     ngx_str_t *value)
  675. {
  676.     u_char      *p, *last;
  677.     in_addr_t    start, end;
  678.     ngx_str_t   *net;
  679.     ngx_uint_t   del;

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

  683.         if (ctx->high.default_value) {
  684.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  685.                 "duplicate default geo range value: \"%V\", old value: \"%v\"",
  686.                 &value[1], ctx->high.default_value);
  687.         }

  689.         ctx->high.default_value = ngx_http_geo_value(cf, ctx, &value[1]);
  690.         if (ctx->high.default_value == NULL) {
  691.             return NGX_CONF_ERROR;
  692.         }

  694.         return NGX_CONF_OK;
  695.     }

  697.     if (ctx->binary_include) {
  698.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  699.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  700.             ctx->include_name.data);
  701.         return NGX_CONF_ERROR;
  702.     }

  704.     if (ctx->high.low == NULL) {
  705.         ctx->high.low = ngx_pcalloc(ctx->pool,
  706.                                     0x10000 * sizeof(ngx_http_geo_range_t *));
  707.         if (ctx->high.low == NULL) {
  708.             return NGX_CONF_ERROR;
  709.         }
  710.     }

  712.     ctx->entries++;
  713.     ctx->outside_entries = 1;

  715.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  716.         net = &value[1];
  717.         del = 1;

  719.     } else {
  720.         net = &value[0];
  721.         del = 0;
  722.     }

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

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

  728.     if (p == NULL) {
  729.         goto invalid;
  730.     }

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

  734.     if (start == INADDR_NONE) {
  735.         goto invalid;
  736.     }

  738.     start = ntohl(start);

  740.     p++;

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

  744.     if (end == INADDR_NONE) {
  745.         goto invalid;
  746.     }

  748.     end = ntohl(end);

  750.     if (start > end) {
  751.         goto invalid;
  752.     }

  754.     if (del) {
  755.         if (ngx_http_geo_delete_range(cf, ctx, start, end)) {
  756.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  757.                                "no address range \"%V\" to delete", net);
  758.         }

  760.         return NGX_CONF_OK;
  761.     }

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

  765.     if (ctx->value == NULL) {
  766.         return NGX_CONF_ERROR;
  767.     }

  769.     ctx->net = net;

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

  773. invalid:

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

  777.     return NGX_CONF_ERROR;
  778. }


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

  783. static char *
  784. ‌ngx_http_geo_add_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  785.     in_addr_t start, in_addr_t end)
  786. {
  787.     in_addr_t              n;
  788.     ngx_uint_t             h, i, s, e;
  789.     ngx_array_t           *a;
  790.     ngx_http_geo_range_t  *range;

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

  794.         h = n >> 16;

  796.         if (n == start) {
  797.             s = n & 0xffff;
  798.         } else {
  799.             s = 0;
  800.         }

  802.         if ((n | 0xffff) > end) {
  803.             e = end & 0xffff;

  805.         } else {
  806.             e = 0xffff;
  807.         }

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

  811.         if (a == NULL) {
  812.             a = ngx_array_create(ctx->temp_pool, 64,
  813.                                  sizeof(ngx_http_geo_range_t));
  814.             if (a == NULL) {
  815.                 return NGX_CONF_ERROR;
  816.             }

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

  821.         i = a->nelts;
  822.         range = a->elts;

  824.         while (i) {

  826.             i--;

  828.             if (e < (ngx_uint_t) range[i].start) {
  829.                 continue;
  830.             }

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

  834.                 /* add after the range */

  836.                 range = ngx_array_push(a);
  837.                 if (range == NULL) {
  838.                     return NGX_CONF_ERROR;
  839.                 }

  841.                 range = a->elts;

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

  846.                 range[i + 1].start = (u_short) s;
  847.                 range[i + 1].end = (u_short) e;
  848.                 range[i + 1].value = ctx->value;

  850.                 goto next;
  851.             }

  853.             if (s == (ngx_uint_t) range[i].start
  854.                 && e == (ngx_uint_t) range[i].end)
  855.             {
  856.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  857.                     "duplicate range \"%V\", value: \"%v\", old value: \"%v\"",
  858.                     ctx->net, ctx->value, range[i].value);

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

  862.                 goto next;
  863.             }

  865.             if (s > (ngx_uint_t) range[i].start
  866.                 && e < (ngx_uint_t) range[i].end)
  867.             {
  868.                 /* split the range and insert the new one */

  870.                 range = ngx_array_push(a);
  871.                 if (range == NULL) {
  872.                     return NGX_CONF_ERROR;
  873.                 }

  875.                 range = ngx_array_push(a);
  876.                 if (range == NULL) {
  877.                     return NGX_CONF_ERROR;
  878.                 }

  880.                 range = a->elts;

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

  885.                 range[i + 2].start = (u_short) (e + 1);
  886.                 range[i + 2].end = range[i].end;
  887.                 range[i + 2].value = range[i].value;

  889.                 range[i + 1].start = (u_short) s;
  890.                 range[i + 1].end = (u_short) e;
  891.                 range[i + 1].value = ctx->value;

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

  895.                 goto next;
  896.             }

  898.             if (s == (ngx_uint_t) range[i].start
  899.                 && e < (ngx_uint_t) range[i].end)
  900.             {
  901.                 /* shift the range start and insert the new range */

  903.                 range = ngx_array_push(a);
  904.                 if (range == NULL) {
  905.                     return NGX_CONF_ERROR;
  906.                 }

  908.                 range = a->elts;

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

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

  915.                 range[i].start = (u_short) s;
  916.                 range[i].end = (u_short) e;
  917.                 range[i].value = ctx->value;

  919.                 goto next;
  920.             }

  922.             if (s > (ngx_uint_t) range[i].start
  923.                 && e == (ngx_uint_t) range[i].end)
  924.             {
  925.                 /* shift the range end and insert the new range */

  927.                 range = ngx_array_push(a);
  928.                 if (range == NULL) {
  929.                     return NGX_CONF_ERROR;
  930.                 }

  932.                 range = a->elts;

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

  937.                 range[i + 1].start = (u_short) s;
  938.                 range[i + 1].end = (u_short) e;
  939.                 range[i + 1].value = ctx->value;

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

  943.                 goto next;
  944.             }

  946.             s = (ngx_uint_t) range[i].start;
  947.             e = (ngx_uint_t) range[i].end;

  949.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  950.                          "range \"%V\" overlaps \"%d.%d.%d.%d-%d.%d.%d.%d\"",
  951.                          ctx->net,
  952.                          h >> 8, h & 0xff, s >> 8, s & 0xff,
  953.                          h >> 8, h & 0xff, e >> 8, e & 0xff);

  955.             return NGX_CONF_ERROR;
  956.         }

  958.         /* add the first range */

  960.         range = ngx_array_push(a);
  961.         if (range == NULL) {
  962.             return NGX_CONF_ERROR;
  963.         }

  965.         range = a->elts;

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

  970.         range[0].start = (u_short) s;
  971.         range[0].end = (u_short) e;
  972.         range[0].value = ctx->value;

  974.     next:

  976.         if (h == 0xffff) {
  977.             break;
  978.         }
  979.     }

  981.     return NGX_CONF_OK;
  982. }


  985. static ngx_uint_t
  986. ‌ngx_http_geo_delete_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  987.     in_addr_t start, in_addr_t end)
  988. {
  989.     in_addr_t              n;
  990.     ngx_uint_t             h, i, s, e, warn;
  991.     ngx_array_t           *a;
  992.     ngx_http_geo_range_t  *range;

  994.     warn = 0;

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

  998.         h = n >> 16;

  1000.         if (n == start) {
  1001.             s = n & 0xffff;
  1002.         } else {
  1003.             s = 0;
  1004.         }

  1006.         if ((n | 0xffff) > end) {
  1007.             e = end & 0xffff;

  1009.         } else {
  1010.             e = 0xffff;
  1011.         }

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

  1015.         if (a == NULL || a->nelts == 0) {
  1016.             warn = 1;
  1017.             goto next;
  1018.         }

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

  1023.             if (s == (ngx_uint_t) range[i].start
  1024.                 && e == (ngx_uint_t) range[i].end)
  1025.             {
  1026.                 ngx_memmove(&range[i], &range[i + 1],
  1027.                             (a->nelts - 1 - i) * sizeof(ngx_http_geo_range_t));

  1029.                 a->nelts--;

  1031.                 break;
  1032.             }

  1034.             if (i == a->nelts - 1) {
  1035.                 warn = 1;
  1036.             }
  1037.         }

  1039.     next:

  1041.         if (h == 0xffff) {
  1042.             break;
  1043.         }
  1044.     }

  1046.     return warn;
  1047. }


  1050. static char *
  1051. ‌ngx_http_geo_cidr(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1052.     ngx_str_t *value)
  1053. {
  1054.     char        *rv;
  1055.     ngx_int_t    rc, del;
  1056.     ngx_str_t   *net;
  1057.     ngx_cidr_t   cidr;

  1059.     if (ctx->tree == NULL) {
  1060.         ctx->tree = ngx_radix_tree_create(ctx->pool, -1);
  1061.         if (ctx->tree == NULL) {
  1062.             return NGX_CONF_ERROR;
  1063.         }
  1064.     }

  1066. #if (NGX_HAVE_INET6)
  1067.     if (ctx->tree6 == NULL) {
  1068.         ctx->tree6 = ngx_radix_tree_create(ctx->pool, -1);
  1069.         if (ctx->tree6 == NULL) {
  1070.             return NGX_CONF_ERROR;
  1071.         }
  1072.     }
  1073. #endif

  1075.     if (ngx_strcmp(value[0].data, "default") == 0) {
  1076.         cidr.family = AF_INET;
  1077.         cidr.u.in.addr = 0;
  1078.         cidr.u.in.mask = 0;

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

  1082.         if (rv != NGX_CONF_OK) {
  1083.             return rv;
  1084.         }

  1086. #if (NGX_HAVE_INET6)
  1087.         cidr.family = AF_INET6;
  1088.         ngx_memzero(&cidr.u.in6, sizeof(ngx_in6_cidr_t));

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

  1092.         if (rv != NGX_CONF_OK) {
  1093.             return rv;
  1094.         }
  1095. #endif

  1097.         return NGX_CONF_OK;
  1098.     }

  1100.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  1101.         net = &value[1];
  1102.         del = 1;

  1104.     } else {
  1105.         net = &value[0];
  1106.         del = 0;
  1107.     }

  1109.     if (ngx_http_geo_cidr_value(cf, net, &cidr) != NGX_OK) {
  1110.         return NGX_CONF_ERROR;
  1111.     }

  1113.     if (cidr.family == AF_INET) {
  1114.         cidr.u.in.addr = ntohl(cidr.u.in.addr);
  1115.         cidr.u.in.mask = ntohl(cidr.u.in.mask);
  1116.     }

  1118.     if (del) {
  1119.         switch (cidr.family) {

  1121. #if (NGX_HAVE_INET6)
  1122.         case AF_INET6:
  1123.             rc = ngx_radix128tree_delete(ctx->tree6,
  1124.                                          cidr.u.in6.addr.s6_addr,
  1125.                                          cidr.u.in6.mask.s6_addr);
  1126.             break;
  1127. #endif

  1129.         default: /* AF_INET */
  1130.             rc = ngx_radix32tree_delete(ctx->tree, cidr.u.in.addr,
  1131.                                         cidr.u.in.mask);
  1132.             break;
  1133.         }

  1135.         if (rc != NGX_OK) {
  1136.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1137.                                "no network \"%V\" to delete", net);
  1138.         }

  1140.         return NGX_CONF_OK;
  1141.     }

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


  1147. static char *
  1148. ‌ngx_http_geo_cidr_add(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1149.     ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net)
  1150. {
  1151.     ngx_int_t                   rc;
  1152.     ngx_http_variable_value_t  *val, *old;

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

  1156.     if (val == NULL) {
  1157.         return NGX_CONF_ERROR;
  1158.     }

  1160.     switch (cidr->family) {

  1162. #if (NGX_HAVE_INET6)
  1163.     case AF_INET6:
  1164.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1165.                                      cidr->u.in6.mask.s6_addr,
  1166.                                      (uintptr_t) val);

  1168.         if (rc == NGX_OK) {
  1169.             return NGX_CONF_OK;
  1170.         }

  1172.         if (rc == NGX_ERROR) {
  1173.             return NGX_CONF_ERROR;
  1174.         }

  1176.         /* rc == NGX_BUSY */

  1178.         old = (ngx_http_variable_value_t *)
  1179.                    ngx_radix128tree_find(ctx->tree6,
  1180.                                          cidr->u.in6.addr.s6_addr);

  1182.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1183.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1184.               net, val, old);

  1186.         rc = ngx_radix128tree_delete(ctx->tree6,
  1187.                                      cidr->u.in6.addr.s6_addr,
  1188.                                      cidr->u.in6.mask.s6_addr);

  1190.         if (rc == NGX_ERROR) {
  1191.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1192.             return NGX_CONF_ERROR;
  1193.         }

  1195.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1196.                                      cidr->u.in6.mask.s6_addr,
  1197.                                      (uintptr_t) val);

  1199.         break;
  1200. #endif

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

  1206.         if (rc == NGX_OK) {
  1207.             return NGX_CONF_OK;
  1208.         }

  1210.         if (rc == NGX_ERROR) {
  1211.             return NGX_CONF_ERROR;
  1212.         }

  1214.         /* rc == NGX_BUSY */

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

  1219.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1220.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1221.               net, val, old);

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

  1226.         if (rc == NGX_ERROR) {
  1227.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1228.             return NGX_CONF_ERROR;
  1229.         }

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

  1234.         break;
  1235.     }

  1237.     if (rc == NGX_OK) {
  1238.         return NGX_CONF_OK;
  1239.     }

  1241.     return NGX_CONF_ERROR;
  1242. }


  1245. static ngx_http_variable_value_t *
  1246. ‌ngx_http_geo_value(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1247.     ngx_str_t *value)
  1248. {
  1249.     uint32_t                             hash;
  1250.     ngx_http_variable_value_t           *val;
  1251.     ngx_http_geo_variable_value_node_t  *gvvn;

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

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

  1258.     if (gvvn) {
  1259.         return gvvn->value;
  1260.     }

  1262.     val = ngx_pcalloc(ctx->pool, sizeof(ngx_http_variable_value_t));
  1263.     if (val == NULL) {
  1264.         return NULL;
  1265.     }

  1267.     val->len = value->len;
  1268.     val->data = ngx_pstrdup(ctx->pool, value);
  1269.     if (val->data == NULL) {
  1270.         return NULL;
  1271.     }

  1273.     val->valid = 1;

  1275.     gvvn = ngx_palloc(ctx->temp_pool,
  1276.                       sizeof(ngx_http_geo_variable_value_node_t));
  1277.     if (gvvn == NULL) {
  1278.         return NULL;
  1279.     }

  1281.     gvvn->sn.node.key = hash;
  1282.     gvvn->sn.str.len = val->len;
  1283.     gvvn->sn.str.data = val->data;
  1284.     gvvn->value = val;
  1285.     gvvn->offset = 0;

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

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

  1292.     return val;
  1293. }


  1296. static char *
  1297. ‌ngx_http_geo_add_proxy(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1298.     ngx_cidr_t *cidr)
  1299. {
  1300.     ngx_cidr_t  *c;

  1302.     if (ctx->proxies == NULL) {
  1303.         ctx->proxies = ngx_array_create(ctx->pool, 4, sizeof(ngx_cidr_t));
  1304.         if (ctx->proxies == NULL) {
  1305.             return NGX_CONF_ERROR;
  1306.         }
  1307.     }

  1309.     c = ngx_array_push(ctx->proxies);
  1310.     if (c == NULL) {
  1311.         return NGX_CONF_ERROR;
  1312.     }

  1314.     *c = *cidr;

  1316.     return NGX_CONF_OK;
  1317. }


  1320. static ngx_int_t
  1321. ‌ngx_http_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net, ngx_cidr_t *cidr)
  1322. {
  1323.     ngx_int_t  rc;

  1325.     if (ngx_strcmp(net->data, "255.255.255.255") == 0) {
  1326.         cidr->family = AF_INET;
  1327.         cidr->u.in.addr = 0xffffffff;
  1328.         cidr->u.in.mask = 0xffffffff;

  1330.         return NGX_OK;
  1331.     }

  1333.     rc = ngx_ptocidr(net, cidr);

  1335.     if (rc == NGX_ERROR) {
  1336.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid network \"%V\"", net);
  1337.         return NGX_ERROR;
  1338.     }

  1340.     if (rc == NGX_DONE) {
  1341.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1342.                            "low address bits of %V are meaningless", net);
  1343.     }

  1345.     return NGX_OK;
  1346. }


  1349. static char *
  1350. ‌ngx_http_geo_include(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1351.     ngx_str_t *name)
  1352. {
  1353.     char       *rv;
  1354.     ngx_str_t   file;

  1356.     file.len = name->len + 4;
  1357.     file.data = ngx_pnalloc(ctx->temp_pool, name->len + 5);
  1358.     if (file.data == NULL) {
  1359.         return NGX_CONF_ERROR;
  1360.     }

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

  1364.     if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
  1365.         return NGX_CONF_ERROR;
  1366.     }

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

  1371.         switch (ngx_http_geo_include_binary_base(cf, ctx, &file)) {
  1372.         case NGX_OK:
  1373.             return NGX_CONF_OK;
  1374.         case NGX_ERROR:
  1375.             return NGX_CONF_ERROR;
  1376.         default:
  1377.             break;
  1378.         }
  1379.     }

  1381.     file.len -= 4;
  1382.     file.data[file.len] = '\0';

  1384.     ctx->include_name = file;

  1386.     if (ctx->outside_entries) {
  1387.         ctx->allow_binary_include = 0;
  1388.     }

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

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

  1394.     ctx->includes++;
  1395.     ctx->outside_entries = 0;

  1397.     return rv;
  1398. }


  1401. static ngx_int_t
  1402. ‌ngx_http_geo_include_binary_base(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
  1403.     ngx_str_t *name)
  1404. {
  1405.     u_char                     *base, ch;
  1406.     time_t                      mtime;
  1407.     size_t                      size, len;
  1408.     ssize_t                     n;
  1409.     uint32_t                    crc32;
  1410.     ngx_err_t                   err;
  1411.     ngx_int_t                   rc;
  1412.     ngx_uint_t                  i;
  1413.     ngx_file_t                  file;
  1414.     ngx_file_info_t             fi;
  1415.     ngx_http_geo_range_t       *range, **ranges;
  1416.     ngx_http_geo_header_t      *header;
  1417.     ngx_http_variable_value_t  *vv;

  1419.     ngx_memzero(&file, sizeof(ngx_file_t));
  1420.     file.name = *name;
  1421.     file.log = cf->log;

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

  1425.     if (file.fd == NGX_INVALID_FILE) {
  1426.         err = ngx_errno;
  1427.         if (err != NGX_ENOENT) {
  1428.             ngx_conf_log_error(NGX_LOG_CRIT, cf, err,
  1429.                                ngx_open_file_n " \"%s\" failed", name->data);
  1430.         }
  1431.         return NGX_DECLINED;
  1432.     }

  1434.     if (ctx->outside_entries) {
  1435.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1436.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  1437.             name->data);
  1438.         rc = NGX_ERROR;
  1439.         goto done;
  1440.     }

  1442.     if (ctx->binary_include) {
  1443.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1444.             "second binary geo range base \"%s\" cannot be mixed with \"%s\"",
  1445.             name->data, ctx->include_name.data);
  1446.         rc = NGX_ERROR;
  1447.         goto done;
  1448.     }

  1450.     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  1451.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1452.                            ngx_fd_info_n " \"%s\" failed", name->data);
  1453.         goto failed;
  1454.     }

  1456.     size = (size_t) ngx_file_size(&fi);
  1457.     mtime = ngx_file_mtime(&fi);

  1459.     ch = name->data[name->len - 4];
  1460.     name->data[name->len - 4] = '\0';

  1462.     if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
  1463.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1464.                            ngx_file_info_n " \"%s\" failed", name->data);
  1465.         goto failed;
  1466.     }

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

  1470.     if (mtime < ngx_file_mtime(&fi)) {
  1471.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1472.                            "stale binary geo range base \"%s\"", name->data);
  1473.         goto failed;
  1474.     }

  1476.     base = ngx_palloc(ctx->pool, size);
  1477.     if (base == NULL) {
  1478.         goto failed;
  1479.     }

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

  1483.     if (n == NGX_ERROR) {
  1484.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1485.                            ngx_read_file_n " \"%s\" failed", name->data);
  1486.         goto failed;
  1487.     }

  1489.     if ((size_t) n != size) {
  1490.         ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  1491.             ngx_read_file_n " \"%s\" returned only %z bytes instead of %z",
  1492.             name->data, n, size);
  1493.         goto failed;
  1494.     }

  1496.     header = (ngx_http_geo_header_t *) base;

  1498.     if (size < 16 || ngx_memcmp(&ngx_http_geo_header, header, 12) != 0) {
  1499.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1500.              "incompatible binary geo range base \"%s\"", name->data);
  1501.         goto failed;
  1502.     }

  1504.     ngx_crc32_init(crc32);

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

  1508.     while (vv->data) {
  1509.         len = ngx_align(sizeof(ngx_http_variable_value_t) + vv->len,
  1510.                         sizeof(void *));
  1511.         ngx_crc32_update(&crc32, (u_char *) vv, len);
  1512.         vv->data += (size_t) base;
  1513.         vv = (ngx_http_variable_value_t *) ((u_char *) vv + len);
  1514.     }
  1515.     ngx_crc32_update(&crc32, (u_char *) vv, sizeof(ngx_http_variable_value_t));
  1516.     vv++;

  1518.     ranges = (ngx_http_geo_range_t **) vv;

  1520.     for (i = 0; i < 0x10000; i++) {
  1521.         ngx_crc32_update(&crc32, (u_char *) &ranges[i], sizeof(void *));
  1522.         if (ranges[i]) {
  1523.             ranges[i] = (ngx_http_geo_range_t *)
  1524.                             ((u_char *) ranges[i] + (size_t) base);
  1525.         }
  1526.     }

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

  1530.     while ((u_char *) range < base + size) {
  1531.         while (range->value) {
  1532.             ngx_crc32_update(&crc32, (u_char *) range,
  1533.                              sizeof(ngx_http_geo_range_t));
  1534.             range->value = (ngx_http_variable_value_t *)
  1535.                                ((u_char *) range->value + (size_t) base);
  1536.             range++;
  1537.         }
  1538.         ngx_crc32_update(&crc32, (u_char *) range, sizeof(void *));
  1539.         range = (ngx_http_geo_range_t *) ((u_char *) range + sizeof(void *));
  1540.     }

  1542.     ngx_crc32_final(crc32);

  1544.     if (crc32 != header->crc32) {
  1545.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1546.                   "CRC32 mismatch in binary geo range base \"%s\"", name->data);
  1547.         goto failed;
  1548.     }

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

  1553.     ctx->include_name = *name;
  1554.     ctx->binary_include = 1;
  1555.     ctx->high.low = ranges;
  1556.     rc = NGX_OK;

  1558.     goto done;

  1560. failed:

  1562.     rc = NGX_DECLINED;

  1564. done:

  1566.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  1567.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  1568.                       ngx_close_file_n " \"%s\" failed", name->data);
  1569.     }

  1571.     return rc;
  1572. }


  1575. static void
  1576. ‌ngx_http_geo_create_binary_base(ngx_http_geo_conf_ctx_t *ctx)
  1577. {
  1578.     u_char                              *p;
  1579.     uint32_t                             hash;
  1580.     ngx_str_t                            s;
  1581.     ngx_uint_t                           i;
  1582.     ngx_file_mapping_t                   fm;
  1583.     ngx_http_geo_range_t                *r, *range, **ranges;
  1584.     ngx_http_geo_header_t               *header;
  1585.     ngx_http_geo_variable_value_node_t  *gvvn;

  1587.     fm.name = ngx_pnalloc(ctx->temp_pool, ctx->include_name.len + 5);
  1588.     if (fm.name == NULL) {
  1589.         return;
  1590.     }

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

  1594.     fm.size = ctx->data_size;
  1595.     fm.log = ctx->pool->log;

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

  1600.     if (ngx_create_file_mapping(&fm) != NGX_OK) {
  1601.         return;
  1602.     }

  1604.     p = ngx_cpymem(fm.addr, &ngx_http_geo_header,
  1605.                    sizeof(ngx_http_geo_header_t));

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

  1610.     p += sizeof(ngx_http_variable_value_t);

  1612.     ranges = (ngx_http_geo_range_t **) p;

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

  1616.     for (i = 0; i < 0x10000; i++) {
  1617.         r = ctx->high.low[i];
  1618.         if (r == NULL) {
  1619.             continue;
  1620.         }

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

  1625.         do {
  1626.             s.len = r->value->len;
  1627.             s.data = r->value->data;
  1628.             hash = ngx_crc32_long(s.data, s.len);
  1629.             gvvn = (ngx_http_geo_variable_value_node_t *)
  1630.                         ngx_str_rbtree_lookup(&ctx->rbtree, &s, hash);

  1632.             range->value = (ngx_http_variable_value_t *) gvvn->offset;
  1633.             range->start = r->start;
  1634.             range->end = r->end;
  1635.             range++;

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

  1639.         range->value = NULL;

  1641.         p = (u_char *) range + sizeof(void *);
  1642.     }

  1644.     header = fm.addr;
  1645.     header->crc32 = ngx_crc32_long((u_char *) fm.addr
  1646.                                        + sizeof(ngx_http_geo_header_t),
  1647.                                    fm.size - sizeof(ngx_http_geo_header_t));

  1649.     ngx_close_file_mapping(&fm);
  1650. }


  1653. static u_char *
  1654. ‌ngx_http_geo_copy_values(u_char *base, u_char *p, ngx_rbtree_node_t *node,
  1655.     ngx_rbtree_node_t *sentinel)
  1656. {
  1657.     ngx_http_variable_value_t           *vv;
  1658.     ngx_http_geo_variable_value_node_t  *gvvn;

  1660.     if (node == sentinel) {
  1661.         return p;
  1662.     }

  1664.     gvvn = (ngx_http_geo_variable_value_node_t *) node;
  1665.     gvvn->offset = p - base;

  1667.     vv = (ngx_http_variable_value_t *) p;
  1668.     *vv = *gvvn->value;
  1669.     p += sizeof(ngx_http_variable_value_t);
  1670.     vv->data = (u_char *) (p - base);

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

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

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

  1678.     return ngx_http_geo_copy_values(base, p, node->right, sentinel);
  1679. }

One Level Up Top Level