One Level Up Top Level

src/stream/ngx_stream_geo_module.c - nginx

Global variables defined

Data types defined

Functions defined

Source code


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


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


  13. ‌typedef struct {
  14.     ngx_stream_variable_value_t       *value;
  15.     u_short                            start;
  16.     u_short                            end;
  17. ‌} ngx_stream_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_stream_geo_trees_t;


  28. ‌typedef struct {
  29.     ngx_stream_geo_range_t           **low;
  30.     ngx_stream_variable_value_t       *default_value;
  31. ‌} ngx_stream_geo_high_ranges_t;


  34. ‌typedef struct {
  35.     ngx_str_node_t                     sn;
  36.     ngx_stream_variable_value_t       *value;
  37.     size_t                             offset;
  38. ‌} ngx_stream_geo_variable_value_node_t;


  41. ‌typedef struct {
  42.     ngx_stream_variable_value_t       *value;
  43.     ngx_str_t                         *net;
  44.     ngx_stream_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_pool_t                        *pool;
  52.     ngx_pool_t                        *temp_pool;

  54.     size_t                             data_size;

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

  60.     unsigned                           ranges:1;
  61.     unsigned                           outside_entries:1;
  62.     unsigned                           allow_binary_include:1;
  63.     unsigned                           binary_include:1;
  64.     unsigned                           no_cacheable:1;
  65. ‌} ngx_stream_geo_conf_ctx_t;


  68. ‌typedef struct {
  69. ‌    union {
  70.         ngx_stream_geo_trees_t         trees;
  71.         ngx_stream_geo_high_ranges_t   high;
  72.     } u;

  74.     ngx_int_t                          index;
  75. ‌} ngx_stream_geo_ctx_t;


  78. static ngx_int_t ngx_stream_geo_addr(ngx_stream_session_t *s,
  79.     ngx_stream_geo_ctx_t *ctx, ngx_addr_t *addr);

  81. static char *ngx_stream_geo_block(ngx_conf_t *cf, ngx_command_t *cmd,
  82.     void *conf);
  83. static char *ngx_stream_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf);
  84. static char *ngx_stream_geo_range(ngx_conf_t *cf,
  85.     ngx_stream_geo_conf_ctx_t *ctx, ngx_str_t *value);
  86. static char *ngx_stream_geo_add_range(ngx_conf_t *cf,
  87.     ngx_stream_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
  88. static ngx_uint_t ngx_stream_geo_delete_range(ngx_conf_t *cf,
  89.     ngx_stream_geo_conf_ctx_t *ctx, in_addr_t start, in_addr_t end);
  90. static char *ngx_stream_geo_cidr(ngx_conf_t *cf,
  91.     ngx_stream_geo_conf_ctx_t *ctx, ngx_str_t *value);
  92. static char *ngx_stream_geo_cidr_add(ngx_conf_t *cf,
  93.     ngx_stream_geo_conf_ctx_t *ctx, ngx_cidr_t *cidr, ngx_str_t *value,
  94.     ngx_str_t *net);
  95. static ngx_stream_variable_value_t *ngx_stream_geo_value(ngx_conf_t *cf,
  96.     ngx_stream_geo_conf_ctx_t *ctx, ngx_str_t *value);
  97. static ngx_int_t ngx_stream_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net,
  98.     ngx_cidr_t *cidr);
  99. static char *ngx_stream_geo_include(ngx_conf_t *cf,
  100.     ngx_stream_geo_conf_ctx_t *ctx, ngx_str_t *name);
  101. static ngx_int_t ngx_stream_geo_include_binary_base(ngx_conf_t *cf,
  102.     ngx_stream_geo_conf_ctx_t *ctx, ngx_str_t *name);
  103. static void ngx_stream_geo_create_binary_base(ngx_stream_geo_conf_ctx_t *ctx);
  104. static u_char *ngx_stream_geo_copy_values(u_char *base, u_char *p,
  105.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);


  108. ‌static ngx_command_t  ngx_stream_geo_commands[] = {

  110.     { ngx_string("geo"),
  111.       NGX_STREAM_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12,
  112.       ngx_stream_geo_block,
  113.       0,
  114.       0,
  115.       NULL },

  117.       ngx_null_command
  118. };


  121. ‌static ngx_stream_module_t  ngx_stream_geo_module_ctx = {
  122.     NULL,                                  /* preconfiguration */
  123.     NULL,                                  /* postconfiguration */

  125.     NULL,                                  /* create main configuration */
  126.     NULL,                                  /* init main configuration */

  128.     NULL,                                  /* create server configuration */
  129.     NULL                                   /* merge server configuration */
  130. };


  133. ‌ngx_module_t  ngx_stream_geo_module = {
  134.     NGX_MODULE_V1,
  135.     &ngx_stream_geo_module_ctx,            /* module context */
  136.     ngx_stream_geo_commands,               /* module directives */
  137.     NGX_STREAM_MODULE,                     /* module type */
  138.     NULL,                                  /* init master */
  139.     NULL,                                  /* init module */
  140.     NULL,                                  /* init process */
  141.     NULL,                                  /* init thread */
  142.     NULL,                                  /* exit thread */
  143.     NULL,                                  /* exit process */
  144.     NULL,                                  /* exit master */
  145.     NGX_MODULE_V1_PADDING
  146. };


  149. ‌typedef struct {
  150.     u_char    GEORNG[6];
  151.     u_char    version;
  152.     u_char    ptr_size;
  153.     uint32_t  endianness;
  154.     uint32_t  crc32;
  155. ‌} ngx_stream_geo_header_t;


  158. ‌static ngx_stream_geo_header_t  ngx_stream_geo_header = {
  159.     { 'G', 'E', 'O', 'R', 'N', 'G' }, 0, sizeof(void *), 0x12345678, 0
  160. };


  163. /* geo range is AF_INET only */

  165. static ngx_int_t
  166. ‌ngx_stream_geo_cidr_variable(ngx_stream_session_t *s,
  167.     ngx_stream_variable_value_t *v, uintptr_t data)
  168. {
  169.     ngx_stream_geo_ctx_t *ctx = (ngx_stream_geo_ctx_t *) data;

  171.     in_addr_t                     inaddr;
  172.     ngx_addr_t                    addr;
  173.     struct sockaddr_in           *sin;
  174.     ngx_stream_variable_value_t  *vv;
  175. #if (NGX_HAVE_INET6)
  176.     u_char                       *p;
  177.     struct in6_addr              *inaddr6;
  178. #endif

  180.     if (ngx_stream_geo_addr(s, ctx, &addr) != NGX_OK) {
  181.         vv = (ngx_stream_variable_value_t *)
  182.                   ngx_radix32tree_find(ctx->u.trees.tree, INADDR_NONE);
  183.         goto done;
  184.     }

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

  188. #if (NGX_HAVE_INET6)
  189.     case AF_INET6:
  190.         inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;
  191.         p = inaddr6->s6_addr;

  193.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  194.             inaddr = (in_addr_t) p[12] << 24;
  195.             inaddr += p[13] << 16;
  196.             inaddr += p[14] << 8;
  197.             inaddr += p[15];

  199.             vv = (ngx_stream_variable_value_t *)
  200.                       ngx_radix32tree_find(ctx->u.trees.tree, inaddr);

  202.         } else {
  203.             vv = (ngx_stream_variable_value_t *)
  204.                       ngx_radix128tree_find(ctx->u.trees.tree6, p);
  205.         }

  207.         break;
  208. #endif

  210. #if (NGX_HAVE_UNIX_DOMAIN)
  211.     case AF_UNIX:
  212.         vv = (ngx_stream_variable_value_t *)
  213.                   ngx_radix32tree_find(ctx->u.trees.tree, INADDR_NONE);
  214.         break;
  215. #endif

  217.     default: /* AF_INET */
  218.         sin = (struct sockaddr_in *) addr.sockaddr;
  219.         inaddr = ntohl(sin->sin_addr.s_addr);

  221.         vv = (ngx_stream_variable_value_t *)
  222.                   ngx_radix32tree_find(ctx->u.trees.tree, inaddr);

  224.         break;
  225.     }

  227. done:

  229.     *v = *vv;

  231.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  232.                    "stream geo: %v", v);

  234.     return NGX_OK;
  235. }


  238. static ngx_int_t
  239. ‌ngx_stream_geo_range_variable(ngx_stream_session_t *s,
  240.     ngx_stream_variable_value_t *v, uintptr_t data)
  241. {
  242.     ngx_stream_geo_ctx_t *ctx = (ngx_stream_geo_ctx_t *) data;

  244.     in_addr_t                inaddr;
  245.     ngx_addr_t               addr;
  246.     ngx_uint_t               n;
  247.     struct sockaddr_in      *sin;
  248.     ngx_stream_geo_range_t  *range;
  249. #if (NGX_HAVE_INET6)
  250.     u_char                  *p;
  251.     struct in6_addr         *inaddr6;
  252. #endif

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

  256.     if (ngx_stream_geo_addr(s, ctx, &addr) == NGX_OK) {

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

  260. #if (NGX_HAVE_INET6)
  261.         case AF_INET6:
  262.             inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;

  264.             if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  265.                 p = inaddr6->s6_addr;

  267.                 inaddr = (in_addr_t) p[12] << 24;
  268.                 inaddr += p[13] << 16;
  269.                 inaddr += p[14] << 8;
  270.                 inaddr += p[15];

  272.             } else {
  273.                 inaddr = INADDR_NONE;
  274.             }

  276.             break;
  277. #endif

  279. #if (NGX_HAVE_UNIX_DOMAIN)
  280.         case AF_UNIX:
  281.             inaddr = INADDR_NONE;
  282.             break;
  283. #endif

  285.         default: /* AF_INET */
  286.             sin = (struct sockaddr_in *) addr.sockaddr;
  287.             inaddr = ntohl(sin->sin_addr.s_addr);
  288.             break;
  289.         }

  291.     } else {
  292.         inaddr = INADDR_NONE;
  293.     }

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

  298.         if (range) {
  299.             n = inaddr & 0xffff;
  300.             do {
  301.                 if (n >= (ngx_uint_t) range->start
  302.                     && n <= (ngx_uint_t) range->end)
  303.                 {
  304.                     *v = *range->value;
  305.                     break;
  306.                 }
  307.             } while ((++range)->value);
  308.         }
  309.     }

  311.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  312.                    "stream geo: %v", v);

  314.     return NGX_OK;
  315. }


  318. static ngx_int_t
  319. ‌ngx_stream_geo_addr(ngx_stream_session_t *s, ngx_stream_geo_ctx_t *ctx,
  320.     ngx_addr_t *addr)
  321. {
  322.     ngx_stream_variable_value_t  *v;

  324.     if (ctx->index == -1) {
  325.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  326.                        "stream geo started: %V", &s->connection->addr_text);

  328.         addr->sockaddr = s->connection->sockaddr;
  329.         addr->socklen = s->connection->socklen;
  330.         /* addr->name = s->connection->addr_text; */

  332.         return NGX_OK;
  333.     }

  335.     v = ngx_stream_get_flushed_variable(s, ctx->index);

  337.     if (v == NULL || v->not_found) {
  338.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  339.                        "stream geo not found");

  341.         return NGX_ERROR;
  342.     }

  344.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  345.                    "stream geo started: %v", v);

  347.     if (ngx_parse_addr(s->connection->pool, addr, v->data, v->len) == NGX_OK) {
  348.         return NGX_OK;
  349.     }

  351.     return NGX_ERROR;
  352. }


  355. static char *
  356. ‌ngx_stream_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  357. {
  358.     char                       *rv;
  359.     size_t                      len;
  360.     ngx_str_t                  *value, name;
  361.     ngx_uint_t                  i;
  362.     ngx_conf_t                  save;
  363.     ngx_pool_t                 *pool;
  364.     ngx_array_t                *a;
  365.     ngx_stream_variable_t      *var;
  366.     ngx_stream_geo_ctx_t       *geo;
  367.     ngx_stream_geo_conf_ctx_t   ctx;
  368. #if (NGX_HAVE_INET6)
  369.     static struct in6_addr      zero;
  370. #endif

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

  374.     geo = ngx_palloc(cf->pool, sizeof(ngx_stream_geo_ctx_t));
  375.     if (geo == NULL) {
  376.         return NGX_CONF_ERROR;
  377.     }

  379.     name = value[1];

  381.     if (name.data[0] != '$') {
  382.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  383.                            "invalid variable name \"%V\"", &name);
  384.         return NGX_CONF_ERROR;
  385.     }

  387.     name.len--;
  388.     name.data++;

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

  392.         geo->index = ngx_stream_get_variable_index(cf, &name);
  393.         if (geo->index == NGX_ERROR) {
  394.             return NGX_CONF_ERROR;
  395.         }

  397.         name = value[2];

  399.         if (name.data[0] != '$') {
  400.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  401.                                "invalid variable name \"%V\"", &name);
  402.             return NGX_CONF_ERROR;
  403.         }

  405.         name.len--;
  406.         name.data++;

  408.     } else {
  409.         geo->index = -1;
  410.     }

  412.     var = ngx_stream_add_variable(cf, &name, NGX_STREAM_VAR_CHANGEABLE);
  413.     if (var == NULL) {
  414.         return NGX_CONF_ERROR;
  415.     }

  417.     pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
  418.     if (pool == NULL) {
  419.         return NGX_CONF_ERROR;
  420.     }

  422.     ngx_memzero(&ctx, sizeof(ngx_stream_geo_conf_ctx_t));

  424.     ctx.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
  425.     if (ctx.temp_pool == NULL) {
  426.         ngx_destroy_pool(pool);
  427.         return NGX_CONF_ERROR;
  428.     }

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

  432.     ctx.pool = cf->pool;
  433.     ctx.data_size = sizeof(ngx_stream_geo_header_t)
  434.                   + sizeof(ngx_stream_variable_value_t)
  435.                   + 0x10000 * sizeof(ngx_stream_geo_range_t *);
  436.     ctx.allow_binary_include = 1;
  437.     ctx.no_cacheable = 0;

  439.     save = *cf;
  440.     cf->pool = pool;
  441.     cf->ctx = &ctx;
  442.     cf->handler = ngx_stream_geo;
  443.     cf->handler_conf = conf;

  445.     rv = ngx_conf_parse(cf, NULL);

  447.     *cf = save;

  449.     if (rv != NGX_CONF_OK) {
  450.         goto failed;
  451.     }

  453.     if (ctx.no_cacheable) {
  454.         var->flags |= NGX_STREAM_VAR_NOCACHEABLE;
  455.     }

  457.     if (ctx.ranges) {

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

  463.                 if (a == NULL) {
  464.                     continue;
  465.                 }

  467.                 if (a->nelts == 0) {
  468.                     ctx.high.low[i] = NULL;
  469.                     continue;
  470.                 }

  472.                 len = a->nelts * sizeof(ngx_stream_geo_range_t);

  474.                 ctx.high.low[i] = ngx_palloc(cf->pool, len + sizeof(void *));
  475.                 if (ctx.high.low[i] == NULL) {
  476.                     goto failed;
  477.                 }

  479.                 ngx_memcpy(ctx.high.low[i], a->elts, len);
  480.                 ctx.high.low[i][a->nelts].value = NULL;
  481.                 ctx.data_size += len + sizeof(void *);
  482.             }

  484.             if (ctx.allow_binary_include
  485.                 && !ctx.outside_entries
  486.                 && ctx.entries > 100000
  487.                 && ctx.includes == 1)
  488.             {
  489.                 ngx_stream_geo_create_binary_base(&ctx);
  490.             }
  491.         }

  493.         if (ctx.high.default_value == NULL) {
  494.             ctx.high.default_value = &ngx_stream_variable_null_value;
  495.         }

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

  499.         var->get_handler = ngx_stream_geo_range_variable;
  500.         var->data = (uintptr_t) geo;

  502.     } else {
  503.         if (ctx.tree == NULL) {
  504.             ctx.tree = ngx_radix_tree_create(cf->pool, -1);
  505.             if (ctx.tree == NULL) {
  506.                 goto failed;
  507.             }
  508.         }

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

  512. #if (NGX_HAVE_INET6)
  513.         if (ctx.tree6 == NULL) {
  514.             ctx.tree6 = ngx_radix_tree_create(cf->pool, -1);
  515.             if (ctx.tree6 == NULL) {
  516.                 goto failed;
  517.             }
  518.         }

  520.         geo->u.trees.tree6 = ctx.tree6;
  521. #endif

  523.         var->get_handler = ngx_stream_geo_cidr_variable;
  524.         var->data = (uintptr_t) geo;

  526.         if (ngx_radix32tree_insert(ctx.tree, 0, 0,
  527.                                    (uintptr_t) &ngx_stream_variable_null_value)
  528.             == NGX_ERROR)
  529.         {
  530.             goto failed;
  531.         }

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

  535. #if (NGX_HAVE_INET6)
  536.         if (ngx_radix128tree_insert(ctx.tree6, zero.s6_addr, zero.s6_addr,
  537.                                     (uintptr_t) &ngx_stream_variable_null_value)
  538.             == NGX_ERROR)
  539.         {
  540.             goto failed;
  541.         }
  542. #endif
  543.     }

  545.     ngx_destroy_pool(ctx.temp_pool);
  546.     ngx_destroy_pool(pool);

  548.     return NGX_CONF_OK;

  550. failed:

  552.     ngx_destroy_pool(ctx.temp_pool);
  553.     ngx_destroy_pool(pool);

  555.     return NGX_CONF_ERROR;
  556. }


  559. static char *
  560. ‌ngx_stream_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  561. {
  562.     char                       *rv;
  563.     ngx_str_t                  *value;
  564.     ngx_stream_geo_conf_ctx_t  *ctx;

  566.     ctx = cf->ctx;

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

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

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

  574.             if (ctx->tree
  575. #if (NGX_HAVE_INET6)
  576.                 || ctx->tree6
  577. #endif
  578.                )
  579.             {
  580.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  581.                                    "the \"ranges\" directive must be "
  582.                                    "the first directive inside \"geo\" block");
  583.                 goto failed;
  584.             }

  586.             ctx->ranges = 1;

  588.             rv = NGX_CONF_OK;

  590.             goto done;
  591.         }

  593.         else if (ngx_strcmp(value[0].data, "volatile") == 0) {
  594.             ctx->no_cacheable = 1;
  595.             rv = NGX_CONF_OK;
  596.             goto done;
  597.         }
  598.     }

  600.     if (cf->args->nelts != 2) {
  601.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  602.                            "invalid number of the geo parameters");
  603.         goto failed;
  604.     }

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

  608.         if (strpbrk((char *) value[1].data, "*?[") == NULL) {
  609.             rv = ngx_stream_geo_include(cf, ctx, &value[1]);

  611.         } else {
  612.             rv = ngx_conf_include(cf, dummy, conf);
  613.         }

  615.         goto done;
  616.     }

  618.     if (ctx->ranges) {
  619.         rv = ngx_stream_geo_range(cf, ctx, value);

  621.     } else {
  622.         rv = ngx_stream_geo_cidr(cf, ctx, value);
  623.     }

  625. done:

  627.     ngx_reset_pool(cf->pool);

  629.     return rv;

  631. failed:

  633.     ngx_reset_pool(cf->pool);

  635.     return NGX_CONF_ERROR;
  636. }


  639. static char *
  640. ‌ngx_stream_geo_range(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  641.     ngx_str_t *value)
  642. {
  643.     u_char      *p, *last;
  644.     in_addr_t    start, end;
  645.     ngx_str_t   *net;
  646.     ngx_uint_t   del;

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

  650.         if (ctx->high.default_value) {
  651.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  652.                 "duplicate default geo range value: \"%V\", old value: \"%v\"",
  653.                 &value[1], ctx->high.default_value);
  654.         }

  656.         ctx->high.default_value = ngx_stream_geo_value(cf, ctx, &value[1]);
  657.         if (ctx->high.default_value == NULL) {
  658.             return NGX_CONF_ERROR;
  659.         }

  661.         return NGX_CONF_OK;
  662.     }

  664.     if (ctx->binary_include) {
  665.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  666.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  667.             ctx->include_name.data);
  668.         return NGX_CONF_ERROR;
  669.     }

  671.     if (ctx->high.low == NULL) {
  672.         ctx->high.low = ngx_pcalloc(ctx->pool,
  673.                                     0x10000 * sizeof(ngx_stream_geo_range_t *));
  674.         if (ctx->high.low == NULL) {
  675.             return NGX_CONF_ERROR;
  676.         }
  677.     }

  679.     ctx->entries++;
  680.     ctx->outside_entries = 1;

  682.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  683.         net = &value[1];
  684.         del = 1;

  686.     } else {
  687.         net = &value[0];
  688.         del = 0;
  689.     }

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

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

  695.     if (p == NULL) {
  696.         goto invalid;
  697.     }

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

  701.     if (start == INADDR_NONE) {
  702.         goto invalid;
  703.     }

  705.     start = ntohl(start);

  707.     p++;

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

  711.     if (end == INADDR_NONE) {
  712.         goto invalid;
  713.     }

  715.     end = ntohl(end);

  717.     if (start > end) {
  718.         goto invalid;
  719.     }

  721.     if (del) {
  722.         if (ngx_stream_geo_delete_range(cf, ctx, start, end)) {
  723.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  724.                                "no address range \"%V\" to delete", net);
  725.         }

  727.         return NGX_CONF_OK;
  728.     }

  730.     ctx->value = ngx_stream_geo_value(cf, ctx, &value[1]);

  732.     if (ctx->value == NULL) {
  733.         return NGX_CONF_ERROR;
  734.     }

  736.     ctx->net = net;

  738.     return ngx_stream_geo_add_range(cf, ctx, start, end);

  740. invalid:

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

  744.     return NGX_CONF_ERROR;
  745. }


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

  750. static char *
  751. ‌ngx_stream_geo_add_range(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  752.     in_addr_t start, in_addr_t end)
  753. {
  754.     in_addr_t                n;
  755.     ngx_uint_t               h, i, s, e;
  756.     ngx_array_t             *a;
  757.     ngx_stream_geo_range_t  *range;

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

  761.         h = n >> 16;

  763.         if (n == start) {
  764.             s = n & 0xffff;
  765.         } else {
  766.             s = 0;
  767.         }

  769.         if ((n | 0xffff) > end) {
  770.             e = end & 0xffff;

  772.         } else {
  773.             e = 0xffff;
  774.         }

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

  778.         if (a == NULL) {
  779.             a = ngx_array_create(ctx->temp_pool, 64,
  780.                                  sizeof(ngx_stream_geo_range_t));
  781.             if (a == NULL) {
  782.                 return NGX_CONF_ERROR;
  783.             }

  785.             ctx->high.low[h] = (ngx_stream_geo_range_t *) a;
  786.         }

  788.         i = a->nelts;
  789.         range = a->elts;

  791.         while (i) {

  793.             i--;

  795.             if (e < (ngx_uint_t) range[i].start) {
  796.                 continue;
  797.             }

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

  801.                 /* add after the range */

  803.                 range = ngx_array_push(a);
  804.                 if (range == NULL) {
  805.                     return NGX_CONF_ERROR;
  806.                 }

  808.                 range = a->elts;

  810.                 ngx_memmove(&range[i + 2], &range[i + 1],
  811.                            (a->nelts - 2 - i) * sizeof(ngx_stream_geo_range_t));

  813.                 range[i + 1].start = (u_short) s;
  814.                 range[i + 1].end = (u_short) e;
  815.                 range[i + 1].value = ctx->value;

  817.                 goto next;
  818.             }

  820.             if (s == (ngx_uint_t) range[i].start
  821.                 && e == (ngx_uint_t) range[i].end)
  822.             {
  823.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  824.                     "duplicate range \"%V\", value: \"%v\", old value: \"%v\"",
  825.                     ctx->net, ctx->value, range[i].value);

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

  829.                 goto next;
  830.             }

  832.             if (s > (ngx_uint_t) range[i].start
  833.                 && e < (ngx_uint_t) range[i].end)
  834.             {
  835.                 /* split the range and insert the new one */

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

  842.                 range = ngx_array_push(a);
  843.                 if (range == NULL) {
  844.                     return NGX_CONF_ERROR;
  845.                 }

  847.                 range = a->elts;

  849.                 ngx_memmove(&range[i + 3], &range[i + 1],
  850.                            (a->nelts - 3 - i) * sizeof(ngx_stream_geo_range_t));

  852.                 range[i + 2].start = (u_short) (e + 1);
  853.                 range[i + 2].end = range[i].end;
  854.                 range[i + 2].value = range[i].value;

  856.                 range[i + 1].start = (u_short) s;
  857.                 range[i + 1].end = (u_short) e;
  858.                 range[i + 1].value = ctx->value;

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

  862.                 goto next;
  863.             }

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

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

  875.                 range = a->elts;

  877.                 ngx_memmove(&range[i + 1], &range[i],
  878.                            (a->nelts - 1 - i) * sizeof(ngx_stream_geo_range_t));

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

  882.                 range[i].start = (u_short) s;
  883.                 range[i].end = (u_short) e;
  884.                 range[i].value = ctx->value;

  886.                 goto next;
  887.             }

  889.             if (s > (ngx_uint_t) range[i].start
  890.                 && e == (ngx_uint_t) range[i].end)
  891.             {
  892.                 /* shift the range end and insert the new range */

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

  899.                 range = a->elts;

  901.                 ngx_memmove(&range[i + 2], &range[i + 1],
  902.                            (a->nelts - 2 - i) * sizeof(ngx_stream_geo_range_t));

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

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

  910.                 goto next;
  911.             }

  913.             s = (ngx_uint_t) range[i].start;
  914.             e = (ngx_uint_t) range[i].end;

  916.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  917.                          "range \"%V\" overlaps \"%d.%d.%d.%d-%d.%d.%d.%d\"",
  918.                          ctx->net,
  919.                          h >> 8, h & 0xff, s >> 8, s & 0xff,
  920.                          h >> 8, h & 0xff, e >> 8, e & 0xff);

  922.             return NGX_CONF_ERROR;
  923.         }

  925.         /* add the first 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[1], &range[0],
  935.                     (a->nelts - 1) * sizeof(ngx_stream_geo_range_t));

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

  941.     next:

  943.         if (h == 0xffff) {
  944.             break;
  945.         }
  946.     }

  948.     return NGX_CONF_OK;
  949. }


  952. static ngx_uint_t
  953. ‌ngx_stream_geo_delete_range(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  954.     in_addr_t start, in_addr_t end)
  955. {
  956.     in_addr_t                n;
  957.     ngx_uint_t               h, i, s, e, warn;
  958.     ngx_array_t             *a;
  959.     ngx_stream_geo_range_t  *range;

  961.     warn = 0;

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

  965.         h = n >> 16;

  967.         if (n == start) {
  968.             s = n & 0xffff;
  969.         } else {
  970.             s = 0;
  971.         }

  973.         if ((n | 0xffff) > end) {
  974.             e = end & 0xffff;

  976.         } else {
  977.             e = 0xffff;
  978.         }

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

  982.         if (a == NULL || a->nelts == 0) {
  983.             warn = 1;
  984.             goto next;
  985.         }

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

  990.             if (s == (ngx_uint_t) range[i].start
  991.                 && e == (ngx_uint_t) range[i].end)
  992.             {
  993.                 ngx_memmove(&range[i], &range[i + 1],
  994.                            (a->nelts - 1 - i) * sizeof(ngx_stream_geo_range_t));

  996.                 a->nelts--;

  998.                 break;
  999.             }

  1001.             if (i == a->nelts - 1) {
  1002.                 warn = 1;
  1003.             }
  1004.         }

  1006.     next:

  1008.         if (h == 0xffff) {
  1009.             break;
  1010.         }
  1011.     }

  1013.     return warn;
  1014. }


  1017. static char *
  1018. ‌ngx_stream_geo_cidr(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1019.     ngx_str_t *value)
  1020. {
  1021.     char        *rv;
  1022.     ngx_int_t    rc, del;
  1023.     ngx_str_t   *net;
  1024.     ngx_cidr_t   cidr;

  1026.     if (ctx->tree == NULL) {
  1027.         ctx->tree = ngx_radix_tree_create(ctx->pool, -1);
  1028.         if (ctx->tree == NULL) {
  1029.             return NGX_CONF_ERROR;
  1030.         }
  1031.     }

  1033. #if (NGX_HAVE_INET6)
  1034.     if (ctx->tree6 == NULL) {
  1035.         ctx->tree6 = ngx_radix_tree_create(ctx->pool, -1);
  1036.         if (ctx->tree6 == NULL) {
  1037.             return NGX_CONF_ERROR;
  1038.         }
  1039.     }
  1040. #endif

  1042.     if (ngx_strcmp(value[0].data, "default") == 0) {
  1043.         cidr.family = AF_INET;
  1044.         cidr.u.in.addr = 0;
  1045.         cidr.u.in.mask = 0;

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

  1049.         if (rv != NGX_CONF_OK) {
  1050.             return rv;
  1051.         }

  1053. #if (NGX_HAVE_INET6)
  1054.         cidr.family = AF_INET6;
  1055.         ngx_memzero(&cidr.u.in6, sizeof(ngx_in6_cidr_t));

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

  1059.         if (rv != NGX_CONF_OK) {
  1060.             return rv;
  1061.         }
  1062. #endif

  1064.         return NGX_CONF_OK;
  1065.     }

  1067.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  1068.         net = &value[1];
  1069.         del = 1;

  1071.     } else {
  1072.         net = &value[0];
  1073.         del = 0;
  1074.     }

  1076.     if (ngx_stream_geo_cidr_value(cf, net, &cidr) != NGX_OK) {
  1077.         return NGX_CONF_ERROR;
  1078.     }

  1080.     if (cidr.family == AF_INET) {
  1081.         cidr.u.in.addr = ntohl(cidr.u.in.addr);
  1082.         cidr.u.in.mask = ntohl(cidr.u.in.mask);
  1083.     }

  1085.     if (del) {
  1086.         switch (cidr.family) {

  1088. #if (NGX_HAVE_INET6)
  1089.         case AF_INET6:
  1090.             rc = ngx_radix128tree_delete(ctx->tree6,
  1091.                                          cidr.u.in6.addr.s6_addr,
  1092.                                          cidr.u.in6.mask.s6_addr);
  1093.             break;
  1094. #endif

  1096.         default: /* AF_INET */
  1097.             rc = ngx_radix32tree_delete(ctx->tree, cidr.u.in.addr,
  1098.                                         cidr.u.in.mask);
  1099.             break;
  1100.         }

  1102.         if (rc != NGX_OK) {
  1103.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1104.                                "no network \"%V\" to delete", net);
  1105.         }

  1107.         return NGX_CONF_OK;
  1108.     }

  1110.     return ngx_stream_geo_cidr_add(cf, ctx, &cidr, &value[1], net);
  1111. }


  1114. static char *
  1115. ‌ngx_stream_geo_cidr_add(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1116.     ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net)
  1117. {
  1118.     ngx_int_t                     rc;
  1119.     ngx_stream_variable_value_t  *val, *old;

  1121.     val = ngx_stream_geo_value(cf, ctx, value);

  1123.     if (val == NULL) {
  1124.         return NGX_CONF_ERROR;
  1125.     }

  1127.     switch (cidr->family) {

  1129. #if (NGX_HAVE_INET6)
  1130.     case AF_INET6:
  1131.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1132.                                      cidr->u.in6.mask.s6_addr,
  1133.                                      (uintptr_t) val);

  1135.         if (rc == NGX_OK) {
  1136.             return NGX_CONF_OK;
  1137.         }

  1139.         if (rc == NGX_ERROR) {
  1140.             return NGX_CONF_ERROR;
  1141.         }

  1143.         /* rc == NGX_BUSY */

  1145.         old = (ngx_stream_variable_value_t *)
  1146.                    ngx_radix128tree_find(ctx->tree6,
  1147.                                          cidr->u.in6.addr.s6_addr);

  1149.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1150.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1151.               net, val, old);

  1153.         rc = ngx_radix128tree_delete(ctx->tree6,
  1154.                                      cidr->u.in6.addr.s6_addr,
  1155.                                      cidr->u.in6.mask.s6_addr);

  1157.         if (rc == NGX_ERROR) {
  1158.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1159.             return NGX_CONF_ERROR;
  1160.         }

  1162.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1163.                                      cidr->u.in6.mask.s6_addr,
  1164.                                      (uintptr_t) val);

  1166.         break;
  1167. #endif

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

  1173.         if (rc == NGX_OK) {
  1174.             return NGX_CONF_OK;
  1175.         }

  1177.         if (rc == NGX_ERROR) {
  1178.             return NGX_CONF_ERROR;
  1179.         }

  1181.         /* rc == NGX_BUSY */

  1183.         old = (ngx_stream_variable_value_t *)
  1184.                    ngx_radix32tree_find(ctx->tree, cidr->u.in.addr);

  1186.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1187.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1188.               net, val, old);

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

  1193.         if (rc == NGX_ERROR) {
  1194.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1195.             return NGX_CONF_ERROR;
  1196.         }

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

  1201.         break;
  1202.     }

  1204.     if (rc == NGX_OK) {
  1205.         return NGX_CONF_OK;
  1206.     }

  1208.     return NGX_CONF_ERROR;
  1209. }


  1212. static ngx_stream_variable_value_t *
  1213. ‌ngx_stream_geo_value(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1214.     ngx_str_t *value)
  1215. {
  1216.     uint32_t                               hash;
  1217.     ngx_stream_variable_value_t           *val;
  1218.     ngx_stream_geo_variable_value_node_t  *gvvn;

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

  1222.     gvvn = (ngx_stream_geo_variable_value_node_t *)
  1223.                ngx_str_rbtree_lookup(&ctx->rbtree, value, hash);

  1225.     if (gvvn) {
  1226.         return gvvn->value;
  1227.     }

  1229.     val = ngx_pcalloc(ctx->pool, sizeof(ngx_stream_variable_value_t));
  1230.     if (val == NULL) {
  1231.         return NULL;
  1232.     }

  1234.     val->len = value->len;
  1235.     val->data = ngx_pstrdup(ctx->pool, value);
  1236.     if (val->data == NULL) {
  1237.         return NULL;
  1238.     }

  1240.     val->valid = 1;

  1242.     gvvn = ngx_palloc(ctx->temp_pool,
  1243.                       sizeof(ngx_stream_geo_variable_value_node_t));
  1244.     if (gvvn == NULL) {
  1245.         return NULL;
  1246.     }

  1248.     gvvn->sn.node.key = hash;
  1249.     gvvn->sn.str.len = val->len;
  1250.     gvvn->sn.str.data = val->data;
  1251.     gvvn->value = val;
  1252.     gvvn->offset = 0;

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

  1256.     ctx->data_size += ngx_align(sizeof(ngx_stream_variable_value_t)
  1257.                                 + value->len, sizeof(void *));

  1259.     return val;
  1260. }


  1263. static ngx_int_t
  1264. ‌ngx_stream_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net, ngx_cidr_t *cidr)
  1265. {
  1266.     ngx_int_t  rc;

  1268.     if (ngx_strcmp(net->data, "255.255.255.255") == 0) {
  1269.         cidr->family = AF_INET;
  1270.         cidr->u.in.addr = 0xffffffff;
  1271.         cidr->u.in.mask = 0xffffffff;

  1273.         return NGX_OK;
  1274.     }

  1276.     rc = ngx_ptocidr(net, cidr);

  1278.     if (rc == NGX_ERROR) {
  1279.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid network \"%V\"", net);
  1280.         return NGX_ERROR;
  1281.     }

  1283.     if (rc == NGX_DONE) {
  1284.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1285.                            "low address bits of %V are meaningless", net);
  1286.     }

  1288.     return NGX_OK;
  1289. }


  1292. static char *
  1293. ‌ngx_stream_geo_include(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1294.     ngx_str_t *name)
  1295. {
  1296.     char       *rv;
  1297.     ngx_str_t   file;

  1299.     file.len = name->len + 4;
  1300.     file.data = ngx_pnalloc(ctx->temp_pool, name->len + 5);
  1301.     if (file.data == NULL) {
  1302.         return NGX_CONF_ERROR;
  1303.     }

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

  1307.     if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
  1308.         return NGX_CONF_ERROR;
  1309.     }

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

  1314.         switch (ngx_stream_geo_include_binary_base(cf, ctx, &file)) {
  1315.         case NGX_OK:
  1316.             return NGX_CONF_OK;
  1317.         case NGX_ERROR:
  1318.             return NGX_CONF_ERROR;
  1319.         default:
  1320.             break;
  1321.         }
  1322.     }

  1324.     file.len -= 4;
  1325.     file.data[file.len] = '\0';

  1327.     ctx->include_name = file;

  1329.     if (ctx->outside_entries) {
  1330.         ctx->allow_binary_include = 0;
  1331.     }

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

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

  1337.     ctx->includes++;
  1338.     ctx->outside_entries = 0;

  1340.     return rv;
  1341. }


  1344. static ngx_int_t
  1345. ‌ngx_stream_geo_include_binary_base(ngx_conf_t *cf,
  1346.     ngx_stream_geo_conf_ctx_t *ctx, ngx_str_t *name)
  1347. {
  1348.     u_char                       *base, ch;
  1349.     time_t                        mtime;
  1350.     size_t                        size, len;
  1351.     ssize_t                       n;
  1352.     uint32_t                      crc32;
  1353.     ngx_err_t                     err;
  1354.     ngx_int_t                     rc;
  1355.     ngx_uint_t                    i;
  1356.     ngx_file_t                    file;
  1357.     ngx_file_info_t               fi;
  1358.     ngx_stream_geo_range_t       *range, **ranges;
  1359.     ngx_stream_geo_header_t      *header;
  1360.     ngx_stream_variable_value_t  *vv;

  1362.     ngx_memzero(&file, sizeof(ngx_file_t));
  1363.     file.name = *name;
  1364.     file.log = cf->log;

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

  1368.     if (file.fd == NGX_INVALID_FILE) {
  1369.         err = ngx_errno;
  1370.         if (err != NGX_ENOENT) {
  1371.             ngx_conf_log_error(NGX_LOG_CRIT, cf, err,
  1372.                                ngx_open_file_n " \"%s\" failed", name->data);
  1373.         }
  1374.         return NGX_DECLINED;
  1375.     }

  1377.     if (ctx->outside_entries) {
  1378.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1379.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  1380.             name->data);
  1381.         rc = NGX_ERROR;
  1382.         goto done;
  1383.     }

  1385.     if (ctx->binary_include) {
  1386.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1387.             "second binary geo range base \"%s\" cannot be mixed with \"%s\"",
  1388.             name->data, ctx->include_name.data);
  1389.         rc = NGX_ERROR;
  1390.         goto done;
  1391.     }

  1393.     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  1394.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1395.                            ngx_fd_info_n " \"%s\" failed", name->data);
  1396.         goto failed;
  1397.     }

  1399.     size = (size_t) ngx_file_size(&fi);
  1400.     mtime = ngx_file_mtime(&fi);

  1402.     ch = name->data[name->len - 4];
  1403.     name->data[name->len - 4] = '\0';

  1405.     if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
  1406.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1407.                            ngx_file_info_n " \"%s\" failed", name->data);
  1408.         goto failed;
  1409.     }

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

  1413.     if (mtime < ngx_file_mtime(&fi)) {
  1414.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1415.                            "stale binary geo range base \"%s\"", name->data);
  1416.         goto failed;
  1417.     }

  1419.     base = ngx_palloc(ctx->pool, size);
  1420.     if (base == NULL) {
  1421.         goto failed;
  1422.     }

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

  1426.     if (n == NGX_ERROR) {
  1427.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1428.                            ngx_read_file_n " \"%s\" failed", name->data);
  1429.         goto failed;
  1430.     }

  1432.     if ((size_t) n != size) {
  1433.         ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  1434.             ngx_read_file_n " \"%s\" returned only %z bytes instead of %z",
  1435.             name->data, n, size);
  1436.         goto failed;
  1437.     }

  1439.     header = (ngx_stream_geo_header_t *) base;

  1441.     if (size < 16 || ngx_memcmp(&ngx_stream_geo_header, header, 12) != 0) {
  1442.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1443.              "incompatible binary geo range base \"%s\"", name->data);
  1444.         goto failed;
  1445.     }

  1447.     ngx_crc32_init(crc32);

  1449.     vv = (ngx_stream_variable_value_t *)
  1450.             (base + sizeof(ngx_stream_geo_header_t));

  1452.     while (vv->data) {
  1453.         len = ngx_align(sizeof(ngx_stream_variable_value_t) + vv->len,
  1454.                         sizeof(void *));
  1455.         ngx_crc32_update(&crc32, (u_char *) vv, len);
  1456.         vv->data += (size_t) base;
  1457.         vv = (ngx_stream_variable_value_t *) ((u_char *) vv + len);
  1458.     }
  1459.     ngx_crc32_update(&crc32, (u_char *) vv,
  1460.                      sizeof(ngx_stream_variable_value_t));
  1461.     vv++;

  1463.     ranges = (ngx_stream_geo_range_t **) vv;

  1465.     for (i = 0; i < 0x10000; i++) {
  1466.         ngx_crc32_update(&crc32, (u_char *) &ranges[i], sizeof(void *));
  1467.         if (ranges[i]) {
  1468.             ranges[i] = (ngx_stream_geo_range_t *)
  1469.                             ((u_char *) ranges[i] + (size_t) base);
  1470.         }
  1471.     }

  1473.     range = (ngx_stream_geo_range_t *) &ranges[0x10000];

  1475.     while ((u_char *) range < base + size) {
  1476.         while (range->value) {
  1477.             ngx_crc32_update(&crc32, (u_char *) range,
  1478.                              sizeof(ngx_stream_geo_range_t));
  1479.             range->value = (ngx_stream_variable_value_t *)
  1480.                                ((u_char *) range->value + (size_t) base);
  1481.             range++;
  1482.         }
  1483.         ngx_crc32_update(&crc32, (u_char *) range, sizeof(void *));
  1484.         range = (ngx_stream_geo_range_t *) ((u_char *) range + sizeof(void *));
  1485.     }

  1487.     ngx_crc32_final(crc32);

  1489.     if (crc32 != header->crc32) {
  1490.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1491.                   "CRC32 mismatch in binary geo range base \"%s\"", name->data);
  1492.         goto failed;
  1493.     }

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

  1498.     ctx->include_name = *name;
  1499.     ctx->binary_include = 1;
  1500.     ctx->high.low = ranges;
  1501.     rc = NGX_OK;

  1503.     goto done;

  1505. failed:

  1507.     rc = NGX_DECLINED;

  1509. done:

  1511.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  1512.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  1513.                       ngx_close_file_n " \"%s\" failed", name->data);
  1514.     }

  1516.     return rc;
  1517. }


  1520. static void
  1521. ‌ngx_stream_geo_create_binary_base(ngx_stream_geo_conf_ctx_t *ctx)
  1522. {
  1523.     u_char                                *p;
  1524.     uint32_t                               hash;
  1525.     ngx_str_t                              s;
  1526.     ngx_uint_t                             i;
  1527.     ngx_file_mapping_t                     fm;
  1528.     ngx_stream_geo_range_t                *r, *range, **ranges;
  1529.     ngx_stream_geo_header_t               *header;
  1530.     ngx_stream_geo_variable_value_node_t  *gvvn;

  1532.     fm.name = ngx_pnalloc(ctx->temp_pool, ctx->include_name.len + 5);
  1533.     if (fm.name == NULL) {
  1534.         return;
  1535.     }

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

  1539.     fm.size = ctx->data_size;
  1540.     fm.log = ctx->pool->log;

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

  1545.     if (ngx_create_file_mapping(&fm) != NGX_OK) {
  1546.         return;
  1547.     }

  1549.     p = ngx_cpymem(fm.addr, &ngx_stream_geo_header,
  1550.                    sizeof(ngx_stream_geo_header_t));

  1552.     p = ngx_stream_geo_copy_values(fm.addr, p, ctx->rbtree.root,
  1553.                                    ctx->rbtree.sentinel);

  1555.     p += sizeof(ngx_stream_variable_value_t);

  1557.     ranges = (ngx_stream_geo_range_t **) p;

  1559.     p += 0x10000 * sizeof(ngx_stream_geo_range_t *);

  1561.     for (i = 0; i < 0x10000; i++) {
  1562.         r = ctx->high.low[i];
  1563.         if (r == NULL) {
  1564.             continue;
  1565.         }

  1567.         range = (ngx_stream_geo_range_t *) p;
  1568.         ranges[i] = (ngx_stream_geo_range_t *) (p - (u_char *) fm.addr);

  1570.         do {
  1571.             s.len = r->value->len;
  1572.             s.data = r->value->data;
  1573.             hash = ngx_crc32_long(s.data, s.len);
  1574.             gvvn = (ngx_stream_geo_variable_value_node_t *)
  1575.                         ngx_str_rbtree_lookup(&ctx->rbtree, &s, hash);

  1577.             range->value = (ngx_stream_variable_value_t *) gvvn->offset;
  1578.             range->start = r->start;
  1579.             range->end = r->end;
  1580.             range++;

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

  1584.         range->value = NULL;

  1586.         p = (u_char *) range + sizeof(void *);
  1587.     }

  1589.     header = fm.addr;
  1590.     header->crc32 = ngx_crc32_long((u_char *) fm.addr
  1591.                                        + sizeof(ngx_stream_geo_header_t),
  1592.                                    fm.size - sizeof(ngx_stream_geo_header_t));

  1594.     ngx_close_file_mapping(&fm);
  1595. }


  1598. static u_char *
  1599. ‌ngx_stream_geo_copy_values(u_char *base, u_char *p, ngx_rbtree_node_t *node,
  1600.     ngx_rbtree_node_t *sentinel)
  1601. {
  1602.     ngx_stream_variable_value_t           *vv;
  1603.     ngx_stream_geo_variable_value_node_t  *gvvn;

  1605.     if (node == sentinel) {
  1606.         return p;
  1607.     }

  1609.     gvvn = (ngx_stream_geo_variable_value_node_t *) node;
  1610.     gvvn->offset = p - base;

  1612.     vv = (ngx_stream_variable_value_t *) p;
  1613.     *vv = *gvvn->value;
  1614.     p += sizeof(ngx_stream_variable_value_t);
  1615.     vv->data = (u_char *) (p - base);

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

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

  1621.     p = ngx_stream_geo_copy_values(base, p, node->left, sentinel);

  1623.     return ngx_stream_geo_copy_values(base, p, node->right, sentinel);
  1624. }

One Level Up Top Level