geoip-c 0.5.5

data/README.md

@@ -0,0 +1,141 @@
+Ruby GeoIP Bindings
+=======================
+
+What?
+-----
+
+This is a library which provides a single function. The function takes as
+input an IP address and it outputs a hash containing best-guess geographical
+information (like city, country, latitude, and longitude).
+
+Actually this is only a Ruby binding to a C library which provides this
+function. Also, you must download a large binary database with all this
+mapping information. It is kindly provided free of charge by MaxMind.com. 
+
+Usage
+
+    require 'geoip'
+    db = GeoIP::City.new('/opt/GeoIP/share/GeoIP/GeoLiteCity.dat')
+    result = db.look_up('24.24.24.24')
+    p result 
+    # => {:city=>"Ithaca", 
+    #     :latitude=>42.4277992248535, 
+    #     :longitude=>-76.4981994628906, 
+    #     :country_code3=>"USA", 
+    #     :country_code=>"US",
+    #     :country_name=>"United States", 
+    #     :dma_code=>555,
+    #     :area_code=>607, 
+    #     :region=>"NY" }
+
+There are arguments to database initializer.
+
+  1. The first argument is the filename of the GeoIPCity.dat file 
+
+  2. The second argument (optional) is to specify how GeoIP should
+     keep the database in memory. There are three possibilities
+
+      * `:filesystem` -- Read database from filesystem, uses least memory.
+
+      * `:index` -- The most frequently accessed index portion of the
+        database, resulting in faster lookups than :filesystem, but less
+        memory usage than :memory.
+
+      * `:memory` -- (Default.) Load database into memory, faster performance but uses more memory.
+
+  3. The third argument is boolean and decides whether the system should
+     reload the database if changes are made to the dat file. (You probably
+     don't need this. Default: false.)
+
+For example 
+
+    GeoIP::City.new(dbfile, :filesystem, true)
+
+Usage for Organization Search
+-----------------------------
+
+    require 'geoip'
+    db = GeoIP::Organization.new('/opt/GeoIP/share/GeoIP/GeoIPOrg.dat')
+    db.look_up('24.24.24.24')
+    # => {:name=>"Road Runner"}
+
+The name is the only data available for Organizations.
+
+Install
+-------
+
+Some variation of the following should work.
+
+  1. Install the GeoCity C library. You can get it from
+  [maxmind](http://www.maxmind.com/app/c).
+  For example, I like to install mine in `/opt/GeoIP`, so I do this:
+
+       tar -zxvf GeoIP-1.4.3.tar.gz 
+
+       cd GeoIP-1.4.3
+
+       ./configure --prefix=/opt/GeoIP
+
+       make && sudo make install
+
+  NOTE: for Intel Mac OS X platforms, try the following:
+
+       env ARCHFLAGS="-arch i386" ./configure --prefix=/opt/GeoIP
+
+       env ARCHFLAGS="-arch i386" make
+
+       sudo env ARCHFLAGS="-arch i386" make install
+
+  2. Now install the `geoip` gem 
+
+       gem install mtodd-geoip -s http://gems.github.com/ -- --with-geoip-dir=/opt/GeoIP
+
+  3. Download the GeoLite City database file in binary format at http://www.maxmind.com/app/geolitecity
+     Maybe this [direct link](http://www.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz) will work.
+     I put this file in 
+
+       /opt/GeoIP/share/GeoIP/GeoLiteCity.dat
+
+     If you are a paying customer, you will download the files required below:
+
+     [MaxMind Customer Downloads](http://www.maxmind.com/app/download_files)
+
+     You will want to get the City Rev1 data file and Organization files at minimum.
+
+  4. Use it!
+
+     See above for usage details.
+
+Hints
+-----
+
+  1. Might need to set
+
+       export ARCHFLAGS="-arch i386"
+
+     to be able to compile the gem.
+
+     Example:
+
+        env ARCHFLAGS="-arch i386" gem install mtodd-geoip -s http://gems.github.com/ -- --with-geoip-dir=/opt/GeoIP
+
+  2. You might find [this shell script](http://github.com/grimen/my_shell_scripts/blob/8cf04cb6829e68a47f2d6f9d9e057766ea72beb4/install_geoip-city.sh)
+     helpful to install the C library.
+
+Links
+-----
+
+This iteration of the library is based on the hard work of Ryah Dahl (ry@tinyclouds.org). You can find the original RDocs and Git Repo below:
+
+[rdocs](http://geoip-city.rubyforge.org/)
+[git repo](https://github.com/ry/geoip-city/tree)
+
+License
+-------
+Copyright (C) 2007--2009 Ryah Dahl (ry@tinyclouds.org), Matt Todd (mtodd@highgroove.com)
+
+This program is free software. It comes without any warranty, to
+the extent permitted by applicable law. You can redistribute it
+and/or modify it under the terms of the Do What The Fuck You Want
+To Public License, Version 2, as published by Sam Hocevar. See
+http://sam.zoy.org/wtfpl/COPYING for more details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => [:compile, :test]
+
+CLEAN.add "geoip.{o,bundle,so,obj,pdb,lib,def,exp}"
+CLOBBER.add ['Makefile', 'mkmf.log','doc']
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.add ['README', 'geoip.c']
+  rdoc.main = "README" # page to start on
+  rdoc.rdoc_dir = 'doc/' # rdoc output folder
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = 'test.rb'
+  t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'geoip-c'
+  s.version           = "0.5.5"
+
+  s.authors           = ['Ryah Dahl', 'Matt Todd', 'Charles Brian Quinn']
+  s.email             = 'mtodd@highgroove.com'
+
+  s.summary           = "A Binding to the GeoIP C library"
+  s.description       = 'Generic GeoIP lookup tool. Based on the geoip_city RubyGem by Ryah Dahl'
+  s.homepage          = "http://github.com/mtodd/geoip"
+
+  s.files             = ["Rakefile", "extconf.rb", "test.rb", "geoip.c", "README.md"]
+  s.test_files        = 'test.rb'
+  s.extensions        = 'extconf.rb'
+  s.require_path      = '.'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+desc 'compile the extension'
+task(:compile => 'Makefile') { sh 'make' }
+file('Makefile' => "geoip.c") { ruby 'extconf.rb' }
+
+task :install => [:gem] do
+  `env ARCHFLAGS="-arch i386" gem install pkg/geoip-c-0.5.0.gem -- --with-geoip-dir=/usr/local/GeoIP`
+end
+
+task(:webpage) do
+  sh 'scp -r doc/* rydahl@rubyforge.org:/var/www/gforge-projects/geoip-city/'
+end

data/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+dir_config("geoip")
+
+if have_library('GeoIP', 'GeoIP_record_by_ipnum') and have_header('GeoIPCity.h')
+  create_makefile('geoip')
+else
+  abort("you must have geoip c library installed!")
+end

data/geoip.c

@@ -0,0 +1,212 @@
+/* ry dahl <ry@tinyclouds.org> May 21, 2007 */
+/* Matt Todd <mtodd@highgroove.com> June 4, 2009 */
+/* This program is free software. It comes without any warranty, to
+ * the extent permitted by applicable law. You can redistribute it
+ * and/or modify it under the terms of the Do What The Fuck You Want
+ * To Public License, Version 2, as published by Sam Hocevar. See
+ * http://sam.zoy.org/wtfpl/COPYING for more details. */
+#include <ruby.h>
+#include <GeoIP.h>
+#include <GeoIPCity.h>
+
+static VALUE mGeoIP;
+static VALUE mGeoIP_City;
+static VALUE mGeoIP_Organization;
+static VALUE rb_geoip_memory;
+static VALUE rb_geoip_filesystem;
+static VALUE rb_geoip_index;
+
+/* helpers */
+void rb_hash_sset(VALUE hash, const char *str, VALUE v) {
+  rb_hash_aset(hash, ID2SYM(rb_intern(str)), v);
+}
+
+int check_load_option(VALUE load_option) {
+  if(load_option == rb_geoip_memory) {
+    return GEOIP_MEMORY_CACHE;
+  } else if(load_option == rb_geoip_filesystem) {
+    return GEOIP_STANDARD;
+  } else if(load_option == rb_geoip_index) {
+    return GEOIP_INDEX_CACHE;
+  } else {
+    rb_raise(rb_eTypeError, "the second option must be :memory, :filesystem, or :index");
+    return Qnil;
+  }
+}
+
+/* Generic initializer */
+static VALUE rb_geoip_database_new(VALUE mGeoIP_Database_Class, int argc, VALUE *argv, VALUE self)
+{
+  GeoIP *gi;
+  VALUE database = Qnil;
+  VALUE filename, load_option = Qnil, check_cache = Qnil;
+  int flag;
+
+  rb_scan_args(argc, argv, "12", &filename, &load_option, &check_cache);
+  if(NIL_P(load_option))
+    load_option = rb_geoip_memory;
+  if(NIL_P(check_cache))
+    check_cache = Qfalse;
+  Check_Type(load_option, T_SYMBOL);
+
+  if(flag = check_load_option(load_option)) flag;
+
+  if(RTEST(check_cache)) flag |= GEOIP_CHECK_CACHE;
+
+  if(gi = GeoIP_open(STR2CSTR(filename), flag)) {
+    database = Data_Wrap_Struct(mGeoIP_Database_Class, 0, GeoIP_delete, gi);
+    rb_obj_call_init(database, 0, 0);
+  } else { 
+    rb_sys_fail("Problem opening database");
+  }
+  return database;
+}
+
+/* GeoIP::City ***************************************************************/
+
+VALUE rb_city_record_to_hash(GeoIPRecord *record) 
+{
+  VALUE hash = rb_hash_new();
+
+  if(record->country_code)
+    rb_hash_sset(hash, "country_code", rb_str_new2(record->country_code));
+  if(record->country_code3)
+    rb_hash_sset(hash, "country_code3", rb_str_new2(record->country_code3));
+  if(record->country_name)
+    rb_hash_sset(hash, "country_name", rb_str_new2(record->country_name));
+  if(record->region)
+    rb_hash_sset(hash, "region", rb_str_new2(record->region));
+  if(record->city)
+    rb_hash_sset(hash, "city", rb_str_new2(record->city));
+  if(record->postal_code)
+    rb_hash_sset(hash, "postal_code", rb_str_new2(record->postal_code));
+  if(record->latitude)
+    rb_hash_sset(hash, "latitude", rb_float_new((double)record->latitude));
+  if(record->longitude)
+    rb_hash_sset(hash, "longitude", rb_float_new((double)record->longitude));
+  if(record->dma_code)
+    rb_hash_sset(hash, "dma_code", INT2NUM(record->dma_code));
+  if(record->area_code)
+    rb_hash_sset(hash, "area_code", INT2NUM(record->area_code));
+  
+  return hash;
+}
+
+/* The first argument is the filename of the GeoIPCity.dat file 
+ * load_option = :standard, :index, or :memory. default :memory
+ * check_cache = true or false. default false
+ * 
+ * filesystem: read database from filesystem, uses least memory.
+ * 
+ * index: the most frequently accessed index portion of the database,
+ *   resulting in faster lookups than :filesystem, but less memory usage than
+ *   :memory.
+ * 
+ * memory: load database into memory, faster performance but uses more
+ *   memory.
+ */
+static VALUE rb_geoip_city_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_City, argc, argv, self);
+}
+
+/* Pass this function an IP address as a string, it will return a hash
+ * containing all the information that the database knows about the IP
+ *    db.look_up('24.24.24.24') 
+ *    => {:city=>"Ithaca", :latitude=>42.4277992248535, 
+ *        :country_code=>"US", :longitude=>-76.4981994628906, 
+ *        :country_code3=>"USA", :dma_code=>555, 
+ *        :country_name=>"United States", :area_code=>607, 
+ *        :region=>"NY"} 
+ */ 
+VALUE rb_geoip_city_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  GeoIPRecord *record = NULL;
+  VALUE hash = Qnil; 
+  
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  if(record = GeoIP_record_by_addr(gi, STR2CSTR(addr))) {
+    hash =  rb_city_record_to_hash(record);
+    GeoIPRecord_delete(record);
+  }
+  return hash;
+}
+
+/* GeoIP::Organization *******************************************************/
+
+/* GeoIP::Organization.new('/path/to/GeoIPOrg.dat', load_option)
+ * load_option can be:
+ * * :memory - load the data into memory, fastest (default)
+ * * :filesystem - look up from filesystem, least memory intensive
+ * * :index - stores in memory most recent queries
+ * 
+ */
+static VALUE rb_geoip_org_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_Organization, argc, argv, self);
+}
+
+/* Pass this function an IP address as a string, it will return a hash
+ * containing all the information that the database knows about the IP:
+ *    db.look_up('24.24.24.24') 
+ *    => {:name => "Road Runner"}
+ */ 
+VALUE rb_geoip_org_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  VALUE hash = rb_hash_new();
+  char * name = NULL;
+  
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  if(name = GeoIP_name_by_addr(gi, STR2CSTR(addr))) {
+    rb_hash_sset(hash, "name", rb_str_new2(name));
+    free(name);
+  }
+  return hash;
+}
+
+/* GeoIP *********************************************************************/
+
+/* Returns the numeric form of an IP address.
+ * 
+ * For example:
+ * 24.24.24.24 => 404232216
+ * 
+ * This is used in order to be able to perform searches in CSV versions of the
+ * data files or in SQL records if the data has been put there.
+ */
+VALUE rb_geoip_addr_to_num(VALUE self, VALUE addr) {
+  Check_Type(addr, T_STRING);
+  return UINT2NUM((unsigned long)_GeoIP_addr_to_num(STR2CSTR(addr)));
+}
+
+VALUE rb_geoip_num_to_addr(VALUE self, VALUE num) {
+  VALUE num_type = TYPE(num);
+  switch(num_type) {
+    case T_FIXNUM: break;
+    case T_BIGNUM: break;
+    default: rb_raise(rb_eTypeError, "wrong argument type %s (expected Fixnum or Bignum)", rb_obj_classname(num));
+  }
+  return rb_str_new2((char*)_GeoIP_num_to_addr(NULL, (unsigned long)NUM2UINT(num)));
+}
+
+void Init_geoip()
+{
+  mGeoIP = rb_define_module("GeoIP");
+
+  rb_geoip_memory = ID2SYM(rb_intern("memory")); 
+  rb_geoip_filesystem = ID2SYM(rb_intern("filesystem")); 
+  rb_geoip_index = ID2SYM(rb_intern("index")); 
+
+  mGeoIP_City = rb_define_class_under(mGeoIP, "City", rb_cObject);
+  rb_define_singleton_method(mGeoIP_City, "new",      rb_geoip_city_new,      -1);
+  rb_define_method(mGeoIP_City,           "look_up",  rb_geoip_city_look_up,  1);
+  
+  mGeoIP_Organization = rb_define_class_under(mGeoIP, "Organization", rb_cObject);
+  rb_define_singleton_method( mGeoIP_Organization, "new",     rb_geoip_org_new,     -1);
+  rb_define_method(           mGeoIP_Organization, "look_up", rb_geoip_org_look_up, 1);
+  
+  rb_define_singleton_method(mGeoIP, "addr_to_num", rb_geoip_addr_to_num, 1);
+  rb_define_singleton_method(mGeoIP, "num_to_addr", rb_geoip_num_to_addr, 1);
+}

data/test.rb

@@ -0,0 +1,162 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/geoip'
+require 'rubygems'
+# require 'ruby-debug'
+# Debugger.start
+
+class Test::Unit::TestCase
+
+  def assert_look_up(db, addr, field, value)
+    h = db.look_up(addr)
+    assert_equal value, h[field]
+    h
+  end
+
+end
+
+class GeoIPTest < Test::Unit::TestCase
+  
+  def setup
+    @ip = "24.24.24.24"
+    @ipnum = 16777216*24 + 65536*24 + 256*24 + 24
+    
+    @large_ip = "245.245.245.245"
+    @large_ipnum = 16777216*245 + 65536*245 + 256*245 + 245
+  end
+  
+  # addr_to_num
+  
+  def test_addr_to_num_converts_an_ip_to_an_ipnum
+    assert_equal @ipnum, GeoIP.addr_to_num(@ip)
+  end
+  
+  def test_addr_to_num_converts_large_ips_to_an_ipnum_correctly
+    assert_equal @large_ipnum, GeoIP.addr_to_num(@large_ip)
+  end
+  
+  def test_addr_to_num_expects_an_ip_string
+    assert_raises TypeError do 
+      GeoIP.addr_to_num(nil) 
+    end
+  end
+  
+  def test_addr_to_num_returns_zero_for_an_illformed_ip_string
+    assert_equal 0, GeoIP.addr_to_num("foo.bar")
+  end
+  
+  # num_to_addr
+  
+  def test_num_to_addr_converts_an_ipnum_to_an_ip
+    assert_equal @ip, GeoIP.num_to_addr(@ipnum)
+  end
+  
+  def test_num_to_addr_converts_large_ipnums_to_an_ip_correctly
+    assert_equal @large_ip, GeoIP.num_to_addr(@large_ipnum)
+  end
+  
+  def test_num_to_addr_expects_a_numeric_ip
+    assert_raises TypeError do
+      GeoIP.num_to_addr(nil)
+    end
+    assert_raises TypeError do
+      GeoIP.num_to_addr("foo.bar")
+    end
+  end
+  
+end
+
+class GeoIPCityTest < Test::Unit::TestCase
+  
+  def setup
+    ## Change me!
+    @dbfile = '/usr/local/GeoIP/share/GeoIP/GeoLiteCity.dat'
+  end
+
+  def test_construction_default
+    db = GeoIP::City.new(@dbfile)
+    
+    assert_raises TypeError do 
+      db.look_up(nil) 
+    end
+    
+    h = db.look_up('24.24.24.24')
+    #debugger
+    assert_kind_of Hash, h
+    assert_equal 'Jamaica', h[:city]
+    assert_equal 'United States', h[:country_name]
+  end
+
+  def test_construction_index
+    db = GeoIP::City.new(@dbfile, :index)
+    assert_look_up(db, '24.24.24.24', :city, 'Jamaica')
+  end
+
+  def test_construction_filesystem
+    db = GeoIP::City.new(@dbfile, :filesystem)
+    assert_look_up(db, '24.24.24.24', :city, 'Jamaica')
+  end
+
+  def test_construction_memory
+    db = GeoIP::City.new(@dbfile, :memory)
+    assert_look_up(db, '24.24.24.24', :city, 'Jamaica')
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIP::City.new(@dbfile, :filesystem, true)
+    assert_look_up(db, '24.24.24.24', :city, 'Jamaica')
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIP::City.new('/blah')
+    end
+  end
+
+end
+
+class GeoIPOrgTest < Test::Unit::TestCase
+  
+  def setup
+    ## Change me!
+    @dbfile = '/usr/local/GeoIP/share/GeoIP/GeoIPOrg.dat'
+  end
+
+  def test_construction_default
+    db = GeoIP::Organization.new(@dbfile)
+    
+    assert_raises TypeError do 
+      db.look_up(nil) 
+    end
+    
+    h = db.look_up('24.24.24.24')
+    assert_kind_of Hash, h
+    assert_equal 'Road Runner', h[:name]
+  end
+
+  def test_construction_index
+    db = GeoIP::Organization.new(@dbfile, :index)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_construction_filesystem
+    db = GeoIP::Organization.new(@dbfile, :filesystem)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_construction_memory
+    db = GeoIP::Organization.new(@dbfile, :memory)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIP::Organization.new(@dbfile, :filesystem, true)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIP::Organization.new('/blah')
+    end
+  end
+
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: geoip-c
+version: !ruby/object:Gem::Version 
+  version: 0.5.5
+platform: ruby
+authors: 
+- Ryah Dahl
+- Matt Todd
+- Charles Brian Quinn
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-27 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Generic GeoIP lookup tool. Based on the geoip_city RubyGem by Ryah Dahl
+email: mtodd@highgroove.com
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- extconf.rb
+- test.rb
+- geoip.c
+- README.md
+has_rdoc: true
+homepage: http://github.com/mtodd/geoip
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: A Binding to the GeoIP C library
+test_files: 
+- test.rb