net-geoip 0.07

data/README

@@ -0,0 +1,41 @@
+$Id: README,v 1.5 2002/10/09 06:29:48 sean Exp $
+
+README for Net::GeoIP
+
+Prerequisites:  libGeoIP
+
+To compile:
+	ruby extconf.rb
+	make
+	make install
+
+To test:
+	rubytest
+
+To use:
+
+	require 'net/geoip'
+	Net::GeoIP::TYPE_DISK                 >> access type constant
+	Net::GeoIP::TYPE_RAM                  >> access type constant
+
+	g = Net::GeoIP.new([access_type])
+	g = Net::GeoIP.open(db_filename[, access_type])
+	Net::GeoIP.update_database(your_key_here[,debug])
+
+	g.country_code_by_addr('127.0.0.1')   >> 'US'
+	g.country_code_by_name('yahoo.com')   >> 'US'
+	g.country_code3_by_addr('127.0.0.1')  >> 'USA'
+	g.country_code3_by_name('yahoo.com')  >> 'USA'
+	g.country_name_by_addr('127.0.0.1')   >> 'United States'
+	g.country_name_by_name('yahoo.com')   >> 'United States'
+	g.country_id_by_addr('127.0.0.1')     >> 225
+	g.country_id_by_name('yahoo.com')     >> 225
+	g.region_by_addr('127.0.0.1')         >> ?? Can't test this
+	g.region_by_name('yahoo.com')         >> ?? Can't test this
+
+	g.database_info()                     >> Misc database info
+
+
+If an address doesn't have a country code, code3, or name, the library
+returns nil.  For country_id_by_*, Net::GeoIP returns 0 for countries
+it can't find.

data/TODO

@@ -0,0 +1,7 @@
+$Id: TODO,v 1.3 2002/10/09 06:29:48 sean Exp $
+
+Need to document Net::GeoIP with rubydoc
+
+Need to be able to specify different types of databases
+
+Figure out why there's a memory leak when using database_info

data/ext/extconf.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+# $Id: extconf.rb,v 1.8 2003/01/07 23:45:07 sean Exp $
+
+require 'rbconfig'
+require 'mkmf'
+
+dir_config('libz')
+dir_config('geoip')
+
+$LIBPATH.push(Config::CONFIG['libdir'])
+$CFLAGS += " -I#{Config::CONFIG['includedir']}"
+
+def crash(str)
+  printf(" extconf failure: %s\n", str)
+  exit 1
+end
+
+
+unless have_library('z','gzopen')
+  crash(<<EOL)
+need libz.
+
+	Install libz or try passing some of the following options
+	to extconf.rb:
+
+        --with-libz-dir=/path/to/libz
+        --with-libz-lib=/path/to/libz/lib
+        --with-libz-include=/path/to/libz/include
+EOL
+end
+
+unless have_header('GeoIP.h') and
+    have_header('GeoIPUpdate.h') and
+    have_library('GeoIP', 'GeoIP_new') and
+    have_library('GeoIPUpdate', 'GeoIP_update_database')
+  crash(<<EOL)
+need libGeoIP.
+
+	Install the library or try passing one of the following
+	options to extconf.rb:
+
+        --with-geoip-dir=/path/to/geoip
+        --with-geoip-lib=/path/to/geoip/lib
+        --with-geoip-include=/path/to/geoip/include
+
+        To obtain libGeoIP, yo ucan download it from:
+
+        http://maxmind.com/geoip/api/c.shtml
+EOL
+end
+
+$CFLAGS = ' -g -Wall ' + $CFLAGS
+
+create_header()
+create_makefile('net/geoip')

data/ext/geoip.c

