|
508
|
1
|
|
|
2 /*
|
|
|
3 * Copyright (C) Igor Sysoev
|
|
|
4 */
|
|
|
5
|
|
|
6
|
|
|
7 #include <ngx_config.h>
|
|
|
8 #include <ngx_core.h>
|
|
|
9 #include <ngx_http.h>
|
|
|
10
|
|
|
11 #include <GeoIP.h>
|
|
|
12 #include <GeoIPCity.h>
|
|
|
13
|
|
|
14
|
|
|
15 typedef struct {
|
|
|
16 GeoIP *country;
|
|
626
|
17 GeoIP *org;
|
|
508
|
18 GeoIP *city;
|
|
|
19 } ngx_http_geoip_conf_t;
|
|
|
20
|
|
|
21
|
|
|
22 typedef struct {
|
|
|
23 ngx_str_t *name;
|
|
|
24 uintptr_t data;
|
|
|
25 } ngx_http_geoip_var_t;
|
|
|
26
|
|
|
27
|
|
|
28 typedef const char *(*ngx_http_geoip_variable_handler_pt)(GeoIP *, u_long addr);
|
|
|
29
|
|
|
30 static ngx_int_t ngx_http_geoip_country_variable(ngx_http_request_t *r,
|
|
|
31 ngx_http_variable_value_t *v, uintptr_t data);
|
|
626
|
32 static ngx_int_t ngx_http_geoip_org_variable(ngx_http_request_t *r,
|
|
|
33 ngx_http_variable_value_t *v, uintptr_t data);
|
|
508
|
34 static ngx_int_t ngx_http_geoip_city_variable(ngx_http_request_t *r,
|
|
|
35 ngx_http_variable_value_t *v, uintptr_t data);
|
|
592
|
36 static ngx_int_t ngx_http_geoip_region_name_variable(ngx_http_request_t *r,
|
|
|
37 ngx_http_variable_value_t *v, uintptr_t data);
|
|
558
|
38 static ngx_int_t ngx_http_geoip_city_float_variable(ngx_http_request_t *r,
|
|
|
39 ngx_http_variable_value_t *v, uintptr_t data);
|
|
592
|
40 static ngx_int_t ngx_http_geoip_city_int_variable(ngx_http_request_t *r,
|
|
|
41 ngx_http_variable_value_t *v, uintptr_t data);
|
|
558
|
42 static GeoIPRecord *ngx_http_geoip_get_city_record(ngx_http_request_t *r);
|
|
508
|
43
|
|
|
44 static ngx_int_t ngx_http_geoip_add_variables(ngx_conf_t *cf);
|
|
|
45 static void *ngx_http_geoip_create_conf(ngx_conf_t *cf);
|
|
|
46 static char *ngx_http_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd,
|
|
|
47 void *conf);
|
|
626
|
48 static char *ngx_http_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd,
|
|
|
49 void *conf);
|
|
508
|
50 static char *ngx_http_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd,
|
|
|
51 void *conf);
|
|
|
52 static void ngx_http_geoip_cleanup(void *data);
|
|
|
53
|
|
|
54
|
|
|
55 static ngx_command_t ngx_http_geoip_commands[] = {
|
|
|
56
|
|
|
57 { ngx_string("geoip_country"),
|
|
614
|
58 NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE12,
|
|
508
|
59 ngx_http_geoip_country,
|
|
|
60 NGX_HTTP_MAIN_CONF_OFFSET,
|
|
|
61 0,
|
|
|
62 NULL },
|
|
|
63
|
|
626
|
64 { ngx_string("geoip_org"),
|
|
|
65 NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE12,
|
|
|
66 ngx_http_geoip_org,
|
|
|
67 NGX_HTTP_MAIN_CONF_OFFSET,
|
|
|
68 0,
|
|
|
69 NULL },
|
|
|
70
|
|
508
|
71 { ngx_string("geoip_city"),
|
|
614
|
72 NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE12,
|
|
508
|
73 ngx_http_geoip_city,
|
|
|
74 NGX_HTTP_MAIN_CONF_OFFSET,
|
|
|
75 0,
|
|
|
76 NULL },
|
|
|
77
|
|
|
78 ngx_null_command
|
|
|
79 };
|
|
|
80
|
|
|
81
|
|
|
82 static ngx_http_module_t ngx_http_geoip_module_ctx = {
|
|
|
83 ngx_http_geoip_add_variables, /* preconfiguration */
|
|
|
84 NULL, /* postconfiguration */
|
|
|
85
|
|
|
86 ngx_http_geoip_create_conf, /* create main configuration */
|
|
|
87 NULL, /* init main configuration */
|
|
|
88
|
|
|
89 NULL, /* create server configuration */
|
|
|
90 NULL, /* merge server configuration */
|
|
|
91
|
|
|
92 NULL, /* create location configuration */
|
|
|
93 NULL /* merge location configuration */
|
|
|
94 };
|
|
|
95
|
|
|
96
|
|
|
97 ngx_module_t ngx_http_geoip_module = {
|
|
|
98 NGX_MODULE_V1,
|
|
|
99 &ngx_http_geoip_module_ctx, /* module context */
|
|
|
100 ngx_http_geoip_commands, /* module directives */
|
|
|
101 NGX_HTTP_MODULE, /* module type */
|
|
|
102 NULL, /* init master */
|
|
|
103 NULL, /* init module */
|
|
|
104 NULL, /* init process */
|
|
|
105 NULL, /* init thread */
|
|
|
106 NULL, /* exit thread */
|
|
|
107 NULL, /* exit process */
|
|
|
108 NULL, /* exit master */
|
|
|
109 NGX_MODULE_V1_PADDING
|
|
|
110 };
|
|
|
111
|
|
|
112
|
|
|
113 static ngx_http_variable_t ngx_http_geoip_vars[] = {
|
|
|
114
|
|
558
|
115 { ngx_string("geoip_country_code"), NULL,
|
|
|
116 ngx_http_geoip_country_variable,
|
|
508
|
117 (uintptr_t) GeoIP_country_code_by_ipnum, 0, 0 },
|
|
|
118
|
|
558
|
119 { ngx_string("geoip_country_code3"), NULL,
|
|
|
120 ngx_http_geoip_country_variable,
|
|
508
|
121 (uintptr_t) GeoIP_country_code3_by_ipnum, 0, 0 },
|
|
|
122
|
|
558
|
123 { ngx_string("geoip_country_name"), NULL,
|
|
|
124 ngx_http_geoip_country_variable,
|
|
508
|
125 (uintptr_t) GeoIP_country_name_by_ipnum, 0, 0 },
|
|
|
126
|
|
626
|
127 { ngx_string("geoip_org"), NULL,
|
|
|
128 ngx_http_geoip_org_variable,
|
|
|
129 (uintptr_t) GeoIP_name_by_ipnum, 0, 0 },
|
|
|
130
|
|
558
|
131 { ngx_string("geoip_city_continent_code"), NULL,
|
|
|
132 ngx_http_geoip_city_variable,
|
|
|
133 offsetof(GeoIPRecord, continent_code), 0, 0 },
|
|
|
134
|
|
|
135 { ngx_string("geoip_city_country_code"), NULL,
|
|
|
136 ngx_http_geoip_city_variable,
|
|
508
|
137 offsetof(GeoIPRecord, country_code), 0, 0 },
|
|
|
138
|
|
|
139 { ngx_string("geoip_city_country_code3"), NULL,
|
|
|
140 ngx_http_geoip_city_variable,
|
|
|
141 offsetof(GeoIPRecord, country_code3), 0, 0 },
|
|
|
142
|
|
558
|
143 { ngx_string("geoip_city_country_name"), NULL,
|
|
|
144 ngx_http_geoip_city_variable,
|
|
508
|
145 offsetof(GeoIPRecord, country_name), 0, 0 },
|
|
|
146
|
|
|
147 { ngx_string("geoip_region"), NULL,
|
|
|
148 ngx_http_geoip_city_variable,
|
|
|
149 offsetof(GeoIPRecord, region), 0, 0 },
|
|
|
150
|
|
592
|
151 { ngx_string("geoip_region_name"), NULL,
|
|
|
152 ngx_http_geoip_region_name_variable,
|
|
|
153 0, 0, 0 },
|
|
|
154
|
|
508
|
155 { ngx_string("geoip_city"), NULL,
|
|
|
156 ngx_http_geoip_city_variable,
|
|
|
157 offsetof(GeoIPRecord, city), 0, 0 },
|
|
|
158
|
|
|
159 { ngx_string("geoip_postal_code"), NULL,
|
|
|
160 ngx_http_geoip_city_variable,
|
|
|
161 offsetof(GeoIPRecord, postal_code), 0, 0 },
|
|
|
162
|
|
558
|
163 { ngx_string("geoip_latitude"), NULL,
|
|
|
164 ngx_http_geoip_city_float_variable,
|
|
|
165 offsetof(GeoIPRecord, latitude), 0, 0 },
|
|
|
166
|
|
|
167 { ngx_string("geoip_longitude"), NULL,
|
|
|
168 ngx_http_geoip_city_float_variable,
|
|
|
169 offsetof(GeoIPRecord, longitude), 0, 0 },
|
|
|
170
|
|
592
|
171 { ngx_string("geoip_dma_code"), NULL,
|
|
|
172 ngx_http_geoip_city_int_variable,
|
|
|
173 offsetof(GeoIPRecord, dma_code), 0, 0 },
|
|
|
174
|
|
|
175 { ngx_string("geoip_area_code"), NULL,
|
|
|
176 ngx_http_geoip_city_int_variable,
|
|
|
177 offsetof(GeoIPRecord, area_code), 0, 0 },
|
|
|
178
|
|
508
|
179 { ngx_null_string, NULL, NULL, 0, 0, 0 }
|
|
|
180 };
|
|
|
181
|
|
|
182
|
|
626
|
183 static u_long
|
|
|
184 ngx_http_geoip_addr(ngx_http_request_t *r)
|
|
|
185 {
|
|
|
186 struct sockaddr_in *sin;
|
|
|
187 #if (NGX_HAVE_INET6)
|
|
|
188 u_char *p;
|
|
|
189 u_long addr;
|
|
|
190 struct sockaddr_in6 *sin6;
|
|
|
191 #endif
|
|
|
192
|
|
|
193 switch (r->connection->sockaddr->sa_family) {
|
|
|
194
|
|
|
195 case AF_INET:
|
|
|
196 sin = (struct sockaddr_in *) r->connection->sockaddr;
|
|
|
197 return ntohl(sin->sin_addr.s_addr);
|
|
|
198
|
|
|
199 #if (NGX_HAVE_INET6)
|
|
|
200
|
|
|
201 case AF_INET6:
|
|
|
202 sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;
|
|
|
203
|
|
|
204 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
205 p = sin6->sin6_addr.s6_addr;
|
|
|
206 addr = p[12] << 24;
|
|
|
207 addr += p[13] << 16;
|
|
|
208 addr += p[14] << 8;
|
|
|
209 addr += p[15];
|
|
|
210
|
|
|
211 return addr;
|
|
|
212 }
|
|
|
213
|
|
|
214 #endif
|
|
|
215 }
|
|
|
216
|
|
|
217 return INADDR_NONE;
|
|
|
218 }
|
|
|
219
|
|
|
220
|
|
508
|
221 static ngx_int_t
|
|
|
222 ngx_http_geoip_country_variable(ngx_http_request_t *r,
|
|
|
223 ngx_http_variable_value_t *v, uintptr_t data)
|
|
|
224 {
|
|
|
225 ngx_http_geoip_variable_handler_pt handler =
|
|
|
226 (ngx_http_geoip_variable_handler_pt) data;
|
|
|
227
|
|
|
228 const char *val;
|
|
|
229 ngx_http_geoip_conf_t *gcf;
|
|
|
230
|
|
|
231 gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);
|
|
|
232
|
|
|
233 if (gcf->country == NULL) {
|
|
|
234 goto not_found;
|
|
|
235 }
|
|
|
236
|
|
626
|
237 val = handler(gcf->country, ngx_http_geoip_addr(r));
|
|
|
238
|
|
|
239 if (val == NULL) {
|
|
508
|
240 goto not_found;
|
|
|
241 }
|
|
|
242
|
|
626
|
243 v->len = ngx_strlen(val);
|
|
|
244 v->valid = 1;
|
|
|
245 v->no_cacheable = 0;
|
|
|
246 v->not_found = 0;
|
|
|
247 v->data = (u_char *) val;
|
|
|
248
|
|
|
249 return NGX_OK;
|
|
|
250
|
|
|
251 not_found:
|
|
|
252
|
|
|
253 v->not_found = 1;
|
|
|
254
|
|
|
255 return NGX_OK;
|
|
|
256 }
|
|
|
257
|
|
508
|
258
|
|
626
|
259 static ngx_int_t
|
|
|
260 ngx_http_geoip_org_variable(ngx_http_request_t *r,
|
|
|
261 ngx_http_variable_value_t *v, uintptr_t data)
|
|
|
262 {
|
|
|
263 ngx_http_geoip_variable_handler_pt handler =
|
|
|
264 (ngx_http_geoip_variable_handler_pt) data;
|
|
|
265
|
|
|
266 const char *val;
|
|
|
267 ngx_http_geoip_conf_t *gcf;
|
|
|
268
|
|
|
269 gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);
|
|
|
270
|
|
|
271 if (gcf->org == NULL) {
|
|
|
272 goto not_found;
|
|
|
273 }
|
|
|
274
|
|
|
275 val = handler(gcf->org, ngx_http_geoip_addr(r));
|
|
508
|
276
|
|
|
277 if (val == NULL) {
|
|
|
278 goto not_found;
|
|
|
279 }
|
|
|
280
|
|
|
281 v->len = ngx_strlen(val);
|
|
|
282 v->valid = 1;
|
|
|
283 v->no_cacheable = 0;
|
|
|
284 v->not_found = 0;
|
|
|
285 v->data = (u_char *) val;
|
|
|
286
|
|
|
287 return NGX_OK;
|
|
|
288
|
|
|
289 not_found:
|
|
|
290
|
|
|
291 v->not_found = 1;
|
|
|
292
|
|
|
293 return NGX_OK;
|
|
|
294 }
|
|
|
295
|
|
|
296
|
|
|
297 static ngx_int_t
|
|
|
298 ngx_http_geoip_city_variable(ngx_http_request_t *r,
|
|
|
299 ngx_http_variable_value_t *v, uintptr_t data)
|
|
|
300 {
|
|
558
|
301 char *val;
|
|
|
302 size_t len;
|
|
|
303 GeoIPRecord *gr;
|
|
508
|
304
|
|
558
|
305 gr = ngx_http_geoip_get_city_record(r);
|
|
508
|
306 if (gr == NULL) {
|
|
|
307 goto not_found;
|
|
|
308 }
|
|
|
309
|
|
|
310 val = *(char **) ((char *) gr + data);
|
|
|
311 if (val == NULL) {
|
|
516
|
312 goto no_value;
|
|
508
|
313 }
|
|
|
314
|
|
516
|
315 len = ngx_strlen(val);
|
|
|
316 v->data = ngx_pnalloc(r->pool, len);
|
|
|
317 if (v->data == NULL) {
|
|
|
318 GeoIPRecord_delete(gr);
|
|
|
319 return NGX_ERROR;
|
|
|
320 }
|
|
|
321
|
|
|
322 ngx_memcpy(v->data, val, len);
|
|
|
323
|
|
|
324 v->len = len;
|
|
508
|
325 v->valid = 1;
|
|
|
326 v->no_cacheable = 0;
|
|
|
327 v->not_found = 0;
|
|
516
|
328
|
|
|
329 GeoIPRecord_delete(gr);
|
|
508
|
330
|
|
|
331 return NGX_OK;
|
|
|
332
|
|
516
|
333 no_value:
|
|
|
334
|
|
|
335 GeoIPRecord_delete(gr);
|
|
|
336
|
|
508
|
337 not_found:
|
|
|
338
|
|
|
339 v->not_found = 1;
|
|
|
340
|
|
|
341 return NGX_OK;
|
|
|
342 }
|
|
|
343
|
|
|
344
|
|
|
345 static ngx_int_t
|
|
592
|
346 ngx_http_geoip_region_name_variable(ngx_http_request_t *r,
|
|
|
347 ngx_http_variable_value_t *v, uintptr_t data)
|
|
|
348 {
|
|
|
349 size_t len;
|
|
|
350 const char *val;
|
|
|
351 GeoIPRecord *gr;
|
|
|
352
|
|
|
353 gr = ngx_http_geoip_get_city_record(r);
|
|
|
354 if (gr == NULL) {
|
|
|
355 goto not_found;
|
|
|
356 }
|
|
|
357
|
|
|
358 val = GeoIP_region_name_by_code(gr->country_code, gr->region);
|
|
|
359
|
|
594
|
360 GeoIPRecord_delete(gr);
|
|
|
361
|
|
|
362 if (val == NULL) {
|
|
|
363 goto not_found;
|
|
|
364 }
|
|
|
365
|
|
592
|
366 len = ngx_strlen(val);
|
|
|
367 v->data = ngx_pnalloc(r->pool, len);
|
|
|
368 if (v->data == NULL) {
|
|
|
369 return NGX_ERROR;
|
|
|
370 }
|
|
|
371
|
|
|
372 ngx_memcpy(v->data, val, len);
|
|
|
373
|
|
|
374 v->len = len;
|
|
|
375 v->valid = 1;
|
|
|
376 v->no_cacheable = 0;
|
|
|
377 v->not_found = 0;
|
|
|
378
|
|
|
379 return NGX_OK;
|
|
|
380
|
|
|
381 not_found:
|
|
|
382
|
|
|
383 v->not_found = 1;
|
|
|
384
|
|
|
385 return NGX_OK;
|
|
|
386 }
|
|
|
387
|
|
|
388
|
|
|
389 static ngx_int_t
|
|
558
|
390 ngx_http_geoip_city_float_variable(ngx_http_request_t *r,
|
|
|
391 ngx_http_variable_value_t *v, uintptr_t data)
|
|
|
392 {
|
|
|
393 float val;
|
|
|
394 GeoIPRecord *gr;
|
|
|
395
|
|
|
396 gr = ngx_http_geoip_get_city_record(r);
|
|
|
397 if (gr == NULL) {
|
|
|
398 v->not_found = 1;
|
|
|
399 return NGX_OK;
|
|
|
400 }
|
|
|
401
|
|
|
402 v->data = ngx_pnalloc(r->pool, NGX_INT64_LEN + 5);
|
|
|
403 if (v->data == NULL) {
|
|
|
404 GeoIPRecord_delete(gr);
|
|
|
405 return NGX_ERROR;
|
|
|
406 }
|
|
|
407
|
|
|
408 val = *(float *) ((char *) gr + data);
|
|
|
409
|
|
|
410 v->len = ngx_sprintf(v->data, "%.4f", val) - v->data;
|
|
|
411
|
|
|
412 GeoIPRecord_delete(gr);
|
|
|
413
|
|
|
414 return NGX_OK;
|
|
|
415 }
|
|
|
416
|
|
|
417
|
|
592
|
418 static ngx_int_t
|
|
|
419 ngx_http_geoip_city_int_variable(ngx_http_request_t *r,
|
|
|
420 ngx_http_variable_value_t *v, uintptr_t data)
|
|
|
421 {
|
|
|
422 int val;
|
|
|
423 GeoIPRecord *gr;
|
|
|
424
|
|
|
425 gr = ngx_http_geoip_get_city_record(r);
|
|
|
426 if (gr == NULL) {
|
|
|
427 v->not_found = 1;
|
|
|
428 return NGX_OK;
|
|
|
429 }
|
|
|
430
|
|
|
431 v->data = ngx_pnalloc(r->pool, NGX_INT64_LEN);
|
|
|
432 if (v->data == NULL) {
|
|
|
433 GeoIPRecord_delete(gr);
|
|
|
434 return NGX_ERROR;
|
|
|
435 }
|
|
|
436
|
|
|
437 val = *(int *) ((char *) gr + data);
|
|
|
438
|
|
|
439 v->len = ngx_sprintf(v->data, "%d", val) - v->data;
|
|
|
440
|
|
|
441 GeoIPRecord_delete(gr);
|
|
|
442
|
|
|
443 return NGX_OK;
|
|
|
444 }
|
|
|
445
|
|
|
446
|
|
558
|
447 static GeoIPRecord *
|
|
|
448 ngx_http_geoip_get_city_record(ngx_http_request_t *r)
|
|
|
449 {
|
|
|
450 ngx_http_geoip_conf_t *gcf;
|
|
|
451
|
|
|
452 gcf = ngx_http_get_module_main_conf(r, ngx_http_geoip_module);
|
|
|
453
|
|
626
|
454 if (gcf->city) {
|
|
|
455 return GeoIP_record_by_ipnum(gcf->city, ngx_http_geoip_addr(r));
|
|
558
|
456 }
|
|
|
457
|
|
|
458 return NULL;
|
|
|
459 }
|
|
|
460
|
|
|
461
|
|
|
462 static ngx_int_t
|
|
508
|
463 ngx_http_geoip_add_variables(ngx_conf_t *cf)
|
|
|
464 {
|
|
|
465 ngx_http_variable_t *var, *v;
|
|
|
466
|
|
|
467 for (v = ngx_http_geoip_vars; v->name.len; v++) {
|
|
|
468 var = ngx_http_add_variable(cf, &v->name, v->flags);
|
|
|
469 if (var == NULL) {
|
|
|
470 return NGX_ERROR;
|
|
|
471 }
|
|
|
472
|
|
|
473 var->get_handler = v->get_handler;
|
|
|
474 var->data = v->data;
|
|
|
475 }
|
|
|
476
|
|
|
477 return NGX_OK;
|
|
|
478 }
|
|
|
479
|
|
|
480
|
|
|
481 static void *
|
|
|
482 ngx_http_geoip_create_conf(ngx_conf_t *cf)
|
|
|
483 {
|
|
|
484 ngx_pool_cleanup_t *cln;
|
|
|
485 ngx_http_geoip_conf_t *conf;
|
|
|
486
|
|
|
487 conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_geoip_conf_t));
|
|
|
488 if (conf == NULL) {
|
|
|
489 return NULL;
|
|
|
490 }
|
|
|
491
|
|
|
492 cln = ngx_pool_cleanup_add(cf->pool, 0);
|
|
|
493 if (cln == NULL) {
|
|
|
494 return NULL;
|
|
|
495 }
|
|
|
496
|
|
|
497 cln->handler = ngx_http_geoip_cleanup;
|
|
|
498 cln->data = conf;
|
|
|
499
|
|
|
500 return conf;
|
|
|
501 }
|
|
|
502
|
|
|
503
|
|
|
504 static char *
|
|
|
505 ngx_http_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
|
|
|
506 {
|
|
|
507 ngx_http_geoip_conf_t *gcf = conf;
|
|
|
508
|
|
|
509 ngx_str_t *value;
|
|
|
510
|
|
|
511 if (gcf->country) {
|
|
|
512 return "is duplicate";
|
|
|
513 }
|
|
|
514
|
|
|
515 value = cf->args->elts;
|
|
|
516
|
|
|
517 gcf->country = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);
|
|
|
518
|
|
|
519 if (gcf->country == NULL) {
|
|
|
520 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
626
|
521 "GeoIP_open(\"%V\") failed", &value[1]);
|
|
508
|
522
|
|
|
523 return NGX_CONF_ERROR;
|
|
|
524 }
|
|
|
525
|
|
614
|
526 if (cf->args->nelts == 3) {
|
|
|
527 if (ngx_strcmp(value[2].data, "utf8") == 0) {
|
|
|
528 GeoIP_set_charset (gcf->country, GEOIP_CHARSET_UTF8);
|
|
|
529
|
|
|
530 } else {
|
|
|
531 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
532 "invalid parameter \"%V\"", &value[2]);
|
|
|
533 return NGX_CONF_ERROR;
|
|
|
534 }
|
|
|
535 }
|
|
|
536
|
|
508
|
537 switch (gcf->country->databaseType) {
|
|
|
538
|
|
|
539 case GEOIP_COUNTRY_EDITION:
|
|
|
540 case GEOIP_PROXY_EDITION:
|
|
|
541 case GEOIP_NETSPEED_EDITION:
|
|
|
542
|
|
|
543 return NGX_CONF_OK;
|
|
|
544
|
|
|
545 default:
|
|
|
546 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
547 "invalid GeoIP database \"%V\" type:%d",
|
|
|
548 &value[1], gcf->country->databaseType);
|
|
|
549 return NGX_CONF_ERROR;
|
|
|
550 }
|
|
|
551 }
|
|
|
552
|
|
|
553
|
|
|
554 static char *
|
|
626
|
555 ngx_http_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
|
|
|
556 {
|
|
|
557 ngx_http_geoip_conf_t *gcf = conf;
|
|
|
558
|
|
|
559 ngx_str_t *value;
|
|
|
560
|
|
|
561 if (gcf->org) {
|
|
|
562 return "is duplicate";
|
|
|
563 }
|
|
|
564
|
|
|
565 value = cf->args->elts;
|
|
|
566
|
|
|
567 gcf->org = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);
|
|
|
568
|
|
|
569 if (gcf->org == NULL) {
|
|
|
570 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
571 "GeoIP_open(\"%V\") failed", &value[1]);
|
|
|
572
|
|
|
573 return NGX_CONF_ERROR;
|
|
|
574 }
|
|
|
575
|
|
|
576 if (cf->args->nelts == 3) {
|
|
|
577 if (ngx_strcmp(value[2].data, "utf8") == 0) {
|
|
|
578 GeoIP_set_charset (gcf->org, GEOIP_CHARSET_UTF8);
|
|
|
579
|
|
|
580 } else {
|
|
|
581 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
582 "invalid parameter \"%V\"", &value[2]);
|
|
|
583 return NGX_CONF_ERROR;
|
|
|
584 }
|
|
|
585 }
|
|
|
586
|
|
|
587 switch (gcf->org->databaseType) {
|
|
|
588
|
|
|
589 case GEOIP_ISP_EDITION:
|
|
|
590 case GEOIP_ORG_EDITION:
|
|
|
591 case GEOIP_DOMAIN_EDITION:
|
|
|
592 case GEOIP_ASNUM_EDITION:
|
|
|
593
|
|
|
594 return NGX_CONF_OK;
|
|
|
595
|
|
|
596 default:
|
|
|
597 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
598 "invalid GeoIP database \"%V\" type:%d",
|
|
|
599 &value[1], gcf->org->databaseType);
|
|
|
600 return NGX_CONF_ERROR;
|
|
|
601 }
|
|
|
602 }
|
|
|
603
|
|
|
604
|
|
|
605 static char *
|
|
508
|
606 ngx_http_geoip_city(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
|
|
|
607 {
|
|
|
608 ngx_http_geoip_conf_t *gcf = conf;
|
|
|
609
|
|
|
610 ngx_str_t *value;
|
|
|
611
|
|
|
612 if (gcf->city) {
|
|
|
613 return "is duplicate";
|
|
|
614 }
|
|
|
615
|
|
|
616 value = cf->args->elts;
|
|
|
617
|
|
|
618 gcf->city = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);
|
|
|
619
|
|
|
620 if (gcf->city == NULL) {
|
|
|
621 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
626
|
622 "GeoIP_open(\"%V\") failed", &value[1]);
|
|
508
|
623
|
|
|
624 return NGX_CONF_ERROR;
|
|
|
625 }
|
|
|
626
|
|
614
|
627 if (cf->args->nelts == 3) {
|
|
|
628 if (ngx_strcmp(value[2].data, "utf8") == 0) {
|
|
|
629 GeoIP_set_charset (gcf->city, GEOIP_CHARSET_UTF8);
|
|
|
630
|
|
|
631 } else {
|
|
|
632 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
633 "invalid parameter \"%V\"", &value[2]);
|
|
|
634 return NGX_CONF_ERROR;
|
|
|
635 }
|
|
|
636 }
|
|
|
637
|
|
508
|
638 switch (gcf->city->databaseType) {
|
|
|
639
|
|
|
640 case GEOIP_CITY_EDITION_REV0:
|
|
|
641 case GEOIP_CITY_EDITION_REV1:
|
|
|
642
|
|
|
643 return NGX_CONF_OK;
|
|
|
644
|
|
|
645 default:
|
|
|
646 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
|
|
647 "invalid GeoIP City database \"%V\" type:%d",
|
|
|
648 &value[1], gcf->city->databaseType);
|
|
|
649 return NGX_CONF_ERROR;
|
|
|
650 }
|
|
|
651 }
|
|
|
652
|
|
|
653
|
|
|
654 static void
|
|
|
655 ngx_http_geoip_cleanup(void *data)
|
|
|
656 {
|
|
|
657 ngx_http_geoip_conf_t *gcf = data;
|
|
|
658
|
|
|
659 if (gcf->country) {
|
|
|
660 GeoIP_delete(gcf->country);
|
|
|
661 }
|
|
|
662
|
|
626
|
663 if (gcf->org) {
|
|
|
664 GeoIP_delete(gcf->org);
|
|
|
665 }
|
|
|
666
|
|
508
|
667 if (gcf->city) {
|
|
|
668 GeoIP_delete(gcf->city);
|
|
|
669 }
|
|
|
670 }
|
