geoipdb 0.5.5-java

data/ext/geoipdb/ipdb.h

@@ -0,0 +1,84 @@
+#ifdef INT_2_BYTES
+typedef char int8;
+typedef int int16;
+typedef unsigned int uint16;
+typedef long int32;
+#else
+typedef char int8;
+typedef short int16;
+typedef unsigned short uint16;
+typedef int int32;
+#endif
+
+#ifdef RSTRING_PTR
+#else
+# define RSTRING_LEN(x) (RSTRING(x)->len)
+# define RSTRING_PTR(x) (RSTRING(x)->ptr)
+#endif
+
+#define RANGES_DELIM ",\n"
+#define CITIES_DELIM ",\n"
+
+#define MAX_CITIES_COUNT 1000000 //Usually we have about 120 000 Cities
+#define MAX_RANGES_COUNT 10000000 //Usually we have about 6 Mio IP-Ranges
+
+#define MAX_ISPS_COUNT 65535
+#define MAX_ISP_NAME_LENGTH 100
+
+#define USE_CACHE 1
+#define DEBUG 0
+
+typedef struct{
+  unsigned long from;
+  unsigned long to;
+  unsigned char is_mobile;
+  int city_index; //index of the city in the cities-array
+  int16 isp_index; //index of the isp in the isps-array
+} IpRange;
+
+typedef struct{
+  int city_code;
+  char name[32];
+  double lat;
+  double lng;
+
+  char country_iso3[4];
+  char country_iso2[3];
+} City;
+
+typedef struct{
+  char *ranges_csv_file; //the CSV-file with ip-ranges-to-city-code-mappings
+  unsigned int max_ranges_count;
+  unsigned int ranges_count;
+
+  char *cities_csv_file;
+  unsigned int cities_count;
+  unsigned int max_cities_count;
+
+  char *cache_file_name; // a binary file to store the whole db.....
+  IpRange * ranges;
+  City * cities;
+
+  char isps[MAX_ISPS_COUNT][MAX_ISP_NAME_LENGTH]; // a fixed size array of strings should be enough here...do not expect the isps to grow dramatically..
+  uint16 isps_count;
+
+
+} IPDB;
+
+IPDB *
+init_db(char * cities_csv_file, char * ranges_csv_file, char * cache_file_name);
+
+void
+print_city(const City * e);
+
+void
+benchmark_search(IPDB * db,int count);
+
+IpRange*
+find_range_for_ip(IPDB *db, char *ip);
+
+City*
+find_city_for_ip_range(IPDB * db, IpRange* range);
+
+char*
+find_isp_for_ip_range(IPDB * db, IpRange* range);

data/ext/geoipdb/src/City.java

