573 lines
19 KiB
C
573 lines
19 KiB
C
/*
|
||
* Created by Wu Jian Ping on - 2023/03/30.
|
||
*/
|
||
|
||
#include "ngx_http_ip2region_module.h"
|
||
|
||
static ngx_int_t ngx_http_ip2region_is_absolute_path(char *name);
|
||
static char *ngx_http_ip2region_init_searcher(ngx_conf_t *cf, char *db_name,
|
||
char *cache_policy, xdb_version_t *expected_version, const char *directive_name);
|
||
|
||
static ngx_int_t ngx_http_ip2region_add_variables(ngx_conf_t *cf);
|
||
|
||
static void *ngx_http_ip2region_create_conf(ngx_conf_t *cf);
|
||
static void ngx_http_ip2region_cleanup(void *data);
|
||
static char *ngx_http_ip2region_init(ngx_conf_t *cf,
|
||
ngx_command_t *cmd, void *conf);
|
||
|
||
static ngx_int_t ngx_http_ip2region_variable(ngx_http_request_t *r,
|
||
ngx_http_variable_value_t *v, uintptr_t data);
|
||
|
||
static ngx_http_module_t ngx_http_ip2region_ctx = {
|
||
ngx_http_ip2region_add_variables, /* pre configuration */
|
||
NULL, /* post configuration */
|
||
ngx_http_ip2region_create_conf, /* create main configuration */
|
||
NULL, /* init main configuration */
|
||
NULL, /* create server configuration */
|
||
NULL, /* merge server configuration */
|
||
NULL, /* create location configuration */
|
||
NULL /* merge location configuration */
|
||
};
|
||
|
||
|
||
static char *ngx_http_ip2region_init(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
|
||
static char *ngx_http_ip2region_init_v6(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
|
||
|
||
static ngx_command_t ngx_http_ip2region_commands[] = {
|
||
{ ngx_string("ip2region_db"),
|
||
NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE12,
|
||
ngx_http_ip2region_init,
|
||
NGX_HTTP_MAIN_CONF_OFFSET,
|
||
0,
|
||
NULL },
|
||
|
||
{ ngx_string("ip2region_db6"),
|
||
NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE12,
|
||
ngx_http_ip2region_init_v6,
|
||
NGX_HTTP_MAIN_CONF_OFFSET,
|
||
0,
|
||
NULL },
|
||
|
||
ngx_null_command
|
||
};
|
||
|
||
|
||
/* ngx_module_t is required, otherwise failed at complie time */
|
||
ngx_module_t ngx_http_ip2region_module = {
|
||
NGX_MODULE_V1,
|
||
&ngx_http_ip2region_ctx, /* module context */
|
||
ngx_http_ip2region_commands, /* module directives */
|
||
NGX_HTTP_MODULE, /* module type */
|
||
NULL, /* init master */
|
||
NULL, /* init module */
|
||
NULL, /* init process */
|
||
NULL, /* init thread */
|
||
NULL, /* exit thread */
|
||
NULL, /* exit process */
|
||
NULL, /* exit master */
|
||
NGX_MODULE_V1_PADDING
|
||
};
|
||
|
||
|
||
static ngx_http_variable_t ngx_http_ip2region_vars[] = {
|
||
{ ngx_string("ip2region"), NULL,
|
||
ngx_http_ip2region_variable,
|
||
0, 0, 0 },
|
||
|
||
ngx_http_null_variable
|
||
};
|
||
|
||
|
||
// 用于初始化带版本校验的搜索器的辅助函数
|
||
static char *
|
||
ngx_http_ip2region_init_searcher(ngx_conf_t *cf, char *db_name,
|
||
char *cache_policy, xdb_version_t *expected_version, const char *directive_name)
|
||
{
|
||
ip2region_searcher_t *ip2region_searcher;
|
||
int err;
|
||
char *db_path;
|
||
size_t len;
|
||
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) == NGX_OK) {
|
||
db_path = db_name;
|
||
} else { // relative path to conf directory
|
||
len = ngx_cycle->conf_prefix.len + strlen(db_name) + 1;
|
||
db_path = malloc(len);
|
||
if (db_path == NULL) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to allocate memory for db_path");
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
memset(db_path, '\0', len);
|
||
memcpy(db_path, ngx_cycle->conf_prefix.data, ngx_cycle->conf_prefix.len);
|
||
strcat(db_path, db_name);
|
||
}
|
||
|
||
ip2region_searcher = ngx_palloc(cf->pool, sizeof(ip2region_searcher_t));
|
||
|
||
if(ip2region_searcher == NULL) {
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
ip2region_searcher->v_index = NULL;
|
||
ip2region_searcher->c_buffer = NULL;
|
||
|
||
// 检查XDB文件的版本信息以确定IP类型
|
||
xdb_header_t *header = xdb_load_header_from_file(db_path);
|
||
if (header == NULL) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to load xdb header from: %s", db_path);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
xdb_version_t *xdb_version = xdb_version_from_header(header);
|
||
if (xdb_version == NULL) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to determine xdb version from header: %s", db_path);
|
||
xdb_free_header((void *)header);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
// 验证XDB文件版本是否匹配
|
||
if (xdb_version->id != expected_version->id) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"%s expects %s xdb file, but got %s: %s",
|
||
directive_name, expected_version->name, xdb_version->name, db_path);
|
||
xdb_free_header((void *)header);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
if (strcmp(cache_policy, "file") == 0) {
|
||
err = xdb_new_with_file_only(xdb_version, &ip2region_searcher->searcher, db_path);
|
||
xdb_free_header((void *)header);
|
||
if (err != 0) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to create searcher: %s", db_path);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
} else if (strcmp(cache_policy, "vectorIndex") == 0) {
|
||
ip2region_searcher->v_index = xdb_load_vector_index_from_file(db_path);
|
||
if (ip2region_searcher->v_index == NULL) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to load vector index from: %s", db_path);
|
||
xdb_free_header((void *)header);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
err = xdb_new_with_vector_index(xdb_version, &ip2region_searcher->searcher, db_path, ip2region_searcher->v_index);
|
||
xdb_free_header((void *)header);
|
||
if (err != 0) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to create vector index cached searcher: %s", db_path);
|
||
xdb_free_vector_index((void *)ip2region_searcher->v_index);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
} else if (strcmp(cache_policy, "content") == 0) {
|
||
ip2region_searcher->c_buffer = xdb_load_content_from_file(db_path);
|
||
if (ip2region_searcher->c_buffer == NULL) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to load xdb content: %s", db_path);
|
||
xdb_free_header((void *)header);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
err = xdb_new_with_buffer(xdb_version, &ip2region_searcher->searcher, ip2region_searcher->c_buffer);
|
||
xdb_free_header((void *)header);
|
||
if (err != 0) {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"failed to create content cached searcher: %s", db_path);
|
||
xdb_free_content((void *)ip2region_searcher->c_buffer);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
} else {
|
||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||
"invalid cache policy, options: file/vectorIndex/content");
|
||
xdb_free_header((void *)header);
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
if(ngx_http_ip2region_is_absolute_path(db_name) != NGX_OK) {
|
||
free(db_path);
|
||
}
|
||
|
||
return (char *)ip2region_searcher;
|
||
}
|
||
|
||
|
||
static char *
|
||
ngx_http_ip2region_init(ngx_conf_t *cf, ngx_command_t *cmd,
|
||
void *conf)
|
||
{
|
||
ngx_http_ip2region_conf_t *ip2region_cf;
|
||
char *db_name, *cache_policy;
|
||
ngx_str_t *value;
|
||
char *result;
|
||
|
||
ip2region_cf = conf;
|
||
|
||
if (ip2region_cf->v4_searcher) {
|
||
return "ip2region_db is duplicate";
|
||
}
|
||
|
||
value = cf->args->elts;
|
||
db_name = (char *)value[1].data;
|
||
|
||
// default cache_policy: content
|
||
if(cf->args->nelts == 2) {
|
||
cache_policy = "content";
|
||
} else {
|
||
cache_policy = (char *)value[2].data;
|
||
}
|
||
|
||
result = ngx_http_ip2region_init_searcher(cf, db_name, cache_policy,
|
||
xdb_version_v4(), "ip2region_db");
|
||
if (result == NGX_CONF_ERROR) {
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
ip2region_cf->v4_searcher = (ip2region_searcher_t *)result;
|
||
|
||
return NGX_CONF_OK;
|
||
}
|
||
|
||
static char *
|
||
ngx_http_ip2region_init_v6(ngx_conf_t *cf, ngx_command_t *cmd,
|
||
void *conf)
|
||
{
|
||
ngx_http_ip2region_conf_t *ip2region_cf;
|
||
char *db_name, *cache_policy;
|
||
ngx_str_t *value;
|
||
char *result;
|
||
|
||
ip2region_cf = conf;
|
||
|
||
if (ip2region_cf->v6_searcher) {
|
||
return "ip2region_db6 is duplicate";
|
||
}
|
||
|
||
value = cf->args->elts;
|
||
db_name = (char *)value[1].data;
|
||
|
||
// default cache_policy: content
|
||
if(cf->args->nelts == 2) {
|
||
cache_policy = "content";
|
||
} else {
|
||
cache_policy = (char *)value[2].data;
|
||
}
|
||
|
||
result = ngx_http_ip2region_init_searcher(cf, db_name, cache_policy,
|
||
xdb_version_v6(), "ip2region_db6");
|
||
if (result == NGX_CONF_ERROR) {
|
||
return NGX_CONF_ERROR;
|
||
}
|
||
|
||
ip2region_cf->v6_searcher = (ip2region_searcher_t *)result;
|
||
|
||
return NGX_CONF_OK;
|
||
}
|
||
|
||
|
||
static void *
|
||
ngx_http_ip2region_create_conf(ngx_conf_t *cf)
|
||
{
|
||
ngx_pool_cleanup_t *cln;
|
||
ngx_http_ip2region_conf_t *conf;
|
||
|
||
conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_ip2region_conf_t));
|
||
if (conf == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
cln = ngx_pool_cleanup_add(cf->pool, 0);
|
||
if (cln == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
cln->handler = ngx_http_ip2region_cleanup;
|
||
cln->data = conf;
|
||
|
||
return conf;
|
||
}
|
||
|
||
|
||
static ngx_int_t
|
||
ngx_http_ip2region_add_variables(ngx_conf_t *cf)
|
||
{
|
||
ngx_http_variable_t *var;
|
||
ngx_http_variable_t *v;
|
||
|
||
for (v = ngx_http_ip2region_vars; v->name.len; v++) {
|
||
var = ngx_http_add_variable(cf, &v->name, v->flags);
|
||
if (var == NULL) {
|
||
return NGX_ERROR;
|
||
}
|
||
|
||
var->get_handler = v->get_handler;
|
||
var->data = v->data;
|
||
}
|
||
return NGX_OK;
|
||
}
|
||
|
||
|
||
static ngx_int_t
|
||
ngx_http_ip2region_variable(ngx_http_request_t *r,
|
||
ngx_http_variable_value_t *v, uintptr_t data)
|
||
{
|
||
ngx_http_ip2region_conf_t *ip2region_conf;
|
||
struct sockaddr_in *sin;
|
||
char region_buffer[512] = {'\0'};
|
||
xdb_region_buffer_t region;
|
||
int err = 1;
|
||
unsigned int ip;
|
||
xdb_searcher_t *searcher_ptr = NULL;
|
||
|
||
#if (NGX_HAVE_INET6)
|
||
u_char *p;
|
||
in_addr_t addr;
|
||
struct sockaddr_in6 *sin6;
|
||
#endif
|
||
|
||
ip2region_conf = ngx_http_get_module_main_conf(r, ngx_http_ip2region_module);
|
||
|
||
if (ip2region_conf->v4_searcher == NULL && ip2region_conf->v6_searcher == NULL) {
|
||
v->not_found = 1;
|
||
return NGX_OK;
|
||
}
|
||
|
||
// 初始化 region buffer
|
||
err = xdb_region_buffer_init(®ion, region_buffer, sizeof(region_buffer));
|
||
if (err != 0) {
|
||
v->not_found = 1;
|
||
return NGX_OK;
|
||
}
|
||
|
||
switch (r->connection->sockaddr->sa_family) {
|
||
case AF_INET:
|
||
sin = (struct sockaddr_in *) r->connection->sockaddr;
|
||
|
||
// 检查是否有IPv4 searcher
|
||
if (ip2region_conf->v4_searcher == NULL) {
|
||
ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
|
||
"no IPv4 searcher available for IPv4 address");
|
||
break;
|
||
}
|
||
|
||
searcher_ptr = &ip2region_conf->v4_searcher->searcher;
|
||
|
||
// 正确转换IP地址字节序，按ip2region期望的格式
|
||
ip = ntohl(sin->sin_addr.s_addr); // 将网络字节序转换为主机字节序
|
||
// 按照xdb_parse_v4_ip中的格式重新组织字节
|
||
{
|
||
bytes_ip_t ip_bytes[4];
|
||
ip_bytes[0] = (ip >> 24) & 0xFF;
|
||
ip_bytes[1] = (ip >> 16) & 0xFF;
|
||
ip_bytes[2] = (ip >> 8) & 0xFF;
|
||
ip_bytes[3] = ip & 0xFF;
|
||
err = xdb_search(searcher_ptr, ip_bytes, 4, ®ion);
|
||
}
|
||
if (err == 0) {
|
||
v->data = (unsigned char *)region.value;
|
||
v->len = strlen(region.value);
|
||
xdb_region_buffer_free(®ion);
|
||
return NGX_OK;
|
||
} else {
|
||
ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
|
||
"ip2region search failed for IPv4 address");
|
||
}
|
||
break;
|
||
|
||
#if (NGX_HAVE_INET6)
|
||
|
||
case AF_INET6:
|
||
sin6 = (struct sockaddr_in6 *) r->connection->sockaddr;
|
||
p = sin6->sin6_addr.s6_addr;
|
||
|
||
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
||
// 处理IPv4映射的IPv6地址
|
||
if (ip2region_conf->v4_searcher != NULL) {
|
||
searcher_ptr = &ip2region_conf->v4_searcher->searcher;
|
||
addr = p[12] << 24;
|
||
addr += p[13] << 16;
|
||
addr += p[14] << 8;
|
||
addr += p[15];
|
||
// 按照xdb_parse_v4_ip中的格式重新组织字节
|
||
{
|
||
bytes_ip_t ip_bytes[4];
|
||
ip_bytes[0] = (addr >> 24) & 0xFF;
|
||
ip_bytes[1] = (addr >> 16) & 0xFF;
|
||
ip_bytes[2] = (addr >> 8) & 0xFF;
|
||
ip_bytes[3] = addr & 0xFF;
|
||
err = xdb_search(searcher_ptr, ip_bytes, 4, ®ion);
|
||
}
|
||
if (err == 0) {
|
||
v->data = (unsigned char *)region.value;
|
||
v->len = strlen(region.value);
|
||
xdb_region_buffer_free(®ion);
|
||
return NGX_OK;
|
||
} else {
|
||
ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
|
||
"ip2region search failed for IPv4-mapped IPv6 address");
|
||
}
|
||
}
|
||
} else {
|
||
// 处理纯IPv6地址
|
||
if (ip2region_conf->v6_searcher != NULL) {
|
||
searcher_ptr = &ip2region_conf->v6_searcher->searcher;
|
||
bytes_ip_t ip6_bytes[16];
|
||
if (p != NULL) {
|
||
memcpy(ip6_bytes, p, 16);
|
||
err = xdb_search(searcher_ptr, ip6_bytes, 16, ®ion);
|
||
if (err == 0) {
|
||
v->data = (unsigned char *)region.value;
|
||
v->len = strlen(region.value);
|
||
xdb_region_buffer_free(®ion);
|
||
return NGX_OK;
|
||
} else {
|
||
ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
|
||
"ip2region search failed for IPv6 address");
|
||
}
|
||
}
|
||
} else {
|
||
ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
|
||
"no IPv6 searcher available for IPv6 address");
|
||
}
|
||
}
|
||
break;
|
||
|
||
#endif
|
||
|
||
}
|
||
// 如果搜索失败，释放 region buffer
|
||
xdb_region_buffer_free(®ion);
|
||
|
||
ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
|
||
"ip2region: no region found for IP address");
|
||
v->not_found = 1;
|
||
return NGX_OK;
|
||
}
|
||
|
||
|
||
static void
|
||
ngx_http_ip2region_cleanup(void *data)
|
||
{
|
||
ngx_http_ip2region_conf_t *ip2region_conf = data;
|
||
|
||
// 清理 IPv4 searcher
|
||
if(ip2region_conf->v4_searcher != NULL) {
|
||
xdb_close(&ip2region_conf->v4_searcher->searcher);
|
||
|
||
// check and free the vector index
|
||
if (ip2region_conf->v4_searcher->v_index != NULL) {
|
||
xdb_free_vector_index((void *)ip2region_conf->v4_searcher->v_index);
|
||
ip2region_conf->v4_searcher->v_index = NULL;
|
||
}
|
||
|
||
// check and free the content buffer
|
||
if (ip2region_conf->v4_searcher->c_buffer != NULL) {
|
||
xdb_free_content((void *)ip2region_conf->v4_searcher->c_buffer);
|
||
ip2region_conf->v4_searcher->c_buffer = NULL;
|
||
}
|
||
|
||
ip2region_conf->v4_searcher = NULL;
|
||
}
|
||
|
||
// 清理 IPv6 searcher
|
||
if(ip2region_conf->v6_searcher != NULL) {
|
||
xdb_close(&ip2region_conf->v6_searcher->searcher);
|
||
|
||
// check and free the vector index
|
||
if (ip2region_conf->v6_searcher->v_index != NULL) {
|
||
xdb_free_vector_index((void *)ip2region_conf->v6_searcher->v_index);
|
||
ip2region_conf->v6_searcher->v_index = NULL;
|
||
}
|
||
|
||
// check and free the content buffer
|
||
if (ip2region_conf->v6_searcher->c_buffer != NULL) {
|
||
xdb_free_content((void *)ip2region_conf->v6_searcher->c_buffer);
|
||
ip2region_conf->v6_searcher->c_buffer = NULL;
|
||
}
|
||
|
||
ip2region_conf->v6_searcher = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
static ngx_int_t
|
||
ngx_http_ip2region_is_absolute_path(char *name)
|
||
{
|
||
#if (NGX_WIN32)
|
||
u_char c0, c1;
|
||
|
||
c0 = name[0];
|
||
|
||
if (strlen(name) < 2) {
|
||
if (c0 == '/') {
|
||
return 2;
|
||
}
|
||
|
||
return NGX_DECLINED;
|
||
}
|
||
|
||
c1 = name[1];
|
||
|
||
if (c1 == ':') {
|
||
c0 |= 0x20;
|
||
|
||
if ((c0 >= 'a' && c0 <= 'z')) {
|
||
return NGX_OK;
|
||
}
|
||
|
||
return NGX_DECLINED;
|
||
}
|
||
|
||
if (c1 == '/') {
|
||
return NGX_OK;
|
||
}
|
||
|
||
if (c0 == '/') {
|
||
return 2;
|
||
}
|
||
|
||
return NGX_DECLINED;
|
||
|
||
#else
|
||
|
||
if (name[0] == '/') {
|
||
return NGX_OK;
|
||
}
|
||
|
||
return NGX_DECLINED;
|
||
|
||
#endif
|
||
}
|