ts-ip2region2 1.0.0

package/ip2region/xdb_api.h

@@ -0,0 +1,272 @@
+// Copyright 2022 The Ip2Region Authors. All rights reserved.
+// Use of this source code is governed by a Apache2.0-style
+// license that can be found in the LICENSE file.
+
+// ---
+// @Author Lion <chenxin619315@gmail.com>
+// @Date   2022/06/27
+
+#ifndef C_IP2REGION_XDB_H
+#define C_IP2REGION_XDB_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if ( defined(WIN32) || defined(_WIN32) || defined(__WINDOWS_) || defined(WINNT) )
+#   define XDB_PUBLIC(type)    extern __declspec(dllexport) type
+#   define XDB_PRIVATE(type)   static type
+#   define XDB_WINDOWS
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#pragma comment(lib, "ws2_32.lib")
+#elif ( defined(linux) || defined(_UNIX) || defined(__APPLE__) )
+#   define XDB_PUBLIC(type)    extern type
+#   define XDB_PRIVATE(type)   static inline type
+#   define XDB_LINUX
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+#define xdb_calloc( _blocks, _bytes )  calloc( _blocks, _bytes )
+#define xdb_malloc( _bytes )           malloc( _bytes )
+#define xdb_free( _ptr )               free( _ptr )
+
+// public constants define
+#define xdb_structure_20 2
+#define xdb_structure_30 3
+#define xdb_header_info_length 256
+#define xdb_vector_index_rows  256
+#define xdb_vector_index_cols  256
+#define xdb_vector_index_size  8
+#define xdb_v4_index_size 14    // 4 + 4 + 2 + 4
+#define xdb_v6_index_size 38    // 16 + 16 + 2 + 4
+
+// --- ip version info
+#define xdb_ipv4_id 4
+#define xdb_ipv6_id 6
+#define xdb_ipv4_bytes 4
+#define xdb_ipv6_bytes 16
+// cache of vector_index_row × vector_index_rows × vector_index_size
+#define xdb_vector_index_length 524288
+
+// --- xdb buffer functions
+
+// use the following buffer struct to wrap the binary buffer data
+// since the buffer data could not be operated with the string API.
+struct xdb_header {
+    unsigned short version;
+    unsigned short index_policy;
+    unsigned int created_at;
+    unsigned int start_index_ptr;
+    unsigned int end_index_ptr;
+    
+    // since 3.0+ with IPv6 supporting
+    unsigned short ip_version;
+    unsigned short runtime_ptr_bytes;
+
+    // the original buffer
+    unsigned int length;
+    char buffer[xdb_header_info_length];
+};
+typedef struct xdb_header xdb_header_t;
+
+XDB_PUBLIC(xdb_header_t *) xdb_load_header(FILE *);
+
+XDB_PUBLIC(xdb_header_t *) xdb_load_header_from_file(const char *);
+
+XDB_PUBLIC(void) xdb_free_header(void *);
+
+
+// --- vector index buffer
+struct xdb_vector_index {
+    unsigned int length;
+    char buffer[xdb_vector_index_length];
+};
+typedef struct xdb_vector_index xdb_vector_index_t;
+
+XDB_PUBLIC(xdb_vector_index_t *) xdb_load_vector_index(FILE *);
+
+XDB_PUBLIC(xdb_vector_index_t *) xdb_load_vector_index_from_file(const char *);
+
+XDB_PUBLIC(void) xdb_free_vector_index(void *);
+
+
+// --- content buffer
+struct xdb_content {
+    unsigned int length;
+    char *buffer;
+};
+typedef struct xdb_content xdb_content_t;
+
+XDB_PUBLIC(xdb_content_t *) xdb_load_content(FILE *);
+
+XDB_PUBLIC(xdb_content_t *) xdb_load_content_from_file(const char *);
+
+XDB_PUBLIC(void) xdb_free_content(void *);
+
+// --- xdb verify
+
+// Verify if the current Searcher could be used to search the specified xdb file.
+// Why do we need this check ?
+// The future features of the xdb impl may cause the current searcher not able to work properly.
+//
+// @Note: You Just need to check this ONCE when the service starts
+// Or use another process (eg, A command) to check once Just to confirm the suitability.
+XDB_PUBLIC(int) xdb_verify(FILE *);
+
+XDB_PUBLIC(int) xdb_verify_from_header(FILE *handle, xdb_header_t *);
+
+XDB_PUBLIC(int) xdb_verify_from_file(const char *);
+
+// --- End xdb buffer
+
+
+// types type define
+typedef char string_ip_t;
+typedef unsigned char bytes_ip_t;
+
+// --- ip version
+#define XDB_IPv4 (xdb_version_v4())
+#define XDB_IPv6 (xdb_version_v6())
+typedef int (* ip_compare_fn_t) (const bytes_ip_t *, int, const char *, int);
+struct xdb_ip_version_entry {
+    int id;                 // version id
+    char *name;             // version name
+    int bytes;              // ip bytes number
+    int segment_index_size; // segment index size in bytes
+
+    // function to compare two ips
+    ip_compare_fn_t ip_compare;
+};
+typedef struct xdb_ip_version_entry xdb_version_t;
+
+XDB_PUBLIC(xdb_version_t *) xdb_version_v4();
+XDB_PUBLIC(xdb_version_t *) xdb_version_v6();
+
+XDB_PUBLIC(int) xdb_version_is_v4(const xdb_version_t *);
+XDB_PUBLIC(int) xdb_version_is_v6(const xdb_version_t *);
+
+XDB_PUBLIC(xdb_version_t *) xdb_version_from_name(char *);
+XDB_PUBLIC(xdb_version_t *) xdb_version_from_header(xdb_header_t *);
+
+// --- END ip version
+
+// --- xdb util functions
+
+// to compatiable with the windows
+// returns: 0 for ok and -1 for failed
+XDB_PUBLIC(int) xdb_init_winsock();
+XDB_PUBLIC(void) xdb_clean_winsock();
+
+// get the current time in microseconds
+XDB_PUBLIC(long) xdb_now();
+
+// get unsigned long (4bytes) from a specified buffer start from the specified offset with little-endian
+XDB_PUBLIC(unsigned int) xdb_le_get_uint32(const char *, int);
+
+// get unsigned short (2bytes) from a specified buffer start from the specified offset with little-endian
+XDB_PUBLIC(int) xdb_le_get_uint16(const char *, int);
+
+
+// parse the specified IP address to byte array.
+// returns: xdb_version_t for valid ipv4 / ipv6, or NULL for failed
+XDB_PUBLIC(xdb_version_t *) xdb_parse_ip(const string_ip_t *, bytes_ip_t *, size_t);
+
+// parse the specified IPv4 address to byte array
+// returns: xdb_version_t for valid ipv4, or NULL for failed
+XDB_PUBLIC(xdb_version_t *) xdb_parse_v4_ip(const string_ip_t *, bytes_ip_t *, size_t);
+
+// parse the specified IPv6 address to byte array
+// returns: xdb_version_t for valid ipv6, or NULL for failed
+XDB_PUBLIC(xdb_version_t *) xdb_parse_v6_ip(const string_ip_t *, bytes_ip_t *, size_t);
+
+// convert a specified ip bytes to humen-readable string.
+// returns: 0 for success or -1 for failed.
+XDB_PUBLIC(int) xdb_ip_to_string(const bytes_ip_t *, int, char *, size_t);
+
+// ipv4 bytes to string
+XDB_PUBLIC(int) xdb_v4_ip_to_string(const bytes_ip_t *, char *, size_t);
+
+// ipv6 bytes to string
+XDB_PUBLIC(int) xdb_v6_ip_to_string(const bytes_ip_t *, char *, size_t);
+
+// compare the specified ip bytes with another ip bytes in the specified buff from offset.
+// ip args must be the return value from #xdb_parse_ip.
+// returns: -1 if ip1 < ip2, 1 if ip1 > ip2 or 0
+XDB_PUBLIC(int) xdb_ip_sub_compare(const bytes_ip_t *, int, const char *, int);
+
+// --- END xdb utils
+
+
+// --- xdb searcher api
+
+// xdb region info structure
+#define xdb_region_buffer_wrapper 1
+#define xdb_region_buffer_auto    2
+struct xdb_region_buffer_entry {
+    int type;           // buffer type
+    char *value;        // region value
+    size_t length;      // buffer length
+};
+typedef struct xdb_region_buffer_entry xdb_region_buffer_t;
+
+// wrapper the region from a local stack buffer.
+// returns: 0 for succeed or failed
+XDB_PUBLIC(int) xdb_region_buffer_init(xdb_region_buffer_t *, char *, size_t);
+
+// do the buffer alloc.
+// returns: 0 for ok or failed
+XDB_PUBLIC(int) xdb_region_buffer_alloc(xdb_region_buffer_t *, int);
+
+XDB_PUBLIC(void) xdb_region_buffer_free(xdb_region_buffer_t *);
+
+// xdb searcher structure
+struct xdb_searcher_entry {
+    // ip version
+    xdb_version_t *version;
+
+    // xdb file handle
+    FILE *handle;
+
+    // header info
+    const char *header;
+    int io_count;
+
+    // vector index buffer cache.
+    // preload the vector index will reduce the number of IO operations
+    // thus speedup the search process.
+    const xdb_vector_index_t *v_index;
+
+    // content buffer.
+    // cache the whole xdb content.
+    const xdb_content_t *content;
+};
+typedef struct xdb_searcher_entry xdb_searcher_t;
+
+// xdb searcher new api define
+XDB_PUBLIC(int) xdb_new_with_file_only(xdb_version_t *, xdb_searcher_t *, const char *);
+
+XDB_PUBLIC(int) xdb_new_with_vector_index(xdb_version_t *, xdb_searcher_t *, const char *, const xdb_vector_index_t *);
+
+XDB_PUBLIC(int) xdb_new_with_buffer(xdb_version_t *, xdb_searcher_t *, const xdb_content_t *);
+
+XDB_PUBLIC(void) xdb_close(void *);
+
+// xdb searcher search api define
+XDB_PUBLIC(int) xdb_search_by_string(xdb_searcher_t *, const string_ip_t *, xdb_region_buffer_t *);
+
+XDB_PUBLIC(int) xdb_search(xdb_searcher_t *, const bytes_ip_t *, int, xdb_region_buffer_t *);
+
+XDB_PUBLIC(xdb_version_t *) xdb_get_version(xdb_searcher_t *);
+
+XDB_PUBLIC(int) xdb_get_io_count(xdb_searcher_t *);
+
+// --- END xdb searcher api
+
+#endif // C_IP2REGION_XDB_H

