ffi-geoip 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ccd128b11adeb854b516279654e8d309c9fc1c32
+  data.tar.gz: 05a0b119ed18f0e236b53605861914adc67e0365
+SHA512:
+  metadata.gz: 325303b0a104fc0a63296051324a90deb16e95c317624c68ef240f3ebf9f36f25528af7b2942940ed589c8caf3f5683bbb2a3560e21f877e0b7cabda43254ad1
+  data.tar.gz: 12a91c22e4902b90ac83bb0b9b83247d01766efa1099d6784be12b5db5a27bdc98cc5e43ceb66a5a7c3edc61766f9fa22ccc79b5d169fc71a742f61afcd6ed77

data/.gitignore

@@ -0,0 +1,23 @@
+*.orig
+.*.swp
+.*.swo
+*.tmp
+*.kpf
+*.komodoproject
+*~
+.DS_Store
+*tmp*
+pkg/
+doc/
+coverage/
+*.orig
+*.patch
+.vimrc_local
+*.rbc
+test-all.sh
+.rbx
+Gemfile.lock
+Gemfile.local
+Guardfile.local
+*.dat
+*.csv

data/.travis.yml

@@ -0,0 +1,14 @@
+cache: bundler
+sudo: false
+language: ruby
+rvm:
+  - 2.2.3
+  - 2.1.7
+  - 2.0.0
+  - 1.9.3
+  - rbx-2
+  - jruby-19mode
+addons:
+  apt:
+    packages:
+      - libgeoip-dev

data/Gemfile

@@ -0,0 +1,25 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "rdoc", "~> 3.12"
+gem "rake", "~> 10.0"
+gem "minitest"
+gem "minitest-reporters"
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubinius-developer_tools'
+end
+
+
+if RUBY_VERSION >= '1.9'
+  gem "simplecov"
+  gem "guard"
+  gem 'guard-minitest'
+end
+
+if File.exists?('Gemfile.local')
+  instance_eval File.read('Gemfile.local')
+end
+

data/Guardfile

@@ -0,0 +1,17 @@
+
+guard 'minitest', :test_folders => 'test', :test_file_patterns => '*_tests.rb' do
+  watch(%r|^test/(.+)_tests\.rb|)
+
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$}) do |m|
+    "test/#{m[2]}_tests.rb"
+  end
+
+  watch(%r|^test/test_helper\.rb|) do
+    "test"
+  end
+end
+
+if File.exists?('Guardfile.local')
+  instance_eval File.read('Guardfile.local')
+end
+

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014-2015 J Smith <dark.panda@gmail.com>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,22 @@
+
+= geoip-c Ruby Bindings via FFI
+
+== Requirements
+
+* the ffi extension for Ruby.
+* the GeoIP library version 1.5 or higher. Lower versions may work to some
+  extent but this is untested.
+
+== Features
+
+ffi-geoip is an FFI-based implementation of the native GeoIP Ruby bindings.
+This gem mimics the native GeoIP bindings as closely as possible and should be
+directly compatible. To test this, you can run the tests using the native
+bindings via the `USE_BINARY` environment variable and they should also
+succeed. A simple use-case for this extension is for, say, JRuby, where the
+native GeoIP gem is not available.
+
+== License
+
+This gem is licensed under an MIT-style license. See the +MIT-LICENSE+ file for
+details.

data/Rakefile

@@ -0,0 +1,29 @@
+
+# -*- ruby -*-
+
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'bundler/gem_tasks'
+
+$:.push File.expand_path(File.dirname(__FILE__), 'lib')
+
+version = GeoIP::VERSION
+
+desc 'Test GeoIP interface'
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/**/*_tests.rb']
+  t.verbose = !!ENV['VERBOSE_TESTS']
+  t.warning = !!ENV['WARNINGS']
+end
+
+task :default => :test
+
+desc 'Build docs'
+Rake::RDocTask.new do |t|
+  t.title = "ffi-geoip #{version}"
+  t.main = 'README.rdoc'
+  t.rdoc_dir = 'doc'
+  t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
+end

data/ffi-geoip.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/ffi-geoip/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "ffi-geoip"
+  s.version = GeoIP::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["J Smith"]
+  s.description = "An ffi wrapper for GeoIP"
+  s.summary = s.description
+  s.email = "dark.panda@gmail.com"
+  s.license = "MIT"
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = `git ls-files`.split($\)
+  s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.homepage = "http://github.com/dark-panda/ffi-geoip"
+  s.require_paths = ["lib"]
+
+  s.add_dependency("ffi", [">= 1.0.0"])
+end
+

