IPinfo 1.0.1 → 2.5.0

data/lib/ipinfo/ipAddressMatcher.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'resolv'
+require 'ipaddr'
+
+class IPinfo::IpAddressMatcher
+    attr_accessor :required_address
+
+    @@bogon_list = [
+        "0.0.0.0/8",
+        "10.0.0.0/8",
+        "100.64.0.0/10",
+        "127.0.0.0/8",
+        "169.254.0.0/16",
+        "172.16.0.0/12",
+        "192.0.0.0/24",
+        "192.0.2.0/24",
+        "192.168.0.0/16",
+        "198.18.0.0/15",
+        "198.51.100.0/24",
+        "203.0.113.0/24",
+        "224.0.0.0/4",
+        "240.0.0.0/4",
+        "255.255.255.255/32",
+        "::/128",
+        "::1/128",
+        "::ffff:0:0/96",
+        "::/96",
+        "100::/64",
+        "2001:10::/28",
+        "2001:db8::/32",
+        "fc00::/7",
+        "fe80::/10",
+        "fec0::/10",
+        "ff00::/8",
+        "2002::/24",
+        "2002:a00::/24",
+        "2002:7f00::/24",
+        "2002:a9fe::/32",
+        "2002:ac10::/28",
+        "2002:c000::/40",
+        "2002:c000:200::/40",
+        "2002:c0a8::/32",
+        "2002:c612::/31",
+        "2002:c633:6400::/40",
+        "2002:cb00:7100::/40",
+        "2002:e000::/20",
+        "2002:f000::/20",
+        "2002:ffff:ffff::/48",
+        "2001::/40",
+        "2001:0:a00::/40",
+        "2001:0:7f00::/40",
+        "2001:0:a9fe::/48",
+        "2001:0:ac10::/44",
+        "2001:0:c000::/56",
+        "2001:0:c000:200::/56",
+        "2001:0:c0a8::/48",
+        "2001:0:c612::/47",
+        "2001:0:c633:6400::/56",
+        "2001:0:cb00:7100::/56",
+        "2001:0:e000::/36",
+        "2001:0:f000::/36",
+        "2001:0:ffff:ffff::/64"
+    ]
+
+    def initialize(ip)
+        if !ip.index('/').nil? and ip.index('/') > 0
+            addr_mask = ip.split('/')
+            ip = addr_mask[0]
+        end
+
+        @required_address = parseAddress(ip)
+    end
+
+    def parseAddress(ip)
+        begin
+            Resolv.getaddress ip
+        rescue Resolv::ResolvError => e
+            pp e
+        end
+    end
+
+    def matches
+        for bogon in @@bogon_list do
+            if bogon.include? required_address
+                return true
+            end
+        end
+
+        false
+    end
+end

data/lib/ipinfo/mod.rb

@@ -2,3 +2,6 @@
 
 module IPinfo
 end
+
+module IPinfoLite
+end

data/lib/ipinfo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IPinfo
-    VERSION = '1.0.1'
+    VERSION = '2.5.0'
 end

data/lib/ipinfo.rb

@@ -8,14 +8,18 @@ require 'ipinfo/errors'
 require 'ipinfo/response'
 require 'ipinfo/version'
 require 'json'
+require_relative 'ipinfo/ipAddressMatcher'
+require_relative 'ipinfo/countriesData'
 
 module IPinfo
+    include CountriesData
     DEFAULT_CACHE_MAXSIZE = 4096
     DEFAULT_CACHE_TTL = 60 * 60 * 24
-    DEFAULT_COUNTRY_FILE = File.join(File.dirname(__FILE__),
-                                     'ipinfo/countries.json')
     RATE_LIMIT_MESSAGE = 'To increase your limits, please review our ' \
                          'paid plans at https://ipinfo.io/pricing'
+    # Base URL to get country flag image link.
+    # "PK" -> "https://cdn.ipinfo.io/static/images/countries-flags/PK.svg"
+    COUNTRY_FLAGS_URL = "https://cdn.ipinfo.io/static/images/countries-flags/"
 
     class << self
         def create(access_token = nil, settings = {})