@@ -0,0 +1,120 @@
+public class City implements Comparable<City>
+{
+    int cityCode;
+    String name;
+    double lat;
+    double lng;
+    String countryISO3;
+    String countryISO2;
+
+
+    public static final String[] country_iso2_codes = {
+        "--", "ap", "eu", "ad", "ae", "af", "ag", "ai", "al", "am", "an", "ao",
+        "aq", "ar", "as", "at", "au", "aw", "az", "ba", "bb", "bd", "be", "bf",
+        "bg", "bh", "bi", "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw",
+        "by", "bz", "ca", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm",
+        "cn", "co", "cr", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk", "dm",
+        "do", "dz", "ec", "ee", "eg", "eh", "er", "es", "et", "fi", "fj", "fk",
+        "fm", "fo", "fr", "fx", "ga", "gb", "gd", "ge", "gf", "gh", "gi", "gl",
+        "gm", "gn", "gp", "gq", "gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm",
+        "hn", "hr", "ht", "hu", "id", "ie", "il", "in", "io", "iq", "ir", "is",
+        "it", "jm", "jo", "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp", "kr",
+        "kw", "ky", "kz", "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu",
+        "lv", "ly", "ma", "mc", "md", "mg", "mh", "mk", "ml", "mm", "mn", "mo",
+        "mp", "mq", "mr", "ms", "mt", "mu", "mv", "mw", "mx", "my", "mz", "na",
+        "nc", "ne", "nf", "ng", "ni", "nl", "no", "np", "nr", "nu", "nz", "om",
+        "pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm", "pn", "pr", "ps", "pt",
+        "pw", "py", "qa", "re", "ro", "ru", "rw", "sa", "sb", "sc", "sd", "se",
+        "sg", "sh", "si", "sj", "sk", "sl", "sm", "sn", "so", "sr", "st", "sv",
+        "sy", "sz", "tc", "td", "tf", "tg", "th", "tj", "tk", "tm", "tn", "to",
+        "tl", "tr", "tt", "tv", "tw", "tz", "ua", "ug", "um", "us", "uy", "uz",
+        "va", "vc", "ve", "vg", "vi", "vn", "vu", "wf", "ws", "ye", "yt", "rs",
+        "za", "zm", "me", "zw", "a1", "a2", "o1", "ax", "gg", "im", "je", "bl",
+        "mf"
+    };
+
+    public static final String[] country_iso3_codes = {
+        "--",  "ap",  "eu",  "and", "are", "afg", "atg", "aia", "alb", "arm",
+        "ant", "ago", "aq",  "arg", "asm", "aut", "aus", "abw", "aze", "bih",
+        "brb", "bgd", "bel", "bfa", "bgr", "bhr", "bdi", "ben", "bmu", "brn",
+        "bol", "bra", "bhs", "btn", "bv",  "bwa", "blr", "blz", "can", "cc",
+        "cod", "caf", "cog", "che", "civ", "cok", "chl", "cmr", "chn", "col",
+        "cri", "cub", "cpv", "cx",  "cyp", "cze", "deu", "dji", "dnk", "dma",
+        "dom", "dza", "ecu", "est", "egy", "esh", "eri", "esp", "eth", "fin",
+        "fji", "flk", "fsm", "fro", "fra", "fx",  "gab", "gbr", "grd", "geo",
+        "guf", "gha", "gib", "grl", "gmb", "gin", "glp", "gnq", "grc", "gs",
+        "gtm", "gum", "gnb", "guy", "hkg", "hm",  "hnd", "hrv", "hti", "hun",
+        "idn", "irl", "isr", "ind", "io",  "irq", "irn", "isl", "ita", "jam",
+        "jor", "jpn", "ken", "kgz", "khm", "kir", "com", "kna", "prk", "kor",
+        "kwt", "cym", "kaz", "lao", "lbn", "lca", "lie", "lka", "lbr", "lso",
+        "ltu", "lux", "lva", "lby", "mar", "mco", "mda", "mdg", "mhl", "mkd",
+        "mli", "mmr", "mng", "mac", "mnp", "mtq", "mrt", "msr", "mlt", "mus",
+        "mdv", "mwi", "mex", "mys", "moz", "nam", "ncl", "ner", "nfk", "nga",
+        "nic", "nld", "nor", "npl", "nru", "niu", "nzl", "omn", "pan", "per",
+        "pyf", "png", "phl", "pak", "pol", "spm", "pcn", "pri", "pse", "prt",
+        "plw", "pry", "qat", "reu", "rou", "rus", "rwa", "sau", "slb", "syc",
+        "sdn", "swe", "sgp", "shn", "svn", "sjm", "svk", "sle", "smr", "sen",
+        "som", "sur", "stp", "slv", "syr", "swz", "tca", "tcd", "tf",  "tgo",
+        "tha", "tjk", "tkl", "tkm", "tun", "ton", "tls", "tur", "tto", "tuv",
+        "twn", "tza", "ukr", "uga", "um",  "usa", "ury", "uzb", "vat", "vct",
+        "ven", "vgb", "vir", "vnm", "vut", "wlf", "wsm", "yem", "yt",  "srb",
+        "zaf", "zmb", "mne", "zwe", "a1",  "a2",  "o1",  "ala", "ggy", "imn",
+        "jey", "blm", "maf"
+    };
+
+    public City(String[] cityValues)
+    {
+        this.cityCode = Integer.parseInt(cityValues[4]);
+        this.name = cityValues[2];
+        this.countryISO2 = iso2_code(cityValues[0]);
+        this.countryISO3 = cityValues[0];
+        this.lat = Double.parseDouble(cityValues[5]);
+        this.lng = Double.parseDouble(cityValues[6]);
+    }
+
+    private String iso2_code(String iso3_code)
+    {
+        int index = 0;
+        for (index = 0; index < country_iso3_codes.length; index++) {
+            if (country_iso3_codes[index].equals(iso3_code)) {
+                return country_iso2_codes[index];
+            }
+        }
+        return country_iso2_codes[0];
+    }
+
+    @Override
+    public int compareTo(City other)
+    {
+        return this.cityCode - other.cityCode;
+    }
+
+    public int getCityCode()
+    {
+        return cityCode;
+    }
+
+    public String getName()
+    {
+        return name;
+    }
+
+    public double getLat()
+    {
+        return lat;
+    }
+
+    public double getLng() {
+        return lng;
+    }
+
+    public String getCountryISO3()
+    {
+        return countryISO3;
+    }
+
+    public String getCountryISO2()
+    {
+        return countryISO2;
+    }
+}