package/ip2region/xdb_searcher.c

@@ -0,0 +1,242 @@
+// Copyright 2022 The Ip2Region Authors. All rights reserved.
+// Use of this source code is governed by a Apache2.0-style
+// license that can be found in the LICENSE file.
+
+// ---
+// @Author Lion <chenxin619315@gmail.com>
+// @Date   2022/06/27
+
+#include "xdb_api.h"
+
+// --- region buffer
+XDB_PUBLIC(int) xdb_region_buffer_init(xdb_region_buffer_t *region, char *buffer, size_t length) {
+    if (buffer == NULL) {
+        region->type   = xdb_region_buffer_auto;
+        region->length = 0;
+    } else if (length <= 0) {
+        return 1;
+    } else {
+        region->type   = xdb_region_buffer_wrapper;
+        region->length = length;
+        memset(buffer, 0x00, length);   // zero-fill the buffer
+    }
+
+    region->value = buffer;
+    return 0;
+}
+
+XDB_PUBLIC(int) xdb_region_buffer_alloc(xdb_region_buffer_t *region, int length) {
+    if (length <= 0) {
+        return 1;
+    }
+
+    // no allocation supports for the buffer wapper
+    if (region->type == xdb_region_buffer_wrapper) {
+        if (length >= region->length) {
+            return 2;
+        }
+
+        region->value[length] = '\0';
+        return 0;
+    }
+
+    // ensure that the value were freed
+    // by calling #xdb_region_buffer_free
+    if (region->value != NULL) {
+        return 3;
+    }
+
+    char *ptr = (char *) xdb_malloc(length + 1);
+    if (ptr == NULL) {
+        return 4;
+    }
+
+    ptr[length]    = '\0';  // NULL-end
+    region->value  = ptr;
+    region->length = length;
+    return 0;
+}
+
+XDB_PUBLIC(void) xdb_region_buffer_free(xdb_region_buffer_t *region) {
+    if (region->type == xdb_region_buffer_auto) {
+        xdb_free(region->value);
+        region->value = NULL;
+    }
+}
+
+// --- END region buffer
+
+// internal function prototype define
+XDB_PRIVATE(int) read(xdb_searcher_t *, long offset, char *, size_t length);
+
+XDB_PRIVATE(int) xdb_new_base(xdb_version_t *version, xdb_searcher_t *xdb, const char *db_path, const xdb_vector_index_t *v_index, const xdb_content_t *c_buffer) {
+    memset(xdb, 0x00, sizeof(xdb_searcher_t));
+
+    // set the version
+    xdb->version = version;
+
+    // check the content buffer first
+    if (c_buffer != NULL) {
+        xdb->v_index = NULL;
+        xdb->content = c_buffer;
+        return 0;
+    }
+
+    // open the xdb binary file
+    FILE *handle = fopen(db_path, "rb");
+    if (handle == NULL) {
+        return 1;
+    }
+
+    xdb->handle = handle;
+    xdb->v_index = v_index;
+
+    return 0;
+}
+
+// xdb searcher new api define
+XDB_PUBLIC(int) xdb_new_with_file_only(xdb_version_t *version, xdb_searcher_t *xdb, const char *db_path) {
+    return xdb_new_base(version, xdb, db_path, NULL, NULL);
+}
+
+XDB_PUBLIC(int) xdb_new_with_vector_index(xdb_version_t *version, xdb_searcher_t *xdb, const char *db_path, const xdb_vector_index_t *v_index) {
+    return xdb_new_base(version, xdb, db_path, v_index, NULL);
+}
+
+XDB_PUBLIC(int) xdb_new_with_buffer(xdb_version_t *version, xdb_searcher_t *xdb, const xdb_content_t *c_buffer) {
+    return xdb_new_base(version, xdb, NULL, NULL, c_buffer);
+}
+
+XDB_PUBLIC(void) xdb_close(void *ptr) {
+    xdb_searcher_t *xdb = (xdb_searcher_t *) ptr;
+    if (xdb->handle != NULL) {
+        fclose(xdb->handle);
+        xdb->handle = NULL;
+    }
+}
+
+// --- xdb searcher search api define
+
+XDB_PUBLIC(int) xdb_search_by_string(xdb_searcher_t *xdb, const string_ip_t *ip_string, xdb_region_buffer_t *region) {
+    bytes_ip_t ip_bytes[16] = {'\0'};
+    xdb_version_t *version = xdb_parse_ip(ip_string, ip_bytes, sizeof(ip_bytes));
+    if (version == NULL) {
+        return 10;
+    } else {
+        return xdb_search(xdb, ip_bytes, version->bytes, region);
+    }
+}
+
+XDB_PUBLIC(int) xdb_search(xdb_searcher_t *xdb, const bytes_ip_t *ip_bytes, int ip_len, xdb_region_buffer_t *region) {
+    int il0, il1, idx, err, bytes, d_bytes;
+    register int seg_index_size, l, h, m, p;
+    unsigned int s_ptr, e_ptr, data_ptr, data_len;
+    char vector_buffer[xdb_vector_index_size];
+    char segment_buffer[xdb_v6_index_size];
+
+    // ip version check
+    if (ip_len != xdb->version->bytes) {
+        return -1;
+    }
+
+    // some resets
+    err = 0;
+    data_len = 0;
+    bytes   = xdb->version->bytes;
+    d_bytes = xdb->version->bytes << 1;
+    xdb->io_count = 0;
+
+    // locate the segment index block based on the vector index
+    il0 = (int) (ip_bytes[0]);
+    il1 = (int) (ip_bytes[1]);
+    idx = il0 * xdb_vector_index_cols * xdb_vector_index_size + il1 * xdb_vector_index_size;
+    if (xdb->v_index != NULL) {
+        s_ptr = xdb_le_get_uint32(xdb->v_index->buffer, idx);
+        e_ptr = xdb_le_get_uint32(xdb->v_index->buffer, idx + 4);
+    } else if (xdb->content != NULL) {
+        s_ptr = xdb_le_get_uint32(xdb->content->buffer, xdb_header_info_length + idx);
+        e_ptr = xdb_le_get_uint32(xdb->content->buffer, xdb_header_info_length + idx + 4);
+    } else {
+        err = read(xdb, xdb_header_info_length + idx, vector_buffer, sizeof(vector_buffer));
+        if (err != 0) {
+            return 10 + err;
+        }
+
+        s_ptr = xdb_le_get_uint32(vector_buffer, 0);
+        e_ptr = xdb_le_get_uint32(vector_buffer, 4);
+    }
+
+    // printf("s_ptr=%u, e_ptr=%u\n", s_ptr, e_ptr);
+    // binary search to get the final region info
+    // segment_buffer = xdb_malloc(seg_index_size);
+    seg_index_size = xdb->version->segment_index_size;
+    data_len = 0, data_ptr = 0;
+    l = 0, h = ((int) (e_ptr - s_ptr)) / seg_index_size;
+    while (l <= h) {
+        m = (l + h) >> 1;
+        p = s_ptr + m * seg_index_size;
+
+        // read the segment index item
+        err = read(xdb, p, segment_buffer, seg_index_size);
+        if (err != 0) {
+            return 20 + err;
+        }
+
+        // decode the data fields as needed
+        if (xdb->version->ip_compare(ip_bytes, bytes, segment_buffer, 0) < 0) {
+            h = m - 1;
+        } else if (xdb->version->ip_compare(ip_bytes, bytes, segment_buffer, bytes) > 0) {
+            l = m + 1;
+        } else {
+            data_len = xdb_le_get_uint16(segment_buffer, d_bytes);
+            data_ptr = xdb_le_get_uint32(segment_buffer, d_bytes + 2);
+            break;
+        }
+    }
+
+    // printf("data_len=%u, data_ptr=%u\n", data_len, data_ptr);
+    if (data_len == 0) {
+        return 100;
+    }
+
+    // buffer alloc checking
+    err = xdb_region_buffer_alloc(region, data_len);
+    if (err != 0) {
+        return 100 + err;
+    }
+
+    err = read(xdb, data_ptr, region->value, data_len);
+    if (err != 0) {
+        return 30 + err;
+    }
+
+    return err;
+}
+
+XDB_PRIVATE(int) read(xdb_searcher_t *xdb, long offset, char *buffer, size_t length) {
+    // check the xdb content cache first
+    if (xdb->content != NULL) {
+        memcpy(buffer, xdb->content->buffer + offset, length);
+        return 0;
+    }
+
+    // seek to the offset
+    if (fseek(xdb->handle, offset, SEEK_SET) == -1) {
+        return 1;
+    }
+
+    xdb->io_count++;
+    if (fread(buffer, 1, length, xdb->handle) != length) {
+        return 2;
+    }
+
+    return 0;
+}
+
+XDB_PUBLIC(xdb_version_t *) xdb_get_version(xdb_searcher_t *xdb) {
+    return xdb->version;
+}
+
+XDB_PUBLIC(int) xdb_get_io_count(xdb_searcher_t *xdb) {
+    return xdb->io_count;
+}