@@ -30,43 +34,120 @@ class IPinfo::IPinfo
 
     def initialize(access_token = nil, settings = {})
         @access_token = access_token
-        @httpc = prepare_http_client(settings.fetch('http_client', nil))
+        prepare_http_client(settings.fetch('http_client', nil))
 
         maxsize = settings.fetch('maxsize', DEFAULT_CACHE_MAXSIZE)
         ttl = settings.fetch('ttl', DEFAULT_CACHE_TTL)
         @cache = settings.fetch('cache', DefaultCache.new(ttl, maxsize))
-        @countries = prepare_countries(settings.fetch('countries',
-                                                      DEFAULT_COUNTRY_FILE))
+        @countries = settings.fetch('countries', DEFAULT_COUNTRY_LIST)
+        @eu_countries = settings.fetch('eu_countries', DEFAULT_EU_COUNTRIES_LIST)
+        @countries_flags = settings.fetch('countries_flags', DEFAULT_COUNTRIES_FLAG_LIST)
+        @countries_currencies = settings.fetch('countries_currencies', DEFAULT_COUNTRIES_CURRENCIES_LIST)
+        @continents = settings.fetch('continents', DEFAULT_CONTINENT_LIST)
     end
 
     def details(ip_address = nil)
-        details = request_details(ip_address)
-        if details.key? :country
-            details[:country_name] =
-                @countries.fetch(details.fetch(:country), nil)
+        details_base(ip_address, :v4)
+    end
+
+    def details_v6(ip_address = nil)
+        details_base(ip_address, :v6)
+    end
+
+    def resproxy(ip_address)
+        cache_key_str = "resproxy:#{ip_address}"
+        res = @cache.get(cache_key(cache_key_str))
+        return Response.new(res) unless res.nil?
+
+        response = @httpc.get("/resproxy/#{CGI.escape(ip_address)}", :v4)
+
+        if response.status.eql?(429)
+            raise RateLimitError,
+                  RATE_LIMIT_MESSAGE
         end
 
-        if details.key? :ip
-            details[:ip_address] =
-                IPAddr.new(details.fetch(:ip))
+        details = JSON.parse(response.body, symbolize_names: true)
+        @cache.set(cache_key(cache_key_str), details)
+        Response.new(details)
+    end
+
+    def get_map_url(ips)
+        if !ips.kind_of?(Array)
+            return JSON.generate({:error => 'Invalid input. Array required!'})
+        end
+        if ips.length > 500000
+            return JSON.generate({:error => 'No more than 500,000 ips allowed!'})
         end
 
-        if details.key? :loc
-            loc = details.fetch(:loc).split(',')
-            details[:latitude] = loc[0]
-            details[:longitude] = loc[1]
+        json_ips = JSON.generate({:ips => ips})
+        res = @httpc.post('/tools/map', json_ips)
+
+        obj = JSON.parse(res.body)
+        obj['reportUrl']
+    end
+
+    def batch_requests(url_array, api_token)
+        result = Hash.new
+        lookup_ips = []
+
+        url_array.each { |url|
+            ip = @cache.get(cache_key(url))
+
+            unless ip.nil?
+                result.store(url, ip)
+            else
+                lookup_ips << url
+            end
+        }
+
+        if lookup_ips.empty?
+            return result
         end
 
-        Response.new(details)
+        begin
+            lookup_ips.each_slice(1000){ |ips|
+                json_arr = JSON.generate(lookup_ips)
+                res = @httpc.post("/batch?token=#{api_token}", json_arr, 5)
+
+                raise StandardError, "Request Quota Exceeded" if res.status == 429
+
+                data = JSON.parse(res.body)
+                data.each { |key, val|
+                    @cache.set(cache_key(key), val)
+                }
+
+                result.merge!(data)
+            }
+
+        rescue StandardError => e
+            return e.message
+        end
+
+        result
     end
 
     protected
 
