One Level Up Top Level

src/http/modules/ngx_http_geoip_module.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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_http.h>

  12. #if (NGX_HAVE_GEOIP)
  13. #include <GeoIP.h>
  14. #include <GeoIPCity.h>
  15. #endif
  16. #if (NGX_HAVE_MAXMINDDB)
  17. #include <maxminddb.h>
  18. #endif


  21. ‌#define NGX_GEOIP_COUNTRY_CODE   0
  22. ‌#define NGX_GEOIP_COUNTRY_CODE3  1
  23. ‌#define NGX_GEOIP_COUNTRY_NAME   2

  25. ‌#define NGX_GEOIP_CITY_CONTINENT_CODE  0
  26. ‌#define NGX_GEOIP_CITY_COUNTRY_CODE    1
  27. ‌#define NGX_GEOIP_CITY_COUNTRY_CODE3   2
  28. ‌#define NGX_GEOIP_CITY_COUNTRY_NAME    3
  29. ‌#define NGX_GEOIP_CITY_REGION          4
  30. ‌#define NGX_GEOIP_CITY_REGION_NAME     5
  31. ‌#define NGX_GEOIP_CITY_NAME            6
  32. ‌#define NGX_GEOIP_CITY_POSTAL_CODE     7
  33. ‌#define NGX_GEOIP_CITY_LATITUDE        8
  34. ‌#define NGX_GEOIP_CITY_LONGITUDE       9
  35. ‌#define NGX_GEOIP_CITY_DMA_CODE        10
  36. ‌#define NGX_GEOIP_CITY_AREA_CODE       11

  38. ‌#define NGX_GEOIP_MAX_COORD            180


  41. ‌typedef struct {
  42. #if (NGX_HAVE_GEOIP)
  43.     GeoIP        *country;
  44.     GeoIP        *org;
  45.     GeoIP        *city;
  46. #endif
  47. #if (NGX_HAVE_MAXMINDDB)
  48.     MMDB_s       *country_mmdb;
  49.     MMDB_s       *org_mmdb;
  50.     MMDB_s       *city_mmdb;
  51. #endif
  52.     ngx_array_t  *proxies;    /* array of ngx_cidr_t */
  53.     ngx_flag_t    proxy_recursive;
  54. #if (NGX_HAVE_GEOIP_V6)
  55.     unsigned      country_v6:1;
  56.     unsigned      org_v6:1;
  57.     unsigned      city_v6:1;
  58. #endif
  59. ‌} ngx_http_geoip_conf_t;


  62. ‌typedef struct {
  63.     ngx_str_t    *name;
  64.     uintptr_t     data;
  65. ‌} ngx_http_geoip_var_t;


  68. #if (NGX_HAVE_MAXMINDDB)

  70. ‌typedef struct {
  71.     const char   *alpha2;
  72.     const char   *alpha3;
  73. ‌} ngx_http_geoip_ccode_t;

  75. #endif


  78. #if (NGX_HAVE_GEOIP)

  80. ‌typedef const char *(*ngx_http_geoip_variable_handler_pt)(GeoIP *,
  81.     u_long addr);


  84. ‌ngx_http_geoip_variable_handler_pt ngx_http_geoip_country_functions[] = {
  85.     GeoIP_country_code_by_ipnum,
  86.     GeoIP_country_code3_by_ipnum,
  87.     GeoIP_country_name_by_ipnum,
  88. };


  91. #if (NGX_HAVE_GEOIP_V6)

  93. ‌typedef const char *(*ngx_http_geoip_variable_handler_v6_pt)(GeoIP *,
  94.     geoipv6_t addr);


  97. ‌ngx_http_geoip_variable_handler_v6_pt ngx_http_geoip_country_v6_functions[] = {
  98.     GeoIP_country_code_by_ipnum_v6,
  99.     GeoIP_country_code3_by_ipnum_v6,
  100.     GeoIP_country_name_by_ipnum_v6,
  101. };

  103. #endif

  105. #endif


  108. static ngx_int_t ngx_http_geoip_country_variable(ngx_http_request_t *r,
  109.     ngx_http_variable_value_t *v, uintptr_t data);
  110. static ngx_int_t ngx_http_geoip_org_variable(ngx_http_request_t *r,
  111.     ngx_http_variable_value_t *v, uintptr_t data);
  112. static ngx_int_t ngx_http_geoip_city_variable(ngx_http_request_t *r,
  113.     ngx_http_variable_value_t *v, uintptr_t data);
  114. static ngx_int_t ngx_http_geoip_region_name_variable(ngx_http_request_t *r,
  115.     ngx_http_variable_value_t *v, uintptr_t data);
  116. static ngx_int_t ngx_http_geoip_city_float_variable(ngx_http_request_t *r,
  117.     ngx_http_variable_value_t *v, uintptr_t data);
  118. static ngx_int_t ngx_http_geoip_city_int_variable(ngx_http_request_t *r,
  119.     ngx_http_variable_value_t *v, uintptr_t data);
  120. #if (NGX_HAVE_GEOIP)
  121. static GeoIPRecord *ngx_http_geoip_get_city_record(ngx_http_request_t *r);
  122. #endif
  123. #if (NGX_HAVE_MAXMINDDB)
  124. static ngx_int_t ngx_http_geoip_str(ngx_http_request_t *r, MMDB_entry_s *entry,
  125.     const char **path, ngx_str_t *value);
  126. static ngx_int_t ngx_http_geoip_code3(ngx_str_t *value);
  127. static ngx_int_t ngx_http_geoip_float(MMDB_entry_s *entry, const char **path,
  128.     double *value);
  129. static ngx_int_t ngx_http_geoip_int(MMDB_entry_s *entry, const char **path,
  130.     int64_t *value);
  131. static ngx_int_t ngx_http_geoip_lookup(ngx_http_request_t *r, MMDB_s *mmdb,
  132.     MMDB_entry_s *entry);
  133. #endif

  135. static ngx_int_t ngx_http_geoip_add_variables(ngx_conf_t *cf);
  136. static void *ngx_http_geoip_create_conf(ngx_conf_t *cf);
  137. static char *ngx_http_geoip_init_conf(ngx_conf_t *cf, void *conf);
  138. static char *ngx_http_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd,
  139.     void *conf);
  140. static char *ngx_http_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd,
  141.     void *conf);
  142. static char *ngx_http_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd,
  143.     void *conf);
  144. #if (NGX_HAVE_MAXMINDDB)
  145. static ngx_int_t ngx_http_geoip_open(ngx_conf_t *cf, ngx_str_t *name,
  146.     MMDB_s **db);
  147. static char *ngx_http_geoip_charset(ngx_conf_t *cf);
  148. #endif
  149. static char *ngx_http_geoip_proxy(ngx_conf_t *cf, ngx_command_t *cmd,
  150.     void *conf);
  151. static ngx_int_t ngx_http_geoip_cidr_value(ngx_conf_t *cf, ngx_str_t *net,
  152.     ngx_cidr_t *cidr);
  153. static void ngx_http_geoip_cleanup(void *data);


  156. ‌static ngx_command_t  ngx_http_geoip_commands[] = {

  158.     { ngx_string("geoip_country"),
  159.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE12,
  160.       ngx_http_geoip_country,
  161.       NGX_HTTP_MAIN_CONF_OFFSET,
  162.       0,
  163.       NULL },

  165.     { ngx_string("geoip_org"),
  166.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE12,
  167.       ngx_http_geoip_org,
  168.       NGX_HTTP_MAIN_CONF_OFFSET,
  169.       0,
  170.       NULL },

  172.     { ngx_string("geoip_city"),
  173.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE12,
  174.       ngx_http_geoip_city,
  175.       NGX_HTTP_MAIN_CONF_OFFSET,
  176.       0,
  177.       NULL },

  179.     { ngx_string("geoip_proxy"),
  180.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  181.       ngx_http_geoip_proxy,
  182.       NGX_HTTP_MAIN_CONF_OFFSET,
  183.       0,
  184.       NULL },

  186.     { ngx_string("geoip_proxy_recursive"),
  187.       NGX_HTTP_MAIN_CONF|NGX_CONF_FLAG,
  188.       ngx_conf_set_flag_slot,
  189.       NGX_HTTP_MAIN_CONF_OFFSET,
  190.       offsetof(ngx_http_geoip_conf_t, proxy_recursive),
  191.       NULL },

  193.       ngx_null_command
  194. };


  197. ‌static ngx_http_module_t  ngx_http_geoip_module_ctx = {
  198.     ngx_http_geoip_add_variables,          /* preconfiguration */
  199.     NULL,                                  /* postconfiguration */

  201.     ngx_http_geoip_create_conf,            /* create main configuration */
  202.     ngx_http_geoip_init_conf,              /* init main configuration */

  204.     NULL,                                  /* create server configuration */
  205.     NULL,                                  /* merge server configuration */

  207.     NULL,                                  /* create location configuration */
  208.     NULL                                   /* merge location configuration */
  209. };


  212. ‌ngx_module_t  ngx_http_geoip_module = {
  213.     NGX_MODULE_V1,
  214.     &ngx_http_geoip_module_ctx,            /* module context */
  215.     ngx_http_geoip_commands,               /* module directives */
  216.     NGX_HTTP_MODULE,                       /* module type */
  217.     NULL,                                  /* init master */
  218.     NULL,                                  /* init module */
  219.     NULL,                                  /* init process */
  220.     NULL,                                  /* init thread */
  221.     NULL,                                  /* exit thread */
  222.     NULL,                                  /* exit process */
  223.     NULL,                                  /* exit master */
  224.     NGX_MODULE_V1_PADDING
  225. };


  228. ‌static ngx_http_variable_t  ngx_http_geoip_vars[] = {

  230.     { ngx_string("geoip_country_code"), NULL,
  231.       ngx_http_geoip_country_variable,
  232.       NGX_GEOIP_COUNTRY_CODE, 0, 0 },

  234.     { ngx_string("geoip_country_code3"), NULL,
  235.       ngx_http_geoip_country_variable,
  236.       NGX_GEOIP_COUNTRY_CODE3, 0, 0 },

  238.     { ngx_string("geoip_country_name"), NULL,
  239.       ngx_http_geoip_country_variable,
  240.       NGX_GEOIP_COUNTRY_NAME, 0, 0 },

  242.     { ngx_string("geoip_org"), NULL,
  243.       ngx_http_geoip_org_variable,
  244.       0, 0, 0 },

  246.     { ngx_string("geoip_city_continent_code"), NULL,
  247.       ngx_http_geoip_city_variable,
  248.       NGX_GEOIP_CITY_CONTINENT_CODE, 0, 0 },

  250.     { ngx_string("geoip_city_country_code"), NULL,
  251.       ngx_http_geoip_city_variable,
  252.       NGX_GEOIP_CITY_COUNTRY_CODE, 0, 0 },

  254.     { ngx_string("geoip_city_country_code3"), NULL,
  255.       ngx_http_geoip_city_variable,
  256.       NGX_GEOIP_CITY_COUNTRY_CODE3, 0, 0 },

  258.     { ngx_string("geoip_city_country_name"), NULL,
  259.       ngx_http_geoip_city_variable,
  260.       NGX_GEOIP_CITY_COUNTRY_NAME, 0, 0 },

  262.     { ngx_string("geoip_region"), NULL,
  263.       ngx_http_geoip_city_variable,
  264.       NGX_GEOIP_CITY_REGION, 0, 0 },

  266.     { ngx_string("geoip_region_name"), NULL,
  267.       ngx_http_geoip_region_name_variable,
  268.       NGX_GEOIP_CITY_REGION_NAME, 0, 0 },

  270.     { ngx_string("geoip_city"), NULL,
  271.       ngx_http_geoip_city_variable,
  272.       NGX_GEOIP_CITY_NAME, 0, 0 },

  274.     { ngx_string("geoip_postal_code"), NULL,
  275.       ngx_http_geoip_city_variable,
  276.       NGX_GEOIP_CITY_POSTAL_CODE, 0, 0 },

  278.     { ngx_string("geoip_latitude"), NULL,
  279.       ngx_http_geoip_city_float_variable,
  280.       NGX_GEOIP_CITY_LATITUDE, 0, 0 },

  282.     { ngx_string("geoip_longitude"), NULL,
  283.       ngx_http_geoip_city_float_variable,
  284.       NGX_GEOIP_CITY_LONGITUDE, 0, 0 },

  286.     { ngx_string("geoip_dma_code"), NULL,
  287.       ngx_http_geoip_city_int_variable,
  288.       NGX_GEOIP_CITY_DMA_CODE, 0, 0 },

  290.     { ngx_string("geoip_area_code"), NULL,
  291.       ngx_http_geoip_city_int_variable,
  292.       NGX_GEOIP_CITY_AREA_CODE, 0, 0 },

  294.       ngx_http_null_variable
  295. };


  298. #if (NGX_HAVE_GEOIP)

  300. /* indexed by NGX_GEOIP_CITY_* */

  302. ‌static size_t  ngx_http_geoip_city_offsets[] = {
  303.     offsetof(GeoIPRecord, continent_code),
  304.     offsetof(GeoIPRecord, country_code),
  305.     offsetof(GeoIPRecord, country_code3),
  306.     offsetof(GeoIPRecord, country_name),
  307.     offsetof(GeoIPRecord, region),
  308.     0,                                     /* no region name */
  309.     offsetof(GeoIPRecord, city),
  310.     offsetof(GeoIPRecord, postal_code),
  311.     offsetof(GeoIPRecord, latitude),
  312.     offsetof(GeoIPRecord, longitude),
  313.     offsetof(GeoIPRecord, dma_code),
  314.     offsetof(GeoIPRecord, area_code)
  315. };

  317. #endif


  320. #if (NGX_HAVE_MAXMINDDB)

  322. ‌static const char  *ngx_http_geoip_path_country_code[] = {
  323.     "country", "iso_code", NULL
  324. };

  326. ‌static const char  *ngx_http_geoip_path_country_name[] = {
  327.     "country", "names", "en", NULL
  328. };

  330. ‌static const char  *ngx_http_geoip_path_continent_code[] = {
  331.     "continent", "code", NULL
  332. };

  334. ‌static const char  *ngx_http_geoip_path_region[] = {
  335.     "subdivisions", "0", "iso_code", NULL
  336. };

  338. ‌static const char  *ngx_http_geoip_path_region_name[] = {
  339.     "subdivisions", "0", "names", "en", NULL
  340. };

  342. ‌static const char  *ngx_http_geoip_path_city[] = {
  343.     "city", "names", "en", NULL
  344. };

  346. ‌static const char  *ngx_http_geoip_path_postal_code[] = {
  347.     "postal", "code", NULL
  348. };

  350. ‌static const char  *ngx_http_geoip_path_latitude[] = {
  351.     "location", "latitude", NULL
  352. };

  354. ‌static const char  *ngx_http_geoip_path_longitude[] = {
  355.     "location", "longitude", NULL
  356. };

  358. ‌static const char  *ngx_http_geoip_path_dma_code[] = {
  359.     "location", "metro_code", NULL
  360. };


  363. /* indexed by NGX_GEOIP_COUNTRY_* */

  365. ‌static const char  **ngx_http_geoip_country_paths[] = {
  366.     ngx_http_geoip_path_country_code,
  367.     ngx_http_geoip_path_country_code,      /* converted to alpha-3 */
  368.     ngx_http_geoip_path_country_name
  369. };


  372. /* indexed by NGX_GEOIP_CITY_* */

  374. ‌static const char  **ngx_http_geoip_city_paths[] = {
  375.     ngx_http_geoip_path_continent_code,
  376.     ngx_http_geoip_path_country_code,
  377.     ngx_http_geoip_path_country_code,      /* converted to alpha-3 */
  378.     ngx_http_geoip_path_country_name,
  379.     ngx_http_geoip_path_region,
  380.     ngx_http_geoip_path_region_name,
  381.     ngx_http_geoip_path_city,
  382.     ngx_http_geoip_path_postal_code,
  383.     ngx_http_geoip_path_latitude,
  384.     ngx_http_geoip_path_longitude,
  385.     ngx_http_geoip_path_dma_code,
  386.     NULL                                   /* no area code */
  387. };


  390. /* ASNum, ISP, Org, and Domain editions, looked up in turn */

  392. ‌static const char  *ngx_http_geoip_org_paths[][2] = {
  393.     { "autonomous_system_organization", NULL },
  394.     { "isp", NULL },
  395.     { "organization", NULL },
  396.     { "domain", NULL },
  397.     { NULL, NULL }
  398. };


  401. /* MaxMind DB provides alpha-2 country codes only */

  403. ‌static ngx_http_geoip_ccode_t  ngx_http_geoip_country_codes[] = {
  404.     { "AD", "AND" }, { "AE", "ARE" }, { "AF", "AFG" }, { "AG", "ATG" },
  405.     { "AI", "AIA" }, { "AL", "ALB" }, { "AM", "ARM" }, { "AO", "AGO" },
  406.     { "AQ", "ATA" }, { "AR", "ARG" }, { "AS", "ASM" }, { "AT", "AUT" },
  407.     { "AU", "AUS" }, { "AW", "ABW" }, { "AX", "ALA" }, { "AZ", "AZE" },
  408.     { "BA", "BIH" }, { "BB", "BRB" }, { "BD", "BGD" }, { "BE", "BEL" },
  409.     { "BF", "BFA" }, { "BG", "BGR" }, { "BH", "BHR" }, { "BI", "BDI" },
  410.     { "BJ", "BEN" }, { "BL", "BLM" }, { "BM", "BMU" }, { "BN", "BRN" },
  411.     { "BO", "BOL" }, { "BQ", "BES" }, { "BR", "BRA" }, { "BS", "BHS" },
  412.     { "BT", "BTN" }, { "BV", "BVT" }, { "BW", "BWA" }, { "BY", "BLR" },
  413.     { "BZ", "BLZ" }, { "CA", "CAN" }, { "CC", "CCK" }, { "CD", "COD" },
  414.     { "CF", "CAF" }, { "CG", "COG" }, { "CH", "CHE" }, { "CI", "CIV" },
  415.     { "CK", "COK" }, { "CL", "CHL" }, { "CM", "CMR" }, { "CN", "CHN" },
  416.     { "CO", "COL" }, { "CR", "CRI" }, { "CU", "CUB" }, { "CV", "CPV" },
  417.     { "CW", "CUW" }, { "CX", "CXR" }, { "CY", "CYP" }, { "CZ", "CZE" },
  418.     { "DE", "DEU" }, { "DJ", "DJI" }, { "DK", "DNK" }, { "DM", "DMA" },
  419.     { "DO", "DOM" }, { "DZ", "DZA" }, { "EC", "ECU" }, { "EE", "EST" },
  420.     { "EG", "EGY" }, { "EH", "ESH" }, { "ER", "ERI" }, { "ES", "ESP" },
  421.     { "ET", "ETH" }, { "FI", "FIN" }, { "FJ", "FJI" }, { "FK", "FLK" },
  422.     { "FM", "FSM" }, { "FO", "FRO" }, { "FR", "FRA" }, { "GA", "GAB" },
  423.     { "GB", "GBR" }, { "GD", "GRD" }, { "GE", "GEO" }, { "GF", "GUF" },
  424.     { "GG", "GGY" }, { "GH", "GHA" }, { "GI", "GIB" }, { "GL", "GRL" },
  425.     { "GM", "GMB" }, { "GN", "GIN" }, { "GP", "GLP" }, { "GQ", "GNQ" },
  426.     { "GR", "GRC" }, { "GS", "SGS" }, { "GT", "GTM" }, { "GU", "GUM" },
  427.     { "GW", "GNB" }, { "GY", "GUY" }, { "HK", "HKG" }, { "HM", "HMD" },
  428.     { "HN", "HND" }, { "HR", "HRV" }, { "HT", "HTI" }, { "HU", "HUN" },
  429.     { "ID", "IDN" }, { "IE", "IRL" }, { "IL", "ISR" }, { "IM", "IMN" },
  430.     { "IN", "IND" }, { "IO", "IOT" }, { "IQ", "IRQ" }, { "IR", "IRN" },
  431.     { "IS", "ISL" }, { "IT", "ITA" }, { "JE", "JEY" }, { "JM", "JAM" },
  432.     { "JO", "JOR" }, { "JP", "JPN" }, { "KE", "KEN" }, { "KG", "KGZ" },
  433.     { "KH", "KHM" }, { "KI", "KIR" }, { "KM", "COM" }, { "KN", "KNA" },
  434.     { "KP", "PRK" }, { "KR", "KOR" }, { "KW", "KWT" }, { "KY", "CYM" },
  435.     { "KZ", "KAZ" }, { "LA", "LAO" }, { "LB", "LBN" }, { "LC", "LCA" },
  436.     { "LI", "LIE" }, { "LK", "LKA" }, { "LR", "LBR" }, { "LS", "LSO" },
  437.     { "LT", "LTU" }, { "LU", "LUX" }, { "LV", "LVA" }, { "LY", "LBY" },
  438.     { "MA", "MAR" }, { "MC", "MCO" }, { "MD", "MDA" }, { "ME", "MNE" },
  439.     { "MF", "MAF" }, { "MG", "MDG" }, { "MH", "MHL" }, { "MK", "MKD" },
  440.     { "ML", "MLI" }, { "MM", "MMR" }, { "MN", "MNG" }, { "MO", "MAC" },
  441.     { "MP", "MNP" }, { "MQ", "MTQ" }, { "MR", "MRT" }, { "MS", "MSR" },
  442.     { "MT", "MLT" }, { "MU", "MUS" }, { "MV", "MDV" }, { "MW", "MWI" },
  443.     { "MX", "MEX" }, { "MY", "MYS" }, { "MZ", "MOZ" }, { "NA", "NAM" },
  444.     { "NC", "NCL" }, { "NE", "NER" }, { "NF", "NFK" }, { "NG", "NGA" },
  445.     { "NI", "NIC" }, { "NL", "NLD" }, { "NO", "NOR" }, { "NP", "NPL" },
  446.     { "NR", "NRU" }, { "NU", "NIU" }, { "NZ", "NZL" }, { "OM", "OMN" },
  447.     { "PA", "PAN" }, { "PE", "PER" }, { "PF", "PYF" }, { "PG", "PNG" },
  448.     { "PH", "PHL" }, { "PK", "PAK" }, { "PL", "POL" }, { "PM", "SPM" },
  449.     { "PN", "PCN" }, { "PR", "PRI" }, { "PS", "PSE" }, { "PT", "PRT" },
  450.     { "PW", "PLW" }, { "PY", "PRY" }, { "QA", "QAT" }, { "RE", "REU" },
  451.     { "RO", "ROU" }, { "RS", "SRB" }, { "RU", "RUS" }, { "RW", "RWA" },
  452.     { "SA", "SAU" }, { "SB", "SLB" }, { "SC", "SYC" }, { "SD", "SDN" },
  453.     { "SE", "SWE" }, { "SG", "SGP" }, { "SH", "SHN" }, { "SI", "SVN" },
  454.     { "SJ", "SJM" }, { "SK", "SVK" }, { "SL", "SLE" }, { "SM", "SMR" },
  455.     { "SN", "SEN" }, { "SO", "SOM" }, { "SR", "SUR" }, { "SS", "SSD" },
  456.     { "ST", "STP" }, { "SV", "SLV" }, { "SX", "SXM" }, { "SY", "SYR" },
  457.     { "SZ", "SWZ" }, { "TC", "TCA" }, { "TD", "TCD" }, { "TF", "ATF" },
  458.     { "TG", "TGO" }, { "TH", "THA" }, { "TJ", "TJK" }, { "TK", "TKL" },
  459.     { "TL", "TLS" }, { "TM", "TKM" }, { "TN", "TUN" }, { "TO", "TON" },
  460.     { "TR", "TUR" }, { "TT", "TTO" }, { "TV", "TUV" }, { "TW", "TWN" },
  461.     { "TZ", "TZA" }, { "UA", "UKR" }, { "UG", "UGA" }, { "UM", "UMI" },
  462.     { "US", "USA" }, { "UY", "URY" }, { "UZ", "UZB" }, { "VA", "VAT" },
  463.     { "VC", "VCT" }, { "VE", "VEN" }, { "VG", "VGB" }, { "VI", "VIR" },
  464.     { "VN", "VNM" }, { "VU", "VUT" }, { "WF", "WLF" }, { "WS", "WSM" },
  465.     { "YE", "YEM" }, { "YT", "MYT" }, { "ZA", "ZAF" }, { "ZM", "ZMB" },
  466.     { "ZW", "ZWE" },
  467.     { NULL, NULL }
  468. };

  470. #endif


  473. #if (NGX_HAVE_GEOIP)

  475. static u_long
  476. ‌ngx_http_geoip_addr(ngx_http_request_t *r, ngx_http_geoip_conf_t *gcf)
  477. {
  478.     ngx_addr_t           addr;
  479.     ngx_table_elt_t     *xfwd;
  480.     struct sockaddr_in  *sin;

  482.     addr.sockaddr = r->connection->sockaddr;
  483.     addr.socklen = r->connection->socklen;
  484.     /* addr.name = r->connection->addr_text; */

  486.     xfwd = r->headers_in.x_forwarded_for;

  488.     if (xfwd != NULL && gcf->proxies != NULL) {
  489.         (void) ngx_http_get_forwarded_addr(r, &addr, xfwd, NULL,
  490.                                            gcf->proxies, gcf->proxy_recursive);
  491.     }

  493. #if (NGX_HAVE_INET6)

  495.     if (addr.sockaddr->sa_family == AF_INET6) {
  496.         u_char           *p;
  497.         in_addr_t         inaddr;
  498.         struct in6_addr  *inaddr6;

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

  502.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  503.             p = inaddr6->s6_addr;

  505.             inaddr = (in_addr_t) p[12] << 24;
  506.             inaddr += p[13] << 16;
  507.             inaddr += p[14] << 8;
  508.             inaddr += p[15];

  510.             return inaddr;
  511.         }
  512.     }

  514. #endif

  516.     if (addr.sockaddr->sa_family != AF_INET) {
  517.         return INADDR_NONE;
  518.     }

  520.     sin = (struct sockaddr_in *) addr.sockaddr;
  521.     return ntohl(sin->sin_addr.s_addr);
  522. }


  525. #if (NGX_HAVE_GEOIP_V6)

  527. static geoipv6_t
  528. ‌ngx_http_geoip_addr_v6(ngx_http_request_t *r, ngx_http_geoip_conf_t *gcf)
  529. {
  530.     ngx_addr_t            addr;
  531.     ngx_table_elt_t      *xfwd;
  532.     in_addr_t             addr4;
  533.     struct in6_addr       addr6;
  534.     struct sockaddr_in   *sin;
  535.     struct sockaddr_in6  *sin6;

  537.     addr.sockaddr = r->connection->sockaddr;
  538.     addr.socklen = r->connection->socklen;
  539.     /* addr.name = r->connection->addr_text; */

  541.     xfwd = r->headers_in.x_forwarded_for;

  543.     if (xfwd != NULL && gcf->proxies != NULL) {
  544.         (void) ngx_http_get_forwarded_addr(r, &addr, xfwd, NULL,
  545.                                            gcf->proxies, gcf->proxy_recursive);
  546.     }

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

  550.     case AF_INET:
  551.         /* Produce IPv4-mapped IPv6 address. */
  552.         sin = (struct sockaddr_in *) addr.sockaddr;
  553.         addr4 = ntohl(sin->sin_addr.s_addr);

  555.         ngx_memzero(&addr6, sizeof(struct in6_addr));
  556.         addr6.s6_addr[10] = 0xff;
  557.         addr6.s6_addr[11] = 0xff;
  558.         addr6.s6_addr[12] = addr4 >> 24;
  559.         addr6.s6_addr[13] = addr4 >> 16;
  560.         addr6.s6_addr[14] = addr4 >> 8;
  561.         addr6.s6_addr[15] = addr4;
  562.         return addr6;

  564.     case AF_INET6:
  565.         sin6 = (struct sockaddr_in6 *) addr.sockaddr;
  566.         return sin6->sin6_addr;

  568.     default:
  569.         return in6addr_any;
  570.     }
  571. }

  573. #endif

  575. #endif


  578. static ngx_int_t
  579. ‌ngx_http_geoip_country_variable(ngx_http_request_t *r,
  580.     ngx_http_variable_value_t *v, uintptr_t data)
  581. {
  582. #if (NGX_HAVE_GEOIP)
  583.     ngx_http_geoip_variable_handler_pt     handler =
  584.         ngx_http_geoip_country_functions[data];
  585. #if (NGX_HAVE_GEOIP_V6)
  586.     ngx_http_geoip_variable_handler_v6_pt  handler_v6 =
  587.         ngx_http_geoip_country_v6_functions[data];
  588. #endif

  590.     const char             *val;
  591. #endif
  592. #if (NGX_HAVE_MAXMINDDB)
  593.     ngx_int_t               rc;
  594.     ngx_str_t               value;
  595.     MMDB_entry_s            entry;
  596. #endif
  597.     ngx_http_geoip_conf_t  *gcf;

  599.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  601. #if (NGX_HAVE_MAXMINDDB)

  603.     if (gcf->country_mmdb) {

  605.         if (ngx_http_geoip_lookup(r, gcf->country_mmdb, &entry) != NGX_OK) {
  606.             goto not_found;
  607.         }

  609.         rc = ngx_http_geoip_str(r, &entry,
  610.                                 ngx_http_geoip_country_paths[data], &value);

  612.         if (rc == NGX_OK && data == NGX_GEOIP_COUNTRY_CODE3) {
  613.             rc = ngx_http_geoip_code3(&value);
  614.         }

  616.         if (rc == NGX_ERROR) {
  617.             return NGX_ERROR;
  618.         }

  620.         if (rc != NGX_OK) {
  621.             goto not_found;
  622.         }

  624.         v->len = value.len;
  625.         v->valid = 1;
  626.         v->no_cacheable = 0;
  627.         v->not_found = 0;
  628.         v->data = value.data;

  630.         return NGX_OK;
  631.     }

  633. #endif

  635. #if (NGX_HAVE_GEOIP)

  637.     if (gcf->country == NULL) {
  638.         goto not_found;
  639.     }

  641. #if (NGX_HAVE_GEOIP_V6)
  642.     val = gcf->country_v6
  643.               ? handler_v6(gcf->country, ngx_http_geoip_addr_v6(r, gcf))
  644.               : handler(gcf->country, ngx_http_geoip_addr(r, gcf));
  645. #else
  646.     val = handler(gcf->country, ngx_http_geoip_addr(r, gcf));
  647. #endif

  649.     if (val == NULL) {
  650.         goto not_found;
  651.     }

  653.     v->len = ngx_strlen(val);
  654.     v->valid = 1;
  655.     v->no_cacheable = 0;
  656.     v->not_found = 0;
  657.     v->data = (u_char *) val;

  659.     return NGX_OK;

  661. #endif

  663. not_found:

  665.     v->not_found = 1;

  667.     return NGX_OK;
  668. }


  671. static ngx_int_t
  672. ‌ngx_http_geoip_org_variable(ngx_http_request_t *r,
  673.     ngx_http_variable_value_t *v, uintptr_t data)
  674. {
  675. #if (NGX_HAVE_GEOIP)
  676.     size_t                  len;
  677.     char                   *val;
  678. #endif
  679. #if (NGX_HAVE_MAXMINDDB)
  680.     ngx_int_t               rc;
  681.     ngx_str_t               value;
  682.     ngx_uint_t              i;
  683.     MMDB_entry_s            entry;
  684. #endif
  685.     ngx_http_geoip_conf_t  *gcf;

  687.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  689. #if (NGX_HAVE_MAXMINDDB)

  691.     if (gcf->org_mmdb) {

  693.         if (ngx_http_geoip_lookup(r, gcf->org_mmdb, &entry) != NGX_OK) {
  694.             goto not_found;
  695.         }

  697.         for (i = 0; ngx_http_geoip_org_paths[i][0]; i++) {

  699.             rc = ngx_http_geoip_str(r, &entry,
  700.                                     ngx_http_geoip_org_paths[i], &value);

  702.             if (rc == NGX_ERROR) {
  703.                 return NGX_ERROR;
  704.             }

  706.             if (rc == NGX_OK) {
  707.                 v->len = value.len;
  708.                 v->valid = 1;
  709.                 v->no_cacheable = 0;
  710.                 v->not_found = 0;
  711.                 v->data = value.data;

  713.                 return NGX_OK;
  714.             }
  715.         }

  717.         goto not_found;
  718.     }

  720. #endif

  722. #if (NGX_HAVE_GEOIP)

  724.     if (gcf->org == NULL) {
  725.         goto not_found;
  726.     }

  728. #if (NGX_HAVE_GEOIP_V6)
  729.     val = gcf->org_v6
  730.               ? GeoIP_name_by_ipnum_v6(gcf->org,
  731.                                        ngx_http_geoip_addr_v6(r, gcf))
  732.               : GeoIP_name_by_ipnum(gcf->org,
  733.                                     ngx_http_geoip_addr(r, gcf));
  734. #else
  735.     val = GeoIP_name_by_ipnum(gcf->org, ngx_http_geoip_addr(r, gcf));
  736. #endif

  738.     if (val == NULL) {
  739.         goto not_found;
  740.     }

  742.     len = ngx_strlen(val);
  743.     v->data = ngx_pnalloc(r->pool, len);
  744.     if (v->data == NULL) {
  745.         ngx_free(val);
  746.         return NGX_ERROR;
  747.     }

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

  751.     v->len = len;
  752.     v->valid = 1;
  753.     v->no_cacheable = 0;
  754.     v->not_found = 0;

  756.     ngx_free(val);

  758.     return NGX_OK;

  760. #endif

  762. not_found:

  764.     v->not_found = 1;

  766.     return NGX_OK;
  767. }


  770. static ngx_int_t
  771. ‌ngx_http_geoip_city_variable(ngx_http_request_t *r,
  772.     ngx_http_variable_value_t *v, uintptr_t data)
  773. {
  774. #if (NGX_HAVE_GEOIP)
  775.     char                   *val;
  776.     size_t                  len;
  777.     GeoIPRecord            *gr;
  778. #endif
  779. #if (NGX_HAVE_MAXMINDDB)
  780.     ngx_int_t               rc;
  781.     ngx_str_t               value;
  782.     MMDB_entry_s            entry;
  783.     ngx_http_geoip_conf_t  *gcf;

  785.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  787.     if (gcf->city_mmdb) {

  789.         if (ngx_http_geoip_lookup(r, gcf->city_mmdb, &entry) != NGX_OK) {
  790.             goto not_found;
  791.         }

  793.         rc = ngx_http_geoip_str(r, &entry,
  794.                                 ngx_http_geoip_city_paths[data], &value);

  796.         if (rc == NGX_OK && data == NGX_GEOIP_CITY_COUNTRY_CODE3) {
  797.             rc = ngx_http_geoip_code3(&value);
  798.         }

  800.         if (rc == NGX_ERROR) {
  801.             return NGX_ERROR;
  802.         }

  804.         if (rc != NGX_OK) {
  805.             goto not_found;
  806.         }

  808.         v->len = value.len;
  809.         v->valid = 1;
  810.         v->no_cacheable = 0;
  811.         v->not_found = 0;
  812.         v->data = value.data;

  814.         return NGX_OK;
  815.     }

  817. #endif

  819. #if (NGX_HAVE_GEOIP)

  821.     gr = ngx_http_geoip_get_city_record(r);
  822.     if (gr == NULL) {
  823.         goto not_found;
  824.     }

  826.     val = *(char **) ((char *) gr + ngx_http_geoip_city_offsets[data]);
  827.     if (val == NULL) {
  828.         goto no_value;
  829.     }

  831.     len = ngx_strlen(val);
  832.     v->data = ngx_pnalloc(r->pool, len);
  833.     if (v->data == NULL) {
  834.         GeoIPRecord_delete(gr);
  835.         return NGX_ERROR;
  836.     }

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

  840.     v->len = len;
  841.     v->valid = 1;
  842.     v->no_cacheable = 0;
  843.     v->not_found = 0;

  845.     GeoIPRecord_delete(gr);

  847.     return NGX_OK;

  849. no_value:

  851.     GeoIPRecord_delete(gr);

  853. #endif

  855. not_found:

  857.     v->not_found = 1;

  859.     return NGX_OK;
  860. }


  863. static ngx_int_t
  864. ‌ngx_http_geoip_region_name_variable(ngx_http_request_t *r,
  865.     ngx_http_variable_value_t *v, uintptr_t data)
  866. {
  867. #if (NGX_HAVE_GEOIP)
  868.     size_t                  len;
  869.     const char             *val;
  870.     GeoIPRecord            *gr;
  871. #endif
  872. #if (NGX_HAVE_MAXMINDDB)
  873.     ngx_int_t               rc;
  874.     ngx_str_t               value;
  875.     MMDB_entry_s            entry;
  876.     ngx_http_geoip_conf_t  *gcf;

  878.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  880.     if (gcf->city_mmdb) {

  882.         if (ngx_http_geoip_lookup(r, gcf->city_mmdb, &entry) != NGX_OK) {
  883.             goto not_found;
  884.         }

  886.         rc = ngx_http_geoip_str(r, &entry,
  887.                                 ngx_http_geoip_city_paths[data], &value);

  889.         if (rc == NGX_ERROR) {
  890.             return NGX_ERROR;
  891.         }

  893.         if (rc != NGX_OK) {
  894.             goto not_found;
  895.         }

  897.         v->len = value.len;
  898.         v->valid = 1;
  899.         v->no_cacheable = 0;
  900.         v->not_found = 0;
  901.         v->data = value.data;

  903.         return NGX_OK;
  904.     }

  906. #endif

  908. #if (NGX_HAVE_GEOIP)

  910.     gr = ngx_http_geoip_get_city_record(r);
  911.     if (gr == NULL) {
  912.         goto not_found;
  913.     }

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

  917.     GeoIPRecord_delete(gr);

  919.     if (val == NULL) {
  920.         goto not_found;
  921.     }

  923.     len = ngx_strlen(val);
  924.     v->data = ngx_pnalloc(r->pool, len);
  925.     if (v->data == NULL) {
  926.         return NGX_ERROR;
  927.     }

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

  931.     v->len = len;
  932.     v->valid = 1;
  933.     v->no_cacheable = 0;
  934.     v->not_found = 0;

  936.     return NGX_OK;

  938. #endif

  940. not_found:

  942.     v->not_found = 1;

  944.     return NGX_OK;
  945. }


  948. static ngx_int_t
  949. ‌ngx_http_geoip_city_float_variable(ngx_http_request_t *r,
  950.     ngx_http_variable_value_t *v, uintptr_t data)
  951. {
  952. #if (NGX_HAVE_GEOIP)
  953.     float                   val;
  954.     GeoIPRecord            *gr;
  955. #endif
  956. #if (NGX_HAVE_MAXMINDDB)
  957.     double                  value;
  958.     ngx_int_t               rc;
  959.     MMDB_entry_s            entry;
  960.     ngx_http_geoip_conf_t  *gcf;

  962.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  964.     if (gcf->city_mmdb) {

  966.         if (ngx_http_geoip_lookup(r, gcf->city_mmdb, &entry) != NGX_OK) {
  967.             goto not_found;
  968.         }

  970.         rc = ngx_http_geoip_float(&entry,
  971.                                   ngx_http_geoip_city_paths[data], &value);

  973.         if (rc != NGX_OK) {
  974.             goto not_found;
  975.         }

  977.         v->data = ngx_pnalloc(r->pool, NGX_INT64_LEN + 5);
  978.         if (v->data == NULL) {
  979.             return NGX_ERROR;
  980.         }

  982.         v->len = ngx_sprintf(v->data, "%.4f", value) - v->data;
  983.         v->valid = 1;
  984.         v->no_cacheable = 0;
  985.         v->not_found = 0;

  987.         return NGX_OK;
  988.     }

  990. #endif

  992. #if (NGX_HAVE_GEOIP)

  994.     gr = ngx_http_geoip_get_city_record(r);
  995.     if (gr == NULL) {
  996.         goto not_found;
  997.     }

  999.     v->data = ngx_pnalloc(r->pool, NGX_INT64_LEN + 5);
  1000.     if (v->data == NULL) {
  1001.         GeoIPRecord_delete(gr);
  1002.         return NGX_ERROR;
  1003.     }

  1005.     val = *(float *) ((char *) gr + ngx_http_geoip_city_offsets[data]);

  1007.     v->len = ngx_sprintf(v->data, "%.4f", val) - v->data;
  1008.     v->valid = 1;
  1009.     v->no_cacheable = 0;
  1010.     v->not_found = 0;

  1012.     GeoIPRecord_delete(gr);

  1014.     return NGX_OK;

  1016. #endif

  1018. not_found:

  1020.     v->not_found = 1;

  1022.     return NGX_OK;
  1023. }


  1026. static ngx_int_t
  1027. ‌ngx_http_geoip_city_int_variable(ngx_http_request_t *r,
  1028.     ngx_http_variable_value_t *v, uintptr_t data)
  1029. {
  1030. #if (NGX_HAVE_GEOIP)
  1031.     int                     val;
  1032.     GeoIPRecord            *gr;
  1033. #endif
  1034. #if (NGX_HAVE_MAXMINDDB)
  1035.     int64_t                 value;
  1036.     ngx_int_t               rc;
  1037.     MMDB_entry_s            entry;
  1038.     ngx_http_geoip_conf_t  *gcf;

  1040.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  1042.     if (gcf->city_mmdb) {

  1044.         if (ngx_http_geoip_lookup(r, gcf->city_mmdb, &entry) != NGX_OK) {
  1045.             goto not_found;
  1046.         }

  1048.         rc = ngx_http_geoip_int(&entry,
  1049.                                 ngx_http_geoip_city_paths[data], &value);

  1051.         if (rc != NGX_OK) {
  1052.             goto not_found;
  1053.         }

  1055.         v->data = ngx_pnalloc(r->pool, NGX_INT64_LEN);
  1056.         if (v->data == NULL) {
  1057.             return NGX_ERROR;
  1058.         }

  1060.         v->len = ngx_sprintf(v->data, "%L", value) - v->data;
  1061.         v->valid = 1;
  1062.         v->no_cacheable = 0;
  1063.         v->not_found = 0;

  1065.         return NGX_OK;
  1066.     }

  1068. #endif

  1070. #if (NGX_HAVE_GEOIP)

  1072.     gr = ngx_http_geoip_get_city_record(r);
  1073.     if (gr == NULL) {
  1074.         goto not_found;
  1075.     }

  1077.     v->data = ngx_pnalloc(r->pool, NGX_INT64_LEN);
  1078.     if (v->data == NULL) {
  1079.         GeoIPRecord_delete(gr);
  1080.         return NGX_ERROR;
  1081.     }

  1083.     val = *(int *) ((char *) gr + ngx_http_geoip_city_offsets[data]);

  1085.     v->len = ngx_sprintf(v->data, "%d", val) - v->data;
  1086.     v->valid = 1;
  1087.     v->no_cacheable = 0;
  1088.     v->not_found = 0;

  1090.     GeoIPRecord_delete(gr);

  1092.     return NGX_OK;

  1094. #endif

  1096. not_found:

  1098.     v->not_found = 1;

  1100.     return NGX_OK;
  1101. }


  1104. #if (NGX_HAVE_GEOIP)

  1106. static GeoIPRecord *
  1107. ‌ngx_http_geoip_get_city_record(ngx_http_request_t *r)
  1108. {
  1109.     ngx_http_geoip_conf_t  *gcf;

  1111.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  1113.     if (gcf->city) {
  1114. #if (NGX_HAVE_GEOIP_V6)
  1115.         return gcf->city_v6
  1116.                    ? GeoIP_record_by_ipnum_v6(gcf->city,
  1117.                                               ngx_http_geoip_addr_v6(r, gcf))
  1118.                    : GeoIP_record_by_ipnum(gcf->city,
  1119.                                            ngx_http_geoip_addr(r, gcf));
  1120. #else
  1121.         return GeoIP_record_by_ipnum(gcf->city, ngx_http_geoip_addr(r, gcf));
  1122. #endif
  1123.     }

  1125.     return NULL;
  1126. }

  1128. #endif


  1131. #if (NGX_HAVE_MAXMINDDB)

  1133. static ngx_int_t
  1134. ‌ngx_http_geoip_str(ngx_http_request_t *r, MMDB_entry_s *entry,
  1135.     const char **path, ngx_str_t *value)
  1136. {
  1137.     MMDB_entry_data_s  entry_data;

  1139.     if (path == NULL
  1140.         || MMDB_aget_value(entry, &entry_data, path) != MMDB_SUCCESS
  1141.         || !entry_data.has_data
  1142.         || entry_data.type != MMDB_DATA_TYPE_UTF8_STRING)
  1143.     {
  1144.         return NGX_DECLINED;
  1145.     }

  1147.     value->data = ngx_pnalloc(r->pool, entry_data.data_size);
  1148.     if (value->data == NULL) {
  1149.         return NGX_ERROR;
  1150.     }

  1152.     ngx_memcpy(value->data, entry_data.utf8_string, entry_data.data_size);
  1153.     value->len = entry_data.data_size;

  1155.     return NGX_OK;
  1156. }


  1159. static ngx_int_t
  1160. ‌ngx_http_geoip_code3(ngx_str_t *value)
  1161. {
  1162.     ngx_http_geoip_ccode_t  *cc;

  1164.     if (value->len != 2) {
  1165.         return NGX_DECLINED;
  1166.     }

  1168.     for (cc = ngx_http_geoip_country_codes; cc->alpha2; cc++) {
  1169.         if (value->data[0] == cc->alpha2[0]
  1170.             && value->data[1] == cc->alpha2[1])
  1171.         {
  1172.             value->len = 3;
  1173.             value->data = (u_char *) cc->alpha3;
  1174.             return NGX_OK;
  1175.         }
  1176.     }

  1178.     return NGX_DECLINED;
  1179. }


  1182. static ngx_int_t
  1183. ‌ngx_http_geoip_float(MMDB_entry_s *entry, const char **path, double *value)
  1184. {
  1185.     MMDB_entry_data_s  entry_data;

  1187.     if (path == NULL
  1188.         || MMDB_aget_value(entry, &entry_data, path) != MMDB_SUCCESS
  1189.         || !entry_data.has_data)
  1190.     {
  1191.         return NGX_DECLINED;
  1192.     }

  1194.     switch (entry_data.type) {

  1196.     case MMDB_DATA_TYPE_DOUBLE:
  1197.         *value = entry_data.double_value;
  1198.         break;

  1200.     case MMDB_DATA_TYPE_FLOAT:
  1201.         *value = entry_data.float_value;
  1202.         break;

  1204.     default:
  1205.         return NGX_DECLINED;
  1206.     }

  1208.     /* the range of a coordinate in degrees; NaN fails the comparison */

  1210.     if (!(*value >= -NGX_GEOIP_MAX_COORD && *value <= NGX_GEOIP_MAX_COORD)) {
  1211.         return NGX_DECLINED;
  1212.     }

  1214.     return NGX_OK;
  1215. }


  1218. static ngx_int_t
  1219. ‌ngx_http_geoip_int(MMDB_entry_s *entry, const char **path, int64_t *value)
  1220. {
  1221.     MMDB_entry_data_s  entry_data;

  1223.     if (path == NULL
  1224.         || MMDB_aget_value(entry, &entry_data, path) != MMDB_SUCCESS
  1225.         || !entry_data.has_data)
  1226.     {
  1227.         return NGX_DECLINED;
  1228.     }

  1230.     switch (entry_data.type) {

  1232.     case MMDB_DATA_TYPE_UINT16:
  1233.         *value = entry_data.uint16;
  1234.         return NGX_OK;

  1236.     case MMDB_DATA_TYPE_UINT32:
  1237.         *value = entry_data.uint32;
  1238.         return NGX_OK;

  1240.     case MMDB_DATA_TYPE_INT32:
  1241.         *value = entry_data.int32;
  1242.         return NGX_OK;

  1244.     default:
  1245.         return NGX_DECLINED;
  1246.     }
  1247. }


  1250. static ngx_int_t
  1251. ‌ngx_http_geoip_lookup(ngx_http_request_t *r, MMDB_s *mmdb, MMDB_entry_s *entry)
  1252. {
  1253.     int                     err;
  1254.     ngx_addr_t              addr;
  1255.     ngx_table_elt_t        *xfwd;
  1256.     MMDB_lookup_result_s    result;
  1257.     ngx_http_geoip_conf_t  *gcf;
  1258. #if (NGX_HAVE_INET6)
  1259.     struct in6_addr        *inaddr6;
  1260.     struct sockaddr_in      sin;
  1261. #endif

  1263.     gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);

  1265.     addr.sockaddr = r->connection->sockaddr;
  1266.     addr.socklen = r->connection->socklen;
  1267.     /* addr.name = r->connection->addr_text; */

  1269.     xfwd = r->headers_in.x_forwarded_for;

  1271.     if (xfwd != NULL && gcf->proxies != NULL) {
  1272.         (void) ngx_http_get_forwarded_addr(r, &addr, xfwd, NULL,
  1273.                                            gcf->proxies, gcf->proxy_recursive);
  1274.     }

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

  1278.     case AF_INET:
  1279.         break;

  1281. #if (NGX_HAVE_INET6)
  1282.     case AF_INET6:
  1283.         inaddr6 = &((struct sockaddr_in6 *) addr.sockaddr)->sin6_addr;

  1285.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  1286.             ngx_memzero(&sin, sizeof(struct sockaddr_in));
  1287.             sin.sin_family = AF_INET;
  1288.             ngx_memcpy(&sin.sin_addr, &inaddr6->s6_addr[12], 4);

  1290.             addr.sockaddr = (struct sockaddr *) &sin;
  1291.             break;
  1292.         }

  1294.         if (mmdb->metadata.ip_version == 4) {
  1295.             return NGX_DECLINED;
  1296.         }

  1298.         break;
  1299. #endif

  1301.     default:
  1302.         return NGX_DECLINED;
  1303.     }

  1305.     result = MMDB_lookup_sockaddr(mmdb, addr.sockaddr, &err);

  1307.     if (err != MMDB_SUCCESS) {
  1308.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1309.                       "MMDB_lookup_sockaddr() failed: %s", MMDB_strerror(err));
  1310.         return NGX_DECLINED;
  1311.     }

  1313.     if (!result.found_entry) {
  1314.         return NGX_DECLINED;
  1315.     }

  1317.     *entry = result.entry;

  1319.     return NGX_OK;
  1320. }

  1322. #endif


  1325. static ngx_int_t
  1326. ‌ngx_http_geoip_add_variables(ngx_conf_t *cf)
  1327. {
  1328.     ngx_http_variable_t  *var, *v;

  1330.     for (v = ngx_http_geoip_vars; v->name.len; v++) {
  1331.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  1332.         if (var == NULL) {
  1333.             return NGX_ERROR;
  1334.         }

  1336.         var->get_handler = v->get_handler;
  1337.         var->data = v->data;
  1338.     }

  1340.     return NGX_OK;
  1341. }


  1344. static void *
  1345. ‌ngx_http_geoip_create_conf(ngx_conf_t *cf)
  1346. {
  1347.     ngx_pool_cleanup_t     *cln;
  1348.     ngx_http_geoip_conf_t  *conf;

  1350.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_geoip_conf_t));
  1351.     if (conf == NULL) {
  1352.         return NULL;
  1353.     }

  1355.     conf->proxy_recursive = NGX_CONF_UNSET;

  1357.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  1358.     if (cln == NULL) {
  1359.         return NULL;
  1360.     }

  1362.     cln->handler = ngx_http_geoip_cleanup;
  1363.     cln->data = conf;

  1365.     return conf;
  1366. }


  1369. static char *
  1370. ‌ngx_http_geoip_init_conf(ngx_conf_t *cf, void *conf)
  1371. {
  1372.     ngx_http_geoip_conf_t  *gcf = conf;

  1374.     ngx_conf_init_value(gcf->proxy_recursive, 0);

  1376.     return NGX_CONF_OK;
  1377. }


  1380. static char *
  1381. ‌ngx_http_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1382. {
  1383.     ngx_http_geoip_conf_t  *gcf = conf;

  1385.     ngx_str_t  *value;

  1387. #if (NGX_HAVE_GEOIP)
  1388.     if (gcf->country) {
  1389.         return "is duplicate";
  1390.     }
  1391. #endif
  1392. #if (NGX_HAVE_MAXMINDDB)
  1393.     if (gcf->country_mmdb) {
  1394.         return "is duplicate";
  1395.     }
  1396. #endif

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

  1400. #if (NGX_HAVE_MAXMINDDB)

  1402.     switch (ngx_http_geoip_open(cf, &value[1], &gcf->country_mmdb)) {

  1404.     case NGX_OK:
  1405.         return ngx_http_geoip_charset(cf);

  1407.     case NGX_ERROR:
  1408.         return NGX_CONF_ERROR;

  1410.     default:
  1411.         break;
  1412.     }

  1414. #endif

  1416. #if (NGX_HAVE_GEOIP)

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

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

  1424.         return NGX_CONF_ERROR;
  1425.     }

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

  1431.         } else {
  1432.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1433.                                "invalid parameter \"%V\"", &value[2]);
  1434.             return NGX_CONF_ERROR;
  1435.         }
  1436.     }

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

  1440.     case GEOIP_COUNTRY_EDITION:

  1442.         return NGX_CONF_OK;

  1444. #if (NGX_HAVE_GEOIP_V6)
  1445.     case GEOIP_COUNTRY_EDITION_V6:

  1447.         gcf->country_v6 = 1;
  1448.         return NGX_CONF_OK;
  1449. #endif

  1451.     default:
  1452.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1453.                            "invalid GeoIP database \"%V\" type:%d",
  1454.                            &value[1], gcf->country->databaseType);
  1455.         return NGX_CONF_ERROR;
  1456.     }

  1458. #else

  1460.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1461.                        "\"%V\" is not a MaxMind DB database", &value[1]);

  1463.     return NGX_CONF_ERROR;

  1465. #endif
  1466. }


  1469. static char *
  1470. ‌ngx_http_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1471. {
  1472.     ngx_http_geoip_conf_t  *gcf = conf;

  1474.     ngx_str_t  *value;

  1476. #if (NGX_HAVE_GEOIP)
  1477.     if (gcf->org) {
  1478.         return "is duplicate";
  1479.     }
  1480. #endif
  1481. #if (NGX_HAVE_MAXMINDDB)
  1482.     if (gcf->org_mmdb) {
  1483.         return "is duplicate";
  1484.     }
  1485. #endif

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

  1489. #if (NGX_HAVE_MAXMINDDB)

  1491.     switch (ngx_http_geoip_open(cf, &value[1], &gcf->org_mmdb)) {

  1493.     case NGX_OK:
  1494.         return ngx_http_geoip_charset(cf);

  1496.     case NGX_ERROR:
  1497.         return NGX_CONF_ERROR;

  1499.     default:
  1500.         break;
  1501.     }

  1503. #endif

  1505. #if (NGX_HAVE_GEOIP)

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

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

  1513.         return NGX_CONF_ERROR;
  1514.     }

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

  1520.         } else {
  1521.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1522.                                "invalid parameter \"%V\"", &value[2]);
  1523.             return NGX_CONF_ERROR;
  1524.         }
  1525.     }

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

  1529.     case GEOIP_ISP_EDITION:
  1530.     case GEOIP_ORG_EDITION:
  1531.     case GEOIP_DOMAIN_EDITION:
  1532.     case GEOIP_ASNUM_EDITION:

  1534.         return NGX_CONF_OK;

  1536. #if (NGX_HAVE_GEOIP_V6)
  1537.     case GEOIP_ISP_EDITION_V6:
  1538.     case GEOIP_ORG_EDITION_V6:
  1539.     case GEOIP_DOMAIN_EDITION_V6:
  1540.     case GEOIP_ASNUM_EDITION_V6:

  1542.         gcf->org_v6 = 1;
  1543.         return NGX_CONF_OK;
  1544. #endif

  1546.     default:
  1547.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1548.                            "invalid GeoIP database \"%V\" type:%d",
  1549.                            &value[1], gcf->org->databaseType);
  1550.         return NGX_CONF_ERROR;
  1551.     }

  1553. #else

  1555.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1556.                        "\"%V\" is not a MaxMind DB database", &value[1]);

  1558.     return NGX_CONF_ERROR;

  1560. #endif
  1561. }


  1564. static char *
  1565. ‌ngx_http_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1566. {
  1567.     ngx_http_geoip_conf_t  *gcf = conf;

  1569.     ngx_str_t  *value;

  1571. #if (NGX_HAVE_GEOIP)
  1572.     if (gcf->city) {
  1573.         return "is duplicate";
  1574.     }
  1575. #endif
  1576. #if (NGX_HAVE_MAXMINDDB)
  1577.     if (gcf->city_mmdb) {
  1578.         return "is duplicate";
  1579.     }
  1580. #endif

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

  1584. #if (NGX_HAVE_MAXMINDDB)

  1586.     switch (ngx_http_geoip_open(cf, &value[1], &gcf->city_mmdb)) {

  1588.     case NGX_OK:
  1589.         return ngx_http_geoip_charset(cf);

  1591.     case NGX_ERROR:
  1592.         return NGX_CONF_ERROR;

  1594.     default:
  1595.         break;
  1596.     }

  1598. #endif

  1600. #if (NGX_HAVE_GEOIP)

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

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

  1608.         return NGX_CONF_ERROR;
  1609.     }

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

  1615.         } else {
  1616.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1617.                                "invalid parameter \"%V\"", &value[2]);
  1618.             return NGX_CONF_ERROR;
  1619.         }
  1620.     }

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

  1624.     case GEOIP_CITY_EDITION_REV0:
  1625.     case GEOIP_CITY_EDITION_REV1:

  1627.         return NGX_CONF_OK;

  1629. #if (NGX_HAVE_GEOIP_V6)
  1630.     case GEOIP_CITY_EDITION_REV0_V6:
  1631.     case GEOIP_CITY_EDITION_REV1_V6:

  1633.         gcf->city_v6 = 1;
  1634.         return NGX_CONF_OK;
  1635. #endif

  1637.     default:
  1638.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1639.                            "invalid GeoIP City database \"%V\" type:%d",
  1640.                            &value[1], gcf->city->databaseType);
  1641.         return NGX_CONF_ERROR;
  1642.     }

  1644. #else

  1646.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1647.                        "\"%V\" is not a MaxMind DB database", &value[1]);

  1649.     return NGX_CONF_ERROR;

  1651. #endif
  1652. }


  1655. #if (NGX_HAVE_MAXMINDDB)

  1657. static ngx_int_t
  1658. ‌ngx_http_geoip_open(ngx_conf_t *cf, ngx_str_t *name, MMDB_s **db)
  1659. {
  1660.     int               status;
  1661.     MMDB_s           *mmdb;
  1662.     ngx_file_info_t   fi;

  1664.     if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
  1665.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1666.                            ngx_file_info_n " \"%V\" failed", name);
  1667.         return NGX_ERROR;
  1668.     }

  1670.     mmdb = ngx_palloc(cf->pool, sizeof(MMDB_s));
  1671.     if (mmdb == NULL) {
  1672.         return NGX_ERROR;
  1673.     }

  1675.     status = MMDB_open((char *) name->data, MMDB_MODE_MMAP, mmdb);

  1677.     if (status == MMDB_SUCCESS) {
  1678.         *db = mmdb;
  1679.         return NGX_OK;
  1680.     }

  1682.     /* presumably a legacy GeoIP database */

  1684.     if (status == MMDB_INVALID_METADATA_ERROR) {
  1685.         return NGX_DECLINED;
  1686.     }

  1688.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "MMDB_open(\"%V\") failed: %s",
  1689.                        name, MMDB_strerror(status));

  1691.     return NGX_ERROR;
  1692. }


  1695. static char *
  1696. ‌ngx_http_geoip_charset(ngx_conf_t *cf)
  1697. {
  1698.     ngx_str_t  *value;

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

  1702.     /* MaxMind DB is always in UTF-8 */

  1704.     if (cf->args->nelts == 3 && ngx_strcmp(value[2].data, "utf8") != 0) {
  1705.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1706.                            "invalid parameter \"%V\"", &value[2]);
  1707.         return NGX_CONF_ERROR;
  1708.     }

  1710.     return NGX_CONF_OK;
  1711. }

  1713. #endif


  1716. static char *
  1717. ‌ngx_http_geoip_proxy(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1718. {
  1719.     ngx_http_geoip_conf_t  *gcf = conf;

  1721.     ngx_str_t   *value;
  1722.     ngx_cidr_t  cidr, *c;

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

  1726.     if (ngx_http_geoip_cidr_value(cf, &value[1], &cidr) != NGX_OK) {
  1727.         return NGX_CONF_ERROR;
  1728.     }

  1730.     if (gcf->proxies == NULL) {
  1731.         gcf->proxies = ngx_array_create(cf->pool, 4, sizeof(ngx_cidr_t));
  1732.         if (gcf->proxies == NULL) {
  1733.             return NGX_CONF_ERROR;
  1734.         }
  1735.     }

  1737.     c = ngx_array_push(gcf->proxies);
  1738.     if (c == NULL) {
  1739.         return NGX_CONF_ERROR;
  1740.     }

  1742.     *c = cidr;

  1744.     return NGX_CONF_OK;
  1745. }

  1747. static ngx_int_t
  1748. ‌ngx_http_geoip_cidr_value(ngx_conf_t *cf, ngx_str_t *net, ngx_cidr_t *cidr)
  1749. {
  1750.     ngx_int_t  rc;

  1752.     if (ngx_strcmp(net->data, "255.255.255.255") == 0) {
  1753.         cidr->family = AF_INET;
  1754.         cidr->u.in.addr = 0xffffffff;
  1755.         cidr->u.in.mask = 0xffffffff;

  1757.         return NGX_OK;
  1758.     }

  1760.     rc = ngx_ptocidr(net, cidr);

  1762.     if (rc == NGX_ERROR) {
  1763.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid network \"%V\"", net);
  1764.         return NGX_ERROR;
  1765.     }

  1767.     if (rc == NGX_DONE) {
  1768.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1769.                            "low address bits of %V are meaningless", net);
  1770.     }

  1772.     return NGX_OK;
  1773. }


  1776. static void
  1777. ‌ngx_http_geoip_cleanup(void *data)
  1778. {
  1779.     ngx_http_geoip_conf_t  *gcf = data;

  1781. #if (NGX_HAVE_GEOIP)

  1783.     if (gcf->country) {
  1784.         GeoIP_delete(gcf->country);
  1785.     }

  1787.     if (gcf->org) {
  1788.         GeoIP_delete(gcf->org);
  1789.     }

  1791.     if (gcf->city) {
  1792.         GeoIP_delete(gcf->city);
  1793.     }

  1795. #endif

  1797. #if (NGX_HAVE_MAXMINDDB)

  1799.     if (gcf->country_mmdb) {
  1800.         MMDB_close(gcf->country_mmdb);
  1801.     }

  1803.     if (gcf->org_mmdb) {
  1804.         MMDB_close(gcf->org_mmdb);
  1805.     }

  1807.     if (gcf->city_mmdb) {
  1808.         MMDB_close(gcf->city_mmdb);
  1809.     }

  1811. #endif
  1812. }

One Level Up Top Level