data/ext/geoipdb/src/CsvReader.java

@@ -0,0 +1,29 @@
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class CsvReader
+{
+    private BufferedReader reader = null;
+
+    public CsvReader(String file_name) throws FileNotFoundException {
+        reader = new BufferedReader(new FileReader(file_name));
+    }
+
+    public String[] readLine()
+    {
+        try {
+            String line = "";
+            String[] token = null;
+
+            if ((line = reader.readLine()) != null) {
+                token = line.split(",");
+            }
+
+            return token;
+        } catch (IOException e) {
+            return null;
+        }
+    }
+}

data/ext/geoipdb/src/GeoIpDb.java

@@ -0,0 +1,101 @@
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+
+public class GeoIpDb
+{
+    private static final int MAX_CITY_COUNT = 1000000;
+    private static final int MAX_RANGE_COUNT = 10000000;
+
+    HashMap<Integer, City> cities;
+    ArrayList<String> isps;
+    ArrayList<IpRange> ranges;
+
+    public GeoIpDb(String citiesFileName, String rangesFileName) throws FileNotFoundException
+    {
+        cities = new HashMap<Integer, City>();
+        isps = new ArrayList<String>();
+        ranges = new ArrayList<IpRange>();
+
+        readCitiesCSV(citiesFileName);
+        readRangesCSV(rangesFileName);
+    }
+
+    public IpRange findRangeForIp(String ip)
+    {
+        if (ranges.isEmpty()) {
+            System.out.println("ERROR: DB has no ranges data. Can not search!");
+            return null;
+        }
+
+        int index = 0;
+        IpRange search = new IpRange(ip, "0");
+        index = Collections.binarySearch(ranges, search);
+        if (index < 0)
+            return null;
+
+        return ranges.get(index);
+    }
+
+    public City findCityForIpRange(IpRange range)
+    {
+        if (range == null) {
+            System.out.println("Cannot find city for no given range, right?");
+            return null;
+        }
+        if (cities.isEmpty()) {
+            System.out.println("ERROR: DB has no city data. Can not search!");
+            return null;
+        }
+
+        if (range.cityCode == 0) {
+            System.out.format("ERROR: Could not find city with index: %d\n", range.cityCode);
+        }
+
+        return cities.get(range.cityCode);
+    }
+
+    public ArrayList<IpRange> get_ranges()
+    {
+        return ranges;
+    }
+
+    private void readCitiesCSV(String file_name) throws FileNotFoundException
+    {
+        CsvReader reader = new CsvReader(file_name);
+        String[] line = null;
+        City city = null;
+
+        reader.readLine(); // skip first line
+
+        while ((line = reader.readLine()) != null) {
+            if (cities.size() >= MAX_CITY_COUNT){
+                System.out.format("ERROR: MAX_CITY_COUNT = %d limit reached - mek it bigger  :-(\n", MAX_CITY_COUNT);
+                return;
+            }
+            city = new City(line);
+            cities.put(city.cityCode, city);
+        }
+    }
+
+    private void readRangesCSV(String file_name) throws FileNotFoundException
+    {
+        CsvReader reader = new CsvReader(file_name);
+        String[] line = null;
+
+        reader.readLine(); // skip first line
+
+        while ((line = reader.readLine()) != null) {
+            if (line.length < 5)
+                continue;
+
+            if (ranges.size() >= MAX_RANGE_COUNT){
+                System.out.format("ERROR: MAX_RANGE_COUNT = %d limit reached - mek it bigger  :-(\n", MAX_RANGE_COUNT);
+                return;
+            }
+
+            ranges.add(new IpRange(line));
+        }
+    }
+}

