One Level Up Top Level

src/stream/ngx_stream_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_stream.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. #if (NGX_HAVE_GEOIP_V6)
  53.     unsigned      country_v6:1;
  54.     unsigned      org_v6:1;
  55.     unsigned      city_v6:1;
  56. #endif
  57. ‌} ngx_stream_geoip_conf_t;


  60. ‌typedef struct {
  61.     ngx_str_t    *name;
  62.     uintptr_t     data;
  63. ‌} ngx_stream_geoip_var_t;


  66. #if (NGX_HAVE_MAXMINDDB)

  68. ‌typedef struct {
  69.     const char   *alpha2;
  70.     const char   *alpha3;
  71. ‌} ngx_stream_geoip_ccode_t;

  73. #endif


  76. #if (NGX_HAVE_GEOIP)

  78. ‌typedef const char *(*ngx_stream_geoip_variable_handler_pt)(GeoIP *,
  79.     u_long addr);


  82. ‌ngx_stream_geoip_variable_handler_pt ngx_stream_geoip_country_functions[] = {
  83.     GeoIP_country_code_by_ipnum,
  84.     GeoIP_country_code3_by_ipnum,
  85.     GeoIP_country_name_by_ipnum,
  86. };


  89. #if (NGX_HAVE_GEOIP_V6)

  91. ‌typedef const char *(*ngx_stream_geoip_variable_handler_v6_pt)(GeoIP *,
  92.     geoipv6_t addr);


  95. ngx_stream_geoip_variable_handler_v6_pt
  96. ‌    ngx_stream_geoip_country_v6_functions[] =
  97. {
  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_stream_geoip_country_variable(ngx_stream_session_t *s,
  109.     ngx_stream_variable_value_t *v, uintptr_t data);
  110. static ngx_int_t ngx_stream_geoip_org_variable(ngx_stream_session_t *s,
  111.     ngx_stream_variable_value_t *v, uintptr_t data);
  112. static ngx_int_t ngx_stream_geoip_city_variable(ngx_stream_session_t *s,
  113.     ngx_stream_variable_value_t *v, uintptr_t data);
  114. static ngx_int_t ngx_stream_geoip_region_name_variable(ngx_stream_session_t *s,
  115.     ngx_stream_variable_value_t *v, uintptr_t data);
  116. static ngx_int_t ngx_stream_geoip_city_float_variable(ngx_stream_session_t *s,
  117.     ngx_stream_variable_value_t *v, uintptr_t data);
  118. static ngx_int_t ngx_stream_geoip_city_int_variable(ngx_stream_session_t *s,
  119.     ngx_stream_variable_value_t *v, uintptr_t data);
  120. #if (NGX_HAVE_GEOIP)
  121. static GeoIPRecord *ngx_stream_geoip_get_city_record(ngx_stream_session_t *s);
  122. #endif
  123. #if (NGX_HAVE_MAXMINDDB)
  124. static ngx_int_t ngx_stream_geoip_str(ngx_stream_session_t *s,
  125.     MMDB_entry_s *entry, const char **path, ngx_str_t *value);
  126. static ngx_int_t ngx_stream_geoip_code3(ngx_str_t *value);
  127. static ngx_int_t ngx_stream_geoip_float(MMDB_entry_s *entry, const char **path,
  128.     double *value);
  129. static ngx_int_t ngx_stream_geoip_int(MMDB_entry_s *entry, const char **path,
  130.     int64_t *value);
  131. static ngx_int_t ngx_stream_geoip_lookup(ngx_stream_session_t *s, MMDB_s *mmdb,
  132.     MMDB_entry_s *entry);
  133. #endif

  135. static ngx_int_t ngx_stream_geoip_add_variables(ngx_conf_t *cf);
  136. static void *ngx_stream_geoip_create_conf(ngx_conf_t *cf);
  137. static char *ngx_stream_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd,
  138.     void *conf);
  139. static char *ngx_stream_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd,
  140.     void *conf);
  141. static char *ngx_stream_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd,
  142.     void *conf);
  143. #if (NGX_HAVE_MAXMINDDB)
  144. static ngx_int_t ngx_stream_geoip_open(ngx_conf_t *cf, ngx_str_t *name,
  145.     MMDB_s **db);
  146. static char *ngx_stream_geoip_charset(ngx_conf_t *cf);
  147. #endif
  148. static void ngx_stream_geoip_cleanup(void *data);


  151. ‌static ngx_command_t  ngx_stream_geoip_commands[] = {

  153.     { ngx_string("geoip_country"),
  154.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE12,
  155.       ngx_stream_geoip_country,
  156.       NGX_STREAM_MAIN_CONF_OFFSET,
  157.       0,
  158.       NULL },

  160.     { ngx_string("geoip_org"),
  161.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE12,
  162.       ngx_stream_geoip_org,
  163.       NGX_STREAM_MAIN_CONF_OFFSET,
  164.       0,
  165.       NULL },

  167.     { ngx_string("geoip_city"),
  168.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE12,
  169.       ngx_stream_geoip_city,
  170.       NGX_STREAM_MAIN_CONF_OFFSET,
  171.       0,
  172.       NULL },

  174.       ngx_null_command
  175. };


  178. ‌static ngx_stream_module_t  ngx_stream_geoip_module_ctx = {
  179.     ngx_stream_geoip_add_variables,        /* preconfiguration */
  180.     NULL,                                  /* postconfiguration */

  182.     ngx_stream_geoip_create_conf,          /* create main configuration */
  183.     NULL,                                  /* init main configuration */

  185.     NULL,                                  /* create server configuration */
  186.     NULL                                   /* merge server configuration */
  187. };


  190. ‌ngx_module_t  ngx_stream_geoip_module = {
  191.     NGX_MODULE_V1,
  192.     &ngx_stream_geoip_module_ctx,          /* module context */
  193.     ngx_stream_geoip_commands,             /* module directives */
  194.     NGX_STREAM_MODULE,                     /* module type */
  195.     NULL,                                  /* init master */
  196.     NULL,                                  /* init module */
  197.     NULL,                                  /* init process */
  198.     NULL,                                  /* init thread */
  199.     NULL,                                  /* exit thread */
  200.     NULL,                                  /* exit process */
  201.     NULL,                                  /* exit master */
  202.     NGX_MODULE_V1_PADDING
  203. };


  206. ‌static ngx_stream_variable_t  ngx_stream_geoip_vars[] = {

  208.     { ngx_string("geoip_country_code"), NULL,
  209.       ngx_stream_geoip_country_variable,
  210.       NGX_GEOIP_COUNTRY_CODE, 0, 0 },

  212.     { ngx_string("geoip_country_code3"), NULL,
  213.       ngx_stream_geoip_country_variable,
  214.       NGX_GEOIP_COUNTRY_CODE3, 0, 0 },

  216.     { ngx_string("geoip_country_name"), NULL,
  217.       ngx_stream_geoip_country_variable,
  218.       NGX_GEOIP_COUNTRY_NAME, 0, 0 },

  220.     { ngx_string("geoip_org"), NULL,
  221.       ngx_stream_geoip_org_variable,
  222.       0, 0, 0 },

  224.     { ngx_string("geoip_city_continent_code"), NULL,
  225.       ngx_stream_geoip_city_variable,
  226.       NGX_GEOIP_CITY_CONTINENT_CODE, 0, 0 },

  228.     { ngx_string("geoip_city_country_code"), NULL,
  229.       ngx_stream_geoip_city_variable,
  230.       NGX_GEOIP_CITY_COUNTRY_CODE, 0, 0 },

  232.     { ngx_string("geoip_city_country_code3"), NULL,
  233.       ngx_stream_geoip_city_variable,
  234.       NGX_GEOIP_CITY_COUNTRY_CODE3, 0, 0 },

  236.     { ngx_string("geoip_city_country_name"), NULL,
  237.       ngx_stream_geoip_city_variable,
  238.       NGX_GEOIP_CITY_COUNTRY_NAME, 0, 0 },

  240.     { ngx_string("geoip_region"), NULL,
  241.       ngx_stream_geoip_city_variable,
  242.       NGX_GEOIP_CITY_REGION, 0, 0 },

  244.     { ngx_string("geoip_region_name"), NULL,
  245.       ngx_stream_geoip_region_name_variable,
  246.       NGX_GEOIP_CITY_REGION_NAME, 0, 0 },

  248.     { ngx_string("geoip_city"), NULL,
  249.       ngx_stream_geoip_city_variable,
  250.       NGX_GEOIP_CITY_NAME, 0, 0 },

  252.     { ngx_string("geoip_postal_code"), NULL,
  253.       ngx_stream_geoip_city_variable,
  254.       NGX_GEOIP_CITY_POSTAL_CODE, 0, 0 },

  256.     { ngx_string("geoip_latitude"), NULL,
  257.       ngx_stream_geoip_city_float_variable,
  258.       NGX_GEOIP_CITY_LATITUDE, 0, 0 },

  260.     { ngx_string("geoip_longitude"), NULL,
  261.       ngx_stream_geoip_city_float_variable,
  262.       NGX_GEOIP_CITY_LONGITUDE, 0, 0 },

  264.     { ngx_string("geoip_dma_code"), NULL,
  265.       ngx_stream_geoip_city_int_variable,
  266.       NGX_GEOIP_CITY_DMA_CODE, 0, 0 },

  268.     { ngx_string("geoip_area_code"), NULL,
  269.       ngx_stream_geoip_city_int_variable,
  270.       NGX_GEOIP_CITY_AREA_CODE, 0, 0 },

  272.       ngx_stream_null_variable
  273. };


  276. #if (NGX_HAVE_GEOIP)

  278. /* indexed by NGX_GEOIP_CITY_* */

  280. ‌static size_t  ngx_stream_geoip_city_offsets[] = {
  281.     offsetof(GeoIPRecord, continent_code),
  282.     offsetof(GeoIPRecord, country_code),
  283.     offsetof(GeoIPRecord, country_code3),
  284.     offsetof(GeoIPRecord, country_name),
  285.     offsetof(GeoIPRecord, region),
  286.     0,                                     /* no region name */
  287.     offsetof(GeoIPRecord, city),
  288.     offsetof(GeoIPRecord, postal_code),
  289.     offsetof(GeoIPRecord, latitude),
  290.     offsetof(GeoIPRecord, longitude),
  291.     offsetof(GeoIPRecord, dma_code),
  292.     offsetof(GeoIPRecord, area_code)
  293. };

  295. #endif


  298. #if (NGX_HAVE_MAXMINDDB)

  300. ‌static const char  *ngx_stream_geoip_path_country_code[] = {
  301.     "country", "iso_code", NULL
  302. };

  304. ‌static const char  *ngx_stream_geoip_path_country_name[] = {
  305.     "country", "names", "en", NULL
  306. };

  308. ‌static const char  *ngx_stream_geoip_path_continent_code[] = {
  309.     "continent", "code", NULL
  310. };

  312. ‌static const char  *ngx_stream_geoip_path_region[] = {
  313.     "subdivisions", "0", "iso_code", NULL
  314. };

  316. ‌static const char  *ngx_stream_geoip_path_region_name[] = {
  317.     "subdivisions", "0", "names", "en", NULL
  318. };

  320. ‌static const char  *ngx_stream_geoip_path_city[] = {
  321.     "city", "names", "en", NULL
  322. };

  324. ‌static const char  *ngx_stream_geoip_path_postal_code[] = {
  325.     "postal", "code", NULL
  326. };

  328. ‌static const char  *ngx_stream_geoip_path_latitude[] = {
  329.     "location", "latitude", NULL
  330. };

  332. ‌static const char  *ngx_stream_geoip_path_longitude[] = {
  333.     "location", "longitude", NULL
  334. };

  336. ‌static const char  *ngx_stream_geoip_path_dma_code[] = {
  337.     "location", "metro_code", NULL
  338. };


  341. /* indexed by NGX_GEOIP_COUNTRY_* */

  343. ‌static const char  **ngx_stream_geoip_country_paths[] = {
  344.     ngx_stream_geoip_path_country_code,
  345.     ngx_stream_geoip_path_country_code,    /* converted to alpha-3 */
  346.     ngx_stream_geoip_path_country_name
  347. };


  350. /* indexed by NGX_GEOIP_CITY_* */

  352. ‌static const char  **ngx_stream_geoip_city_paths[] = {
  353.     ngx_stream_geoip_path_continent_code,
  354.     ngx_stream_geoip_path_country_code,
  355.     ngx_stream_geoip_path_country_code,    /* converted to alpha-3 */
  356.     ngx_stream_geoip_path_country_name,
  357.     ngx_stream_geoip_path_region,
  358.     ngx_stream_geoip_path_region_name,
  359.     ngx_stream_geoip_path_city,
  360.     ngx_stream_geoip_path_postal_code,
  361.     ngx_stream_geoip_path_latitude,
  362.     ngx_stream_geoip_path_longitude,
  363.     ngx_stream_geoip_path_dma_code,
  364.     NULL                                   /* no area code */
  365. };


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

  370. ‌static const char  *ngx_stream_geoip_org_paths[][2] = {
  371.     { "autonomous_system_organization", NULL },
  372.     { "isp", NULL },
  373.     { "organization", NULL },
  374.     { "domain", NULL },
  375.     { NULL, NULL }
  376. };


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

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

  448. #endif


  451. #if (NGX_HAVE_GEOIP)

  453. static u_long
  454. ‌ngx_stream_geoip_addr(ngx_stream_session_t *s, ngx_stream_geoip_conf_t *gcf)
  455. {
  456.     ngx_addr_t           addr;
  457.     struct sockaddr_in  *sin;

  459.     addr.sockaddr = s->connection->sockaddr;
  460.     addr.socklen = s->connection->socklen;
  461.     /* addr.name = s->connection->addr_text; */

  463. #if (NGX_HAVE_INET6)

  465.     if (addr.sockaddr->sa_family == AF_INET6) {
  466.         u_char           *p;
  467.         in_addr_t         inaddr;
  468.         struct in6_addr  *inaddr6;

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

  472.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  473.             p = inaddr6->s6_addr;

  475.             inaddr = (in_addr_t) p[12] << 24;
  476.             inaddr += p[13] << 16;
  477.             inaddr += p[14] << 8;
  478.             inaddr += p[15];

  480.             return inaddr;
  481.         }
  482.     }

  484. #endif

  486.     if (addr.sockaddr->sa_family != AF_INET) {
  487.         return INADDR_NONE;
  488.     }

  490.     sin = (struct sockaddr_in *) addr.sockaddr;
  491.     return ntohl(sin->sin_addr.s_addr);
  492. }


  495. #if (NGX_HAVE_GEOIP_V6)

  497. static geoipv6_t
  498. ‌ngx_stream_geoip_addr_v6(ngx_stream_session_t *s, ngx_stream_geoip_conf_t *gcf)
  499. {
  500.     ngx_addr_t            addr;
  501.     in_addr_t             addr4;
  502.     struct in6_addr       addr6;
  503.     struct sockaddr_in   *sin;
  504.     struct sockaddr_in6  *sin6;

  506.     addr.sockaddr = s->connection->sockaddr;
  507.     addr.socklen = s->connection->socklen;
  508.     /* addr.name = s->connection->addr_text; */

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

  512.     case AF_INET:
  513.         /* Produce IPv4-mapped IPv6 address. */
  514.         sin = (struct sockaddr_in *) addr.sockaddr;
  515.         addr4 = ntohl(sin->sin_addr.s_addr);

  517.         ngx_memzero(&addr6, sizeof(struct in6_addr));
  518.         addr6.s6_addr[10] = 0xff;
  519.         addr6.s6_addr[11] = 0xff;
  520.         addr6.s6_addr[12] = addr4 >> 24;
  521.         addr6.s6_addr[13] = addr4 >> 16;
  522.         addr6.s6_addr[14] = addr4 >> 8;
  523.         addr6.s6_addr[15] = addr4;
  524.         return addr6;

  526.     case AF_INET6:
  527.         sin6 = (struct sockaddr_in6 *) addr.sockaddr;
  528.         return sin6->sin6_addr;

  530.     default:
  531.         return in6addr_any;
  532.     }
  533. }

  535. #endif

  537. #endif


  540. static ngx_int_t
  541. ‌ngx_stream_geoip_country_variable(ngx_stream_session_t *s,
  542.     ngx_stream_variable_value_t *v, uintptr_t data)
  543. {
  544. #if (NGX_HAVE_GEOIP)
  545.     ngx_stream_geoip_variable_handler_pt     handler =
  546.         ngx_stream_geoip_country_functions[data];
  547. #if (NGX_HAVE_GEOIP_V6)
  548.     ngx_stream_geoip_variable_handler_v6_pt  handler_v6 =
  549.         ngx_stream_geoip_country_v6_functions[data];
  550. #endif

  552.     const char               *val;
  553. #endif
  554. #if (NGX_HAVE_MAXMINDDB)
  555.     ngx_int_t                 rc;
  556.     ngx_str_t                 value;
  557.     MMDB_entry_s              entry;
  558. #endif
  559.     ngx_stream_geoip_conf_t  *gcf;

  561.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  563. #if (NGX_HAVE_MAXMINDDB)

  565.     if (gcf->country_mmdb) {

  567.         if (ngx_stream_geoip_lookup(s, gcf->country_mmdb, &entry) != NGX_OK) {
  568.             goto not_found;
  569.         }

  571.         rc = ngx_stream_geoip_str(s, &entry,
  572.                                   ngx_stream_geoip_country_paths[data], &value);

  574.         if (rc == NGX_OK && data == NGX_GEOIP_COUNTRY_CODE3) {
  575.             rc = ngx_stream_geoip_code3(&value);
  576.         }

  578.         if (rc == NGX_ERROR) {
  579.             return NGX_ERROR;
  580.         }

  582.         if (rc != NGX_OK) {
  583.             goto not_found;
  584.         }

  586.         v->len = value.len;
  587.         v->valid = 1;
  588.         v->no_cacheable = 0;
  589.         v->not_found = 0;
  590.         v->data = value.data;

  592.         return NGX_OK;
  593.     }

  595. #endif

  597. #if (NGX_HAVE_GEOIP)

  599.     if (gcf->country == NULL) {
  600.         goto not_found;
  601.     }

  603. #if (NGX_HAVE_GEOIP_V6)
  604.     val = gcf->country_v6
  605.               ? handler_v6(gcf->country, ngx_stream_geoip_addr_v6(s, gcf))
  606.               : handler(gcf->country, ngx_stream_geoip_addr(s, gcf));
  607. #else
  608.     val = handler(gcf->country, ngx_stream_geoip_addr(s, gcf));
  609. #endif

  611.     if (val == NULL) {
  612.         goto not_found;
  613.     }

  615.     v->len = ngx_strlen(val);
  616.     v->valid = 1;
  617.     v->no_cacheable = 0;
  618.     v->not_found = 0;
  619.     v->data = (u_char *) val;

  621.     return NGX_OK;

  623. #endif

  625. not_found:

  627.     v->not_found = 1;

  629.     return NGX_OK;
  630. }


  633. static ngx_int_t
  634. ‌ngx_stream_geoip_org_variable(ngx_stream_session_t *s,
  635.     ngx_stream_variable_value_t *v, uintptr_t data)
  636. {
  637. #if (NGX_HAVE_GEOIP)
  638.     size_t                    len;
  639.     char                     *val;
  640. #endif
  641. #if (NGX_HAVE_MAXMINDDB)
  642.     ngx_int_t                 rc;
  643.     ngx_str_t                 value;
  644.     ngx_uint_t                i;
  645.     MMDB_entry_s              entry;
  646. #endif
  647.     ngx_stream_geoip_conf_t  *gcf;

  649.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  651. #if (NGX_HAVE_MAXMINDDB)

  653.     if (gcf->org_mmdb) {

  655.         if (ngx_stream_geoip_lookup(s, gcf->org_mmdb, &entry) != NGX_OK) {
  656.             goto not_found;
  657.         }

  659.         for (i = 0; ngx_stream_geoip_org_paths[i][0]; i++) {

  661.             rc = ngx_stream_geoip_str(s, &entry,
  662.                                       ngx_stream_geoip_org_paths[i], &value);

  664.             if (rc == NGX_ERROR) {
  665.                 return NGX_ERROR;
  666.             }

  668.             if (rc == NGX_OK) {
  669.                 v->len = value.len;
  670.                 v->valid = 1;
  671.                 v->no_cacheable = 0;
  672.                 v->not_found = 0;
  673.                 v->data = value.data;

  675.                 return NGX_OK;
  676.             }
  677.         }

  679.         goto not_found;
  680.     }

  682. #endif

  684. #if (NGX_HAVE_GEOIP)

  686.     if (gcf->org == NULL) {
  687.         goto not_found;
  688.     }

  690. #if (NGX_HAVE_GEOIP_V6)
  691.     val = gcf->org_v6
  692.               ? GeoIP_name_by_ipnum_v6(gcf->org,
  693.                                        ngx_stream_geoip_addr_v6(s, gcf))
  694.               : GeoIP_name_by_ipnum(gcf->org,
  695.                                     ngx_stream_geoip_addr(s, gcf));
  696. #else
  697.     val = GeoIP_name_by_ipnum(gcf->org, ngx_stream_geoip_addr(s, gcf));
  698. #endif

  700.     if (val == NULL) {
  701.         goto not_found;
  702.     }

  704.     len = ngx_strlen(val);
  705.     v->data = ngx_pnalloc(s->connection->pool, len);
  706.     if (v->data == NULL) {
  707.         ngx_free(val);
  708.         return NGX_ERROR;
  709.     }

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

  713.     v->len = len;
  714.     v->valid = 1;
  715.     v->no_cacheable = 0;
  716.     v->not_found = 0;

  718.     ngx_free(val);

  720.     return NGX_OK;

  722. #endif

  724. not_found:

  726.     v->not_found = 1;

  728.     return NGX_OK;
  729. }


  732. static ngx_int_t
  733. ‌ngx_stream_geoip_city_variable(ngx_stream_session_t *s,
  734.     ngx_stream_variable_value_t *v, uintptr_t data)
  735. {
  736. #if (NGX_HAVE_GEOIP)
  737.     char                     *val;
  738.     size_t                    len;
  739.     GeoIPRecord              *gr;
  740. #endif
  741. #if (NGX_HAVE_MAXMINDDB)
  742.     ngx_int_t                 rc;
  743.     ngx_str_t                 value;
  744.     MMDB_entry_s              entry;
  745.     ngx_stream_geoip_conf_t  *gcf;

  747.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  749.     if (gcf->city_mmdb) {

  751.         if (ngx_stream_geoip_lookup(s, gcf->city_mmdb, &entry) != NGX_OK) {
  752.             goto not_found;
  753.         }

  755.         rc = ngx_stream_geoip_str(s, &entry,
  756.                                   ngx_stream_geoip_city_paths[data], &value);

  758.         if (rc == NGX_OK && data == NGX_GEOIP_CITY_COUNTRY_CODE3) {
  759.             rc = ngx_stream_geoip_code3(&value);
  760.         }

  762.         if (rc == NGX_ERROR) {
  763.             return NGX_ERROR;
  764.         }

  766.         if (rc != NGX_OK) {
  767.             goto not_found;
  768.         }

  770.         v->len = value.len;
  771.         v->valid = 1;
  772.         v->no_cacheable = 0;
  773.         v->not_found = 0;
  774.         v->data = value.data;

  776.         return NGX_OK;
  777.     }

  779. #endif

  781. #if (NGX_HAVE_GEOIP)

  783.     gr = ngx_stream_geoip_get_city_record(s);
  784.     if (gr == NULL) {
  785.         goto not_found;
  786.     }

  788.     val = *(char **) ((char *) gr + ngx_stream_geoip_city_offsets[data]);
  789.     if (val == NULL) {
  790.         goto no_value;
  791.     }

  793.     len = ngx_strlen(val);
  794.     v->data = ngx_pnalloc(s->connection->pool, len);
  795.     if (v->data == NULL) {
  796.         GeoIPRecord_delete(gr);
  797.         return NGX_ERROR;
  798.     }

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

  802.     v->len = len;
  803.     v->valid = 1;
  804.     v->no_cacheable = 0;
  805.     v->not_found = 0;

  807.     GeoIPRecord_delete(gr);

  809.     return NGX_OK;

  811. no_value:

  813.     GeoIPRecord_delete(gr);

  815. #endif

  817. not_found:

  819.     v->not_found = 1;

  821.     return NGX_OK;
  822. }


  825. static ngx_int_t
  826. ‌ngx_stream_geoip_region_name_variable(ngx_stream_session_t *s,
  827.     ngx_stream_variable_value_t *v, uintptr_t data)
  828. {
  829. #if (NGX_HAVE_GEOIP)
  830.     size_t                    len;
  831.     const char               *val;
  832.     GeoIPRecord              *gr;
  833. #endif
  834. #if (NGX_HAVE_MAXMINDDB)
  835.     ngx_int_t                 rc;
  836.     ngx_str_t                 value;
  837.     MMDB_entry_s              entry;
  838.     ngx_stream_geoip_conf_t  *gcf;

  840.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  842.     if (gcf->city_mmdb) {

  844.         if (ngx_stream_geoip_lookup(s, gcf->city_mmdb, &entry) != NGX_OK) {
  845.             goto not_found;
  846.         }

  848.         rc = ngx_stream_geoip_str(s, &entry,
  849.                                   ngx_stream_geoip_city_paths[data], &value);

  851.         if (rc == NGX_ERROR) {
  852.             return NGX_ERROR;
  853.         }

  855.         if (rc != NGX_OK) {
  856.             goto not_found;
  857.         }

  859.         v->len = value.len;
  860.         v->valid = 1;
  861.         v->no_cacheable = 0;
  862.         v->not_found = 0;
  863.         v->data = value.data;

  865.         return NGX_OK;
  866.     }

  868. #endif

  870. #if (NGX_HAVE_GEOIP)

  872.     gr = ngx_stream_geoip_get_city_record(s);
  873.     if (gr == NULL) {
  874.         goto not_found;
  875.     }

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

  879.     GeoIPRecord_delete(gr);

  881.     if (val == NULL) {
  882.         goto not_found;
  883.     }

  885.     len = ngx_strlen(val);
  886.     v->data = ngx_pnalloc(s->connection->pool, len);
  887.     if (v->data == NULL) {
  888.         return NGX_ERROR;
  889.     }

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

  893.     v->len = len;
  894.     v->valid = 1;
  895.     v->no_cacheable = 0;
  896.     v->not_found = 0;

  898.     return NGX_OK;

  900. #endif

  902. not_found:

  904.     v->not_found = 1;

  906.     return NGX_OK;
  907. }


  910. static ngx_int_t
  911. ‌ngx_stream_geoip_city_float_variable(ngx_stream_session_t *s,
  912.     ngx_stream_variable_value_t *v, uintptr_t data)
  913. {
  914. #if (NGX_HAVE_GEOIP)
  915.     float                     val;
  916.     GeoIPRecord              *gr;
  917. #endif
  918. #if (NGX_HAVE_MAXMINDDB)
  919.     double                    value;
  920.     ngx_int_t                 rc;
  921.     MMDB_entry_s              entry;
  922.     ngx_stream_geoip_conf_t  *gcf;

  924.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  926.     if (gcf->city_mmdb) {

  928.         if (ngx_stream_geoip_lookup(s, gcf->city_mmdb, &entry) != NGX_OK) {
  929.             goto not_found;
  930.         }

  932.         rc = ngx_stream_geoip_float(&entry,
  933.                                     ngx_stream_geoip_city_paths[data], &value);

  935.         if (rc != NGX_OK) {
  936.             goto not_found;
  937.         }

  939.         v->data = ngx_pnalloc(s->connection->pool, NGX_INT64_LEN + 5);
  940.         if (v->data == NULL) {
  941.             return NGX_ERROR;
  942.         }

  944.         v->len = ngx_sprintf(v->data, "%.4f", value) - v->data;
  945.         v->valid = 1;
  946.         v->no_cacheable = 0;
  947.         v->not_found = 0;

  949.         return NGX_OK;
  950.     }

  952. #endif

  954. #if (NGX_HAVE_GEOIP)

  956.     gr = ngx_stream_geoip_get_city_record(s);
  957.     if (gr == NULL) {
  958.         goto not_found;
  959.     }

  961.     v->data = ngx_pnalloc(s->connection->pool, NGX_INT64_LEN + 5);
  962.     if (v->data == NULL) {
  963.         GeoIPRecord_delete(gr);
  964.         return NGX_ERROR;
  965.     }

  967.     val = *(float *) ((char *) gr + ngx_stream_geoip_city_offsets[data]);

  969.     v->len = ngx_sprintf(v->data, "%.4f", val) - v->data;
  970.     v->valid = 1;
  971.     v->no_cacheable = 0;
  972.     v->not_found = 0;

  974.     GeoIPRecord_delete(gr);

  976.     return NGX_OK;

  978. #endif

  980. not_found:

  982.     v->not_found = 1;

  984.     return NGX_OK;
  985. }


  988. static ngx_int_t
  989. ‌ngx_stream_geoip_city_int_variable(ngx_stream_session_t *s,
  990.     ngx_stream_variable_value_t *v, uintptr_t data)
  991. {
  992. #if (NGX_HAVE_GEOIP)
  993.     int                       val;
  994.     GeoIPRecord              *gr;
  995. #endif
  996. #if (NGX_HAVE_MAXMINDDB)
  997.     int64_t                   value;
  998.     ngx_int_t                 rc;
  999.     MMDB_entry_s              entry;
  1000.     ngx_stream_geoip_conf_t  *gcf;

  1002.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  1004.     if (gcf->city_mmdb) {

  1006.         if (ngx_stream_geoip_lookup(s, gcf->city_mmdb, &entry) != NGX_OK) {
  1007.             goto not_found;
  1008.         }

  1010.         rc = ngx_stream_geoip_int(&entry,
  1011.                                   ngx_stream_geoip_city_paths[data], &value);

  1013.         if (rc != NGX_OK) {
  1014.             goto not_found;
  1015.         }

  1017.         v->data = ngx_pnalloc(s->connection->pool, NGX_INT64_LEN);
  1018.         if (v->data == NULL) {
  1019.             return NGX_ERROR;
  1020.         }

  1022.         v->len = ngx_sprintf(v->data, "%L", value) - v->data;
  1023.         v->valid = 1;
  1024.         v->no_cacheable = 0;
  1025.         v->not_found = 0;

  1027.         return NGX_OK;
  1028.     }

  1030. #endif

  1032. #if (NGX_HAVE_GEOIP)

  1034.     gr = ngx_stream_geoip_get_city_record(s);
  1035.     if (gr == NULL) {
  1036.         goto not_found;
  1037.     }

  1039.     v->data = ngx_pnalloc(s->connection->pool, NGX_INT64_LEN);
  1040.     if (v->data == NULL) {
  1041.         GeoIPRecord_delete(gr);
  1042.         return NGX_ERROR;
  1043.     }

  1045.     val = *(int *) ((char *) gr + ngx_stream_geoip_city_offsets[data]);

  1047.     v->len = ngx_sprintf(v->data, "%d", val) - v->data;
  1048.     v->valid = 1;
  1049.     v->no_cacheable = 0;
  1050.     v->not_found = 0;

  1052.     GeoIPRecord_delete(gr);

  1054.     return NGX_OK;

  1056. #endif

  1058. not_found:

  1060.     v->not_found = 1;

  1062.     return NGX_OK;
  1063. }


  1066. #if (NGX_HAVE_GEOIP)

  1068. static GeoIPRecord *
  1069. ‌ngx_stream_geoip_get_city_record(ngx_stream_session_t *s)
  1070. {
  1071.     ngx_stream_geoip_conf_t  *gcf;

  1073.     gcf = ngx_stream_get_module_main_conf(s, ngx_stream_geoip_module);

  1075.     if (gcf->city) {
  1076. #if (NGX_HAVE_GEOIP_V6)
  1077.         return gcf->city_v6
  1078.                    ? GeoIP_record_by_ipnum_v6(gcf->city,
  1079.                                               ngx_stream_geoip_addr_v6(s, gcf))
  1080.                    : GeoIP_record_by_ipnum(gcf->city,
  1081.                                            ngx_stream_geoip_addr(s, gcf));
  1082. #else
  1083.         return GeoIP_record_by_ipnum(gcf->city, ngx_stream_geoip_addr(s, gcf));
  1084. #endif
  1085.     }

  1087.     return NULL;
  1088. }

  1090. #endif


  1093. #if (NGX_HAVE_MAXMINDDB)

  1095. static ngx_int_t
  1096. ‌ngx_stream_geoip_str(ngx_stream_session_t *s, MMDB_entry_s *entry,
  1097.     const char **path, ngx_str_t *value)
  1098. {
  1099.     MMDB_entry_data_s  entry_data;

  1101.     if (path == NULL
  1102.         || MMDB_aget_value(entry, &entry_data, path) != MMDB_SUCCESS
  1103.         || !entry_data.has_data
  1104.         || entry_data.type != MMDB_DATA_TYPE_UTF8_STRING)
  1105.     {
  1106.         return NGX_DECLINED;
  1107.     }

  1109.     value->data = ngx_pnalloc(s->connection->pool, entry_data.data_size);
  1110.     if (value->data == NULL) {
  1111.         return NGX_ERROR;
  1112.     }

  1114.     ngx_memcpy(value->data, entry_data.utf8_string, entry_data.data_size);
  1115.     value->len = entry_data.data_size;

  1117.     return NGX_OK;
  1118. }


  1121. static ngx_int_t
  1122. ‌ngx_stream_geoip_code3(ngx_str_t *value)
  1123. {
  1124.     ngx_stream_geoip_ccode_t  *cc;

  1126.     if (value->len != 2) {
  1127.         return NGX_DECLINED;
  1128.     }

  1130.     for (cc = ngx_stream_geoip_country_codes; cc->alpha2; cc++) {
  1131.         if (value->data[0] == cc->alpha2[0]
  1132.             && value->data[1] == cc->alpha2[1])
  1133.         {
  1134.             value->len = 3;
  1135.             value->data = (u_char *) cc->alpha3;
  1136.             return NGX_OK;
  1137.         }
  1138.     }

  1140.     return NGX_DECLINED;
  1141. }


  1144. static ngx_int_t
  1145. ‌ngx_stream_geoip_float(MMDB_entry_s *entry, const char **path, double *value)
  1146. {
  1147.     MMDB_entry_data_s  entry_data;

  1149.     if (path == NULL
  1150.         || MMDB_aget_value(entry, &entry_data, path) != MMDB_SUCCESS
  1151.         || !entry_data.has_data)
  1152.     {
  1153.         return NGX_DECLINED;
  1154.     }

  1156.     switch (entry_data.type) {

  1158.     case MMDB_DATA_TYPE_DOUBLE:
  1159.         *value = entry_data.double_value;
  1160.         break;

  1162.     case MMDB_DATA_TYPE_FLOAT:
  1163.         *value = entry_data.float_value;
  1164.         break;

  1166.     default:
  1167.         return NGX_DECLINED;
  1168.     }

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

  1172.     if (!(*value >= -NGX_GEOIP_MAX_COORD && *value <= NGX_GEOIP_MAX_COORD)) {
  1173.         return NGX_DECLINED;
  1174.     }

  1176.     return NGX_OK;
  1177. }


  1180. static ngx_int_t
  1181. ‌ngx_stream_geoip_int(MMDB_entry_s *entry, const char **path, int64_t *value)
  1182. {
  1183.     MMDB_entry_data_s  entry_data;

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

  1192.     switch (entry_data.type) {

  1194.     case MMDB_DATA_TYPE_UINT16:
  1195.         *value = entry_data.uint16;
  1196.         return NGX_OK;

  1198.     case MMDB_DATA_TYPE_UINT32:
  1199.         *value = entry_data.uint32;
  1200.         return NGX_OK;

  1202.     case MMDB_DATA_TYPE_INT32:
  1203.         *value = entry_data.int32;
  1204.         return NGX_OK;

  1206.     default:
  1207.         return NGX_DECLINED;
  1208.     }
  1209. }


  1212. static ngx_int_t
  1213. ‌ngx_stream_geoip_lookup(ngx_stream_session_t *s, MMDB_s *mmdb,
  1214.     MMDB_entry_s *entry)
  1215. {
  1216.     int                    err;
  1217.     struct sockaddr       *sa;
  1218.     MMDB_lookup_result_s   result;
  1219. #if (NGX_HAVE_INET6)
  1220.     struct in6_addr       *inaddr6;
  1221.     struct sockaddr_in     sin;
  1222. #endif

  1224.     sa = s->connection->sockaddr;

  1226.     switch (sa->sa_family) {

  1228.     case AF_INET:
  1229.         break;

  1231. #if (NGX_HAVE_INET6)
  1232.     case AF_INET6:
  1233.         inaddr6 = &((struct sockaddr_in6 *) sa)->sin6_addr;

  1235.         if (IN6_IS_ADDR_V4MAPPED(inaddr6)) {
  1236.             ngx_memzero(&sin, sizeof(struct sockaddr_in));
  1237.             sin.sin_family = AF_INET;
  1238.             ngx_memcpy(&sin.sin_addr, &inaddr6->s6_addr[12], 4);

  1240.             sa = (struct sockaddr *) &sin;
  1241.             break;
  1242.         }

  1244.         if (mmdb->metadata.ip_version == 4) {
  1245.             return NGX_DECLINED;
  1246.         }

  1248.         break;
  1249. #endif

  1251.     default:
  1252.         return NGX_DECLINED;
  1253.     }

  1255.     result = MMDB_lookup_sockaddr(mmdb, sa, &err);

  1257.     if (err != MMDB_SUCCESS) {
  1258.         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  1259.                       "MMDB_lookup_sockaddr() failed: %s", MMDB_strerror(err));
  1260.         return NGX_DECLINED;
  1261.     }

  1263.     if (!result.found_entry) {
  1264.         return NGX_DECLINED;
  1265.     }

  1267.     *entry = result.entry;

  1269.     return NGX_OK;
  1270. }

  1272. #endif


  1275. static ngx_int_t
  1276. ‌ngx_stream_geoip_add_variables(ngx_conf_t *cf)
  1277. {
  1278.     ngx_stream_variable_t  *var, *v;

  1280.     for (v = ngx_stream_geoip_vars; v->name.len; v++) {
  1281.         var = ngx_stream_add_variable(cf, &v->name, v->flags);
  1282.         if (var == NULL) {
  1283.             return NGX_ERROR;
  1284.         }

  1286.         var->get_handler = v->get_handler;
  1287.         var->data = v->data;
  1288.     }

  1290.     return NGX_OK;
  1291. }


  1294. static void *
  1295. ‌ngx_stream_geoip_create_conf(ngx_conf_t *cf)
  1296. {
  1297.     ngx_pool_cleanup_t       *cln;
  1298.     ngx_stream_geoip_conf_t  *conf;

  1300.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_geoip_conf_t));
  1301.     if (conf == NULL) {
  1302.         return NULL;
  1303.     }

  1305.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  1306.     if (cln == NULL) {
  1307.         return NULL;
  1308.     }

  1310.     cln->handler = ngx_stream_geoip_cleanup;
  1311.     cln->data = conf;

  1313.     return conf;
  1314. }


  1317. static char *
  1318. ‌ngx_stream_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1319. {
  1320.     ngx_stream_geoip_conf_t  *gcf = conf;

  1322.     ngx_str_t  *value;

  1324. #if (NGX_HAVE_GEOIP)
  1325.     if (gcf->country) {
  1326.         return "is duplicate";
  1327.     }
  1328. #endif
  1329. #if (NGX_HAVE_MAXMINDDB)
  1330.     if (gcf->country_mmdb) {
  1331.         return "is duplicate";
  1332.     }
  1333. #endif

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

  1337. #if (NGX_HAVE_MAXMINDDB)

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

  1341.     case NGX_OK:
  1342.         return ngx_stream_geoip_charset(cf);

  1344.     case NGX_ERROR:
  1345.         return NGX_CONF_ERROR;

  1347.     default:
  1348.         break;
  1349.     }

  1351. #endif

  1353. #if (NGX_HAVE_GEOIP)

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

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

  1361.         return NGX_CONF_ERROR;
  1362.     }

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

  1368.         } else {
  1369.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1370.                                "invalid parameter \"%V\"", &value[2]);
  1371.             return NGX_CONF_ERROR;
  1372.         }
  1373.     }

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

  1377.     case GEOIP_COUNTRY_EDITION:

  1379.         return NGX_CONF_OK;

  1381. #if (NGX_HAVE_GEOIP_V6)
  1382.     case GEOIP_COUNTRY_EDITION_V6:

  1384.         gcf->country_v6 = 1;
  1385.         return NGX_CONF_OK;
  1386. #endif

  1388.     default:
  1389.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1390.                            "invalid GeoIP database \"%V\" type:%d",
  1391.                            &value[1], gcf->country->databaseType);
  1392.         return NGX_CONF_ERROR;
  1393.     }

  1395. #else

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

  1400.     return NGX_CONF_ERROR;

  1402. #endif
  1403. }


  1406. static char *
  1407. ‌ngx_stream_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1408. {
  1409.     ngx_stream_geoip_conf_t  *gcf = conf;

  1411.     ngx_str_t  *value;

  1413. #if (NGX_HAVE_GEOIP)
  1414.     if (gcf->org) {
  1415.         return "is duplicate";
  1416.     }
  1417. #endif
  1418. #if (NGX_HAVE_MAXMINDDB)
  1419.     if (gcf->org_mmdb) {
  1420.         return "is duplicate";
  1421.     }
  1422. #endif

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

  1426. #if (NGX_HAVE_MAXMINDDB)

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

  1430.     case NGX_OK:
  1431.         return ngx_stream_geoip_charset(cf);

  1433.     case NGX_ERROR:
  1434.         return NGX_CONF_ERROR;

  1436.     default:
  1437.         break;
  1438.     }

  1440. #endif

  1442. #if (NGX_HAVE_GEOIP)

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

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

  1450.         return NGX_CONF_ERROR;
  1451.     }

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

  1457.         } else {
  1458.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1459.                                "invalid parameter \"%V\"", &value[2]);
  1460.             return NGX_CONF_ERROR;
  1461.         }
  1462.     }

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

  1466.     case GEOIP_ISP_EDITION:
  1467.     case GEOIP_ORG_EDITION:
  1468.     case GEOIP_DOMAIN_EDITION:
  1469.     case GEOIP_ASNUM_EDITION:

  1471.         return NGX_CONF_OK;

  1473. #if (NGX_HAVE_GEOIP_V6)
  1474.     case GEOIP_ISP_EDITION_V6:
  1475.     case GEOIP_ORG_EDITION_V6:
  1476.     case GEOIP_DOMAIN_EDITION_V6:
  1477.     case GEOIP_ASNUM_EDITION_V6:

  1479.         gcf->org_v6 = 1;
  1480.         return NGX_CONF_OK;
  1481. #endif

  1483.     default:
  1484.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1485.                            "invalid GeoIP database \"%V\" type:%d",
  1486.                            &value[1], gcf->org->databaseType);
  1487.         return NGX_CONF_ERROR;
  1488.     }

  1490. #else

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

  1495.     return NGX_CONF_ERROR;

  1497. #endif
  1498. }


  1501. static char *
  1502. ‌ngx_stream_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1503. {
  1504.     ngx_stream_geoip_conf_t  *gcf = conf;

  1506.     ngx_str_t  *value;

  1508. #if (NGX_HAVE_GEOIP)
  1509.     if (gcf->city) {
  1510.         return "is duplicate";
  1511.     }
  1512. #endif
  1513. #if (NGX_HAVE_MAXMINDDB)
  1514.     if (gcf->city_mmdb) {
  1515.         return "is duplicate";
  1516.     }
  1517. #endif

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

  1521. #if (NGX_HAVE_MAXMINDDB)

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

  1525.     case NGX_OK:
  1526.         return ngx_stream_geoip_charset(cf);

  1528.     case NGX_ERROR:
  1529.         return NGX_CONF_ERROR;

  1531.     default:
  1532.         break;
  1533.     }

  1535. #endif

  1537. #if (NGX_HAVE_GEOIP)

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

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

  1545.         return NGX_CONF_ERROR;
  1546.     }

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

  1552.         } else {
  1553.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1554.                                "invalid parameter \"%V\"", &value[2]);
  1555.             return NGX_CONF_ERROR;
  1556.         }
  1557.     }

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

  1561.     case GEOIP_CITY_EDITION_REV0:
  1562.     case GEOIP_CITY_EDITION_REV1:

  1564.         return NGX_CONF_OK;

  1566. #if (NGX_HAVE_GEOIP_V6)
  1567.     case GEOIP_CITY_EDITION_REV0_V6:
  1568.     case GEOIP_CITY_EDITION_REV1_V6:

  1570.         gcf->city_v6 = 1;
  1571.         return NGX_CONF_OK;
  1572. #endif

  1574.     default:
  1575.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1576.                            "invalid GeoIP City database \"%V\" type:%d",
  1577.                            &value[1], gcf->city->databaseType);
  1578.         return NGX_CONF_ERROR;
  1579.     }

  1581. #else

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

  1586.     return NGX_CONF_ERROR;

  1588. #endif
  1589. }


  1592. #if (NGX_HAVE_MAXMINDDB)

  1594. static ngx_int_t
  1595. ‌ngx_stream_geoip_open(ngx_conf_t *cf, ngx_str_t *name, MMDB_s **db)
  1596. {
  1597.     int               status;
  1598.     MMDB_s           *mmdb;
  1599.     ngx_file_info_t   fi;

  1601.     if (ngx_file_info(name->data, &fi) == NGX_FILE_ERROR) {
  1602.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1603.                            ngx_file_info_n " \"%V\" failed", name);
  1604.         return NGX_ERROR;
  1605.     }

  1607.     mmdb = ngx_palloc(cf->pool, sizeof(MMDB_s));
  1608.     if (mmdb == NULL) {
  1609.         return NGX_ERROR;
  1610.     }

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

  1614.     if (status == MMDB_SUCCESS) {
  1615.         *db = mmdb;
  1616.         return NGX_OK;
  1617.     }

  1619.     /* presumably a legacy GeoIP database */

  1621.     if (status == MMDB_INVALID_METADATA_ERROR) {
  1622.         return NGX_DECLINED;
  1623.     }

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

  1628.     return NGX_ERROR;
  1629. }


  1632. static char *
  1633. ‌ngx_stream_geoip_charset(ngx_conf_t *cf)
  1634. {
  1635.     ngx_str_t  *value;

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

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

  1641.     if (cf->args->nelts == 3 && ngx_strcmp(value[2].data, "utf8") != 0) {
  1642.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1643.                            "invalid parameter \"%V\"", &value[2]);
  1644.         return NGX_CONF_ERROR;
  1645.     }

  1647.     return NGX_CONF_OK;
  1648. }

  1650. #endif


  1653. static void
  1654. ‌ngx_stream_geoip_cleanup(void *data)
  1655. {
  1656.     ngx_stream_geoip_conf_t  *gcf = data;

  1658. #if (NGX_HAVE_GEOIP)

  1660.     if (gcf->country) {
  1661.         GeoIP_delete(gcf->country);
  1662.     }

  1664.     if (gcf->org) {
  1665.         GeoIP_delete(gcf->org);
  1666.     }

  1668.     if (gcf->city) {
  1669.         GeoIP_delete(gcf->city);
  1670.     }

  1672. #endif

  1674. #if (NGX_HAVE_MAXMINDDB)

  1676.     if (gcf->country_mmdb) {
  1677.         MMDB_close(gcf->country_mmdb);
  1678.     }

  1680.     if (gcf->org_mmdb) {
  1681.         MMDB_close(gcf->org_mmdb);
  1682.     }

  1684.     if (gcf->city_mmdb) {
  1685.         MMDB_close(gcf->city_mmdb);
  1686.     }

  1688. #endif
  1689. }

One Level Up Top Level