-    def request_details(ip_address = nil)
-        res = @cache.get(ip_address)
+    def prepare_http_client(httpc = nil)
+        @httpc = Adapter.new(access_token, httpc || :net_http)
+    end
+
+    private
+
+    def request_details(ip_address = nil, host_type)
+        if isBogon(ip_address)
+            details = {}
+            details[:ip] = ip_address
+            details[:bogon] = true
+            details[:ip_address] = IPAddr.new(ip_address)
+
+            return details
+        end
+
+        res = @cache.get(cache_key(ip_address))
         return res unless res.nil?
 
-        response = @httpc.get(escape_path(ip_address))
+        response = @httpc.get(escape_path(ip_address), host_type)
 
         if response.status.eql?(429)
             raise RateLimitError,
@@ -74,26 +155,54 @@ class IPinfo::IPinfo
         end
 
         details = JSON.parse(response.body, symbolize_names: true)
-        @cache.set(ip_address, details)
+        @cache.set(cache_key(ip_address), details)
         details
     end
 
-    def prepare_http_client(httpc = nil)
-        @httpc = if httpc
-                     Adapter.new(access_token, httpc)
-                 else
-                     Adapter.new(access_token)
-                 end
-    end
+    def details_base(ip_address, host_type)
+        details = request_details(ip_address, host_type)
+        if details.key? :country
+            details[:country_name] =
+                @countries.fetch(details.fetch(:country), nil)
+            details[:is_eu] =
+                @eu_countries.include?(details.fetch(:country))
+            details[:country_flag] =
+                @countries_flags.fetch(details.fetch(:country), nil)
+            details[:country_currency] =
+                @countries_currencies.fetch(details.fetch(:country), nil)
+            details[:continent] =
+                @continents.fetch(details.fetch(:country), nil)
+            details[:country_flag_url] = COUNTRY_FLAGS_URL + details.fetch(:country) + ".svg"
+        end
+
+        if details.key? :ip
+            details[:ip_address] =
+                IPAddr.new(details.fetch(:ip))
+        end
 
-    def prepare_countries(filename)
-        file = File.read(filename)
-        JSON.parse(file)
+        if details.key? :loc
+            loc = details.fetch(:loc).split(',')
+            details[:latitude] = loc[0]
+            details[:longitude] = loc[1]
+        end
+
+        Response.new(details)
     end
 
-    private
+    def isBogon(ip)
+        if ip.nil?
+            return false
+        end
+
+        matcher_object = IpAddressMatcher.new(ip)
+        matcher_object.matches
+    end
 
     def escape_path(ip)
         ip ? "/#{CGI.escape(ip)}" : '/'
     end
+
+    def cache_key(ip)
+        "1:#{ip}"
+    end
 end

