Back to home page

Nginx displayed by LXR

Source navigation ]
Diff markup ]
Identifier search ]
general search ]
 
 
Version: nginx-1.13.12 ]​[ nginx-1.12.2 ]​

0001 
0002 /*
0003  * Copyright (C) Igor Sysoev
0004  * Copyright (C) Nginx, Inc.
0005  */
0006 
0007 
0008 #include <ngx_config.h>
0009 #include <ngx_core.h>
0010 #include <ngx_http.h>
0011 
0012 
0013 typedef struct {
0014     ngx_http_variable_value_t       *value;
0015     u_short                          start;
0016     u_short                          end;
0017 } ngx_http_geo_range_t;
0018 
0019 
0020 typedef struct {
0021     ngx_radix_tree_t                *tree;
0022 #if (NGX_HAVE_INET6)
0023     ngx_radix_tree_t                *tree6;
0024 #endif
0025 } ngx_http_geo_trees_t;
0026 
0027 
0028 typedef struct {
0029     ngx_http_geo_range_t           **low;
0030     ngx_http_variable_value_t       *default_value;
0031 } ngx_http_geo_high_ranges_t;
0032 
0033 
0034 typedef struct {
0035     ngx_str_node_t                   sn;
0036     ngx_http_variable_value_t       *value;
0037     size_t                           offset;
0038 } ngx_http_geo_variable_value_node_t;
0039 
0040 
0041 typedef struct {
0042     ngx_http_variable_value_t       *value;
0043     ngx_str_t                       *net;
0044     ngx_http_geo_high_ranges_t       high;
0045     ngx_radix_tree_t                *tree;
0046 #if (NGX_HAVE_INET6)
0047     ngx_radix_tree_t                *tree6;
0048 #endif
0049     ngx_rbtree_t                     rbtree;
0050     ngx_rbtree_node_t                sentinel;
0051     ngx_array_t                     *proxies;
0052     ngx_pool_t                      *pool;
0053     ngx_pool_t                      *temp_pool;
0054 
0055     size_t                           data_size;
0056 
0057     ngx_str_t                        include_name;
0058     ngx_uint_t                       includes;
0059     ngx_uint_t                       entries;
0060 
0061     unsigned                         ranges:1;
0062     unsigned                         outside_entries:1;
0063     unsigned                         allow_binary_include:1;
0064     unsigned                         binary_include:1;
0065     unsigned                         proxy_recursive:1;
0066 } ngx_http_geo_conf_ctx_t;
0067 
0068 
0069 typedef struct {
0070     union {
0071         ngx_http_geo_trees_t         trees;
0072         ngx_http_geo_high_ranges_t   high;
0073     } u;
0074 
0075     ngx_array_t                     *proxies;
0076     unsigned                         proxy_recursive:1;
0077 
0078     ngx_int_t                        index;
0079 } ngx_http_geo_ctx_t;
0080 
0081 
0082 static ngx_int_t ngx_http_geo_addr(ngx_http_request_t *r,
0083     ngx_http_geo_ctx_t *ctx, ngx_addr_t *addr);
0084 static ngx_int_t ngx_http_geo_real_addr(ngx_http_request_t *r,
0085     ngx_http_geo_ctx_t *ctx, ngx_addr_t *addr);
0086 static char *ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
0087 static char *ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf);
0088 static char *ngx_http_geo_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
0089     ngx_str_t *value);
0090 static char *ngx_http_geo_add_range(ngx_conf_t *cf,
0091     ngx_http_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
0092 static ngx_uint_t ngx_http_geo_delete_range(ngx_conf_t *cf,
0093     ngx_http_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
0094 static char *ngx_http_geo_cidr(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
0095     ngx_str_t *value);
0096 static char *ngx_http_geo_cidr_add(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
0097     ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net);
0098 static ngx_http_variable_value_t *ngx_http_geo_value(ngx_conf_t *cf,
0099     ngx_http_geo_conf_ctx_t *ctx, ngx_str_t *value);
0100 static char *ngx_http_geo_add_proxy(ngx_conf_t *cf,
0101     ngx_http_geo_conf_ctx_t *ctx, ngx_cidr_t *cidr);
0102 static ngx_int_t ngx_http_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net,
0103     ngx_cidr_t *cidr);
0104 static char *ngx_http_geo_include(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
0105     ngx_str_t *name);
0106 static ngx_int_t ngx_http_geo_include_binary_base(ngx_conf_t *cf,
0107     ngx_http_geo_conf_ctx_t *ctx, ngx_str_t *name);
0108 static void ngx_http_geo_create_binary_base(ngx_http_geo_conf_ctx_t *ctx);
0109 static u_char *ngx_http_geo_copy_values(u_char *base, u_char *p,
0110     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
0111 
0112 
0113 static ngx_command_t  ngx_http_geo_commands[] = {
0114 
0115     { ngx_string("geo"),
0116       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
0117       ngx_http_geo_block,
0118       NGX_HTTP_MAIN_CONF_OFFSET,
0119       0,
0120       NULL },
0121 
0122       ngx_null_command
0123 };
0124 
0125 
0126 static ngx_http_module_t  ngx_http_geo_module_ctx = {
0127     NULL,                                  /* preconfiguration */
0128     NULL,                                  /* postconfiguration */
0129 
0130     NULL,                                  /* create main configuration */
0131     NULL,                                  /* init main configuration */
0132 
0133     NULL,                                  /* create server configuration */
0134     NULL,                                  /* merge server configuration */
0135 
0136     NULL,                                  /* create location configuration */
0137     NULL                                   /* merge location configuration */
0138 };
0139 
0140 
0141 ngx_module_t  ngx_http_geo_module = {
0142     NGX_MODULE_V1,
0143     &ngx_http_geo_module_ctx,              /* module context */
0144     ngx_http_geo_commands,                 /* module directives */
0145     NGX_HTTP_MODULE,                       /* module type */
0146     NULL,                                  /* init master */
0147     NULL,                                  /* init module */
0148     NULL,                                  /* init process */
0149     NULL,                                  /* init thread */
0150     NULL,                                  /* exit thread */
0151     NULL,                                  /* exit process */
0152     NULL,                                  /* exit master */
0153     NGX_MODULE_V1_PADDING
0154 };
0155 
0156 
0157 typedef struct {
0158     u_char    GEORNG[6];
0159     u_char    version;
0160     u_char    ptr_size;
0161     uint32_t  endianness;
0162     uint32_t  crc32;
0163 } ngx_http_geo_header_t;
0164 
0165 
0166 static ngx_http_geo_header_t  ngx_http_geo_header = {
0167     { 'G', 'E', 'O', 'R', 'N', 'G' }, 0, sizeof(void *), 0x12345678, 0
0168 };
0169 
0170 
0171 /* geo range is AF_INET only */
0172 
0173 static ngx_int_t
0174 ngx_http_geo_cidr_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
0175     uintptr_t data)
0176 {
0177     ngx_http_geo_ctx_t *ctx = (ngx_http_geo_ctx_t *) data;
0178 
0179     in_addr_t                   inaddr;
0180     ngx_addr_t                  addr;
0181     struct sockaddr_in         *sin;
0182     ngx_http_variable_value_t  *vv;
0183 #if (NGX_HAVE_INET6)
0184     u_char                     *p;
0185     struct in6_addr            *inaddr6;
0186 #endif
0187 
0188     if (ngx_http_geo_addr(r, ctx, &addr) != NGX_OK) {
0189         vv = (ngx_http_variable_value_t *)
0190                   ngx_radix32tree_find(ctx->u.trees.tree, INADDR_NONE);
0191         goto done;
0192     }
0193 
0194     switch (addr.sockaddr->sa_family) {
0195 
0196 #if (NGX_HAVE_INET6)
0197     case AF_INET6:
0198         inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;
0199         p = inaddr6->s6_addr;
0200 
0201         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
0202             inaddr = p[12] << 24;
0203             inaddr += p[13] << 16;
0204             inaddr += p[14] << 8;
0205             inaddr += p[15];
0206 
0207             vv = (ngx_http_variable_value_t *)
0208                       ngx_radix32tree_find(ctx->u.trees.tree, inaddr);
0209 
0210         } else {
0211             vv = (ngx_http_variable_value_t *)
0212                       ngx_radix128tree_find(ctx->u.trees.tree6, p);
0213         }
0214 
0215         break;
0216 #endif
0217 
0218     default: /* AF_INET */
0219         sin = (struct sockaddr_in *) addr.sockaddr;
0220         inaddr = ntohl(sin->sin_addr.s_addr);
0221 
0222         vv = (ngx_http_variable_value_t *)
0223                   ngx_radix32tree_find(ctx->u.trees.tree, inaddr);
0224 
0225         break;
0226     }
0227 
0228 done:
0229 
0230     *v = *vv;
0231 
0232     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
0233                    "http geo: %v", v);
0234 
0235     return NGX_OK;
0236 }
0237 
0238 
0239 static ngx_int_t
0240 ngx_http_geo_range_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
0241     uintptr_t data)
0242 {
0243     ngx_http_geo_ctx_t *ctx = (ngx_http_geo_ctx_t *) data;
0244 
0245     in_addr_t              inaddr;
0246     ngx_addr_t             addr;
0247     ngx_uint_t             n;
0248     struct sockaddr_in    *sin;
0249     ngx_http_geo_range_t  *range;
0250 #if (NGX_HAVE_INET6)
0251     u_char                *p;
0252     struct in6_addr       *inaddr6;
0253 #endif
0254 
0255     *v = *ctx->u.high.default_value;
0256 
0257     if (ngx_http_geo_addr(r, ctx, &addr) == NGX_OK) {
0258 
0259         switch (addr.sockaddr->sa_family) {
0260 
0261 #if (NGX_HAVE_INET6)
0262         case AF_INET6:
0263             inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;
0264 
0265             if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
0266                 p = inaddr6->s6_addr;
0267 
0268                 inaddr = p[12] << 24;
0269                 inaddr += p[13] << 16;
0270                 inaddr += p[14] << 8;
0271                 inaddr += p[15];
0272 
0273             } else {
0274                 inaddr = INADDR_NONE;
0275             }
0276 
0277             break;
0278 #endif
0279 
0280         default: /* AF_INET */
0281             sin = (struct sockaddr_in *) addr.sockaddr;
0282             inaddr = ntohl(sin->sin_addr.s_addr);
0283             break;
0284         }
0285 
0286     } else {
0287         inaddr = INADDR_NONE;
0288     }
0289 
0290     if (ctx->u.high.low) {
0291         range = ctx->u.high.low[inaddr >> 16];
0292 
0293         if (range) {
0294             n = inaddr & 0xffff;
0295             do {
0296                 if (n >= (ngx_uint_t) range->start
0297                     && n <= (ngx_uint_t) range->end)
0298                 {
0299                     *v = *range->value;
0300                     break;
0301                 }
0302             } while ((++range)->value);
0303         }
0304     }
0305 
0306     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
0307                    "http geo: %v", v);
0308 
0309     return NGX_OK;
0310 }
0311 
0312 
0313 static ngx_int_t
0314 ngx_http_geo_addr(ngx_http_request_t *r, ngx_http_geo_ctx_t *ctx,
0315     ngx_addr_t *addr)
0316 {
0317     ngx_array_t  *xfwd;
0318 
0319     if (ngx_http_geo_real_addr(r, ctx, addr) != NGX_OK) {
0320         return NGX_ERROR;
0321     }
0322 
0323     xfwd = &r->headers_in.x_forwarded_for;
0324 
0325     if (xfwd->nelts > 0 && ctx->proxies != NULL) {
0326         (void) ngx_http_get_forwarded_addr(r, addr, xfwd, NULL,
0327                                            ctx->proxies, ctx->proxy_recursive);
0328     }
0329 
0330     return NGX_OK;
0331 }
0332 
0333 
0334 static ngx_int_t
0335 ngx_http_geo_real_addr(ngx_http_request_t *r, ngx_http_geo_ctx_t *ctx,
0336     ngx_addr_t *addr)
0337 {
0338     ngx_http_variable_value_t  *v;
0339 
0340     if (ctx->index == -1) {
0341         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
0342                        "http geo started: %V", &r->connection->addr_text);
0343 
0344         addr->sockaddr = r->connection->sockaddr;
0345         addr->socklen = r->connection->socklen;
0346         /* addr->name = r->connection->addr_text; */
0347 
0348         return NGX_OK;
0349     }
0350 
0351     v = ngx_http_get_flushed_variable(r, ctx->index);
0352 
0353     if (v == NULL || v->not_found) {
0354         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
0355                        "http geo not found");
0356 
0357         return NGX_ERROR;
0358     }
0359 
0360     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
0361                    "http geo started: %v", v);
0362 
0363     if (ngx_parse_addr(r->pool, addr, v->data, v->len) == NGX_OK) {
0364         return NGX_OK;
0365     }
0366 
0367     return NGX_ERROR;
0368 }
0369 
0370 
0371 static char *
0372 ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
0373 {
0374     char                     *rv;
0375     size_t                    len;
0376     ngx_str_t                *value, name;
0377     ngx_uint_t                i;
0378     ngx_conf_t                save;
0379     ngx_pool_t               *pool;
0380     ngx_array_t              *a;
0381     ngx_http_variable_t      *var;
0382     ngx_http_geo_ctx_t       *geo;
0383     ngx_http_geo_conf_ctx_t   ctx;
0384 #if (NGX_HAVE_INET6)
0385     static struct in6_addr    zero;
0386 #endif
0387 
0388     value = cf->args->elts;
0389 
0390     geo = ngx_palloc(cf->pool, sizeof(ngx_http_geo_ctx_t));
0391     if (geo == NULL) {
0392         return NGX_CONF_ERROR;
0393     }
0394 
0395     name = value[1];
0396 
0397     if (name.data[0] != '$') {
0398         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
0399                            "invalid variable name \"%V\"", &name);
0400         return NGX_CONF_ERROR;
0401     }
0402 
0403     name.len--;
0404     name.data++;
0405 
0406     if (cf->args->nelts == 3) {
0407 
0408         geo->index = ngx_http_get_variable_index(cf, &name);
0409         if (geo->index == NGX_ERROR) {
0410             return NGX_CONF_ERROR;
0411         }
0412 
0413         name = value[2];
0414 
0415         if (name.data[0] != '$') {
0416             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
0417                                "invalid variable name \"%V\"", &name);
0418             return NGX_CONF_ERROR;
0419         }
0420 
0421         name.len--;
0422         name.data++;
0423 
0424     } else {
0425         geo->index = -1;
0426     }
0427 
0428     var = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
0429     if (var == NULL) {
0430         return NGX_CONF_ERROR;
0431     }
0432 
0433     pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
0434     if (pool == NULL) {
0435         return NGX_CONF_ERROR;
0436     }
0437 
0438     ngx_memzero(&ctx, sizeof(ngx_http_geo_conf_ctx_t));
0439 
0440     ctx.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
0441     if (ctx.temp_pool == NULL) {
0442         return NGX_CONF_ERROR;
0443     }
0444 
0445     ngx_rbtree_init(&ctx.rbtree, &ctx.sentinel, ngx_str_rbtree_insert_value);
0446 
0447     ctx.pool = cf->pool;
0448     ctx.data_size = sizeof(ngx_http_geo_header_t)
0449                   + sizeof(ngx_http_variable_value_t)
0450                   + 0x10000 * sizeof(ngx_http_geo_range_t *);
0451     ctx.allow_binary_include = 1;
0452 
0453     save = *cf;
0454     cf->pool = pool;
0455     cf->ctx = &ctx;
0456     cf->handler = ngx_http_geo;
0457     cf->handler_conf = conf;
0458 
0459     rv = ngx_conf_parse(cf, NULL);
0460 
0461     *cf = save;
0462 
0463     geo->proxies = ctx.proxies;
0464     geo->proxy_recursive = ctx.proxy_recursive;
0465 
0466     if (ctx.ranges) {
0467 
0468         if (ctx.high.low && !ctx.binary_include) {
0469             for (i = 0; i < 0x10000; i++) {
0470                 a = (ngx_array_t *) ctx.high.low[i];
0471 
0472                 if (a == NULL) {
0473                     continue;
0474                 }
0475 
0476                 if (a->nelts == 0) {
0477                     ctx.high.low[i] = NULL;
0478                     continue;
0479                 }
0480 
0481                 len = a->nelts * sizeof(ngx_http_geo_range_t);
0482 
0483                 ctx.high.low[i] = ngx_palloc(cf->pool, len + sizeof(void *));
0484                 if (ctx.high.low[i] == NULL) {
0485                     return NGX_CONF_ERROR;
0486                 }
0487 
0488                 ngx_memcpy(ctx.high.low[i], a->elts, len);
0489                 ctx.high.low[i][a->nelts].value = NULL;
0490                 ctx.data_size += len + sizeof(void *);
0491             }
0492 
0493             if (ctx.allow_binary_include
0494                 && !ctx.outside_entries
0495                 && ctx.entries > 100000
0496                 && ctx.includes == 1)
0497             {
0498                 ngx_http_geo_create_binary_base(&ctx);
0499             }
0500         }
0501 
0502         if (ctx.high.default_value == NULL) {
0503             ctx.high.default_value = &ngx_http_variable_null_value;
0504         }
0505 
0506         geo->u.high = ctx.high;
0507 
0508         var->get_handler = ngx_http_geo_range_variable;
0509         var->data = (uintptr_t) geo;
0510 
0511         ngx_destroy_pool(ctx.temp_pool);
0512         ngx_destroy_pool(pool);
0513 
0514     } else {
0515         if (ctx.tree == NULL) {
0516             ctx.tree = ngx_radix_tree_create(cf->pool, -1);
0517             if (ctx.tree == NULL) {
0518                 return NGX_CONF_ERROR;
0519             }
0520         }
0521 
0522         geo->u.trees.tree = ctx.tree;
0523 
0524 #if (NGX_HAVE_INET6)
0525         if (ctx.tree6 == NULL) {
0526             ctx.tree6 = ngx_radix_tree_create(cf->pool, -1);
0527             if (ctx.tree6 == NULL) {
0528                 return NGX_CONF_ERROR;
0529             }
0530         }
0531 
0532         geo->u.trees.tree6 = ctx.tree6;
0533 #endif
0534 
0535         var->get_handler = ngx_http_geo_cidr_variable;
0536         var->data = (uintptr_t) geo;
0537 
0538         ngx_destroy_pool(ctx.temp_pool);
0539         ngx_destroy_pool(pool);
0540 
0541         if (ngx_radix32tree_insert(ctx.tree, 0, 0,
0542                                    (uintptr_t) &ngx_http_variable_null_value)
0543             == NGX_ERROR)
0544         {
0545             return NGX_CONF_ERROR;
0546         }
0547 
0548         /* NGX_BUSY is okay (default was set explicitly) */
0549 
0550 #if (NGX_HAVE_INET6)
0551         if (ngx_radix128tree_insert(ctx.tree6, zero.s6_addr, zero.s6_addr,
0552                                     (uintptr_t) &ngx_http_variable_null_value)
0553             == NGX_ERROR)
0554         {
0555             return NGX_CONF_ERROR;
0556         }
0557 #endif
0558     }
0559 
0560     return rv;
0561 }
0562 
0563 
0564 static char *
0565 ngx_http_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
0566 {
0567     char                     *rv;
0568     ngx_str_t                *value;
0569     ngx_cidr_t                cidr;
0570     ngx_http_geo_conf_ctx_t  *ctx;
0571 
0572     ctx = cf->ctx;
0573 
0574     value = cf->args->elts;
0575 
0576     if (cf->args->nelts == 1) {
0577 
0578         if (ngx_strcmp(value[0].data, "ranges") == 0) {
0579 
0580             if (ctx->tree
0581 #if (NGX_HAVE_INET6)
0582                 || ctx->tree6
0583 #endif
0584                )
0585             {
0586                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
0587                                    "the \"ranges\" directive must be "
0588                                    "the first directive inside \"geo\" block");
0589                 goto failed;
0590             }
0591 
0592             ctx->ranges = 1;
0593 
0594             rv = NGX_CONF_OK;
0595 
0596             goto done;
0597         }
0598 
0599         else if (ngx_strcmp(value[0].data, "proxy_recursive") == 0) {
0600             ctx->proxy_recursive = 1;
0601             rv = NGX_CONF_OK;
0602             goto done;
0603         }
0604     }
0605 
0606     if (cf->args->nelts != 2) {
0607         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
0608                            "invalid number of the geo parameters");
0609         goto failed;
0610     }
0611 
0612     if (ngx_strcmp(value[0].data, "include") == 0) {
0613 
0614         rv = ngx_http_geo_include(cf, ctx, &value[1]);
0615 
0616         goto done;
0617 
0618     } else if (ngx_strcmp(value[0].data, "proxy") == 0) {
0619 
0620         if (ngx_http_geo_cidr_value(cf, &value[1], &cidr) != NGX_OK) {
0621             goto failed;
0622         }
0623 
0624         rv = ngx_http_geo_add_proxy(cf, ctx, &cidr);
0625 
0626         goto done;
0627     }
0628 
0629     if (ctx->ranges) {
0630         rv = ngx_http_geo_range(cf, ctx, value);
0631 
0632     } else {
0633         rv = ngx_http_geo_cidr(cf, ctx, value);
0634     }
0635 
0636 done:
0637 
0638     ngx_reset_pool(cf->pool);
0639 
0640     return rv;
0641 
0642 failed:
0643 
0644     ngx_reset_pool(cf->pool);
0645 
0646     return NGX_CONF_ERROR;
0647 }
0648 
0649 
0650 static char *
0651 ngx_http_geo_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
0652     ngx_str_t *value)
0653 {
0654     u_char      *p, *last;
0655     in_addr_t    start, end;
0656     ngx_str_t   *net;
0657     ngx_uint_t   del;
0658 
0659     if (ngx_strcmp(value[0].data, "default") == 0) {
0660 
0661         if (ctx->high.default_value) {
0662             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
0663                 "duplicate default geo range value: \"%V\", old value: \"%v\"",
0664                 &value[1], ctx->high.default_value);
0665         }
0666 
0667         ctx->high.default_value = ngx_http_geo_value(cf, ctx, &value[1]);
0668         if (ctx->high.default_value == NULL) {
0669             return NGX_CONF_ERROR;
0670         }
0671 
0672         return NGX_CONF_OK;
0673     }
0674 
0675     if (ctx->binary_include) {
0676         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
0677             "binary geo range base \"%s\" cannot be mixed with usual entries",
0678             ctx->include_name.data);
0679         return NGX_CONF_ERROR;
0680     }
0681 
0682     if (ctx->high.low == NULL) {
0683         ctx->high.low = ngx_pcalloc(ctx->pool,
0684                                     0x10000 * sizeof(ngx_http_geo_range_t *));
0685         if (ctx->high.low == NULL) {
0686             return NGX_CONF_ERROR;
0687         }
0688     }
0689 
0690     ctx->entries++;
0691     ctx->outside_entries = 1;
0692 
0693     if (ngx_strcmp(value[0].data, "delete") == 0) {
0694         net = &value[1];
0695         del = 1;
0696 
0697     } else {
0698         net = &value[0];
0699         del = 0;
0700     }
0701 
0702     last = net->data + net->len;
0703 
0704     p = ngx_strlchr(net->data, last, '-');
0705 
0706     if (p == NULL) {
0707         goto invalid;
0708     }
0709 
0710     start = ngx_inet_addr(net->data, p - net->data);
0711 
0712     if (start == INADDR_NONE) {
0713         goto invalid;
0714     }
0715 
0716     start = ntohl(start);
0717 
0718     p++;
0719 
0720     end = ngx_inet_addr(p, last - p);
0721 
0722     if (end == INADDR_NONE) {
0723         goto invalid;
0724     }
0725 
0726     end = ntohl(end);
0727 
0728     if (start > end) {
0729         goto invalid;
0730     }
0731 
0732     if (del) {
0733         if (ngx_http_geo_delete_range(cf, ctx, start, end)) {
0734             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
0735                                "no address range \"%V\" to delete", net);
0736         }
0737 
0738         return NGX_CONF_OK;
0739     }
0740 
0741     ctx->value = ngx_http_geo_value(cf, ctx, &value[1]);
0742 
0743     if (ctx->value == NULL) {
0744         return NGX_CONF_ERROR;
0745     }
0746 
0747     ctx->net = net;
0748 
0749     return ngx_http_geo_add_range(cf, ctx, start, end);
0750 
0751 invalid:
0752 
0753     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid range \"%V\"", net);
0754 
0755     return NGX_CONF_ERROR;
0756 }
0757 
0758 
0759 /* the add procedure is optimized to add a growing up sequence */
0760 
0761 static char *
0762 ngx_http_geo_add_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
0763     in_addr_t start, in_addr_t end)
0764 {
0765     in_addr_t              n;
0766     ngx_uint_t             h, i, s, e;
0767     ngx_array_t           *a;
0768     ngx_http_geo_range_t  *range;
0769 
0770     for (n = start; n <= end; n = (n + 0x10000) & 0xffff0000) {
0771 
0772         h = n >> 16;
0773 
0774         if (n == start) {
0775             s = n & 0xffff;
0776         } else {
0777             s = 0;
0778         }
0779 
0780         if ((n | 0xffff) > end) {
0781             e = end & 0xffff;
0782 
0783         } else {
0784             e = 0xffff;
0785         }
0786 
0787         a = (ngx_array_t *) ctx->high.low[h];
0788 
0789         if (a == NULL) {
0790             a = ngx_array_create(ctx->temp_pool, 64,
0791                                  sizeof(ngx_http_geo_range_t));
0792             if (a == NULL) {
0793                 return NGX_CONF_ERROR;
0794             }
0795 
0796             ctx->high.low[h] = (ngx_http_geo_range_t *) a;
0797         }
0798 
0799         i = a->nelts;
0800         range = a->elts;
0801 
0802         while (i) {
0803 
0804             i--;
0805 
0806             if (e < (ngx_uint_t) range[i].start) {
0807                 continue;
0808             }
0809 
0810             if (s > (ngx_uint_t) range[i].end) {
0811 
0812                 /* add after the range */
0813 
0814                 range = ngx_array_push(a);
0815                 if (range == NULL) {
0816                     return NGX_CONF_ERROR;
0817                 }
0818 
0819                 range = a->elts;
0820 
0821                 ngx_memmove(&range[i + 2], &range[i + 1],
0822                             (a->nelts - 2 - i) * sizeof(ngx_http_geo_range_t));
0823 
0824                 range[i + 1].start = (u_short) s;
0825                 range[i + 1].end = (u_short) e;
0826                 range[i + 1].value = ctx->value;
0827 
0828                 goto next;
0829             }
0830 
0831             if (s == (ngx_uint_t) range[i].start
0832                 && e == (ngx_uint_t) range[i].end)
0833             {
0834                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
0835                     "duplicate range \"%V\", value: \"%v\", old value: \"%v\"",
0836                     ctx->net, ctx->value, range[i].value);
0837 
0838                 range[i].value = ctx->value;
0839 
0840                 goto next;
0841             }
0842 
0843             if (s > (ngx_uint_t) range[i].start
0844                 && e < (ngx_uint_t) range[i].end)
0845             {
0846                 /* split the range and insert the new one */
0847 
0848                 range = ngx_array_push(a);
0849                 if (range == NULL) {
0850                     return NGX_CONF_ERROR;
0851                 }
0852 
0853                 range = ngx_array_push(a);
0854                 if (range == NULL) {
0855                     return NGX_CONF_ERROR;
0856                 }
0857 
0858                 range = a->elts;
0859 
0860                 ngx_memmove(&range[i + 3], &range[i + 1],
0861                             (a->nelts - 3 - i) * sizeof(ngx_http_geo_range_t));
0862 
0863                 range[i + 2].start = (u_short) (e + 1);
0864                 range[i + 2].end = range[i].end;
0865                 range[i + 2].value = range[i].value;
0866 
0867                 range[i + 1].start = (u_short) s;
0868                 range[i + 1].end = (u_short) e;
0869                 range[i + 1].value = ctx->value;
0870 
0871                 range[i].end = (u_short) (s - 1);
0872 
0873                 goto next;
0874             }
0875 
0876             if (s == (ngx_uint_t) range[i].start
0877                 && e < (ngx_uint_t) range[i].end)
0878             {
0879                 /* shift the range start and insert the new range */
0880 
0881                 range = ngx_array_push(a);
0882                 if (range == NULL) {
0883                     return NGX_CONF_ERROR;
0884                 }
0885 
0886                 range = a->elts;
0887 
0888                 ngx_memmove(&range[i + 1], &range[i],
0889                             (a->nelts - 1 - i) * sizeof(ngx_http_geo_range_t));
0890 
0891                 range[i + 1].start = (u_short) (e + 1);
0892 
0893                 range[i].start = (u_short) s;
0894                 range[i].end = (u_short) e;
0895                 range[i].value = ctx->value;
0896 
0897                 goto next;
0898             }
0899 
0900             if (s > (ngx_uint_t) range[i].start
0901                 && e == (ngx_uint_t) range[i].end)
0902             {
0903                 /* shift the range end and insert the new range */
0904 
0905                 range = ngx_array_push(a);
0906                 if (range == NULL) {
0907                     return NGX_CONF_ERROR;
0908                 }
0909 
0910                 range = a->elts;
0911 
0912                 ngx_memmove(&range[i + 2], &range[i + 1],
0913                             (a->nelts - 2 - i) * sizeof(ngx_http_geo_range_t));
0914 
0915                 range[i + 1].start = (u_short) s;
0916                 range[i + 1].end = (u_short) e;
0917                 range[i + 1].value = ctx->value;
0918 
0919                 range[i].end = (u_short) (s - 1);
0920 
0921                 goto next;
0922             }
0923 
0924             s = (ngx_uint_t) range[i].start;
0925             e = (ngx_uint_t) range[i].end;
0926 
0927             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
0928                          "range \"%V\" overlaps \"%d.%d.%d.%d-%d.%d.%d.%d\"",
0929                          ctx->net,
0930                          h >> 8, h & 0xff, s >> 8, s & 0xff,
0931                          h >> 8, h & 0xff, e >> 8, e & 0xff);
0932 
0933             return NGX_CONF_ERROR;
0934         }
0935 
0936         /* add the first range */
0937 
0938         range = ngx_array_push(a);
0939         if (range == NULL) {
0940             return NGX_CONF_ERROR;
0941         }
0942 
0943         range = a->elts;
0944 
0945         ngx_memmove(&range[1], &range[0],
0946                     (a->nelts - 1) * sizeof(ngx_http_geo_range_t));
0947 
0948         range[0].start = (u_short) s;
0949         range[0].end = (u_short) e;
0950         range[0].value = ctx->value;
0951 
0952     next:
0953 
0954         if (h == 0xffff) {
0955             break;
0956         }
0957     }
0958 
0959     return NGX_CONF_OK;
0960 }
0961 
0962 
0963 static ngx_uint_t
0964 ngx_http_geo_delete_range(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
0965     in_addr_t start, in_addr_t end)
0966 {
0967     in_addr_t              n;
0968     ngx_uint_t             h, i, s, e, warn;
0969     ngx_array_t           *a;
0970     ngx_http_geo_range_t  *range;
0971 
0972     warn = 0;
0973 
0974     for (n = start; n <= end; n = (n + 0x10000) & 0xffff0000) {
0975 
0976         h = n >> 16;
0977 
0978         if (n == start) {
0979             s = n & 0xffff;
0980         } else {
0981             s = 0;
0982         }
0983 
0984         if ((n | 0xffff) > end) {
0985             e = end & 0xffff;
0986 
0987         } else {
0988             e = 0xffff;
0989         }
0990 
0991         a = (ngx_array_t *) ctx->high.low[h];
0992 
0993         if (a == NULL || a->nelts == 0) {
0994             warn = 1;
0995             goto next;
0996         }
0997 
0998         range = a->elts;
0999         for (i = 0; i < a->nelts; i++) {
1000 
1001             if (s == (ngx_uint_t) range[i].start
1002                 && e == (ngx_uint_t) range[i].end)
1003             {
1004                 ngx_memmove(&range[i], &range[i + 1],
1005                             (a->nelts - 1 - i) * sizeof(ngx_http_geo_range_t));
1006 
1007                 a->nelts--;
1008 
1009                 break;
1010             }
1011 
1012             if (i == a->nelts - 1) {
1013                 warn = 1;
1014             }
1015         }
1016 
1017     next:
1018 
1019         if (h == 0xffff) {
1020             break;
1021         }
1022     }
1023 
1024     return warn;
1025 }
1026 
1027 
1028 static char *
1029 ngx_http_geo_cidr(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1030     ngx_str_t *value)
1031 {
1032     char        *rv;
1033     ngx_int_t    rc, del;
1034     ngx_str_t   *net;
1035     ngx_cidr_t   cidr;
1036 
1037     if (ctx->tree == NULL) {
1038         ctx->tree = ngx_radix_tree_create(ctx->pool, -1);
1039         if (ctx->tree == NULL) {
1040             return NGX_CONF_ERROR;
1041         }
1042     }
1043 
1044 #if (NGX_HAVE_INET6)
1045     if (ctx->tree6 == NULL) {
1046         ctx->tree6 = ngx_radix_tree_create(ctx->pool, -1);
1047         if (ctx->tree6 == NULL) {
1048             return NGX_CONF_ERROR;
1049         }
1050     }
1051 #endif
1052 
1053     if (ngx_strcmp(value[0].data, "default") == 0) {
1054         cidr.family = AF_INET;
1055         cidr.u.in.addr = 0;
1056         cidr.u.in.mask = 0;
1057 
1058         rv = ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], &value[0]);
1059 
1060         if (rv != NGX_CONF_OK) {
1061             return rv;
1062         }
1063 
1064 #if (NGX_HAVE_INET6)
1065         cidr.family = AF_INET6;
1066         ngx_memzero(&cidr.u.in6, sizeof(ngx_in6_cidr_t));
1067 
1068         rv = ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], &value[0]);
1069 
1070         if (rv != NGX_CONF_OK) {
1071             return rv;
1072         }
1073 #endif
1074 
1075         return NGX_CONF_OK;
1076     }
1077 
1078     if (ngx_strcmp(value[0].data, "delete") == 0) {
1079         net = &value[1];
1080         del = 1;
1081 
1082     } else {
1083         net = &value[0];
1084         del = 0;
1085     }
1086 
1087     if (ngx_http_geo_cidr_value(cf, net, &cidr) != NGX_OK) {
1088         return NGX_CONF_ERROR;
1089     }
1090 
1091     if (cidr.family == AF_INET) {
1092         cidr.u.in.addr = ntohl(cidr.u.in.addr);
1093         cidr.u.in.mask = ntohl(cidr.u.in.mask);
1094     }
1095 
1096     if (del) {
1097         switch (cidr.family) {
1098 
1099 #if (NGX_HAVE_INET6)
1100         case AF_INET6:
1101             rc = ngx_radix128tree_delete(ctx->tree6,
1102                                          cidr.u.in6.addr.s6_addr,
1103                                          cidr.u.in6.mask.s6_addr);
1104             break;
1105 #endif
1106 
1107         default: /* AF_INET */
1108             rc = ngx_radix32tree_delete(ctx->tree, cidr.u.in.addr,
1109                                         cidr.u.in.mask);
1110             break;
1111         }
1112 
1113         if (rc != NGX_OK) {
1114             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1115                                "no network \"%V\" to delete", net);
1116         }
1117 
1118         return NGX_CONF_OK;
1119     }
1120 
1121     return ngx_http_geo_cidr_add(cf, ctx, &cidr, &value[1], net);
1122 }
1123 
1124 
1125 static char *
1126 ngx_http_geo_cidr_add(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1127     ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net)
1128 {
1129     ngx_int_t                   rc;
1130     ngx_http_variable_value_t  *val, *old;
1131 
1132     val = ngx_http_geo_value(cf, ctx, value);
1133 
1134     if (val == NULL) {
1135         return NGX_CONF_ERROR;
1136     }
1137 
1138     switch (cidr->family) {
1139 
1140 #if (NGX_HAVE_INET6)
1141     case AF_INET6:
1142         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
1143                                      cidr->u.in6.mask.s6_addr,
1144                                      (uintptr_t) val);
1145 
1146         if (rc == NGX_OK) {
1147             return NGX_CONF_OK;
1148         }
1149 
1150         if (rc == NGX_ERROR) {
1151             return NGX_CONF_ERROR;
1152         }
1153 
1154         /* rc == NGX_BUSY */
1155 
1156         old = (ngx_http_variable_value_t *)
1157                    ngx_radix128tree_find(ctx->tree6,
1158                                          cidr->u.in6.addr.s6_addr);
1159 
1160         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1161               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
1162               net, val, old);
1163 
1164         rc = ngx_radix128tree_delete(ctx->tree6,
1165                                      cidr->u.in6.addr.s6_addr,
1166                                      cidr->u.in6.mask.s6_addr);
1167 
1168         if (rc == NGX_ERROR) {
1169             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
1170             return NGX_CONF_ERROR;
1171         }
1172 
1173         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
1174                                      cidr->u.in6.mask.s6_addr,
1175                                      (uintptr_t) val);
1176 
1177         break;
1178 #endif
1179 
1180     default: /* AF_INET */
1181         rc = ngx_radix32tree_insert(ctx->tree, cidr->u.in.addr,
1182                                     cidr->u.in.mask, (uintptr_t) val);
1183 
1184         if (rc == NGX_OK) {
1185             return NGX_CONF_OK;
1186         }
1187 
1188         if (rc == NGX_ERROR) {
1189             return NGX_CONF_ERROR;
1190         }
1191 
1192         /* rc == NGX_BUSY */
1193 
1194         old = (ngx_http_variable_value_t *)
1195                    ngx_radix32tree_find(ctx->tree, cidr->u.in.addr);
1196 
1197         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1198               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
1199               net, val, old);
1200 
1201         rc = ngx_radix32tree_delete(ctx->tree,
1202                                     cidr->u.in.addr, cidr->u.in.mask);
1203 
1204         if (rc == NGX_ERROR) {
1205             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
1206             return NGX_CONF_ERROR;
1207         }
1208 
1209         rc = ngx_radix32tree_insert(ctx->tree, cidr->u.in.addr,
1210                                     cidr->u.in.mask, (uintptr_t) val);
1211 
1212         break;
1213     }
1214 
1215     if (rc == NGX_OK) {
1216         return NGX_CONF_OK;
1217     }
1218 
1219     return NGX_CONF_ERROR;
1220 }
1221 
1222 
1223 static ngx_http_variable_value_t *
1224 ngx_http_geo_value(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1225     ngx_str_t *value)
1226 {
1227     uint32_t                             hash;
1228     ngx_http_variable_value_t           *val;
1229     ngx_http_geo_variable_value_node_t  *gvvn;
1230 
1231     hash = ngx_crc32_long(value->data, value->len);
1232 
1233     gvvn = (ngx_http_geo_variable_value_node_t *)
1234                ngx_str_rbtree_lookup(&ctx->rbtree, value, hash);
1235 
1236     if (gvvn) {
1237         return gvvn->value;
1238     }
1239 
1240     val = ngx_palloc(ctx->pool, sizeof(ngx_http_variable_value_t));
1241     if (val == NULL) {
1242         return NULL;
1243     }
1244 
1245     val->len = value->len;
1246     val->data = ngx_pstrdup(ctx->pool, value);
1247     if (val->data == NULL) {
1248         return NULL;
1249     }
1250 
1251     val->valid = 1;
1252     val->no_cacheable = 0;
1253     val->not_found = 0;
1254 
1255     gvvn = ngx_palloc(ctx->temp_pool,
1256                       sizeof(ngx_http_geo_variable_value_node_t));
1257     if (gvvn == NULL) {
1258         return NULL;
1259     }
1260 
1261     gvvn->sn.node.key = hash;
1262     gvvn->sn.str.len = val->len;
1263     gvvn->sn.str.data = val->data;
1264     gvvn->value = val;
1265     gvvn->offset = 0;
1266 
1267     ngx_rbtree_insert(&ctx->rbtree, &gvvn->sn.node);
1268 
1269     ctx->data_size += ngx_align(sizeof(ngx_http_variable_value_t) + value->len,
1270                                 sizeof(void *));
1271 
1272     return val;
1273 }
1274 
1275 
1276 static char *
1277 ngx_http_geo_add_proxy(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1278     ngx_cidr_t *cidr)
1279 {
1280     ngx_cidr_t  *c;
1281 
1282     if (ctx->proxies == NULL) {
1283         ctx->proxies = ngx_array_create(ctx->pool, 4, sizeof(ngx_cidr_t));
1284         if (ctx->proxies == NULL) {
1285             return NGX_CONF_ERROR;
1286         }
1287     }
1288 
1289     c = ngx_array_push(ctx->proxies);
1290     if (c == NULL) {
1291         return NGX_CONF_ERROR;
1292     }
1293 
1294     *c = *cidr;
1295 
1296     return NGX_CONF_OK;
1297 }
1298 
1299 
1300 static ngx_int_t
1301 ngx_http_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net, ngx_cidr_t *cidr)
1302 {
1303     ngx_int_t  rc;
1304 
1305     if (ngx_strcmp(net->data, "255.255.255.255") == 0) {
1306         cidr->family = AF_INET;
1307         cidr->u.in.addr = 0xffffffff;
1308         cidr->u.in.mask = 0xffffffff;
1309 
1310         return NGX_OK;
1311     }
1312 
1313     rc = ngx_ptocidr(net, cidr);
1314 
1315     if (rc == NGX_ERROR) {
1316         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid network \"%V\"", net);
1317         return NGX_ERROR;
1318     }
1319 
1320     if (rc == NGX_DONE) {
1321         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1322                            "low address bits of %V are meaningless", net);
1323     }
1324 
1325     return NGX_OK;
1326 }
1327 
1328 
1329 static char *
1330 ngx_http_geo_include(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1331     ngx_str_t *name)
1332 {
1333     char       *rv;
1334     ngx_str_t   file;
1335 
1336     file.len = name->len + 4;
1337     file.data = ngx_pnalloc(ctx->temp_pool, name->len + 5);
1338     if (file.data == NULL) {
1339         return NGX_CONF_ERROR;
1340     }
1341 
1342     ngx_sprintf(file.data, "%V.bin%Z", name);
1343 
1344     if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
1345         return NGX_CONF_ERROR;
1346     }
1347 
1348     if (ctx->ranges) {
1349         ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
1350 
1351         switch (ngx_http_geo_include_binary_base(cf, ctx, &file)) {
1352         case NGX_OK:
1353             return NGX_CONF_OK;
1354         case NGX_ERROR:
1355             return NGX_CONF_ERROR;
1356         default:
1357             break;
1358         }
1359     }
1360 
1361     file.len -= 4;
1362     file.data[file.len] = '\0';
1363 
1364     ctx->include_name = file;
1365 
1366     if (ctx->outside_entries) {
1367         ctx->allow_binary_include = 0;
1368     }
1369 
1370     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
1371 
1372     rv = ngx_conf_parse(cf, &file);
1373 
1374     ctx->includes++;
1375     ctx->outside_entries = 0;
1376 
1377     return rv;
1378 }
1379 
1380 
1381 static ngx_int_t
1382 ngx_http_geo_include_binary_base(ngx_conf_t *cf, ngx_http_geo_conf_ctx_t *ctx,
1383     ngx_str_t *name)
1384 {
1385     u_char                     *base, ch;
1386     time_t                      mtime;
1387     size_t                      size, len;
1388     ssize_t                     n;
1389     uint32_t                    crc32;
1390     ngx_err_t                   err;
1391     ngx_int_t                   rc;
1392     ngx_uint_t                  i;
1393     ngx_file_t                  file;
1394     ngx_file_info_t             fi;
1395     ngx_http_geo_range_t       *range, **ranges;
1396     ngx_http_geo_header_t      *header;
1397     ngx_http_variable_value_t  *vv;
1398 
1399     ngx_memzero(&file, sizeof(ngx_file_t));
1400     file.name = *name;
1401     file.log = cf->log;
1402 
1403     file.fd = ngx_open_file(name->data, NGX_FILE_RDONLY, 0, 0);
1404     if (file.fd == NGX_INVALID_FILE) {
1405         err = ngx_errno;
1406         if (err != NGX_ENOENT) {
1407             ngx_conf_log_error(NGX_LOG_CRIT, cf, err,
1408                                ngx_open_file_n " \"%s\" failed", name->data);
1409         }
1410         return NGX_DECLINED;
1411     }
1412 
1413     if (ctx->outside_entries) {
1414         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1415             "binary geo range base \"%s\" cannot be mixed with usual entries",
1416             name->data);
1417         rc = NGX_ERROR;
1418         goto done;
1419     }
1420 
1421     if (ctx->binary_include) {
1422         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1423             "second binary geo range base \"%s\" cannot be mixed with \"%s\"",
1424             name->data, ctx->include_name.data);
1425         rc = NGX_ERROR;
1426         goto done;
1427     }
1428 
1429     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
1430         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
1431                            ngx_fd_info_n " \"%s\" failed", name->data);
1432         goto failed;
1433     }
1434 
1435     size = (size_t) ngx_file_size(&fi);
1436     mtime = ngx_file_mtime(&fi);
1437 
1438     ch = name->data[name->len - 4];
1439     name->data[name->len - 4] = '\0';
1440 
1441     if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
1442         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
1443                            ngx_file_info_n " \"%s\" failed", name->data);
1444         goto failed;
1445     }
1446 
1447     name->data[name->len - 4] = ch;
1448 
1449     if (mtime < ngx_file_mtime(&fi)) {
1450         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1451                            "stale binary geo range base \"%s\"", name->data);
1452         goto failed;
1453     }
1454 
1455     base = ngx_palloc(ctx->pool, size);
1456     if (base == NULL) {
1457         goto failed;
1458     }
1459 
1460     n = ngx_read_file(&file, base, size, 0);
1461 
1462     if (n == NGX_ERROR) {
1463         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
1464                            ngx_read_file_n " \"%s\" failed", name->data);
1465         goto failed;
1466     }
1467 
1468     if ((size_t) n != size) {
1469         ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
1470             ngx_read_file_n " \"%s\" returned only %z bytes instead of %z",
1471             name->data, n, size);
1472         goto failed;
1473     }
1474 
1475     header = (ngx_http_geo_header_t *) base;
1476 
1477     if (size < 16 || ngx_memcmp(&ngx_http_geo_header, header, 12) != 0) {
1478         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1479              "incompatible binary geo range base \"%s\"", name->data);
1480         goto failed;
1481     }
1482 
1483     ngx_crc32_init(crc32);
1484 
1485     vv = (ngx_http_variable_value_t *) (base + sizeof(ngx_http_geo_header_t));
1486 
1487     while (vv->data) {
1488         len = ngx_align(sizeof(ngx_http_variable_value_t) + vv->len,
1489                         sizeof(void *));
1490         ngx_crc32_update(&crc32, (u_char *) vv, len);
1491         vv->data += (size_t) base;
1492         vv = (ngx_http_variable_value_t *) ((u_char *) vv + len);
1493     }
1494     ngx_crc32_update(&crc32, (u_char *) vv, sizeof(ngx_http_variable_value_t));
1495     vv++;
1496 
1497     ranges = (ngx_http_geo_range_t **) vv;
1498 
1499     for (i = 0; i < 0x10000; i++) {
1500         ngx_crc32_update(&crc32, (u_char *) &ranges[i], sizeof(void *));
1501         if (ranges[i]) {
1502             ranges[i] = (ngx_http_geo_range_t *)
1503                             ((u_char *) ranges[i] + (size_t) base);
1504         }
1505     }
1506 
1507     range = (ngx_http_geo_range_t *) &ranges[0x10000];
1508 
1509     while ((u_char *) range < base + size) {
1510         while (range->value) {
1511             ngx_crc32_update(&crc32, (u_char *) range,
1512                              sizeof(ngx_http_geo_range_t));
1513             range->value = (ngx_http_variable_value_t *)
1514                                ((u_char *) range->value + (size_t) base);
1515             range++;
1516         }
1517         ngx_crc32_update(&crc32, (u_char *) range, sizeof(void *));
1518         range = (ngx_http_geo_range_t *) ((u_char *) range + sizeof(void *));
1519     }
1520 
1521     ngx_crc32_final(crc32);
1522 
1523     if (crc32 != header->crc32) {
1524         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1525                   "CRC32 mismatch in binary geo range base \"%s\"", name->data);
1526         goto failed;
1527     }
1528 
1529     ngx_conf_log_error(NGX_LOG_NOTICE, cf, 0,
1530                        "using binary geo range base \"%s\"", name->data);
1531 
1532     ctx->include_name = *name;
1533     ctx->binary_include = 1;
1534     ctx->high.low = ranges;
1535     rc = NGX_OK;
1536 
1537     goto done;
1538 
1539 failed:
1540 
1541     rc = NGX_DECLINED;
1542 
1543 done:
1544 
1545     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
1546         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
1547                       ngx_close_file_n " \"%s\" failed", name->data);
1548     }
1549 
1550     return rc;
1551 }
1552 
1553 
1554 static void
1555 ngx_http_geo_create_binary_base(ngx_http_geo_conf_ctx_t *ctx)
1556 {
1557     u_char                              *p;
1558     uint32_t                             hash;
1559     ngx_str_t                            s;
1560     ngx_uint_t                           i;
1561     ngx_file_mapping_t                   fm;
1562     ngx_http_geo_range_t                *r, *range, **ranges;
1563     ngx_http_geo_header_t               *header;
1564     ngx_http_geo_variable_value_node_t  *gvvn;
1565 
1566     fm.name = ngx_pnalloc(ctx->temp_pool, ctx->include_name.len + 5);
1567     if (fm.name == NULL) {
1568         return;
1569     }
1570 
1571     ngx_sprintf(fm.name, "%V.bin%Z", &ctx->include_name);
1572 
1573     fm.size = ctx->data_size;
1574     fm.log = ctx->pool->log;
1575 
1576     ngx_log_error(NGX_LOG_NOTICE, fm.log, 0,
1577                   "creating binary geo range base \"%s\"", fm.name);
1578 
1579     if (ngx_create_file_mapping(&fm) != NGX_OK) {
1580         return;
1581     }
1582 
1583     p = ngx_cpymem(fm.addr, &ngx_http_geo_header,
1584                    sizeof(ngx_http_geo_header_t));
1585 
1586     p = ngx_http_geo_copy_values(fm.addr, p, ctx->rbtree.root,
1587                                  ctx->rbtree.sentinel);
1588 
1589     p += sizeof(ngx_http_variable_value_t);
1590 
1591     ranges = (ngx_http_geo_range_t **) p;
1592 
1593     p += 0x10000 * sizeof(ngx_http_geo_range_t *);
1594 
1595     for (i = 0; i < 0x10000; i++) {
1596         r = ctx->high.low[i];
1597         if (r == NULL) {
1598             continue;
1599         }
1600 
1601         range = (ngx_http_geo_range_t *) p;
1602         ranges[i] = (ngx_http_geo_range_t *) (p - (u_char *) fm.addr);
1603 
1604         do {
1605             s.len = r->value->len;
1606             s.data = r->value->data;
1607             hash = ngx_crc32_long(s.data, s.len);
1608             gvvn = (ngx_http_geo_variable_value_node_t *)
1609                         ngx_str_rbtree_lookup(&ctx->rbtree, &s, hash);
1610 
1611             range->value = (ngx_http_variable_value_t *) gvvn->offset;
1612             range->start = r->start;
1613             range->end = r->end;
1614             range++;
1615 
1616         } while ((++r)->value);
1617 
1618         range->value = NULL;
1619 
1620         p = (u_char *) range + sizeof(void *);
1621     }
1622 
1623     header = fm.addr;
1624     header->crc32 = ngx_crc32_long((u_char *) fm.addr
1625                                        + sizeof(ngx_http_geo_header_t),
1626                                    fm.size - sizeof(ngx_http_geo_header_t));
1627 
1628     ngx_close_file_mapping(&fm);
1629 }
1630 
1631 
1632 static u_char *
1633 ngx_http_geo_copy_values(u_char *base, u_char *p, ngx_rbtree_node_t *node,
1634     ngx_rbtree_node_t *sentinel)
1635 {
1636     ngx_http_variable_value_t           *vv;
1637     ngx_http_geo_variable_value_node_t  *gvvn;
1638 
1639     if (node == sentinel) {
1640         return p;
1641     }
1642 
1643     gvvn = (ngx_http_geo_variable_value_node_t *) node;
1644     gvvn->offset = p - base;
1645 
1646     vv = (ngx_http_variable_value_t *) p;
1647     *vv = *gvvn->value;
1648     p += sizeof(ngx_http_variable_value_t);
1649     vv->data = (u_char *) (p - base);
1650 
1651     p = ngx_cpymem(p, gvvn->sn.str.data, gvvn->sn.str.len);
1652 
1653     p = ngx_align_ptr(p, sizeof(void *));
1654 
1655     p = ngx_http_geo_copy_values(base, p, node->left, sentinel);
1656 
1657     return ngx_http_geo_copy_values(base, p, node->right, sentinel);
1658 }