@@ -0,0 +1,326 @@
+/* $Id: geoip.c,v 1.6 2002/11/19 21:21:38 sean Exp $ */
+
+#include "ruby_geoip.h"
+#include "GeoIP.h"
+#include "GeoIPUpdate.h"
+
+VALUE ruby_net_geoip_country_code_by_addr(VALUE self, VALUE addr) {
+  ruby_net_geoip *rng;
+  char *cc;
+
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  cc = (char *)GeoIP_country_code_by_addr(rng->g, STR2CSTR(addr));
+  if (cc == NULL) {
+    return(Qnil);
+  } else {
+    return(rb_str_new2(cc));
+  }
+}
+
+
+VALUE ruby_net_geoip_country_code3_by_addr(VALUE self, VALUE addr) {
+  ruby_net_geoip *rng;
+  char *cc;
+
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  cc = (char *)GeoIP_country_code3_by_addr(rng->g, STR2CSTR(addr));
+  if (cc == NULL) {
+    return(Qnil);
+  } else {
+    return(rb_str_new2(cc));
+  }
+}
+
+
+VALUE ruby_net_geoip_country_code_by_name(VALUE self, VALUE name) {
+  ruby_net_geoip *rng;
+  char *cc;
+
+  Check_Type(name, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  cc = (char *)GeoIP_country_code_by_name(rng->g, STR2CSTR(name));
+  if (cc == NULL) {
+    return(Qnil);
+  } else {
+    return(rb_str_new2(cc));
+  }
+}
+
+
+VALUE ruby_net_geoip_country_code3_by_name(VALUE self, VALUE name) {
+  ruby_net_geoip *rng;
+  char *cc;
+
+  Check_Type(name, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  cc = (char *)GeoIP_country_code3_by_name(rng->g, STR2CSTR(name));
+  if (cc == NULL) {
+    return(Qnil);
+  } else {
+    return(rb_str_new2(cc));
+  }
+}
+
+
+VALUE ruby_net_geoip_country_id_by_addr(VALUE self, VALUE addr) {
+  ruby_net_geoip *rng;
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  return(INT2NUM(GeoIP_country_id_by_addr(rng->g, STR2CSTR(addr))));
+}
+
+
+VALUE ruby_net_geoip_country_id_by_name(VALUE self, VALUE name) {
+  ruby_net_geoip *rng;
+  Check_Type(name, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  return(INT2NUM(GeoIP_country_id_by_name(rng->g, STR2CSTR(name))));
+}
+
+
+VALUE ruby_net_geoip_country_name_by_addr(VALUE self, VALUE addr) {
+  ruby_net_geoip *rng;
+  char *cn;
+
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  cn = (char *)GeoIP_country_name_by_addr(rng->g, STR2CSTR(addr));
+  if (cn == NULL) {
+    return(Qnil);
+  } else {
+    return(rb_str_new2(cn));
+  }
+}
+
+
+VALUE ruby_net_geoip_country_name_by_name(VALUE self, VALUE name) {
+  ruby_net_geoip *rng;
+  char *cn;
+
+  Check_Type(name, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  cn = (char *)GeoIP_country_name_by_name(rng->g, STR2CSTR(name));
+  if (cn == NULL) {
+    return(Qnil);
+  } else {
+    return(rb_str_new2(cn));
+  }
+}
+
+
+void ruby_net_geoip_free(ruby_net_geoip *rng) {
+  if (rng->g != NULL)
+    GeoIP_delete(rng->g);
+
+  free(rng);
+}
+
+
+VALUE ruby_net_geoip_new(int argc, VALUE *argv, VALUE class) {
+  ruby_net_geoip *rng;
+  int db_type;
+  VALUE type;
+
+  switch (argc) {
+  case 0:
+    db_type = GEOIP_STANDARD;
+    break;
+  case 1:
+    rb_scan_args(argc, argv, "01", &type);
+    Check_Type(type, T_FIXNUM);
+    switch (NUM2INT(type)) {
+    case GEOIP_STANDARD:
+      db_type = NUM2INT(type);
+      break;
+    case GEOIP_MEMORY_CACHE:
+      db_type = NUM2INT(type);
+      break;
+    default:
+      rb_raise(rb_eArgError, "invalid database type: bust be TYPE_DISK or TYPE_RAM");
+    }
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (needs 0 or 1)");
+  }
+  rng = ALLOC(ruby_net_geoip);
+  rng->g = GeoIP_new(db_type);
+
+  return(Data_Wrap_Struct(class, 0, ruby_net_geoip_free, rng));
+}
+
+
+VALUE ruby_net_geoip_open(int argc, VALUE *argv, VALUE class) {
+  ruby_net_geoip *rng;
+  int db_type;
+  VALUE filename, type;
+
+  switch (argc) {
+  case 1:
+    rb_scan_args(argc, argv, "01", &filename);
+    Check_Type(filename, T_STRING);
+    db_type = GEOIP_STANDARD;
+    break;
+  case 2:
+    rb_scan_args(argc, argv, "02", &filename, &type);
+    Check_Type(filename, T_STRING);
+    Check_Type(type, T_FIXNUM);
+
+    switch (NUM2INT(type)) {
+    case GEOIP_STANDARD:
+      db_type = NUM2INT(type);
+      break;
+    case GEOIP_MEMORY_CACHE:
+      db_type = NUM2INT(type);
+      break;
+    default:
+      rb_raise(rb_eArgError, "invalid database type");
+    }
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (needs 0 or 1)");
+  }
+  rng = ALLOC(ruby_net_geoip);
+  rng->g = GeoIP_open(STR2CSTR(filename), db_type);
+
+  return(Data_Wrap_Struct(class, 0, ruby_net_geoip_free, rng));
+}
+
+
+VALUE ruby_net_geoip_database_info(VALUE self) {
+  ruby_net_geoip *rng;
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  return(rb_str_new2(GeoIP_database_info(rng->g)));
+}
+
+
+VALUE ruby_net_geoip_region_by_addr(VALUE self, VALUE addr) {
+  ruby_net_geoip *rng;
+  GeoIPRegion *r;
+  VALUE reg;
+
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  r = GeoIP_region_by_addr(rng->g, STR2CSTR(addr));
+  if (r == NULL)
+    return(Qnil);
+
+  reg = rb_str_new2(r->region);
+  GeoIPRegion_delete(r);
+  return(reg);
+}
+
+
+VALUE ruby_net_geoip_region_by_name(VALUE self, VALUE name) {
+  ruby_net_geoip *rng;
+  GeoIPRegion *r;
+  VALUE reg;
+
+  Check_Type(name, T_STRING);
+  Data_Get_Struct(self, ruby_net_geoip, rng);
+  r = GeoIP_region_by_name(rng->g, STR2CSTR(name));
+  if (r == NULL)
+    return(Qnil);
+
+  reg = rb_str_new2(r->region);
+  GeoIPRegion_delete(r);
+  return(reg);
+}
+
+
+VALUE ruby_net_geoip_update_database(int argc, VALUE *argv, VALUE class) {
+  int ret, debug;
+  VALUE bool, key;
+
+  if (argc == 1) {
+    rb_scan_args(argc, argv, "10", &key);
+    Check_Type(key, T_STRING);
+    debug = 0;
+  } else if (argc == 2) {
+    rb_scan_args(argc, argv, "20", &key, &bool);
+    switch (TYPE(bool)) {
+    case T_TRUE:
+      debug = 1;
+      break;
+    case T_FALSE:
+      debug = 0;
+      break;
+    default:
+      rb_raise(rb_eArgError, "Invalid argument: debug flag must be boolean");
+    }
+  } else {
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)");
+  }
+
+  ret = GeoIP_update_database(STR2CSTR(key), debug, NULL);
+
+  switch (ret) {
+  case 0:           /* Success, database updated */
+    return(Qtrue);
+  case 1:           /* Database up-to-date, no action taken */
+    return(Qfalse);
+  case -1:
+    rb_raise(eNetGeoIPError, "Invalid License Key in %s", STR2CSTR(key));
+  case -11:
+    rb_raise(eNetGeoIPError, "Unable to resolve hostname");
+  case -12:
+    rb_raise(eNetGeoIPError, "Non-IPv4 addres");
+  case -13:
+    rb_raise(eNetGeoIPError, "Error opening socket");
+  case -14:
+    rb_raise(eNetGeoIPError, "Unable to connect");
+  case -15:
+    rb_raise(eNetGeoIPError, "Unable to write GeoIP.dat.gz file");
+  case -16:
+    rb_raise(eNetGeoIPError, "Unable to write GeoIP.dat file");
+  case -17:
+    rb_raise(eNetGeoIPError, "Unable to read gzip data");
+  case -18:
+    rb_raise(eNetGeoIPError, "Out of memory error");
+  case -19:
+    rb_raise(eNetGeoIPError, "Error reading from socket, see errno");
+  default:
+    rb_raise(eNetGeoIPError, "Unknown error: contact the maintainer");
+  }
+}
+
+
+void Init_geoip(void) {
+  mNet = rb_define_module("Net");
+  cNetGeoIP = rb_define_class_under(mNet, "GeoIP", rb_cObject);
+  eNetGeoIPError = rb_define_class_under(cNetGeoIP, "Error", rb_eException);
+
+  rb_define_const(cNetGeoIP, "TYPE_DISK", INT2NUM(GEOIP_STANDARD));
+  rb_define_const(cNetGeoIP, "TYPE_RAM", INT2NUM(GEOIP_MEMORY_CACHE));
+  rb_define_const(cNetGeoIP, "VERSION", rb_str_new2(RUBY_GEOIP_VERSION));
+  rb_define_const(cNetGeoIP, "VERNUM", INT2NUM(RUBY_GEOIP_VERNUM));
+
+  rb_define_singleton_method(cNetGeoIP, "new", ruby_net_geoip_new, -1);
+  rb_define_singleton_method(cNetGeoIP, "open", ruby_net_geoip_open, -1);
+  rb_define_singleton_method(cNetGeoIP, "update_database",
+			     ruby_net_geoip_update_database, -1);
+
+  rb_define_method(cNetGeoIP, "country_code_by_addr",
+		   ruby_net_geoip_country_code_by_addr, 1);
+  rb_define_method(cNetGeoIP, "country_code3_by_addr",
+		   ruby_net_geoip_country_code3_by_addr, 1);
+  rb_define_method(cNetGeoIP, "country_code_by_name",
+		   ruby_net_geoip_country_code_by_name, 1);
+  rb_define_method(cNetGeoIP, "country_code3_by_name",
+		   ruby_net_geoip_country_code3_by_name, 1);
+  rb_define_method(cNetGeoIP, "country_id_by_addr",
+		   ruby_net_geoip_country_id_by_addr, 1);
+  rb_define_method(cNetGeoIP, "country_id_by_name",
+		   ruby_net_geoip_country_id_by_name, 1);
+  rb_define_method(cNetGeoIP, "country_name_by_addr",
+		   ruby_net_geoip_country_name_by_addr, 1);
+  rb_define_method(cNetGeoIP, "country_name_by_name",
+		   ruby_net_geoip_country_name_by_name, 1);
+  rb_define_method(cNetGeoIP, "database_info",
+		   ruby_net_geoip_database_info, 0);
+  rb_define_method(cNetGeoIP, "region_by_addr",
+		   ruby_net_geoip_region_by_addr, 1);
+  rb_define_method(cNetGeoIP, "region_by_name",
+		   ruby_net_geoip_region_by_name, 1);
+}

data/ext/ruby_geoip.h

@@ -0,0 +1,24 @@
+/* $Id: geoip.h,v 1.2 2002/09/28 04:51:09 sean Exp $ */
+
+#ifndef __RUBY_GEOIP_H__
+#define __RUBY_GEOIP_H__
+
+/* Don't nuke this block!  It is used for automatically updating the
+ * versions below. VERSION = string formatting, VERNUM = numbered
+ * version for inline testing: increment both or none at all. */
+#define RUBY_GEOIP_VERSION  "0.01"
+#define RUBY_GEOIP_VERNUM   1
+
+#include <ruby.h>
+#include <rubyio.h>
+#include <GeoIP.h>
+
+VALUE mNet;
+VALUE cNetGeoIP;
+VALUE eNetGeoIPError;
+
+typedef struct ruby_net_geoip {
+  GeoIP *g;
+} ruby_net_geoip;
+
+#endif

data/net-geoip.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = 'net-geoip'
+  s.date        = "2011-05-02"
+  s.version     = '0.07'
+
+  s.authors     = ["Sean Chittenden", "Steven Baker", "MaxMind", "Ken Robertson"]
+  s.email       = ["ken@invalidlogic.com"]
+
+  s.summary     = 'Net::GeoIP'
+  s.description = "Gem for Net::GeoIP"
+
+  s.files       = `git ls-files`.split("\n")
+  s.extensions  = ["ext/extconf.rb"]
+
+  s.add_development_dependency 'rake-compiler'
+end

data/tests/tc_Net::GeoIP.rb

@@ -0,0 +1,124 @@
+# $Id: tc_Net::GeoIP.rb,v 1.4 2002/10/08 21:14:47 sean Exp $
+
+class TC_Net_GeoIP < Test::Unit::TestCase
+  def set_up()
+    @g = Net::GeoIP.new()
+    assert(@g)
+    @bad_ips  = ['66.250.180.0']
+    @bad_names = ['tgd.net']
+    @good_ips = [['64.81.67.0','US','USA','United States',225],['210.157.158.0','JP','JPN','Japan',111]]
+    @good_names = [['whitehouse.gov','US','United States',225],['freebsd.org','US','United States',225]]
+  end
+
+  def tear_down()
+    @g = nil
+    @bad_ips = nil
+    @bad_names = nil
+    @good_ips = nil
+    @good_names = nil
+  end
+
+
+  def test_net_geoip_constants()
+    assert_instance_of(String, Net::GeoIP::VERSION)
+    assert_instance_of(Fixnum, Net::GeoIP::VERNUM)
+    assert_instance_of(Fixnum, Net::GeoIP::TYPE_DISK)
+    assert_instance_of(Fixnum, Net::GeoIP::TYPE_RAM)
+  end
+
+
+  def test_net_geoip_country_code_by_addr()
+    for ip in @good_ips
+      assert_instance_of(ip[1].class, @g.country_code_by_addr(ip[0]))
+      assert_equal(ip[1], @g.country_code_by_addr(ip[0]))
+    end
+
+    for ip in @bad_ips
+      assert_instance_of(NilClass, @g.country_code_by_addr(ip))
+    end
+  end
+
+
+  def test_net_geoip_country_code3_by_addr()
+    for ip in @good_ips
+      assert_instance_of(ip[2].class, @g.country_code3_by_addr(ip[0]))
+      assert_equal(ip[2], @g.country_code3_by_addr(ip[0]))
+    end
+
+    for ip in @bad_ips
+      assert_instance_of(NilClass, @g.country_code3_by_addr(ip))
+    end
+  end
+
+
+  def test_net_geoip_country_name_by_addr()
+    for ip in @good_ips
+      assert_instance_of(ip[3].class, @g.country_name_by_addr(ip[0]))
+      assert_equal(ip[3], @g.country_name_by_addr(ip[0]))
+    end
+
+    for ip in @bad_ips
+      assert_instance_of(NilClass, @g.country_name_by_addr(ip))
+    end
+  end
+
+
+  def test_net_geoip_country_id_by_addr()
+    for ip in @good_ips
+      assert_instance_of(ip[4].class, @g.country_id_by_addr(ip[0]))
+      assert_equal(ip[4], @g.country_id_by_addr(ip[0]))
+    end
+
+    for ip in @bad_ips
+      assert_equal(0, @g.country_id_by_addr(ip))
+    end
+  end
+
+
+  def test_net_geoip_country_code_by_name()
+    for name in @good_names
+      assert_instance_of(name[1].class, @g.country_code_by_name(name[0]))
+      assert_equal(name[1], @g.country_code_by_addr(name[0]))
+    end
+
+    for name in @bad_names
+      assert_instance_of(NilClass, @g.country_code_by_name(name))
+    end
+  end
+
+
+  def test_net_geoip_country_name_by_name()
+    for name in @good_names
+      assert_instance_of(name[2].class, @g.country_name_by_name(name[0]))
+      assert_equal(name[2], @g.country_name_by_addr(name[0]))
+    end
+
+    for name in @bad_names
+      assert_instance_of(NilClass, @g.country_name_by_name(name))
+    end
+  end
+
+
+  def test_net_geoip_country_id_by_name()
+    for name in @good_names
+      assert_instance_of(name[3].class, @g.country_id_by_name(name[0]))
+      assert_equal(name[3], @g.country_id_by_addr(name[0]))
+    end
+
+    for name in @bad_names
+      assert_equal(0, @g.country_id_by_name(name))
+    end
+  end
+
+
+  def test_net_geoip_database_info()
+    assert_instance_of(String, @g.database_info)
+  end
+
+
+  def test_net_geoip_update_database()
+    # assert_raises(Net::GeoIP::Error) do
+    #  @Net::GeoIP.update_database('ruby-Net::GeoIP-test-bad_key', false)
+    # end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: net-geoip
+version: !ruby/object:Gem::Version 
+  hash: 5
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  version: "0.07"
+platform: ruby
+authors: 
+- Sean Chittenden
+- Steven Baker
+- MaxMind
+- Ken Robertson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Gem for Net::GeoIP
+email: 
+- ken@invalidlogic.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README
+- TODO
+- ext/extconf.rb
+- ext/geoip.c
+- ext/ruby_geoip.h
+- net-geoip.gemspec
+- tests/tc_Net::GeoIP.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Net::GeoIP
+test_files: []
+