data/lib/ipinfo_core.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'ipinfo/adapter'
+require 'ipinfo/cache/default_cache'
+require 'ipinfo/errors'
+require 'ipinfo/response'
+require_relative 'ipinfo/ipAddressMatcher'
+require_relative 'ipinfo/countriesData'
+require 'ipaddr'
+require 'cgi'
+
+module IPinfoCore
+    include CountriesData
+    DEFAULT_CACHE_MAXSIZE = 4096
+    DEFAULT_CACHE_TTL = 60 * 60 * 24
+    RATE_LIMIT_MESSAGE = 'To increase your limits, please review our ' \
+                         'paid plans at https://ipinfo.io/pricing'
+    # Base URL to get country flag image link.
+    # "PK" -> "https://cdn.ipinfo.io/static/images/countries-flags/PK.svg"
+    COUNTRY_FLAGS_URL = 'https://cdn.ipinfo.io/static/images/countries-flags/'
+
+    class << self
+        def create(access_token = nil, settings = {})
+            IPinfo::IPinfoCore.new(access_token, settings)
+        end
+    end
+end
+
+class IPinfo::IPinfoCore
+    include IPinfoCore
+    attr_accessor :access_token, :countries, :httpc
+
+    def initialize(access_token = nil, settings = {})
+        @access_token = access_token
+        @httpc = IPinfo::AdapterCore.new(access_token, httpc || :net_http)
+
+        maxsize = settings.fetch('maxsize', DEFAULT_CACHE_MAXSIZE)
+        ttl = settings.fetch('ttl', DEFAULT_CACHE_TTL)
+        @cache = settings.fetch('cache', IPinfo::DefaultCache.new(ttl, maxsize))
+        @countries = settings.fetch('countries', DEFAULT_COUNTRY_LIST)
+        @eu_countries = settings.fetch('eu_countries', DEFAULT_EU_COUNTRIES_LIST)
+        @countries_flags = settings.fetch('countries_flags', DEFAULT_COUNTRIES_FLAG_LIST)
+        @countries_currencies = settings.fetch('countries_currencies', DEFAULT_COUNTRIES_CURRENCIES_LIST)
+        @continents = settings.fetch('continents', DEFAULT_CONTINENT_LIST)
+    end
+
+    def details(ip_address = nil)
+        details_base(ip_address)
+    end
+
+    def request_details(ip_address = nil)
+        if ip_address && isBogon(ip_address)
+            details = {}
+            details[:ip] = ip_address
+            details[:bogon] = true
+            details[:ip_address] = IPAddr.new(ip_address)
+            return details
+        end
+
+        res = @cache.get(cache_key(ip_address))
+        return res unless res.nil?
+
+        response = @httpc.get(escape_path(ip_address))
+
+        if response.status.eql?(429)
+            raise RateLimitError,
+                  RATE_LIMIT_MESSAGE
+        end
+
+        details = JSON.parse(response.body, symbolize_names: true)
+        @cache.set(cache_key(ip_address), details)
+        details
+    end
+
+    def details_base(ip_address)
+        details = request_details(ip_address)
+
+        # Core response has nested geo object
+        if details.key?(:geo) && details[:geo].is_a?(Hash) && details[:geo].key?(:country_code)
+            country_code = details[:geo][:country_code]
+            details[:geo][:country_name] = @countries.fetch(country_code, nil)
+            details[:geo][:is_eu] = @eu_countries.include?(country_code)
+            details[:geo][:country_flag] = @countries_flags.fetch(country_code, nil)
+            details[:geo][:country_currency] = @countries_currencies.fetch(country_code, nil)
+            details[:geo][:continent] = @continents.fetch(country_code, nil)
+            details[:geo][:country_flag_url] = "#{COUNTRY_FLAGS_URL}#{country_code}.svg"
+        end
+
+        # Handle top-level country_code if present (for certain edge cases)
+        if details.key?(:country_code)
+            country_code = details[:country_code]
+            details[:country_name] = @countries.fetch(country_code, nil)
+            details[:is_eu] = @eu_countries.include?(country_code)
+            details[:country_flag] = @countries_flags.fetch(country_code, nil)
+            details[:country_currency] = @countries_currencies.fetch(country_code, nil)
+            details[:continent] = @continents.fetch(country_code, nil)
+            details[:country_flag_url] = "#{COUNTRY_FLAGS_URL}#{country_code}.svg"
+        end
+
+        if details.key? :ip
+            details[:ip_address] =
+                IPAddr.new(details.fetch(:ip))
+        end
+
+        IPinfo::Response.new(details)
+    end
+
+    def isBogon(ip)
+        if ip.nil?
+          return false
+        end
+
+        matcher_object = IPinfo::IpAddressMatcher.new(ip)
+        matcher_object.matches
+    end
+
+    def escape_path(ip)
+        ip ? "/#{CGI.escape(ip)}" : '/'
+    end
+
+    def cache_key(ip)
+        "1:#{ip}"
+    end
+end

