ip2region_ext 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29c808556500f049f3e21908c35fbb809b992874f21f9cf81478c862d541f0f0
+  data.tar.gz: e40d4f499e75a22adea750e529dbaee7be7ad25b0549ba9b4c0d703596593c60
+SHA512:
+  metadata.gz: '048a8fdd7e4942b348ce08f1d3d962c2bdb3d64535b86471200b569ef427bb82be6a9913f6aa83462247acc6af78c8a475d8bba7ae0d15fe4492a93b3d80293c'
+  data.tar.gz: c89112c8ea4797e9e5288ad8c906042dd532a1e1440937ed04dba94a84877cc3c073fb78c4c0597744c5a46b5b59edfe5268b8ab936cf44543fc1c9b0657fd01

data/README.md

@@ -0,0 +1,34 @@
+
+# Ip2regionExt
+
+## 介绍
+
+这是一个ip2region库c客户端的ruby ffi扩展,  基于 [lionsoul2014/ip2region](https://github.com/lionsoul2014/ip2region) 最新版本开发
+
+直接调用c原生api,充分发挥IO操作的性能优势
+
+## 安装
+`gem install ip2region_ext`
+## 使用
+
+```ruby
+require 'ip2region_ext'
+
+# 查询
+#db_type = :file|:index|:cache
+#Ip2regionExt.connect({db_type: :index, db_path: "/var/ip2region.xdb"})
+Ip2regionExt.connect({db_type: :index})
+p Ip2regionExt.search('114.114.114.114')
+Ip2regionExt.close
+# => "中国|0|辽宁省|丹东市|联通"
+
+```
+
+## 如何下载外挂 xdb 文件
+
+下载这个文件 [https://github.com/lionsoul2014/ip2region/blob/master/data/ip2region.xdb](https://github.com/lionsoul2014/ip2region/blob/master/data/ip2region.xdb)
+
+
+## 协议
+
+MIT 协议

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/ext/ip2region/extconf.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'mkmf'
+
+extension_name = 'libip2region_ext'
+dir_config(extension_name)
+
+create_makefile(extension_name)
+

data/ext/ip2region/xdb_searcher.c

@@ -0,0 +1,428 @@
+// 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_searcher.h"
+
+// for Linux
+#ifdef XDB_LINUX
+#include "sys/time.h"
+#endif
+
+// @Note: since 2023/10/13 to compatible with the windows system
+#ifdef XDB_WINDOWS
+#include <windows.h>
+XDB_PRIVATE(int) gettimeofday(struct timeval* tp, void* tzp) {
+    FILETIME ft;
+    ULARGE_INTEGER uint64;
+    long long ns100 = 116444736000000000LL;
+
+    GetSystemTimeAsFileTime(&ft);
+    uint64.LowPart = ft.dwLowDateTime;
+    uint64.HighPart = ft.dwHighDateTime;
+    uint64.QuadPart -= ns100;
+    uint64.QuadPart /= 10;
+
+    tp->tv_sec = uint64.QuadPart / 1000000;
+    tp->tv_usec = uint64.QuadPart % 1000000;
+
+    return 0;
+}
+#endif
+
+
+// internal function prototype define
+XDB_PRIVATE(int) read(xdb_searcher_t *, long offset, char *, size_t length);
+
+XDB_PRIVATE(int) xdb_new_base(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));
+
+    // 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_searcher_t *xdb, const char *db_path) {
+    return xdb_new_base(xdb, db_path, NULL, NULL);
+}
+
+XDB_PUBLIC(int) xdb_new_with_vector_index(xdb_searcher_t *xdb, const char *db_path, const xdb_vector_index_t *v_index) {
+    return xdb_new_base(xdb, db_path, v_index, NULL);
+}
+
+XDB_PUBLIC(int) xdb_new_with_buffer(xdb_searcher_t *xdb, const xdb_content_t *c_buffer) {
+    return xdb_new_base(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 char *str_ip, char *region_buffer, size_t length) {
+    unsigned int ip = 0;
+    int errcode = xdb_check_ip(str_ip, &ip);
+    if (errcode != 0) {
+        return 10 + errcode;
+    } else {
+        return xdb_search(xdb, ip, region_buffer, length);
+    }
+}
+
+XDB_PUBLIC(int) xdb_search(xdb_searcher_t *xdb, unsigned int ip, char *region_buffer, size_t length) {
+    int il0, il1, idx, err, l, h, m, data_len;
+    unsigned int s_ptr, e_ptr, p, sip, eip, data_ptr;
+    char vector_buffer[xdb_vector_index_size], segment_buffer[xdb_segment_index_size];
+
+    // reset the io counter
+    xdb->io_count = 0;
+
+    // locate the segment index block based on the vector index
+    il0 = ((int) (ip >> 24)) & 0xFF;
+    il1 = ((int) (ip >> 16)) & 0xFF;
+    idx = il0 * xdb_vector_index_cols * xdb_vector_index_size + il1 * xdb_vector_index_size;
+    if (xdb->v_index != NULL) {
+        s_ptr = xdb_get_uint(xdb->v_index->buffer, idx);
+        e_ptr = xdb_get_uint(xdb->v_index->buffer, idx + 4);
+    } else if (xdb->content != NULL) {
+        s_ptr = xdb_get_uint(xdb->content->buffer, xdb_header_info_length + idx);
+        e_ptr = xdb_get_uint(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_get_uint(vector_buffer, 0);
+        e_ptr = xdb_get_uint(vector_buffer, 4);
+    }
+
+    // printf("s_ptr=%u, e_ptr=%u\n", s_ptr, e_ptr);
+    // binary search to get the final region info
+    data_len = 0, data_ptr = 0;
+    l = 0, h = ((int) (e_ptr - s_ptr)) / xdb_segment_index_size;
+    while (l <= h) {
+        m = (l + h) >> 1;
+        p = s_ptr + m * xdb_segment_index_size;
+
+        // read the segment index item
+        err = read(xdb, p, segment_buffer, sizeof(segment_buffer));
+        if (err != 0) {
+            return 20 + err;
+        }
+
+        // decode the data fields as needed
+        sip = xdb_get_uint(segment_buffer, 0);
+        if (ip < sip) {
+            h = m - 1;
+        } else {
+            eip = xdb_get_uint(segment_buffer, 4);
+            if (ip > eip) {
+                l = m + 1;
+            } else {
+                data_len = xdb_get_ushort(segment_buffer, 8);
+                data_ptr = xdb_get_uint(segment_buffer, 10);
+                break;
+            }
+        }
+    }
+
+    // printf("data_len=%u, data_ptr=%u\n", data_len, data_ptr);
+    if (data_len == 0) {
+        region_buffer[0] = '\0';
+        return 0;
+    }
+
+    // buffer length checking
+    if (data_len >= (int) length) {
+        return 1;
+    }
+
+    err = read(xdb, data_ptr, region_buffer, data_len);
+    if (err != 0) {
+        return 30 + err;
+    }
+
+    // auto append a NULL-end
+    region_buffer[data_len] = '\0';
+    return 0;
+}
+
+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(int) xdb_get_io_count(xdb_searcher_t *xdb) {
+    return xdb->io_count;
+}
+
+
+// --- buffer load util functions
+
+XDB_PUBLIC(xdb_header_t *) xdb_load_header(FILE *handle) {
+    xdb_header_t *header;
+    unsigned int size = xdb_header_info_length;
+
+    // entry alloc
+    header = (xdb_header_t *) xdb_malloc(sizeof(xdb_header_t));
+    if (header == NULL) {
+        return NULL;
+    }
+
+    if (fseek(handle, 0, SEEK_SET) == -1) {
+        xdb_free(header);
+        return NULL;
+    }
+
+    if (fread(header->buffer, 1,size, handle) != size) {
+        xdb_free(header);
+        return NULL;
+    }
+
+    // fill the fields
+    header->length = size;
+    header->version = (unsigned short) xdb_get_ushort(header->buffer, 0);
+    header->index_policy = (unsigned short) xdb_get_ushort(header->buffer, 2);
+    header->created_at = xdb_get_uint(header->buffer, 4);
+    header->start_index_ptr = xdb_get_uint(header->buffer, 8);
+    header->end_index_ptr = xdb_get_uint(header->buffer,12);
+
+    return header;
+}
+
+XDB_PUBLIC(xdb_header_t *) xdb_load_header_from_file(const char *db_path) {
+    xdb_header_t *header;
+    FILE *handle = fopen(db_path, "rb");
+    if (handle == NULL) {
+        return NULL;
+    }
+
+    header = xdb_load_header(handle);
+    fclose(handle);
+    return header;
+}
+
+XDB_PUBLIC(void) xdb_close_header(void *ptr) {
+    xdb_header_t *header = (xdb_header_t *) ptr;
+    if (header->length > 0) {
+        header->length = 0;
+        xdb_free(header);
+    }
+}
+
+// --- vector index
+
+XDB_PUBLIC(xdb_vector_index_t *) xdb_load_vector_index(FILE *handle) {
+    xdb_vector_index_t *v_index;
+    unsigned int size = xdb_vector_index_length;
+
+    // seek to the vector index offset
+    if (fseek(handle, xdb_header_info_length, SEEK_SET) == -1) {
+        return NULL;
+    }
+
+    // do the buffer read
+    v_index = (xdb_vector_index_t *) xdb_malloc(sizeof(xdb_vector_index_t));
+    if (v_index == NULL) {
+        return NULL;
+    }
+
+    v_index->length = size;
+    if (fread(v_index->buffer, 1, size, handle) != size) {
+        xdb_free(v_index);
+        return NULL;
+    }
+
+    return v_index;
+}
+
+XDB_PUBLIC(xdb_vector_index_t *) xdb_load_vector_index_from_file(const char *db_path) {
+    xdb_vector_index_t *v_index;
+    FILE *handle = fopen(db_path, "rb");
+    if (handle == NULL) {
+        return NULL;
+    }
+
+    v_index = xdb_load_vector_index(handle);
+    fclose(handle);
+    return v_index;
+}
+
+XDB_PUBLIC(void) xdb_close_vector_index(void *ptr) {
+    xdb_vector_index_t *v_index = (xdb_vector_index_t *) ptr;
+    if (v_index->length > 0) {
+        v_index->length = 0;
+        xdb_free(v_index);
+    }
+}
+
+// --- content buffer
+
+XDB_PUBLIC(xdb_content_t *) xdb_load_content(FILE *handle) {
+    unsigned int size;
+    xdb_content_t *content;
+
+    // determine the file size
+    if (fseek(handle, 0, SEEK_END) == -1) {
+        return NULL;
+    }
+
+    size = (unsigned int) ftell(handle);
+    if (fseek(handle, 0, SEEK_SET) == -1) {
+        return NULL;
+    }
+
+    // do the file read
+    content = (xdb_content_t *) xdb_malloc(sizeof(xdb_content_t));
+    if (content == NULL) {
+        return NULL;
+    }
+
+    // do the buffer alloc
+    content->buffer = (char *) xdb_malloc(size);
+    if (content->buffer == NULL) {
+        xdb_free(content);
+        return NULL;
+    }
+
+    // read the content into the buffer
+    content->length = size;
+    if (fread(content->buffer, 1, size, handle) != size) {
+        xdb_free(content);
+        return NULL;
+    }
+
+    return content;
+}
+
+XDB_PUBLIC(xdb_content_t *) xdb_load_content_from_file(const char *db_path) {
+    xdb_content_t *content;
+    FILE *handle = fopen(db_path, "rb");
+    if (handle == NULL) {
+        return NULL;
+    }
+
+    content = xdb_load_content(handle);
+    fclose(handle);
+    return content;
+}
+
+XDB_PUBLIC(void) xdb_close_content(void *ptr) {
+    xdb_content_t *content = (xdb_content_t *) ptr;
+    if (content->length > 0) {
+        content->length = 0;
+        xdb_free(content->buffer);
+        content->buffer = NULL;
+        xdb_free(content);
+    }
+}
+
+// --- End
+
+// get unsigned long (4bytes) from a specified buffer start from the specified offset
+XDB_PUBLIC(unsigned int) xdb_get_uint(const char *buffer, int offset) {
+    return (
+        ((buffer[offset  ]) & 0x000000FF) |
+        ((buffer[offset+1] <<  8) & 0x0000FF00) |
+        ((buffer[offset+2] << 16) & 0x00FF0000) |
+        ((buffer[offset+3] << 24) & 0xFF000000)
+    );
+}
+
+// get unsigned short (2bytes) from a specified buffer start from the specified offset
+XDB_PUBLIC(int) xdb_get_ushort(const char *buffer, int offset) {
+    return (
+        ((buffer[offset  ]) & 0x000000FF) |
+        ((buffer[offset+1] << 8) & 0x0000FF00)
+    );
+}
+
+// string ip to unsigned int
+static int shiftIndex[4] = {24, 16, 8, 0};
+XDB_PUBLIC(int) xdb_check_ip(const char *src_ip, unsigned int *dst_ip) {
+    char c;
+    int i, n, ip = 0;
+    const char *ptr = src_ip;
+    for (i = 0; i < 4; i++) {
+        n = 0;
+        while (1) {
+            c = *ptr;
+            ptr++;
+            if (c >= '0' && c <= '9') {
+                n *= 10;
+                n += c - '0';
+            } else if ((i < 3 && c == '.') || i == 3) {
+                // stopping at the '.' but ignore the tailing chars
+                // after the 3rd one (auto clean the tailing none-integer ?).
+                break;
+            } else {
+                return 1;
+            }
+        }
+
+        if (n > 0xFF) {
+            return 2;
+        }
+
+        ip |= (n << shiftIndex[i]);
+    }
+
+    *dst_ip = ip;
+    return 0;
+}
+
+// unsigned int ip to string ip
+XDB_PUBLIC(void) xdb_long2ip(unsigned int ip, char *buffer) {
+    sprintf(buffer, "%d.%d.%d.%d", (ip >> 24) & 0xFF, (ip >> 16) & 0xFF, (ip >> 8) & 0xFF, ip & 0xFF);
+}
+
+// get the middle ip of a and b
+XDB_PUBLIC(unsigned int) xdb_mip(unsigned long a, unsigned long b) {
+    return (unsigned int) ((a + b) >> 1);
+}
+
+XDB_PUBLIC(long) xdb_now() {
+    struct timeval c_time;
+    gettimeofday(&c_time, NULL);
+    return c_time.tv_sec * (int)1e6 + c_time.tv_usec;
+}

data/ext/ip2region/xdb_searcher.h

@@ -0,0 +1,149 @@
+// 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_XDB_SEARCHER_H
+#define C_XDB_SEARCHER_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
+#elif ( defined(linux) || defined(_UNIX) || defined(__APPLE__) )
+#   define XDB_PUBLIC(type)    extern type
+#   define XDB_PRIVATE(type)   static inline type
+#   define XDB_LINUX
+#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_header_info_length 256
+#define xdb_vector_index_rows  256
+#define xdb_vector_index_cols  256
+#define xdb_vector_index_size  8
+#define xdb_segment_index_size 14
+
+// cache of vector_index_row × vector_index_rows × vector_index_size
+#define xdb_vector_index_length 524288
+
+
+// --- buffer load util 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;
+
+    // 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_close_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_close_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_close_content(void *);
+
+// --- End buffer load
+
+// xdb searcher structure
+struct xdb_searcher_entry {
+    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_searcher_t *, const char *);
+
+XDB_PUBLIC(int) xdb_new_with_vector_index(xdb_searcher_t *, const char *, const xdb_vector_index_t *);
+
+XDB_PUBLIC(int) xdb_new_with_buffer(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 char *, char *, size_t);
+
+XDB_PUBLIC(int) xdb_search(xdb_searcher_t *, unsigned int, char *, size_t);
+
+XDB_PUBLIC(int) xdb_get_io_count(xdb_searcher_t *);
+
+
+// get unsigned long (4bytes) from a specified buffer start from the specified offset with little-endian
+XDB_PUBLIC(unsigned int) xdb_get_uint(const char *, int);
+
+// get unsigned short (2bytes) from a specified buffer start from the specified offset with little-endian
+XDB_PUBLIC(int) xdb_get_ushort(const char *, int);
+
+// check the specified string ip and convert it to an unsigned int
+XDB_PUBLIC(int) xdb_check_ip(const char *, unsigned int *);
+
+// unsigned int ip to string ip
+XDB_PUBLIC(void) xdb_long2ip(unsigned int, char *);
+
+// get the middle ip of a and b
+XDB_PUBLIC(unsigned int) xdb_mip(unsigned long, unsigned long);
+
+// get the current time in microseconds
+XDB_PUBLIC(long) xdb_now();
+
+
+#endif //C_XDB_SEARCHER_H

data/lib/ip2region_ext/ip2region_ffi.rb

@@ -0,0 +1,53 @@
+require 'ffi'
+
+module Ip2regionExt
+  extend FFI::Library
+  ffi_lib File.join(__dir__, '../','libip2region_ext.so')
+
+  XDB_HEADER_INFO_LENGTH = 256
+  XDB_VECTOR_INDEX_LENGTH = 524288
+
+  class XdbHeaderT < FFI::Struct
+    layout :version, :ushort,
+           :index_policy, :ushort,
+           :created_at, :uint,
+           :start_index_ptr, :uint,
+           :end_index_ptr, :uint,
+           :length, :uint,
+           :buffer, [:char, XDB_HEADER_INFO_LENGTH] # xdb_header_info_length 需要替换为实际的值
+  end
+
+  class XdbVectorIndexT < FFI::Struct
+    layout :length, :uint,
+           :buffer, [:char, XDB_VECTOR_INDEX_LENGTH]
+  end
+
+  class XdbContentT < FFI::Struct
+    layout :length, :uint,
+           :buffer, :pointer
+  end
+
+  class XdbSearcherT < FFI::Struct
+    layout :handle, :pointer,
+           :header, :string,
+           :io_count, :int,
+           :v_index, :pointer, # 指向 xdb_vector_index_t 结构体的指针
+           :content, :pointer   # 指向 xdb_content_t 结构体的指针
+  end
+
+  #attach_function :xdb_load_content_from_file, [:string], XdbContentT.ptr
+  attach_function :xdb_new_with_file_only, [:pointer, :string], :int
+  attach_function :xdb_check_ip, [:string, :pointer], :int
+  attach_function :xdb_search_by_string, [ :pointer, :string, :pointer, :size_t ], :int
+  #attach_function :xdb_search, [:pointer, :uint, :string, :size_t], :int
+  attach_function :xdb_close, [:pointer], :void
+  attach_function :xdb_load_vector_index_from_file, [:string], XdbVectorIndexT.ptr
+  attach_function :xdb_new_with_vector_index, [:pointer, :string, :pointer], :int
+  attach_function :xdb_close_vector_index, [:pointer], :void
+  attach_function :xdb_load_content_from_file, [:string], :pointer
+  attach_function :xdb_new_with_buffer, [:pointer, :pointer], :int
+  attach_function :xdb_close_content, [:pointer], :void
+
+
+end
+

data/lib/ip2region_ext/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ip2regionExt
+  VERSION = "0.1.0"
+end

data/lib/ip2region_ext/xdb.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require 'singleton'
+module Ip2regionExt
+  class Xdb
+    include Singleton
+
+    def connect(opt = {})
+      @option = {db_path: nil, db_type: :file}.merge(opt)
+      @searcher =  XdbSearcherT.new()
+      #@vector_index = XdbVectorIndexT.new()
+      #@content = XdbContentT.new()
+
+      case @option[:db_type]
+      when :file
+        load_by_file
+      when :index
+        load_by_index
+      when :cache
+        load_by_cache
+      else
+        load_by_file
+      end
+    end
+
+    def load_by_file
+      err = Ip2regionExt.xdb_new_with_file_only(@searcher, @option[:db_path])
+      raise Error.new("failed to create xdb searcher from `#{@option[:db_path]}` with errno=#{err}\n") if err != 0
+    end
+
+    def load_by_index
+      @vector_index = Ip2regionExt.xdb_load_vector_index_from_file(@option[:db_path])
+      raise Error.new("failed to load vector index from `#{@option[:db_path]}`\n") unless @vector_index
+
+      err = Ip2regionExt.xdb_new_with_vector_index(@searcher.pointer, @option[:db_path], @vector_index)
+      raise Error.new("failed to create vector index cached searcher with errno=#{err}\n") if err != 0
+    end
+
+    def load_by_cache
+      @content = Ip2regionExt.xdb_load_content_from_file(@option[:db_path])
+      raise Error.new("failed to load xdb content from `#{}`\n") unless @content
+
+      err = Ip2regionExt.xdb_new_with_buffer(@searcher, @content)
+      raise Error.new("failed to create content cached searcher with errno=#{err}\n") if err != 0
+    end
+
+    def query(ip_address)
+      region_buffer = FFI::MemoryPointer.new(:char, 256)
+      err = Ip2regionExt.xdb_search_by_string(@searcher, ip_address, region_buffer, region_buffer.size)
+      raise Error.new("failed search(#{ip_address}) with errno=#{err}\n") if err != 0
+      region_buffer.read_string.force_encoding('UTF-8')
+    end
+
+    def close
+      Ip2regionExt.xdb_close(@searcher)
+      Ip2regionExt.xdb_close_vector_index(@vector_index) if @option[:db_type] == :index
+      Ip2regionExt.xdb_close_content(@content) if @option[:db_type] == :cache
+    end
+
+    def check_ip(ip_address)
+      result = FFI::MemoryPointer.new(:int)
+      err = Ip2regionExt.xdb_check_ip(ip_address, result)
+      raise Error.new("failed check ip(#{ip_address}) with errno=#{err}\n") if err != 0
+      result.get_int(0)
+    end
+
+
+  end
+
+end
+

data/lib/ip2region_ext.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "ip2region_ext/version"
+require_relative 'ip2region_ext/ip2region_ffi'
+require_relative 'ip2region_ext/xdb'
+
+module Ip2regionExt
+  class Error < StandardError; end
+
+  @@xdb_path = File.join(__dir__, '../db','ip2region.xdb')
+
+  def self.connect(option = {})
+    option[:db_path] ||= @@xdb_path
+    Xdb.instance.connect(option)
+  end
+
+  def self.search(ip_address)
+    Xdb.instance.query(ip_address)
+  end
+
+  def self.close
+    Xdb.instance.close
+  end
+
+
+end

data/sig/ip2region.rbs

@@ -0,0 +1,4 @@
+module Ip2region
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ip2region_ext
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- songgz
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 直接调用c原生api,充分发挥IO操作的性能优势
+email:
+- sgzhe@163.com
+executables: []
+extensions:
+- ext/ip2region/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- db/ip2region.xdb
+- ext/ip2region/extconf.rb
+- ext/ip2region/xdb_searcher.c
+- ext/ip2region/xdb_searcher.h
+- lib/ip2region_ext.rb
+- lib/ip2region_ext/ip2region_ffi.rb
+- lib/ip2region_ext/version.rb
+- lib/ip2region_ext/xdb.rb
+- sig/ip2region.rbs
+homepage: https://github.com/songgz/ip2region_ext
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/songgz/ip2region_ext
+  source_code_uri: https://github.com/songgz/ip2region_ext
+  changelog_uri: https://github.com/songgz/ip2region_ext
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.10
+signing_key:
+specification_version: 4
+summary: 这是一个ip2region库c客户端的ruby ffi扩展
+test_files: []