One Level Up Top Level

src/stream/ngx_stream_geo_module.c - nginx source code

Global variables defined

Data types defined

Functions defined

Source code


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


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_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. ‌} ngx_stream_geo_conf_ctx_t;


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

  73.     ngx_int_t                          index;
  74. ‌} ngx_stream_geo_ctx_t;


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

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


  107. ‌static ngx_command_t  ngx_stream_geo_commands[] = {

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

  116.       ngx_null_command
  117. };


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

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

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


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


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


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


  162. /* geo range is AF_INET only */

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

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

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

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

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

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

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

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

  206.         break;
  207. #endif

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

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

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

  223.         break;
  224.     }

  226. done:

  228.     *v = *vv;

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

  233.     return NGX_OK;
  234. }


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

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

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

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

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

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

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

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

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

  275.             break;
  276. #endif

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

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

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

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

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

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

  313.     return NGX_OK;
  314. }


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

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

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

  331.         return NGX_OK;
  332.     }

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

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

  340.         return NGX_ERROR;
  341.     }

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

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

  350.     return NGX_ERROR;
  351. }


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

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

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

  378.     name = value[1];

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

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

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

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

  396.         name = value[2];

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

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

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

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

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

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

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

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

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

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

  443.     rv = ngx_conf_parse(cf, NULL);

  445.     *cf = save;

  447.     if (rv != NGX_CONF_OK) {
  448.         goto failed;
  449.     }

  451.     if (ctx.ranges) {

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

  457.                 if (a == NULL) {
  458.                     continue;
  459.                 }

  461.                 if (a->nelts == 0) {
  462.                     ctx.high.low[i] = NULL;
  463.                     continue;
  464.                 }

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

  468.                 ctx.high.low[i] = ngx_palloc(cf->pool, len + sizeof(void *));
  469.                 if (ctx.high.low[i] == NULL) {
  470.                     goto failed;
  471.                 }

  473.                 ngx_memcpy(ctx.high.low[i], a->elts, len);
  474.                 ctx.high.low[i][a->nelts].value = NULL;
  475.                 ctx.data_size += len + sizeof(void *);
  476.             }

  478.             if (ctx.allow_binary_include
  479.                 && !ctx.outside_entries
  480.                 && ctx.entries > 100000
  481.                 && ctx.includes == 1)
  482.             {
  483.                 ngx_stream_geo_create_binary_base(&ctx);
  484.             }
  485.         }

  487.         if (ctx.high.default_value == NULL) {
  488.             ctx.high.default_value = &ngx_stream_variable_null_value;
  489.         }

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

  493.         var->get_handler = ngx_stream_geo_range_variable;
  494.         var->data = (uintptr_t) geo;

  496.     } else {
  497.         if (ctx.tree == NULL) {
  498.             ctx.tree = ngx_radix_tree_create(cf->pool, -1);
  499.             if (ctx.tree == NULL) {
  500.                 goto failed;
  501.             }
  502.         }

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

  506. #if (NGX_HAVE_INET6)
  507.         if (ctx.tree6 == NULL) {
  508.             ctx.tree6 = ngx_radix_tree_create(cf->pool, -1);
  509.             if (ctx.tree6 == NULL) {
  510.                 goto failed;
  511.             }
  512.         }

  514.         geo->u.trees.tree6 = ctx.tree6;
  515. #endif

  517.         var->get_handler = ngx_stream_geo_cidr_variable;
  518.         var->data = (uintptr_t) geo;

  520.         if (ngx_radix32tree_insert(ctx.tree, 0, 0,
  521.                                    (uintptr_t) &ngx_stream_variable_null_value)
  522.             == NGX_ERROR)
  523.         {
  524.             goto failed;
  525.         }

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

  529. #if (NGX_HAVE_INET6)
  530.         if (ngx_radix128tree_insert(ctx.tree6, zero.s6_addr, zero.s6_addr,
  531.                                     (uintptr_t) &ngx_stream_variable_null_value)
  532.             == NGX_ERROR)
  533.         {
  534.             goto failed;
  535.         }
  536. #endif
  537.     }

  539.     ngx_destroy_pool(ctx.temp_pool);
  540.     ngx_destroy_pool(pool);

  542.     return NGX_CONF_OK;

  544. failed:

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

  549.     return NGX_CONF_ERROR;
  550. }


  553. static char *
  554. ‌ngx_stream_geo(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
  555. {
  556.     char                       *rv;
  557.     ngx_str_t                  *value;
  558.     ngx_stream_geo_conf_ctx_t  *ctx;

  560.     ctx = cf->ctx;

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

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

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

  568.             if (ctx->tree
  569. #if (NGX_HAVE_INET6)
  570.                 || ctx->tree6
  571. #endif
  572.                )
  573.             {
  574.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  575.                                    "the \"ranges\" directive must be "
  576.                                    "the first directive inside \"geo\" block");
  577.                 goto failed;
  578.             }

  580.             ctx->ranges = 1;

  582.             rv = NGX_CONF_OK;

  584.             goto done;
  585.         }
  586.     }

  588.     if (cf->args->nelts != 2) {
  589.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  590.                            "invalid number of the geo parameters");
  591.         goto failed;
  592.     }

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

  596.         rv = ngx_stream_geo_include(cf, ctx, &value[1]);

  598.         goto done;
  599.     }

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

  604.     } else {
  605.         rv = ngx_stream_geo_cidr(cf, ctx, value);
  606.     }

  608. done:

  610.     ngx_reset_pool(cf->pool);

  612.     return rv;

  614. failed:

  616.     ngx_reset_pool(cf->pool);

  618.     return NGX_CONF_ERROR;
  619. }


  622. static char *
  623. ‌ngx_stream_geo_range(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  624.     ngx_str_t *value)
  625. {
  626.     u_char      *p, *last;
  627.     in_addr_t    start, end;
  628.     ngx_str_t   *net;
  629.     ngx_uint_t   del;

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

  633.         if (ctx->high.default_value) {
  634.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  635.                 "duplicate default geo range value: \"%V\", old value: \"%v\"",
  636.                 &value[1], ctx->high.default_value);
  637.         }

  639.         ctx->high.default_value = ngx_stream_geo_value(cf, ctx, &value[1]);
  640.         if (ctx->high.default_value == NULL) {
  641.             return NGX_CONF_ERROR;
  642.         }

  644.         return NGX_CONF_OK;
  645.     }

  647.     if (ctx->binary_include) {
  648.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  649.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  650.             ctx->include_name.data);
  651.         return NGX_CONF_ERROR;
  652.     }

  654.     if (ctx->high.low == NULL) {
  655.         ctx->high.low = ngx_pcalloc(ctx->pool,
  656.                                     0x10000 * sizeof(ngx_stream_geo_range_t *));
  657.         if (ctx->high.low == NULL) {
  658.             return NGX_CONF_ERROR;
  659.         }
  660.     }

  662.     ctx->entries++;
  663.     ctx->outside_entries = 1;

  665.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  666.         net = &value[1];
  667.         del = 1;

  669.     } else {
  670.         net = &value[0];
  671.         del = 0;
  672.     }

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

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

  678.     if (p == NULL) {
  679.         goto invalid;
  680.     }

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

  684.     if (start == INADDR_NONE) {
  685.         goto invalid;
  686.     }

  688.     start = ntohl(start);

  690.     p++;

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

  694.     if (end == INADDR_NONE) {
  695.         goto invalid;
  696.     }

  698.     end = ntohl(end);

  700.     if (start > end) {
  701.         goto invalid;
  702.     }

  704.     if (del) {
  705.         if (ngx_stream_geo_delete_range(cf, ctx, start, end)) {
  706.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  707.                                "no address range \"%V\" to delete", net);
  708.         }

  710.         return NGX_CONF_OK;
  711.     }

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

  715.     if (ctx->value == NULL) {
  716.         return NGX_CONF_ERROR;
  717.     }

  719.     ctx->net = net;

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

  723. invalid:

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

  727.     return NGX_CONF_ERROR;
  728. }


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

  733. static char *
  734. ‌ngx_stream_geo_add_range(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  735.     in_addr_t start, in_addr_t end)
  736. {
  737.     in_addr_t                n;
  738.     ngx_uint_t               h, i, s, e;
  739.     ngx_array_t             *a;
  740.     ngx_stream_geo_range_t  *range;

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

  744.         h = n >> 16;

  746.         if (n == start) {
  747.             s = n & 0xffff;
  748.         } else {
  749.             s = 0;
  750.         }

  752.         if ((n | 0xffff) > end) {
  753.             e = end & 0xffff;

  755.         } else {
  756.             e = 0xffff;
  757.         }

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

  761.         if (a == NULL) {
  762.             a = ngx_array_create(ctx->temp_pool, 64,
  763.                                  sizeof(ngx_stream_geo_range_t));
  764.             if (a == NULL) {
  765.                 return NGX_CONF_ERROR;
  766.             }

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

  771.         i = a->nelts;
  772.         range = a->elts;

  774.         while (i) {

  776.             i--;

  778.             if (e < (ngx_uint_t) range[i].start) {
  779.                 continue;
  780.             }

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

  784.                 /* add after the range */

  786.                 range = ngx_array_push(a);
  787.                 if (range == NULL) {
  788.                     return NGX_CONF_ERROR;
  789.                 }

  791.                 range = a->elts;

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

  796.                 range[i + 1].start = (u_short) s;
  797.                 range[i + 1].end = (u_short) e;
  798.                 range[i + 1].value = ctx->value;

  800.                 goto next;
  801.             }

  803.             if (s == (ngx_uint_t) range[i].start
  804.                 && e == (ngx_uint_t) range[i].end)
  805.             {
  806.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  807.                     "duplicate range \"%V\", value: \"%v\", old value: \"%v\"",
  808.                     ctx->net, ctx->value, range[i].value);

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

  812.                 goto next;
  813.             }

  815.             if (s > (ngx_uint_t) range[i].start
  816.                 && e < (ngx_uint_t) range[i].end)
  817.             {
  818.                 /* split the range and insert the new one */

  820.                 range = ngx_array_push(a);
  821.                 if (range == NULL) {
  822.                     return NGX_CONF_ERROR;
  823.                 }

  825.                 range = ngx_array_push(a);
  826.                 if (range == NULL) {
  827.                     return NGX_CONF_ERROR;
  828.                 }

  830.                 range = a->elts;

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

  835.                 range[i + 2].start = (u_short) (e + 1);
  836.                 range[i + 2].end = range[i].end;
  837.                 range[i + 2].value = range[i].value;

  839.                 range[i + 1].start = (u_short) s;
  840.                 range[i + 1].end = (u_short) e;
  841.                 range[i + 1].value = ctx->value;

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

  845.                 goto next;
  846.             }

  848.             if (s == (ngx_uint_t) range[i].start
  849.                 && e < (ngx_uint_t) range[i].end)
  850.             {
  851.                 /* shift the range start and insert the new range */

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

  858.                 range = a->elts;

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

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

  865.                 range[i].start = (u_short) s;
  866.                 range[i].end = (u_short) e;
  867.                 range[i].value = ctx->value;

  869.                 goto next;
  870.             }

  872.             if (s > (ngx_uint_t) range[i].start
  873.                 && e == (ngx_uint_t) range[i].end)
  874.             {
  875.                 /* shift the range end and insert the new range */

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

  882.                 range = a->elts;

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

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

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

  893.                 goto next;
  894.             }

  896.             s = (ngx_uint_t) range[i].start;
  897.             e = (ngx_uint_t) range[i].end;

  899.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  900.                          "range \"%V\" overlaps \"%d.%d.%d.%d-%d.%d.%d.%d\"",
  901.                          ctx->net,
  902.                          h >> 8, h & 0xff, s >> 8, s & 0xff,
  903.                          h >> 8, h & 0xff, e >> 8, e & 0xff);

  905.             return NGX_CONF_ERROR;
  906.         }

  908.         /* add the first range */

  910.         range = ngx_array_push(a);
  911.         if (range == NULL) {
  912.             return NGX_CONF_ERROR;
  913.         }

  915.         range = a->elts;

  917.         ngx_memmove(&range[1], &range[0],
  918.                     (a->nelts - 1) * sizeof(ngx_stream_geo_range_t));

  920.         range[0].start = (u_short) s;
  921.         range[0].end = (u_short) e;
  922.         range[0].value = ctx->value;

  924.     next:

  926.         if (h == 0xffff) {
  927.             break;
  928.         }
  929.     }

  931.     return NGX_CONF_OK;
  932. }


  935. static ngx_uint_t
  936. ‌ngx_stream_geo_delete_range(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  937.     in_addr_t start, in_addr_t end)
  938. {
  939.     in_addr_t                n;
  940.     ngx_uint_t               h, i, s, e, warn;
  941.     ngx_array_t             *a;
  942.     ngx_stream_geo_range_t  *range;

  944.     warn = 0;

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

  948.         h = n >> 16;

  950.         if (n == start) {
  951.             s = n & 0xffff;
  952.         } else {
  953.             s = 0;
  954.         }

  956.         if ((n | 0xffff) > end) {
  957.             e = end & 0xffff;

  959.         } else {
  960.             e = 0xffff;
  961.         }

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

  965.         if (a == NULL || a->nelts == 0) {
  966.             warn = 1;
  967.             goto next;
  968.         }

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

  973.             if (s == (ngx_uint_t) range[i].start
  974.                 && e == (ngx_uint_t) range[i].end)
  975.             {
  976.                 ngx_memmove(&range[i], &range[i + 1],
  977.                            (a->nelts - 1 - i) * sizeof(ngx_stream_geo_range_t));

  979.                 a->nelts--;

  981.                 break;
  982.             }

  984.             if (i == a->nelts - 1) {
  985.                 warn = 1;
  986.             }
  987.         }

  989.     next:

  991.         if (h == 0xffff) {
  992.             break;
  993.         }
  994.     }

  996.     return warn;
  997. }


  1000. static char *
  1001. ‌ngx_stream_geo_cidr(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1002.     ngx_str_t *value)
  1003. {
  1004.     char        *rv;
  1005.     ngx_int_t    rc, del;
  1006.     ngx_str_t   *net;
  1007.     ngx_cidr_t   cidr;

  1009.     if (ctx->tree == NULL) {
  1010.         ctx->tree = ngx_radix_tree_create(ctx->pool, -1);
  1011.         if (ctx->tree == NULL) {
  1012.             return NGX_CONF_ERROR;
  1013.         }
  1014.     }

  1016. #if (NGX_HAVE_INET6)
  1017.     if (ctx->tree6 == NULL) {
  1018.         ctx->tree6 = ngx_radix_tree_create(ctx->pool, -1);
  1019.         if (ctx->tree6 == NULL) {
  1020.             return NGX_CONF_ERROR;
  1021.         }
  1022.     }
  1023. #endif

  1025.     if (ngx_strcmp(value[0].data, "default") == 0) {
  1026.         cidr.family = AF_INET;
  1027.         cidr.u.in.addr = 0;
  1028.         cidr.u.in.mask = 0;

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

  1032.         if (rv != NGX_CONF_OK) {
  1033.             return rv;
  1034.         }

  1036. #if (NGX_HAVE_INET6)
  1037.         cidr.family = AF_INET6;
  1038.         ngx_memzero(&cidr.u.in6, sizeof(ngx_in6_cidr_t));

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

  1042.         if (rv != NGX_CONF_OK) {
  1043.             return rv;
  1044.         }
  1045. #endif

  1047.         return NGX_CONF_OK;
  1048.     }

  1050.     if (ngx_strcmp(value[0].data, "delete") == 0) {
  1051.         net = &value[1];
  1052.         del = 1;

  1054.     } else {
  1055.         net = &value[0];
  1056.         del = 0;
  1057.     }

  1059.     if (ngx_stream_geo_cidr_value(cf, net, &cidr) != NGX_OK) {
  1060.         return NGX_CONF_ERROR;
  1061.     }

  1063.     if (cidr.family == AF_INET) {
  1064.         cidr.u.in.addr = ntohl(cidr.u.in.addr);
  1065.         cidr.u.in.mask = ntohl(cidr.u.in.mask);
  1066.     }

  1068.     if (del) {
  1069.         switch (cidr.family) {

  1071. #if (NGX_HAVE_INET6)
  1072.         case AF_INET6:
  1073.             rc = ngx_radix128tree_delete(ctx->tree6,
  1074.                                          cidr.u.in6.addr.s6_addr,
  1075.                                          cidr.u.in6.mask.s6_addr);
  1076.             break;
  1077. #endif

  1079.         default: /* AF_INET */
  1080.             rc = ngx_radix32tree_delete(ctx->tree, cidr.u.in.addr,
  1081.                                         cidr.u.in.mask);
  1082.             break;
  1083.         }

  1085.         if (rc != NGX_OK) {
  1086.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1087.                                "no network \"%V\" to delete", net);
  1088.         }

  1090.         return NGX_CONF_OK;
  1091.     }

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


  1097. static char *
  1098. ‌ngx_stream_geo_cidr_add(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1099.     ngx_cidr_t *cidr, ngx_str_t *value, ngx_str_t *net)
  1100. {
  1101.     ngx_int_t                     rc;
  1102.     ngx_stream_variable_value_t  *val, *old;

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

  1106.     if (val == NULL) {
  1107.         return NGX_CONF_ERROR;
  1108.     }

  1110.     switch (cidr->family) {

  1112. #if (NGX_HAVE_INET6)
  1113.     case AF_INET6:
  1114.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1115.                                      cidr->u.in6.mask.s6_addr,
  1116.                                      (uintptr_t) val);

  1118.         if (rc == NGX_OK) {
  1119.             return NGX_CONF_OK;
  1120.         }

  1122.         if (rc == NGX_ERROR) {
  1123.             return NGX_CONF_ERROR;
  1124.         }

  1126.         /* rc == NGX_BUSY */

  1128.         old = (ngx_stream_variable_value_t *)
  1129.                    ngx_radix128tree_find(ctx->tree6,
  1130.                                          cidr->u.in6.addr.s6_addr);

  1132.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1133.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1134.               net, val, old);

  1136.         rc = ngx_radix128tree_delete(ctx->tree6,
  1137.                                      cidr->u.in6.addr.s6_addr,
  1138.                                      cidr->u.in6.mask.s6_addr);

  1140.         if (rc == NGX_ERROR) {
  1141.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1142.             return NGX_CONF_ERROR;
  1143.         }

  1145.         rc = ngx_radix128tree_insert(ctx->tree6, cidr->u.in6.addr.s6_addr,
  1146.                                      cidr->u.in6.mask.s6_addr,
  1147.                                      (uintptr_t) val);

  1149.         break;
  1150. #endif

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

  1156.         if (rc == NGX_OK) {
  1157.             return NGX_CONF_OK;
  1158.         }

  1160.         if (rc == NGX_ERROR) {
  1161.             return NGX_CONF_ERROR;
  1162.         }

  1164.         /* rc == NGX_BUSY */

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

  1169.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1170.               "duplicate network \"%V\", value: \"%v\", old value: \"%v\"",
  1171.               net, val, old);

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

  1176.         if (rc == NGX_ERROR) {
  1177.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid radix tree");
  1178.             return NGX_CONF_ERROR;
  1179.         }

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

  1184.         break;
  1185.     }

  1187.     if (rc == NGX_OK) {
  1188.         return NGX_CONF_OK;
  1189.     }

  1191.     return NGX_CONF_ERROR;
  1192. }


  1195. static ngx_stream_variable_value_t *
  1196. ‌ngx_stream_geo_value(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1197.     ngx_str_t *value)
  1198. {
  1199.     uint32_t                               hash;
  1200.     ngx_stream_variable_value_t           *val;
  1201.     ngx_stream_geo_variable_value_node_t  *gvvn;

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

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

  1208.     if (gvvn) {
  1209.         return gvvn->value;
  1210.     }

  1212.     val = ngx_pcalloc(ctx->pool, sizeof(ngx_stream_variable_value_t));
  1213.     if (val == NULL) {
  1214.         return NULL;
  1215.     }

  1217.     val->len = value->len;
  1218.     val->data = ngx_pstrdup(ctx->pool, value);
  1219.     if (val->data == NULL) {
  1220.         return NULL;
  1221.     }

  1223.     val->valid = 1;

  1225.     gvvn = ngx_palloc(ctx->temp_pool,
  1226.                       sizeof(ngx_stream_geo_variable_value_node_t));
  1227.     if (gvvn == NULL) {
  1228.         return NULL;
  1229.     }

  1231.     gvvn->sn.node.key = hash;
  1232.     gvvn->sn.str.len = val->len;
  1233.     gvvn->sn.str.data = val->data;
  1234.     gvvn->value = val;
  1235.     gvvn->offset = 0;

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

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

  1242.     return val;
  1243. }


  1246. static ngx_int_t
  1247. ‌ngx_stream_geo_cidr_value(ngx_conf_t *cf, ngx_str_t *net, ngx_cidr_t *cidr)
  1248. {
  1249.     ngx_int_t  rc;

  1251.     if (ngx_strcmp(net->data, "255.255.255.255") == 0) {
  1252.         cidr->family = AF_INET;
  1253.         cidr->u.in.addr = 0xffffffff;
  1254.         cidr->u.in.mask = 0xffffffff;

  1256.         return NGX_OK;
  1257.     }

  1259.     rc = ngx_ptocidr(net, cidr);

  1261.     if (rc == NGX_ERROR) {
  1262.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid network \"%V\"", net);
  1263.         return NGX_ERROR;
  1264.     }

  1266.     if (rc == NGX_DONE) {
  1267.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1268.                            "low address bits of %V are meaningless", net);
  1269.     }

  1271.     return NGX_OK;
  1272. }


  1275. static char *
  1276. ‌ngx_stream_geo_include(ngx_conf_t *cf, ngx_stream_geo_conf_ctx_t *ctx,
  1277.     ngx_str_t *name)
  1278. {
  1279.     char       *rv;
  1280.     ngx_str_t   file;

  1282.     file.len = name->len + 4;
  1283.     file.data = ngx_pnalloc(ctx->temp_pool, name->len + 5);
  1284.     if (file.data == NULL) {
  1285.         return NGX_CONF_ERROR;
  1286.     }

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

  1290.     if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
  1291.         return NGX_CONF_ERROR;
  1292.     }

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

  1297.         switch (ngx_stream_geo_include_binary_base(cf, ctx, &file)) {
  1298.         case NGX_OK:
  1299.             return NGX_CONF_OK;
  1300.         case NGX_ERROR:
  1301.             return NGX_CONF_ERROR;
  1302.         default:
  1303.             break;
  1304.         }
  1305.     }

  1307.     file.len -= 4;
  1308.     file.data[file.len] = '\0';

  1310.     ctx->include_name = file;

  1312.     if (ctx->outside_entries) {
  1313.         ctx->allow_binary_include = 0;
  1314.     }

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

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

  1320.     ctx->includes++;
  1321.     ctx->outside_entries = 0;

  1323.     return rv;
  1324. }


  1327. static ngx_int_t
  1328. ‌ngx_stream_geo_include_binary_base(ngx_conf_t *cf,
  1329.     ngx_stream_geo_conf_ctx_t *ctx, ngx_str_t *name)
  1330. {
  1331.     u_char                       *base, ch;
  1332.     time_t                        mtime;
  1333.     size_t                        size, len;
  1334.     ssize_t                       n;
  1335.     uint32_t                      crc32;
  1336.     ngx_err_t                     err;
  1337.     ngx_int_t                     rc;
  1338.     ngx_uint_t                    i;
  1339.     ngx_file_t                    file;
  1340.     ngx_file_info_t               fi;
  1341.     ngx_stream_geo_range_t       *range, **ranges;
  1342.     ngx_stream_geo_header_t      *header;
  1343.     ngx_stream_variable_value_t  *vv;

  1345.     ngx_memzero(&file, sizeof(ngx_file_t));
  1346.     file.name = *name;
  1347.     file.log = cf->log;

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

  1351.     if (file.fd == NGX_INVALID_FILE) {
  1352.         err = ngx_errno;
  1353.         if (err != NGX_ENOENT) {
  1354.             ngx_conf_log_error(NGX_LOG_CRIT, cf, err,
  1355.                                ngx_open_file_n " \"%s\" failed", name->data);
  1356.         }
  1357.         return NGX_DECLINED;
  1358.     }

  1360.     if (ctx->outside_entries) {
  1361.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1362.             "binary geo range base \"%s\" cannot be mixed with usual entries",
  1363.             name->data);
  1364.         rc = NGX_ERROR;
  1365.         goto done;
  1366.     }

  1368.     if (ctx->binary_include) {
  1369.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1370.             "second binary geo range base \"%s\" cannot be mixed with \"%s\"",
  1371.             name->data, ctx->include_name.data);
  1372.         rc = NGX_ERROR;
  1373.         goto done;
  1374.     }

  1376.     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  1377.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1378.                            ngx_fd_info_n " \"%s\" failed", name->data);
  1379.         goto failed;
  1380.     }

  1382.     size = (size_t) ngx_file_size(&fi);
  1383.     mtime = ngx_file_mtime(&fi);

  1385.     ch = name->data[name->len - 4];
  1386.     name->data[name->len - 4] = '\0';

  1388.     if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
  1389.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1390.                            ngx_file_info_n " \"%s\" failed", name->data);
  1391.         goto failed;
  1392.     }

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

  1396.     if (mtime < ngx_file_mtime(&fi)) {
  1397.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1398.                            "stale binary geo range base \"%s\"", name->data);
  1399.         goto failed;
  1400.     }

  1402.     base = ngx_palloc(ctx->pool, size);
  1403.     if (base == NULL) {
  1404.         goto failed;
  1405.     }

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

  1409.     if (n == NGX_ERROR) {
  1410.         ngx_conf_log_error(NGX_LOG_CRIT, cf, ngx_errno,
  1411.                            ngx_read_file_n " \"%s\" failed", name->data);
  1412.         goto failed;
  1413.     }

  1415.     if ((size_t) n != size) {
  1416.         ngx_conf_log_error(NGX_LOG_CRIT, cf, 0,
  1417.             ngx_read_file_n " \"%s\" returned only %z bytes instead of %z",
  1418.             name->data, n, size);
  1419.         goto failed;
  1420.     }

  1422.     header = (ngx_stream_geo_header_t *) base;

  1424.     if (size < 16 || ngx_memcmp(&ngx_stream_geo_header, header, 12) != 0) {
  1425.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1426.              "incompatible binary geo range base \"%s\"", name->data);
  1427.         goto failed;
  1428.     }

  1430.     ngx_crc32_init(crc32);

  1432.     vv = (ngx_stream_variable_value_t *)
  1433.             (base + sizeof(ngx_stream_geo_header_t));

  1435.     while (vv->data) {
  1436.         len = ngx_align(sizeof(ngx_stream_variable_value_t) + vv->len,
  1437.                         sizeof(void *));
  1438.         ngx_crc32_update(&crc32, (u_char *) vv, len);
  1439.         vv->data += (size_t) base;
  1440.         vv = (ngx_stream_variable_value_t *) ((u_char *) vv + len);
  1441.     }
  1442.     ngx_crc32_update(&crc32, (u_char *) vv,
  1443.                      sizeof(ngx_stream_variable_value_t));
  1444.     vv++;

  1446.     ranges = (ngx_stream_geo_range_t **) vv;

  1448.     for (i = 0; i < 0x10000; i++) {
  1449.         ngx_crc32_update(&crc32, (u_char *) &ranges[i], sizeof(void *));
  1450.         if (ranges[i]) {
  1451.             ranges[i] = (ngx_stream_geo_range_t *)
  1452.                             ((u_char *) ranges[i] + (size_t) base);
  1453.         }
  1454.     }

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

  1458.     while ((u_char *) range < base + size) {
  1459.         while (range->value) {
  1460.             ngx_crc32_update(&crc32, (u_char *) range,
  1461.                              sizeof(ngx_stream_geo_range_t));
  1462.             range->value = (ngx_stream_variable_value_t *)
  1463.                                ((u_char *) range->value + (size_t) base);
  1464.             range++;
  1465.         }
  1466.         ngx_crc32_update(&crc32, (u_char *) range, sizeof(void *));
  1467.         range = (ngx_stream_geo_range_t *) ((u_char *) range + sizeof(void *));
  1468.     }

  1470.     ngx_crc32_final(crc32);

  1472.     if (crc32 != header->crc32) {
  1473.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1474.                   "CRC32 mismatch in binary geo range base \"%s\"", name->data);
  1475.         goto failed;
  1476.     }

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

  1481.     ctx->include_name = *name;
  1482.     ctx->binary_include = 1;
  1483.     ctx->high.low = ranges;
  1484.     rc = NGX_OK;

  1486.     goto done;

  1488. failed:

  1490.     rc = NGX_DECLINED;

  1492. done:

  1494.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  1495.         ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  1496.                       ngx_close_file_n " \"%s\" failed", name->data);
  1497.     }

  1499.     return rc;
  1500. }


  1503. static void
  1504. ‌ngx_stream_geo_create_binary_base(ngx_stream_geo_conf_ctx_t *ctx)
  1505. {
  1506.     u_char                                *p;
  1507.     uint32_t                               hash;
  1508.     ngx_str_t                              s;
  1509.     ngx_uint_t                             i;
  1510.     ngx_file_mapping_t                     fm;
  1511.     ngx_stream_geo_range_t                *r, *range, **ranges;
  1512.     ngx_stream_geo_header_t               *header;
  1513.     ngx_stream_geo_variable_value_node_t  *gvvn;

  1515.     fm.name = ngx_pnalloc(ctx->temp_pool, ctx->include_name.len + 5);
  1516.     if (fm.name == NULL) {
  1517.         return;
  1518.     }

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

  1522.     fm.size = ctx->data_size;
  1523.     fm.log = ctx->pool->log;

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

  1528.     if (ngx_create_file_mapping(&fm) != NGX_OK) {
  1529.         return;
  1530.     }

  1532.     p = ngx_cpymem(fm.addr, &ngx_stream_geo_header,
  1533.                    sizeof(ngx_stream_geo_header_t));

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

  1538.     p += sizeof(ngx_stream_variable_value_t);

  1540.     ranges = (ngx_stream_geo_range_t **) p;

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

  1544.     for (i = 0; i < 0x10000; i++) {
  1545.         r = ctx->high.low[i];
  1546.         if (r == NULL) {
  1547.             continue;
  1548.         }

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

  1553.         do {
  1554.             s.len = r->value->len;
  1555.             s.data = r->value->data;
  1556.             hash = ngx_crc32_long(s.data, s.len);
  1557.             gvvn = (ngx_stream_geo_variable_value_node_t *)
  1558.                         ngx_str_rbtree_lookup(&ctx->rbtree, &s, hash);

  1560.             range->value = (ngx_stream_variable_value_t *) gvvn->offset;
  1561.             range->start = r->start;
  1562.             range->end = r->end;
  1563.             range++;

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

  1567.         range->value = NULL;

  1569.         p = (u_char *) range + sizeof(void *);
  1570.     }

  1572.     header = fm.addr;
  1573.     header->crc32 = ngx_crc32_long((u_char *) fm.addr
  1574.                                        + sizeof(ngx_stream_geo_header_t),
  1575.                                    fm.size - sizeof(ngx_stream_geo_header_t));

  1577.     ngx_close_file_mapping(&fm);
  1578. }


  1581. static u_char *
  1582. ‌ngx_stream_geo_copy_values(u_char *base, u_char *p, ngx_rbtree_node_t *node,
  1583.     ngx_rbtree_node_t *sentinel)
  1584. {
  1585.     ngx_stream_variable_value_t           *vv;
  1586.     ngx_stream_geo_variable_value_node_t  *gvvn;

  1588.     if (node == sentinel) {
  1589.         return p;
  1590.     }

  1592.     gvvn = (ngx_stream_geo_variable_value_node_t *) node;
  1593.     gvvn->offset = p - base;

  1595.     vv = (ngx_stream_variable_value_t *) p;
  1596.     *vv = *gvvn->value;
  1597.     p += sizeof(ngx_stream_variable_value_t);
  1598.     vv->data = (u_char *) (p - base);

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

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

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

  1606.     return ngx_stream_geo_copy_values(base, p, node->right, sentinel);
  1607. }

One Level Up Top Level