One Level Up Top Level

src/stream/ngx_stream_geoip_module.c - nginx source code

Global variables defined

Data types defined

Functions defined

Macros 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>

  12. #include <GeoIP.h>
  13. #include <GeoIPCity.h>


  16. ‌#define NGX_GEOIP_COUNTRY_CODE   0
  17. ‌#define NGX_GEOIP_COUNTRY_CODE3  1
  18. ‌#define NGX_GEOIP_COUNTRY_NAME   2


  21. ‌typedef struct {
  22.     GeoIP        *country;
  23.     GeoIP        *org;
  24.     GeoIP        *city;
  25. #if (NGX_HAVE_GEOIP_V6)
  26.     unsigned      country_v6:1;
  27.     unsigned      org_v6:1;
  28.     unsigned      city_v6:1;
  29. #endif
  30. ‌} ngx_stream_geoip_conf_t;


  33. ‌typedef struct {
  34.     ngx_str_t    *name;
  35.     uintptr_t     data;
  36. ‌} ngx_stream_geoip_var_t;


  39. ‌typedef const char *(*ngx_stream_geoip_variable_handler_pt)(GeoIP *,
  40.     u_long addr);


  43. ‌ngx_stream_geoip_variable_handler_pt ngx_stream_geoip_country_functions[] = {
  44.     GeoIP_country_code_by_ipnum,
  45.     GeoIP_country_code3_by_ipnum,
  46.     GeoIP_country_name_by_ipnum,
  47. };


  50. #if (NGX_HAVE_GEOIP_V6)

  52. ‌typedef const char *(*ngx_stream_geoip_variable_handler_v6_pt)(GeoIP *,
  53.     geoipv6_t addr);


  56. ngx_stream_geoip_variable_handler_v6_pt
  57. ‌    ngx_stream_geoip_country_v6_functions[] =
  58. {
  59.     GeoIP_country_code_by_ipnum_v6,
  60.     GeoIP_country_code3_by_ipnum_v6,
  61.     GeoIP_country_name_by_ipnum_v6,
  62. };

  64. #endif


  67. static ngx_int_t ngx_stream_geoip_country_variable(ngx_stream_session_t *s,
  68.     ngx_stream_variable_value_t *v, uintptr_t data);
  69. static ngx_int_t ngx_stream_geoip_org_variable(ngx_stream_session_t *s,
  70.     ngx_stream_variable_value_t *v, uintptr_t data);
  71. static ngx_int_t ngx_stream_geoip_city_variable(ngx_stream_session_t *s,
  72.     ngx_stream_variable_value_t *v, uintptr_t data);
  73. static ngx_int_t ngx_stream_geoip_region_name_variable(ngx_stream_session_t *s,
  74.     ngx_stream_variable_value_t *v, uintptr_t data);
  75. static ngx_int_t ngx_stream_geoip_city_float_variable(ngx_stream_session_t *s,
  76.     ngx_stream_variable_value_t *v, uintptr_t data);
  77. static ngx_int_t ngx_stream_geoip_city_int_variable(ngx_stream_session_t *s,
  78.     ngx_stream_variable_value_t *v, uintptr_t data);
  79. static GeoIPRecord *ngx_stream_geoip_get_city_record(ngx_stream_session_t *s);

  81. static ngx_int_t ngx_stream_geoip_add_variables(ngx_conf_t *cf);
  82. static void *ngx_stream_geoip_create_conf(ngx_conf_t *cf);
  83. static char *ngx_stream_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd,
  84.     void *conf);
  85. static char *ngx_stream_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd,
  86.     void *conf);
  87. static char *ngx_stream_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd,
  88.     void *conf);
  89. static void ngx_stream_geoip_cleanup(void *data);


  92. ‌static ngx_command_t  ngx_stream_geoip_commands[] = {

  94.     { ngx_string("geoip_country"),
  95.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE12,
  96.       ngx_stream_geoip_country,
  97.       NGX_STREAM_MAIN_CONF_OFFSET,
  98.       0,
  99.       NULL },

  101.     { ngx_string("geoip_org"),
  102.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE12,
  103.       ngx_stream_geoip_org,
  104.       NGX_STREAM_MAIN_CONF_OFFSET,
  105.       0,
  106.       NULL },

  108.     { ngx_string("geoip_city"),
  109.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE12,
  110.       ngx_stream_geoip_city,
  111.       NGX_STREAM_MAIN_CONF_OFFSET,
  112.       0,
  113.       NULL },

  115.       ngx_null_command
  116. };


  119. ‌static ngx_stream_module_t  ngx_stream_geoip_module_ctx = {
  120.     ngx_stream_geoip_add_variables,        /* preconfiguration */
  121.     NULL,                                  /* postconfiguration */

  123.     ngx_stream_geoip_create_conf,          /* create main configuration */
  124.     NULL,                                  /* init main configuration */

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


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


  147. ‌static ngx_stream_variable_t  ngx_stream_geoip_vars[] = {

  149.     { ngx_string("geoip_country_code"), NULL,
  150.       ngx_stream_geoip_country_variable,
  151.       NGX_GEOIP_COUNTRY_CODE, 0, 0 },

  153.     { ngx_string("geoip_country_code3"), NULL,
  154.       ngx_stream_geoip_country_variable,
  155.       NGX_GEOIP_COUNTRY_CODE3, 0, 0 },

  157.     { ngx_string("geoip_country_name"), NULL,
  158.       ngx_stream_geoip_country_variable,
  159.       NGX_GEOIP_COUNTRY_NAME, 0, 0 },

  161.     { ngx_string("geoip_org"), NULL,
  162.       ngx_stream_geoip_org_variable,
  163.       0, 0, 0 },

  165.     { ngx_string("geoip_city_continent_code"), NULL,
  166.       ngx_stream_geoip_city_variable,
  167.       offsetof(GeoIPRecord, continent_code), 0, 0 },

  169.     { ngx_string("geoip_city_country_code"), NULL,
  170.       ngx_stream_geoip_city_variable,
  171.       offsetof(GeoIPRecord, country_code), 0, 0 },

  173.     { ngx_string("geoip_city_country_code3"), NULL,
  174.       ngx_stream_geoip_city_variable,
  175.       offsetof(GeoIPRecord, country_code3), 0, 0 },

  177.     { ngx_string("geoip_city_country_name"), NULL,
  178.       ngx_stream_geoip_city_variable,
  179.       offsetof(GeoIPRecord, country_name), 0, 0 },

  181.     { ngx_string("geoip_region"), NULL,
  182.       ngx_stream_geoip_city_variable,
  183.       offsetof(GeoIPRecord, region), 0, 0 },

  185.     { ngx_string("geoip_region_name"), NULL,
  186.       ngx_stream_geoip_region_name_variable,
  187.       0, 0, 0 },

  189.     { ngx_string("geoip_city"), NULL,
  190.       ngx_stream_geoip_city_variable,
  191.       offsetof(GeoIPRecord, city), 0, 0 },

  193.     { ngx_string("geoip_postal_code"), NULL,
  194.       ngx_stream_geoip_city_variable,
  195.       offsetof(GeoIPRecord, postal_code), 0, 0 },

  197.     { ngx_string("geoip_latitude"), NULL,
  198.       ngx_stream_geoip_city_float_variable,
  199.       offsetof(GeoIPRecord, latitude), 0, 0 },

  201.     { ngx_string("geoip_longitude"), NULL,
  202.       ngx_stream_geoip_city_float_variable,
  203.       offsetof(GeoIPRecord, longitude), 0, 0 },

  205.     { ngx_string("geoip_dma_code"), NULL,
  206.       ngx_stream_geoip_city_int_variable,
  207.       offsetof(GeoIPRecord, dma_code), 0, 0 },

  209.     { ngx_string("geoip_area_code"), NULL,
  210.       ngx_stream_geoip_city_int_variable,
  211.       offsetof(GeoIPRecord, area_code), 0, 0 },

  213.       ngx_stream_null_variable
  214. };


  217. static u_long
  218. ‌ngx_stream_geoip_addr(ngx_stream_session_t *s, ngx_stream_geoip_conf_t *gcf)
  219. {
  220.     ngx_addr_t           addr;
  221.     struct sockaddr_in  *sin;

  223.     addr.sockaddr = s->connection->sockaddr;
  224.     addr.socklen = s->connection->socklen;
  225.     /* addr.name = s->connection->addr_text; */

  227. #if (NGX_HAVE_INET6)

  229.     if (addr.sockaddr->sa_family == AF_INET6) {
  230.         u_char           *p;
  231.         in_addr_t         inaddr;
  232.         struct in6_addr  *inaddr6;

  234.         inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;

  236.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  237.             p = inaddr6->s6_addr;

  239.             inaddr = (in_addr_t) p[12] << 24;
  240.             inaddr += p[13] << 16;
  241.             inaddr += p[14] << 8;
  242.             inaddr += p[15];

  244.             return inaddr;
  245.         }
  246.     }

  248. #endif

  250.     if (addr.sockaddr->sa_family != AF_INET) {
  251.         return INADDR_NONE;
  252.     }

  254.     sin = (struct sockaddr_in *) addr.sockaddr;
  255.     return ntohl(sin->sin_addr.s_addr);
  256. }


  259. #if (NGX_HAVE_GEOIP_V6)

  261. static geoipv6_t
  262. ‌ngx_stream_geoip_addr_v6(ngx_stream_session_t *s, ngx_stream_geoip_conf_t *gcf)
  263. {
  264.     ngx_addr_t            addr;
  265.     in_addr_t             addr4;
  266.     struct in6_addr       addr6;
  267.     struct sockaddr_in   *sin;
  268.     struct sockaddr_in6  *sin6;

  270.     addr.sockaddr = s->connection->sockaddr;
  271.     addr.socklen = s->connection->socklen;
  272.     /* addr.name = s->connection->addr_text; */

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

  276.     case AF_INET:
  277.         /* Produce IPv4-mapped IPv6 address. */
  278.         sin = (struct sockaddr_in *) addr.sockaddr;
  279.         addr4 = ntohl(sin->sin_addr.s_addr);

  281.         ngx_memzero(&addr6, sizeof(struct in6_addr));
  282.         addr6.s6_addr[10] = 0xff;
  283.         addr6.s6_addr[11] = 0xff;
  284.         addr6.s6_addr[12] = addr4 >> 24;
  285.         addr6.s6_addr[13] = addr4 >> 16;
  286.         addr6.s6_addr[14] = addr4 >> 8;
  287.         addr6.s6_addr[15] = addr4;
  288.         return addr6;

  290.     case AF_INET6:
  291.         sin6 = (struct sockaddr_in6 *) addr.sockaddr;
  292.         return sin6->sin6_addr;

  294.     default:
  295.         return in6addr_any;
  296.     }
  297. }

  299. #endif


  302. static ngx_int_t
  303. ‌ngx_stream_geoip_country_variable(ngx_stream_session_t *s,
  304.     ngx_stream_variable_value_t *v, uintptr_t data)
  305. {
  306.     ngx_stream_geoip_variable_handler_pt     handler =
  307.         ngx_stream_geoip_country_functions[data];
  308. #if (NGX_HAVE_GEOIP_V6)
  309.     ngx_stream_geoip_variable_handler_v6_pt  handler_v6 =
  310.         ngx_stream_geoip_country_v6_functions[data];
  311. #endif

  313.     const char               *val;
  314.     ngx_stream_geoip_conf_t  *gcf;

  316.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  318.     if (gcf->country == NULL) {
  319.         goto not_found;
  320.     }

  322. #if (NGX_HAVE_GEOIP_V6)
  323.     val = gcf->country_v6
  324.               ? handler_v6(gcf->country, ngx_stream_geoip_addr_v6(s, gcf))
  325.               : handler(gcf->country, ngx_stream_geoip_addr(s, gcf));
  326. #else
  327.     val = handler(gcf->country, ngx_stream_geoip_addr(s, gcf));
  328. #endif

  330.     if (val == NULL) {
  331.         goto not_found;
  332.     }

  334.     v->len = ngx_strlen(val);
  335.     v->valid = 1;
  336.     v->no_cacheable = 0;
  337.     v->not_found = 0;
  338.     v->data = (u_char *) val;

  340.     return NGX_OK;

  342. not_found:

  344.     v->not_found = 1;

  346.     return NGX_OK;
  347. }


  350. static ngx_int_t
  351. ‌ngx_stream_geoip_org_variable(ngx_stream_session_t *s,
  352.     ngx_stream_variable_value_t *v, uintptr_t data)
  353. {
  354.     size_t                    len;
  355.     char                     *val;
  356.     ngx_stream_geoip_conf_t  *gcf;

  358.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  360.     if (gcf->org == NULL) {
  361.         goto not_found;
  362.     }

  364. #if (NGX_HAVE_GEOIP_V6)
  365.     val = gcf->org_v6
  366.               ? GeoIP_name_by_ipnum_v6(gcf->org,
  367.                                        ngx_stream_geoip_addr_v6(s, gcf))
  368.               : GeoIP_name_by_ipnum(gcf->org,
  369.                                     ngx_stream_geoip_addr(s, gcf));
  370. #else
  371.     val = GeoIP_name_by_ipnum(gcf->org, ngx_stream_geoip_addr(s, gcf));
  372. #endif

  374.     if (val == NULL) {
  375.         goto not_found;
  376.     }

  378.     len = ngx_strlen(val);
  379.     v->data = ngx_pnalloc(s->connection->pool, len);
  380.     if (v->data == NULL) {
  381.         ngx_free(val);
  382.         return NGX_ERROR;
  383.     }

  385.     ngx_memcpy(v->data, val, len);

  387.     v->len = len;
  388.     v->valid = 1;
  389.     v->no_cacheable = 0;
  390.     v->not_found = 0;

  392.     ngx_free(val);

  394.     return NGX_OK;

  396. not_found:

  398.     v->not_found = 1;

  400.     return NGX_OK;
  401. }


  404. static ngx_int_t
  405. ‌ngx_stream_geoip_city_variable(ngx_stream_session_t *s,
  406.     ngx_stream_variable_value_t *v, uintptr_t data)
  407. {
  408.     char         *val;
  409.     size_t        len;
  410.     GeoIPRecord  *gr;

  412.     gr = ngx_stream_geoip_get_city_record(s);
  413.     if (gr == NULL) {
  414.         goto not_found;
  415.     }

  417.     val = *(char **) ((char *) gr + data);
  418.     if (val == NULL) {
  419.         goto no_value;
  420.     }

  422.     len = ngx_strlen(val);
  423.     v->data = ngx_pnalloc(s->connection->pool, len);
  424.     if (v->data == NULL) {
  425.         GeoIPRecord_delete(gr);
  426.         return NGX_ERROR;
  427.     }

  429.     ngx_memcpy(v->data, val, len);

  431.     v->len = len;
  432.     v->valid = 1;
  433.     v->no_cacheable = 0;
  434.     v->not_found = 0;

  436.     GeoIPRecord_delete(gr);

  438.     return NGX_OK;

  440. no_value:

  442.     GeoIPRecord_delete(gr);

  444. not_found:

  446.     v->not_found = 1;

  448.     return NGX_OK;
  449. }


  452. static ngx_int_t
  453. ‌ngx_stream_geoip_region_name_variable(ngx_stream_session_t *s,
  454.     ngx_stream_variable_value_t *v, uintptr_t data)
  455. {
  456.     size_t        len;
  457.     const char   *val;
  458.     GeoIPRecord  *gr;

  460.     gr = ngx_stream_geoip_get_city_record(s);
  461.     if (gr == NULL) {
  462.         goto not_found;
  463.     }

  465.     val = GeoIP_region_name_by_code(gr->country_code, gr->region);

  467.     GeoIPRecord_delete(gr);

  469.     if (val == NULL) {
  470.         goto not_found;
  471.     }

  473.     len = ngx_strlen(val);
  474.     v->data = ngx_pnalloc(s->connection->pool, len);
  475.     if (v->data == NULL) {
  476.         return NGX_ERROR;
  477.     }

  479.     ngx_memcpy(v->data, val, len);

  481.     v->len = len;
  482.     v->valid = 1;
  483.     v->no_cacheable = 0;
  484.     v->not_found = 0;

  486.     return NGX_OK;

  488. not_found:

  490.     v->not_found = 1;

  492.     return NGX_OK;
  493. }


  496. static ngx_int_t
  497. ‌ngx_stream_geoip_city_float_variable(ngx_stream_session_t *s,
  498.     ngx_stream_variable_value_t *v, uintptr_t data)
  499. {
  500.     float         val;
  501.     GeoIPRecord  *gr;

  503.     gr = ngx_stream_geoip_get_city_record(s);
  504.     if (gr == NULL) {
  505.         v->not_found = 1;
  506.         return NGX_OK;
  507.     }

  509.     v->data = ngx_pnalloc(s->connection->pool, NGX_INT64_LEN + 5);
  510.     if (v->data == NULL) {
  511.         GeoIPRecord_delete(gr);
  512.         return NGX_ERROR;
  513.     }

  515.     val = *(float *) ((char *) gr + data);

  517.     v->len = ngx_sprintf(v->data, "%.4f", val) - v->data;
  518.     v->valid = 1;
  519.     v->no_cacheable = 0;
  520.     v->not_found = 0;

  522.     GeoIPRecord_delete(gr);

  524.     return NGX_OK;
  525. }


  528. static ngx_int_t
  529. ‌ngx_stream_geoip_city_int_variable(ngx_stream_session_t *s,
  530.     ngx_stream_variable_value_t *v, uintptr_t data)
  531. {
  532.     int           val;
  533.     GeoIPRecord  *gr;

  535.     gr = ngx_stream_geoip_get_city_record(s);
  536.     if (gr == NULL) {
  537.         v->not_found = 1;
  538.         return NGX_OK;
  539.     }

  541.     v->data = ngx_pnalloc(s->connection->pool, NGX_INT64_LEN);
  542.     if (v->data == NULL) {
  543.         GeoIPRecord_delete(gr);
  544.         return NGX_ERROR;
  545.     }

  547.     val = *(int *) ((char *) gr + data);

  549.     v->len = ngx_sprintf(v->data, "%d", val) - v->data;
  550.     v->valid = 1;
  551.     v->no_cacheable = 0;
  552.     v->not_found = 0;

  554.     GeoIPRecord_delete(gr);

  556.     return NGX_OK;
  557. }


  560. static GeoIPRecord *
  561. ‌ngx_stream_geoip_get_city_record(ngx_stream_session_t *s)
  562. {
  563.     ngx_stream_geoip_conf_t  *gcf;

  565.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  567.     if (gcf->city) {
  568. #if (NGX_HAVE_GEOIP_V6)
  569.         return gcf->city_v6
  570.                    ? GeoIP_record_by_ipnum_v6(gcf->city,
  571.                                               ngx_stream_geoip_addr_v6(s, gcf))
  572.                    : GeoIP_record_by_ipnum(gcf->city,
  573.                                            ngx_stream_geoip_addr(s, gcf));
  574. #else
  575.         return GeoIP_record_by_ipnum(gcf->city, ngx_stream_geoip_addr(s, gcf));
  576. #endif
  577.     }

  579.     return NULL;
  580. }


  583. static ngx_int_t
  584. ‌ngx_stream_geoip_add_variables(ngx_conf_t *cf)
  585. {
  586.     ngx_stream_variable_t  *var, *v;

  588.     for (v = ngx_stream_geoip_vars; v->name.len; v++) {
  589.         var = ngx_stream_add_variable(cf, &v->name, v->flags);
  590.         if (var == NULL) {
  591.             return NGX_ERROR;
  592.         }

  594.         var->get_handler = v->get_handler;
  595.         var->data = v->data;
  596.     }

  598.     return NGX_OK;
  599. }


  602. static void *
  603. ‌ngx_stream_geoip_create_conf(ngx_conf_t *cf)
  604. {
  605.     ngx_pool_cleanup_t       *cln;
  606.     ngx_stream_geoip_conf_t  *conf;

  608.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_geoip_conf_t));
  609.     if (conf == NULL) {
  610.         return NULL;
  611.     }

  613.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  614.     if (cln == NULL) {
  615.         return NULL;
  616.     }

  618.     cln->handler = ngx_stream_geoip_cleanup;
  619.     cln->data = conf;

  621.     return conf;
  622. }


  625. static char *
  626. ‌ngx_stream_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  627. {
  628.     ngx_stream_geoip_conf_t  *gcf = conf;

  630.     ngx_str_t  *value;

  632.     if (gcf->country) {
  633.         return "is duplicate";
  634.     }

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

  638.     gcf->country = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);

  640.     if (gcf->country == NULL) {
  641.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  642.                            "GeoIP_open(\"%V\") failed", &value[1]);

  644.         return NGX_CONF_ERROR;
  645.     }

  647.     if (cf->args->nelts == 3) {
  648.         if (ngx_strcmp(value[2].data, "utf8") == 0) {
  649.             GeoIP_set_charset(gcf->country, GEOIP_CHARSET_UTF8);

  651.         } else {
  652.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  653.                                "invalid parameter \"%V\"", &value[2]);
  654.             return NGX_CONF_ERROR;
  655.         }
  656.     }

  658.     switch (gcf->country->databaseType) {

  660.     case GEOIP_COUNTRY_EDITION:

  662.         return NGX_CONF_OK;

  664. #if (NGX_HAVE_GEOIP_V6)
  665.     case GEOIP_COUNTRY_EDITION_V6:

  667.         gcf->country_v6 = 1;
  668.         return NGX_CONF_OK;
  669. #endif

  671.     default:
  672.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  673.                            "invalid GeoIP database \"%V\" type:%d",
  674.                            &value[1], gcf->country->databaseType);
  675.         return NGX_CONF_ERROR;
  676.     }
  677. }


  680. static char *
  681. ‌ngx_stream_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  682. {
  683.     ngx_stream_geoip_conf_t  *gcf = conf;

  685.     ngx_str_t  *value;

  687.     if (gcf->org) {
  688.         return "is duplicate";
  689.     }

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

  693.     gcf->org = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);

  695.     if (gcf->org == NULL) {
  696.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  697.                            "GeoIP_open(\"%V\") failed", &value[1]);

  699.         return NGX_CONF_ERROR;
  700.     }

  702.     if (cf->args->nelts == 3) {
  703.         if (ngx_strcmp(value[2].data, "utf8") == 0) {
  704.             GeoIP_set_charset(gcf->org, GEOIP_CHARSET_UTF8);

  706.         } else {
  707.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  708.                                "invalid parameter \"%V\"", &value[2]);
  709.             return NGX_CONF_ERROR;
  710.         }
  711.     }

  713.     switch (gcf->org->databaseType) {

  715.     case GEOIP_ISP_EDITION:
  716.     case GEOIP_ORG_EDITION:
  717.     case GEOIP_DOMAIN_EDITION:
  718.     case GEOIP_ASNUM_EDITION:

  720.         return NGX_CONF_OK;

  722. #if (NGX_HAVE_GEOIP_V6)
  723.     case GEOIP_ISP_EDITION_V6:
  724.     case GEOIP_ORG_EDITION_V6:
  725.     case GEOIP_DOMAIN_EDITION_V6:
  726.     case GEOIP_ASNUM_EDITION_V6:

  728.         gcf->org_v6 = 1;
  729.         return NGX_CONF_OK;
  730. #endif

  732.     default:
  733.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  734.                            "invalid GeoIP database \"%V\" type:%d",
  735.                            &value[1], gcf->org->databaseType);
  736.         return NGX_CONF_ERROR;
  737.     }
  738. }


  741. static char *
  742. ‌ngx_stream_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  743. {
  744.     ngx_stream_geoip_conf_t  *gcf = conf;

  746.     ngx_str_t  *value;

  748.     if (gcf->city) {
  749.         return "is duplicate";
  750.     }

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

  754.     gcf->city = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);

  756.     if (gcf->city == NULL) {
  757.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  758.                            "GeoIP_open(\"%V\") failed", &value[1]);

  760.         return NGX_CONF_ERROR;
  761.     }

  763.     if (cf->args->nelts == 3) {
  764.         if (ngx_strcmp(value[2].data, "utf8") == 0) {
  765.             GeoIP_set_charset(gcf->city, GEOIP_CHARSET_UTF8);

  767.         } else {
  768.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  769.                                "invalid parameter \"%V\"", &value[2]);
  770.             return NGX_CONF_ERROR;
  771.         }
  772.     }

  774.     switch (gcf->city->databaseType) {

  776.     case GEOIP_CITY_EDITION_REV0:
  777.     case GEOIP_CITY_EDITION_REV1:

  779.         return NGX_CONF_OK;

  781. #if (NGX_HAVE_GEOIP_V6)
  782.     case GEOIP_CITY_EDITION_REV0_V6:
  783.     case GEOIP_CITY_EDITION_REV1_V6:

  785.         gcf->city_v6 = 1;
  786.         return NGX_CONF_OK;
  787. #endif

  789.     default:
  790.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  791.                            "invalid GeoIP City database \"%V\" type:%d",
  792.                            &value[1], gcf->city->databaseType);
  793.         return NGX_CONF_ERROR;
  794.     }
  795. }


  798. static void
  799. ‌ngx_stream_geoip_cleanup(void *data)
  800. {
  801.     ngx_stream_geoip_conf_t  *gcf = data;

  803.     if (gcf->country) {
  804.         GeoIP_delete(gcf->country);
  805.     }

  807.     if (gcf->org) {
  808.         GeoIP_delete(gcf->org);
  809.     }

  811.     if (gcf->city) {
  812.         GeoIP_delete(gcf->city);
  813.     }
  814. }

One Level Up Top Level