data/ext/geoipdb/src/IpRange.java

@@ -0,0 +1,110 @@
+public class IpRange implements Comparable<IpRange>
+{
+    long from;
+    long to;
+    boolean isMobile;
+    int cityCode;
+    String ispName;
+
+    public IpRange(String[] rangeValues)
+    {
+        this.from = ipToLong(rangeValues[0]);
+        this.to = ipToLong(rangeValues[1]);
+        this.isMobile = conTypeToBool(rangeValues[2]);
+        this.cityCode = Integer.parseInt(rangeValues[3]);
+
+        if (!rangeValues[4].equals("?")) {
+            // Use only the first 100 chars to be compliant with the c implementation
+            this.ispName = rangeValues[4].length() > 100 ? rangeValues[4].substring(0, 100) : rangeValues[4];
+        }
+    }
+
+    public IpRange(String from, String to)
+    {
+        this.from = ipToLong(from);
+        this.to = ipToLong(to);
+    }
+
+    public int getCityCode()
+    {
+        return cityCode;
+    }
+
+    public void setCityCode(int cityCode)
+    {
+        this.cityCode = cityCode;
+    }
+
+    public long getFrom()
+    {
+        return from;
+    }
+
+    public long getTo()
+    {
+        return to;
+    }
+
+    public boolean getIsMobile()
+    {
+        return isMobile;
+    }
+
+    public String getIspName()
+    {
+        return ispName;
+    }
+
+    private boolean conTypeToBool(String conType)
+    {
+        return (conType.length() > 0) && (conType.charAt(0) == 'm');
+    }
+
+    private long ipToLong(String ip)
+    {
+        long result = 0;
+
+        if (!(ip == null || ip.equals(""))) {
+            for (String octet : ip.split("\\.")) {
+                result = (result << 8) | Integer.parseInt(octet);
+            }
+        }
+
+        return result;
+    }
+
+    @Override
+    public int compareTo(IpRange other)
+    {
+        if (other == null) {
+            return 0;
+        }
+
+        if (other.from > 0 && other.to > 0 && this.from > 0 && this.to > 0) {
+            if (other.from < this.from)
+                return 1;
+            else if (other.from > this.to)
+                return -1;
+            else
+                return 0;
+        } else if (other.to == 0 && this.to > 0) {
+            if (other.from < this.from)
+                return 1;
+            else if (other.from > this.to)
+                return -1;
+            else
+                return 0;
+        } else if (this.to == 0 && other.to > 0) {
+            if (this.from < other.from)
+                return 1;
+            else if (this.from > other.from)
+                return -1;
+            else
+                return 0;
+        } else if (other.to == 0 && this.to == 0) {
+            return (int)(other.from - this.from);
+        }
+
+        return 0;
+    }
+}