data/lib/ffi-geoip.rb

@@ -0,0 +1,470 @@
+# encoding: UTF-8
+
+require 'ffi'
+require 'rbconfig'
+require 'ffi-geoip/version'
+
+module GeoIP
+  GEOIP_BASE = File.join(File.dirname(__FILE__), 'ffi-geoip')
+
+  autoload :Base,
+    File.join(GEOIP_BASE, 'base')
+
+  autoload :City,
+    File.join(GEOIP_BASE, 'city')
+
+  autoload :Country,
+    File.join(GEOIP_BASE, 'country')
+
+  autoload :Organization,
+    File.join(GEOIP_BASE, 'organization')
+
+  autoload :ISP,
+    File.join(GEOIP_BASE, 'isp')
+
+  autoload :NetSpeed,
+    File.join(GEOIP_BASE, 'netspeed')
+
+  autoload :Domain,
+    File.join(GEOIP_BASE, 'domain')
+
+  autoload :Tools,
+    File.join(GEOIP_BASE, 'tools')
+
+  autoload :Record,
+    File.join(GEOIP_BASE, 'record')
+
+  module FFIGeoIP
+    def self.search_paths
+      @search_paths ||= begin
+        if ENV['GEOIP_LIBRARY_PATH']
+          [ ENV['GEOIP_LIBRARY_PATH'] ]
+        elsif FFI::Platform::IS_WINDOWS
+          ENV['PATH'].split(File::PATH_SEPARATOR)
+        else
+          [ '/usr/local/{lib64,lib}', '/opt/local/{lib64,lib}', '/usr/{lib64,lib}' ]
+          [ '/usr/local/{lib64,lib}', '/opt/local/{lib64,lib}', '/usr/{lib64,lib}', '/usr/lib/{x86_64,i386}-linux-gnu' ]
+        end
+      end
+    end
+
+    def self.find_lib(lib)
+      if ENV['GEOIP_LIBRARY_PATH'] && File.file?(ENV['GEOIP_LIBRARY_PATH'])
+        ENV['GEOIP_LIBRARY_PATH']
+      else
+        Dir.glob(search_paths.map { |path|
+          File.expand_path(File.join(path, "#{lib}.#{FFI::Platform::LIBSUFFIX}"))
+        }).first
+      end
+    end
+
+    def self.geoip_library_path
+      @geoip_library_path ||= begin
+        # On MingW the libraries have version numbers
+        find_lib('{lib,}GeoIP{,-?}')
+      end
+    end
+
+    extend ::FFI::Library
+
+    GeoIP::GeoIPOptions = enum(:geoip_option, [
+      :standard, 0,
+      :memory_cache, 1,
+      :check_cache, 2,
+      :index_cache, 4,
+      :mmap_cache, 8
+    ])
+
+    FFI_LAYOUT = {
+      :GeoIP_open => [
+        # GeoIP*, filename, flags
+        :pointer, :string, :int
+      ],
+
+      :GeoIP_delete => [
+        # void, GeoIP*
+        :void, :pointer
+      ],
+
+      #### countries ####
+      # string, GeoIP*, addr
+      :GeoIP_country_code_by_addr => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, host
+      :GeoIP_country_code_by_name => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, addr
+      :GeoIP_country_code3_by_addr => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, host
+      :GeoIP_country_code3_by_name => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, addr
+      :GeoIP_country_name_by_addr => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, host
+      :GeoIP_country_name_by_name => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, ipnum
+      :GeoIP_country_name_by_ipnum => [
+        :string, :pointer, :ulong
+      ],
+
+      # string, GeoIP*, ipnum
+      :GeoIP_country_code_by_ipnum => [
+        :string, :pointer, :ulong
+      ],
+
+      # string, GeoIP*, ipnum
+      :GeoIP_country_code3_by_ipnum => [
+        :string, :pointer, :ulong
+      ],
+
+      # # string, GeoIP*, geoipv6_t ipnum
+      # :GeoIP_country_name_by_ipnum_v6 => [
+      #   :string, :pointer, :geoipv6_t
+      # ],
+      # # string, GeoIP*, geoipv6_t ipnum
+      # :GeoIP_country_code_by_ipnum_v6 => [
+      #   :string, :pointer, :geoipv6_t
+      # ],
+      # # string, GeoIP*, geoipv6_t ipnum
+      # :GeoIP_country_code3_by_ipnum_v6 => [
+      #   :string, :pointer, :geoipv6_t
+      # ],
+
+      # string, GeoIP*, addr
+      :GeoIP_country_code_by_addr_v6 => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, host
+      :GeoIP_country_code_by_name_v6 => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, addr
+      :GeoIP_country_code3_by_addr_v6 => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, host
+      :GeoIP_country_code3_by_name_v6 => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, addr
+      :GeoIP_country_name_by_addr_v6 => [
+        :string, :pointer, :string
+      ],
+
+      # string, GeoIP*, host
+      :GeoIP_country_name_by_name_v6 => [
+        :string, :pointer, :string
+      ],
+      #### /countries ####
+
+      #### IDs ####
+      # id, GeoIP*, addr
+      :GeoIP_id_by_addr => [
+        :int, :pointer, :string
+      ],
+
+      # id, GeoIP*, host
+      :GeoIP_id_by_name => [
+        :int, :pointer, :string
+      ],
+
+      # id, GeoIP*, ipnum
+      :GeoIP_id_by_ipnum => [
+        :int, :pointer, :ulong
+      ],
+
+      # id, GeoIP*, addr
+      :GeoIP_id_by_addr_v6 => [
+        :int, :pointer, :string
+      ],
+
+      # id, GeoIP*, host
+      :GeoIP_id_by_name_v6 => [
+        :int, :pointer, :string
+      ],
+
+      # # id, GeoIP*, ipnum
+      # :GeoIP_id_by_ipnum_v6 => [
+      #   :int, :pointer, :geoipv6_t
+      # ],
+      #### /IDs ####
+
+      #### regions ####
+      # GeoIPRegion*, GeoIP*, addr
+      :GeoIP_region_by_addr => [
+        :pointer, :pointer, :string
+      ],
+
+      # GeoIPRegion*, GeoIP*, host
+      :GeoIP_region_by_name => [
+        :pointer, :pointer, :string
+      ],
+
+      # GeoIPRegion*, GeoIP*, ipnum
+      :GeoIP_region_by_ipnum => [
+        :pointer, :pointer, :ulong
+      ],
+
+      # GeoIPRegion*, GeoIP*, addr
+      :GeoIP_region_by_addr_v6 => [
+        :pointer, :pointer, :string
+      ],
+
+      # GeoIPRegion*, GeoIP*, host
+      :GeoIP_region_by_name_v6 => [
+        :pointer, :pointer, :string
+      ],
+
+      # # GeoIPRegion*, GeoIP*, ipnum
+      # :GeoIP_region_by_ipnum_v6 => [
+      #   :pointer, :pointer, :geoipv6_t
+      # ],
+
+      # void, GeoIPRegion*
+      :GeoIPRegion_delete => [
+        :void, :pointer
+      ],
+      #### /region
+
+      #### organization names ####
+      # name, GeoIP*, ipnum
+      :GeoIP_name_by_ipnum => [
+        :string, :pointer, :ulong
+      ],
+      # name, GeoIP*, addr
+      :GeoIP_name_by_addr => [
+        :string, :pointer, :string
+      ],
+      # name, GeoIP*, host
+      :GeoIP_name_by_name => [
+        :string, :pointer, :string
+      ],
+
+      # # name, GeoIP*, ipnum
+      # :GeoIP_name_by_ipnum_v6 => [
+      #   :string, :pointer, :geoipv6_t
+      # ],
+
+      # name, GeoIP*, addr
+      :GeoIP_name_by_addr_v6 => [
+        :string, :pointer, :string
+      ],
+      # name, GeoIP*, host
+      :GeoIP_name_by_name_v6 => [
+        :string, :pointer, :string
+      ],
+      #### /organization names ####
+
+      #### fetch by IDs ####
+      # string, id
+      :GeoIP_code_by_id => [
+        :string, :int
+      ],
+
+      # string, id
+      :GeoIP_code3_by_id => [
+        :string, :int
+      ],
+
+      # string, GeoIP*, id
+      :GeoIP_country_name_by_id => [
+        :string, :pointer, :int
+      ],
+
+      # string, id
+      :GeoIP_name_by_id => [
+        :string, :int
+      ],
+
+      # string, id
+      :GeoIP_continent_by_id => [
+        :string, :int
+      ],
+
+      # id, country
+      :GeoIP_id_by_code => [
+        :int, :string
+      ],
+      #### /fetch by IDs ####
+
+      #### full city records ####
+      # GeoIPRecord*, GeoIP*, ipnum
+      :GeoIP_record_by_ipnum => [
+        GeoIP::Record, :pointer, :ulong
+      ],
+
+      # GeoIPRecord*, GeoIP*, addr
+      :GeoIP_record_by_addr => [
+        GeoIP::Record, :pointer, :string
+      ],
+
+      # GeoIPRecord*, GeoIP*, host
+      :GeoIP_record_by_name => [
+        GeoIP::Record, :pointer, :string
+      ],
+
+      # # GeoIPRecord*, GeoIP*, geoipv6_t ipnum
+      # :GeoIP_record_by_ipnum_v6 => [
+      #   :pointer, :pointer, :geoipv6_t
+      # ],
+
+      # GeoIPRecord*, GeoIP*, addr
+      :GeoIP_record_by_addr_v6 => [
+        GeoIP::Record, :pointer, :string
+      ],
+
+      # GeoIPRecord*, GeoIP*, host
+      :GeoIP_record_by_name_v6 => [
+        GeoIP::Record, :pointer, :string
+      ],
+
+      # record ID, GeoIP*, addr
+      :GeoIP_record_id_by_addr => [
+        :int, :pointer, :string
+      ],
+
+      # record ID, GeoIP*, string
+      :GeoIP_record_id_by_addr_v6 => [
+        :int, :pointer, :string
+      ],
+
+      # void, GeoIPRecord*
+      :GeoIPRecord_delete => [
+        :void, GeoIP::Record
+      ],
+      #### /full record
+
+      #### utility functions ####
+      # num, void
+      :GeoIP_num_countries => [
+        :uint
+      ],
+
+      # info, GeoIP*
+      :GeoIP_database_info => [
+        :string, :pointer
+      ],
+
+      # edition, GeoIP*
+      :GeoIP_database_edition => [
+        :uchar, :pointer
+      ],
+
+      # int, GeoIP*
+      :GeoIP_charset => [
+        :int, :pointer
+      ],
+
+      # int, GeoIP*, charset
+      :GeoIP_set_charset => [
+        :int, :pointer, :int
+      ],
+
+      # int, GeoIP*, true/false
+      :GeoIP_enable_teredo => [
+        :int, :pointer, :int
+      ],
+
+      # int, GeoIP*
+      :GeoIP_teredo => [
+        :int, :pointer
+      ],
+
+      # int, GeoIP*
+      :GeoIP_last_netmask => [
+        :int, :pointer
+      ],
+
+      # char**, GeoIP*, addr
+      :GeoIP_range_by_ip => [
+        :pointer, :pointer, :string
+      ],
+
+      # ipnum, addr
+      :GeoIP_addr_to_num => [
+        :ulong, :string
+      ],
+
+      # addr, ipnum
+      :GeoIP_num_to_addr => [
+        :string, :ulong
+      ],
+      #### /utility functions ####
+
+      #### region code ####
+      # string, country_code, region_code
+      :GeoIP_region_name_by_code => [
+        :string, :string, :string
+      ],
+      #### /region code ####
+
+      #### time zone ####
+      # string, country_code, region_code
+      :GeoIP_time_zone_by_country_and_region => [
+        :string, :string, :string
+      ],
+      #### /time zone ####
+
+      # string, void
+      :GeoIP_lib_version => [
+        :string
+      ]
+    }
+
+    begin
+      ffi_lib(geoip_library_path)
+
+      FFI_LAYOUT.each do |fun, ary|
+        ret = ary.shift
+        begin
+          self.class_eval do
+            attach_function(fun, ary, ret)
+          end
+        rescue FFI::NotFoundError
+          # that's okay
+        end
+      end
+
+    rescue LoadError, NoMethodError
+      raise LoadError.new("Couldn't load the GeoIP library.")
+    end
+  end
+
+  class << self
+    include GeoIP::Tools
+
+    def version
+      @version ||= FFIGeoIP.GeoIP_lib_version
+    end
+
+    def addr_to_num(addr)
+      check_type(addr, String)
+      FFIGeoIP.GeoIP_addr_to_num(addr)
+    end
+
+    def num_to_addr(num)
+      check_type(num, Fixnum, Bignum)
+      FFIGeoIP.GeoIP_num_to_addr(num)
+    end
+  end
+end
+