data/lib/ipinfo_lite.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'ipinfo/adapter'
+require 'ipinfo/cache/default_cache'
+require 'ipinfo/errors'
+require 'ipinfo/response'
+require_relative 'ipinfo/ipAddressMatcher'
+require_relative 'ipinfo/countriesData'
+require 'ipaddr'
+require 'cgi'
+
+module IPinfoLite
+    include CountriesData
+    DEFAULT_CACHE_MAXSIZE = 4096
+    DEFAULT_CACHE_TTL = 60 * 60 * 24
+    RATE_LIMIT_MESSAGE = 'To increase your limits, please review our ' \
+                         'paid plans at https://ipinfo.io/pricing'
+    # Base URL to get country flag image link.
+    # "PK" -> "https://cdn.ipinfo.io/static/images/countries-flags/PK.svg"
+    COUNTRY_FLAGS_URL = 'https://cdn.ipinfo.io/static/images/countries-flags/'
+
+    class << self
+        def create(access_token = nil, settings = {})
+            IPinfo::IPinfoLite.new(access_token, settings)
+        end
+    end
+end
+
+class IPinfo::IPinfoLite
+    include IPinfoLite
+    attr_accessor :access_token, :countries, :httpc
+
+    def initialize(access_token = nil, settings = {})
+        @access_token = access_token
+        @httpc = IPinfo::AdapterLite.new(access_token, httpc || :net_http)
+
+        maxsize = settings.fetch('maxsize', DEFAULT_CACHE_MAXSIZE)
+        ttl = settings.fetch('ttl', DEFAULT_CACHE_TTL)
+        @cache = settings.fetch('cache', IPinfo::DefaultCache.new(ttl, maxsize))
+        @countries = settings.fetch('countries', DEFAULT_COUNTRY_LIST)
+        @eu_countries = settings.fetch('eu_countries', DEFAULT_EU_COUNTRIES_LIST)
+        @countries_flags = settings.fetch('countries_flags', DEFAULT_COUNTRIES_FLAG_LIST)
+        @countries_currencies = settings.fetch('countries_currencies', DEFAULT_COUNTRIES_CURRENCIES_LIST)
+        @continents = settings.fetch('continents', DEFAULT_CONTINENT_LIST)
+    end
+
+    def details(ip_address = nil)
+        details_base(ip_address)
+    end
+
+    def request_details(ip_address = nil)
+        if ip_address && ip_address != 'me' && isBogon(ip_address)
+            details = {}
+            details[:ip] = ip_address
+            details[:bogon] = true
+            details[:ip_address] = IPAddr.new(ip_address)
+            return details
+        end
+
+        res = @cache.get(cache_key(ip_address))
+        return res unless res.nil?
+
+        ip_address ||= 'me'
+        response = @httpc.get(escape_path(ip_address))
+
+        if response.status.eql?(429)
+            raise RateLimitError,
+                  RATE_LIMIT_MESSAGE
+        end
+
+        details = JSON.parse(response.body, symbolize_names: true)
+        @cache.set(cache_key(ip_address), details)
+        details
+    end
+
+    def details_base(ip_address)
+        details = request_details(ip_address)
+        if details.key? :country_code
+            details[:country_name] =
+                @countries.fetch(details.fetch(:country_code), nil)
+            details[:is_eu] =
+                @eu_countries.include?(details.fetch(:country_code))
+            details[:country_flag] =
+                @countries_flags.fetch(details.fetch(:country_code), nil)
+            details[:country_currency] =
+                @countries_currencies.fetch(details.fetch(:country_code), nil)
+            details[:continent] =
+                @continents.fetch(details.fetch(:country_code), nil)
+            details[:country_flag_url] = "#{COUNTRY_FLAGS_URL}#{details.fetch(:country_code)}.svg"
+        end
+
+        if details.key? :ip
+            details[:ip_address] =
+                IPAddr.new(details.fetch(:ip))
+        end
+
+        IPinfo::Response.new(details)
+    end
+
+    def isBogon(ip)
+        if ip.nil?
+          return false
+        end
+
+        matcher_object = IPinfo::IpAddressMatcher.new(ip)
+        matcher_object.matches
+    end
+
+    def escape_path(ip)
+        ip ? "/#{CGI.escape(ip)}" : '/'
+    end
+
+    def cache_key(ip)
+        "1:#{ip}"
+    end
+end