pax_global_header00006660000000000000000000000064125364035170014520gustar00rootroot0000000000000052 comment=e5f8ea00f476d60a1e539d74211ce24881347d9e golang-github-abh-geoip-dev-0.0~git20150611/000077500000000000000000000000001253640351700202355ustar00rootroot00000000000000golang-github-abh-geoip-dev-0.0~git20150611/.gitignore000066400000000000000000000004371253640351700222310ustar00rootroot00000000000000geoip-demo *~ /db/GeoLiteCity.dat # Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe golang-github-abh-geoip-dev-0.0~git20150611/.travis.yml000066400000000000000000000006121253640351700223450ustar00rootroot00000000000000language: go go: - 1.3 - 1.4 - tip before_install: - sudo apt-get install libgeoip-dev bzr install: - mkdir -p $TRAVIS_BUILD_DIR/db - curl http://geodns.bitnames.com/geoip/GeoLiteCity.dat.gz | gzip -cd > $TRAVIS_BUILD_DIR/db/GeoLiteCity.dat - go get gopkg.in/check.v1 script: - cd $TRAVIS_BUILD_DIR && go test -gocheck.v - go test -gocheck.v -gocheck.b -gocheck.btime=2s golang-github-abh-geoip-dev-0.0~git20150611/LICENSE000066400000000000000000000021511253640351700212410ustar00rootroot00000000000000Copyright (C) 2012 Stiletto Copyright (C) 2012-2013 Ask BjУИrn Hansen, Develooper LLC 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. golang-github-abh-geoip-dev-0.0~git20150611/README.md000066400000000000000000000021321253640351700215120ustar00rootroot00000000000000# GeoIP API for Go This package wraps the [libgeoip C library](http://www.maxmind.com/app/c) for access from Go (golang). [![Build Status](https://travis-ci.org/abh/geoip.png?branch=master)](https://travis-ci.org/abh/geoip) Install with `go get github.com/abh/geoip` and use [godoc geoip](http://godoc.org/github.com/abh/geoip) to read the documentation. There's a small example in the `ex/` subdirectory. You can download the free [GeoLite Country](http://www.maxmind.com/app/geoip_country) database or you can [subscribe to updates](http://www.maxmind.com/app/country). ## Examples file := "/usr/share/GeoIP/GeoIP.dat" gi, err := geoip.Open(file) if err != nil { fmt.Printf("Could not open GeoIP database\n") } if gi != nil { country, netmask := gi.GetCountry("207.171.7.51") } // Setup gi6 by opening the optional IPv6 database and then... country := gi6.GetCountry_v6("2607:f238:2::5") fmt.Println(country) ## Contact Copyright 2012-2013 Ask BjУИrn Hansen . The package is MIT licensed, see the LICENSE file. Originally based on example code from blasux@blasux.ru. golang-github-abh-geoip-dev-0.0~git20150611/const.go000066400000000000000000000026141253640351700217150ustar00rootroot00000000000000package geoip // GeoIPDBTypes enum in GeoIP.h const ( GEOIP_COUNTRY_EDITION = 1 GEOIP_REGION_EDITION_REV0 = 7 GEOIP_CITY_EDITION_REV0 = 6 GEOIP_ORG_EDITION = 5 GEOIP_ISP_EDITION = 4 GEOIP_CITY_EDITION_REV1 = 2 GEOIP_REGION_EDITION_REV1 = 3 GEOIP_PROXY_EDITION = 8 GEOIP_ASNUM_EDITION = 9 GEOIP_NETSPEED_EDITION = 10 GEOIP_DOMAIN_EDITION = 11 GEOIP_COUNTRY_EDITION_V6 = 12 GEOIP_LOCATIONA_EDITION = 13 GEOIP_ACCURACYRADIUS_EDITION = 14 GEOIP_CITYCONFIDENCE_EDITION = 15 GEOIP_CITYCONFIDENCEDIST_EDITION = 16 GEOIP_LARGE_COUNTRY_EDITION = 17 GEOIP_LARGE_COUNTRY_EDITION_V6 = 18 GEOIP_ASNUM_EDITION_V6 = 21 GEOIP_ISP_EDITION_V6 = 22 GEOIP_ORG_EDITION_V6 = 23 GEOIP_DOMAIN_EDITION_V6 = 24 GEOIP_LOCATIONA_EDITION_V6 = 25 GEOIP_REGISTRAR_EDITION = 26 GEOIP_REGISTRAR_EDITION_V6 = 27 GEOIP_USERTYPE_EDITION = 28 GEOIP_USERTYPE_EDITION_V6 = 29 GEOIP_CITY_EDITION_REV1_V6 = 30 GEOIP_CITY_EDITION_REV0_V6 = 31 GEOIP_NETSPEED_EDITION_REV1 = 32 GEOIP_NETSPEED_EDITION_REV1_V6 = 33 ) // GeoIPOptions enum in GeoIP.h const ( GEOIP_STANDARD = 0 GEOIP_MEMORY_CACHE = 1 GEOIP_CHECK_CACHE = 2 GEOIP_INDEX_CACHE = 4 GEOIP_MMAP_CACHE = 8 ) golang-github-abh-geoip-dev-0.0~git20150611/db/000077500000000000000000000000001253640351700206225ustar00rootroot00000000000000golang-github-abh-geoip-dev-0.0~git20150611/db/.gitignore000066400000000000000000000000111253640351700226020ustar00rootroot00000000000000*.dat.gz golang-github-abh-geoip-dev-0.0~git20150611/db/download000077500000000000000000000016321253640351700223610ustar00rootroot00000000000000#!/usr/bin/env perl use strict; use v5.12.0; use LWP::Simple qw(mirror); use File::Basename qw(basename); my @files = qw( http://geolite.maxmind.com/download/geoip/database/GeoLiteCountry/GeoIP.dat.gz http://geolite.maxmind.com/download/geoip/database/GeoIPv6.dat.gz http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz http://geolite.maxmind.com/download/geoip/database/GeoLiteCityv6-beta/GeoLiteCityv6.dat.gz http://download.maxmind.com/download/geoip/database/asnum/GeoIPASNum.dat.gz http://download.maxmind.com/download/geoip/database/asnum/GeoIPASNumv6.dat.gz ); for my $url (@files) { my $file = basename($url); my ($dat_name) = ($file =~ m/(.*)\.gz/); my $rv = mirror($url, $file); if ($rv == 200) { system("gzip -cd $file > $dat_name"); } elsif ($rv == 304) { # already updated } else { say "$url:", $rv; } } golang-github-abh-geoip-dev-0.0~git20150611/ex/000077500000000000000000000000001253640351700206515ustar00rootroot00000000000000golang-github-abh-geoip-dev-0.0~git20150611/ex/geoip-demo.go000066400000000000000000000024621253640351700232310ustar00rootroot00000000000000package main import ( "fmt" "github.com/abh/geoip" ) func main() { file6 := "../db/GeoIPv6.dat" gi6, err := geoip.Open(file6) if err != nil { fmt.Printf("Could not open GeoIPv6 database: %s\n", err) } gi, err := geoip.Open() if err != nil { fmt.Printf("Could not open GeoIP database: %s\n", err) } giasn, err := geoip.Open("../db/GeoIPASNum.dat") if err != nil { fmt.Printf("Could not open GeoIPASN database: %s\n", err) } giasn6, err := geoip.Open("../db/GeoIPASNumv6.dat") if err != nil { fmt.Printf("Could not open GeoIPASN database: %s\n", err) } if giasn != nil { ip := "207.171.7.51" asn, netmask := giasn.GetName(ip) fmt.Printf("%s: %s (netmask /%d)\n", ip, asn, netmask) } if gi != nil { test4(*gi, "207.171.7.51") test4(*gi, "127.0.0.1") } if gi6 != nil { ip := "2607:f238:2::5" country, netmask := gi6.GetCountry_v6(ip) var asn string var asn_netmask int if giasn6 != nil { asn, asn_netmask = giasn6.GetNameV6(ip) } fmt.Printf("%s: %s/%d %s/%d\n", ip, country, netmask, asn, asn_netmask) } } func test4(g geoip.GeoIP, ip string) { test(func(s string) (string, int) { return g.GetCountry(s) }, ip) } func test(f func(string) (string, int), ip string) { country, netmask := f(ip) fmt.Printf("ip: %s is [%s] (netmask %d)\n", ip, country, netmask) } golang-github-abh-geoip-dev-0.0~git20150611/geoip.go000066400000000000000000000177721253640351700217050ustar00rootroot00000000000000/* Go (cgo) interface to libgeoip */ package geoip /* #cgo pkg-config: geoip #include #include #include #include //typedef GeoIP* GeoIP_pnt */ import "C" import ( "fmt" "log" "os" "runtime" "sync" "unsafe" ) type GeoIP struct { db *C.GeoIP // We don't use GeoIP's thread-safe API calls, which means there is a // single global netmask variable that gets clobbered in the main // lookup routine. Any calls which have _GeoIP_seek_record_gl need to // be wrapped in this mutex. mu sync.Mutex } func (gi *GeoIP) free() { if gi == nil { return } if gi.db == nil { gi = nil return } C.GeoIP_delete(gi.db) gi = nil return } // Default convenience wrapper around OpenDb func Open(files ...string) (*GeoIP, error) { return OpenDb(files, GEOIP_MEMORY_CACHE) } // Opens a GeoIP database by filename with specified GeoIPOptions flag. // All formats supported by libgeoip are supported though there are only // functions to access some of the databases in this API. // If you don't pass a filename, it will try opening the database from // a list of common paths. func OpenDb(files []string, flag int) (*GeoIP, error) { if len(files) == 0 { files = []string{ "/usr/share/GeoIP/GeoIP.dat", // Linux default "/usr/share/local/GeoIP/GeoIP.dat", // source install? "/usr/local/share/GeoIP/GeoIP.dat", // FreeBSD "/opt/local/share/GeoIP/GeoIP.dat", // MacPorts "/usr/share/GeoIP/GeoIP.dat", // ArchLinux } } g := &GeoIP{} runtime.SetFinalizer(g, (*GeoIP).free) var err error for _, file := range files { // libgeoip prints errors if it can't open the file, so check first if _, err := os.Stat(file); err != nil { if os.IsExist(err) { log.Println(err) } continue } cbase := C.CString(file) defer C.free(unsafe.Pointer(cbase)) g.db, err = C.GeoIP_open(cbase, C.int(flag)) if g.db != nil && err != nil { break } } if err != nil { return nil, fmt.Errorf("Error opening GeoIP database (%s): %s", files, err) } if g.db == nil { return nil, fmt.Errorf("Didn't open GeoIP database (%s)", files) } C.GeoIP_set_charset(g.db, C.GEOIP_CHARSET_UTF8) return g, nil } // SetCustomDirectory sets the default location for the GeoIP .dat files used when // calling OpenType() func SetCustomDirectory(dir string) { cdir := C.CString(dir) // GeoIP doesn't copy the string, so don't free it when we're done here. // defer C.free(unsafe.Pointer(cdir)) C.GeoIP_setup_custom_directory(cdir) } // OpenType opens a specified GeoIP database type in the default location with the // specified GeoIPOptions flag. Constants are defined for each database type // (for example GEOIP_COUNTRY_EDITION). func OpenTypeFlag(dbType int, flag int) (*GeoIP, error) { g := &GeoIP{} runtime.SetFinalizer(g, (*GeoIP).free) var err error g.db, err = C.GeoIP_open_type(C.int(dbType), C.int(flag)) if err != nil { return nil, fmt.Errorf("Error opening GeoIP database (%d): %s", dbType, err) } if g.db == nil { return nil, fmt.Errorf("Didn't open GeoIP database (%d)", dbType) } C.GeoIP_set_charset(g.db, C.GEOIP_CHARSET_UTF8) return g, nil } // OpenType opens a specified GeoIP database type in the default location // and the 'memory cache' flag. Use OpenTypeFlag() to specify flag. func OpenType(dbType int) (*GeoIP, error) { return OpenTypeFlag(dbType, GEOIP_MEMORY_CACHE) } // Takes an IPv4 address string and returns the organization name for that IP. // Requires the GeoIP organization database. func (gi *GeoIP) GetOrg(ip string) string { name, _ := gi.GetName(ip) return name } // Works on the ASN, Netspeed, Organization and probably other // databases, takes and IP string and returns a "name" and the // netmask. func (gi *GeoIP) GetName(ip string) (name string, netmask int) { if gi.db == nil { return } gi.mu.Lock() defer gi.mu.Unlock() cip := C.CString(ip) defer C.free(unsafe.Pointer(cip)) cname := C.GeoIP_name_by_addr(gi.db, cip) if cname != nil { name = C.GoString(cname) defer C.free(unsafe.Pointer(cname)) netmask = int(C.GeoIP_last_netmask(gi.db)) return } return } type GeoIPRecord struct { CountryCode string CountryCode3 string CountryName string Region string City string PostalCode string Latitude float32 Longitude float32 MetroCode int AreaCode int CharSet int ContinentCode string } // Returns the "City Record" for an IP address. Requires the GeoCity(Lite) // database - http://www.maxmind.com/en/city func (gi *GeoIP) GetRecord(ip string) *GeoIPRecord { if gi.db == nil { return nil } cip := C.CString(ip) defer C.free(unsafe.Pointer(cip)) gi.mu.Lock() record := C.GeoIP_record_by_addr(gi.db, cip) gi.mu.Unlock() if record == nil { return nil } // defer C.free(unsafe.Pointer(record)) defer C.GeoIPRecord_delete(record) rec := new(GeoIPRecord) rec.CountryCode = C.GoString(record.country_code) rec.CountryCode3 = C.GoString(record.country_code3) rec.CountryName = C.GoString(record.country_name) rec.Region = C.GoString(record.region) rec.City = C.GoString(record.city) rec.PostalCode = C.GoString(record.postal_code) rec.Latitude = float32(record.latitude) rec.Longitude = float32(record.longitude) rec.CharSet = int(record.charset) rec.ContinentCode = C.GoString(record.continent_code) if gi.db.databaseType != C.GEOIP_CITY_EDITION_REV0 { /* DIRTY HACK BELOW: The GeoIPRecord struct in GeoIPCity.h contains an int32 union of metro_code and dma_code. The union is unnamed, so cgo names it anon0 and assumes it's a 4-byte array. */ union_int := (*int32)(unsafe.Pointer(&record.anon0)) rec.MetroCode = int(*union_int) rec.AreaCode = int(record.area_code) } return rec } // Returns the country code and region code for an IP address. Requires // the GeoIP Region database. func (gi *GeoIP) GetRegion(ip string) (string, string) { if gi.db == nil { return "", "" } cip := C.CString(ip) defer C.free(unsafe.Pointer(cip)) gi.mu.Lock() region := C.GeoIP_region_by_addr(gi.db, cip) gi.mu.Unlock() if region == nil { return "", "" } countryCode := C.GoString(®ion.country_code[0]) regionCode := C.GoString(®ion.region[0]) defer C.free(unsafe.Pointer(region)) return countryCode, regionCode } // Returns the region name given a country code and region code func GetRegionName(countryCode, regionCode string) string { cc := C.CString(countryCode) defer C.free(unsafe.Pointer(cc)) rc := C.CString(regionCode) defer C.free(unsafe.Pointer(rc)) region := C.GeoIP_region_name_by_code(cc, rc) if region == nil { return "" } // it's a static string constant, don't free this regionName := C.GoString(region) return regionName } // Same as GetName() but for IPv6 addresses. func (gi *GeoIP) GetNameV6(ip string) (name string, netmask int) { if gi.db == nil { return } gi.mu.Lock() defer gi.mu.Unlock() cip := C.CString(ip) defer C.free(unsafe.Pointer(cip)) cname := C.GeoIP_name_by_addr_v6(gi.db, cip) if cname != nil { name = C.GoString(cname) defer C.free(unsafe.Pointer(cname)) netmask = int(C.GeoIP_last_netmask(gi.db)) return } return } // Takes an IPv4 address string and returns the country code for that IP // and the netmask for that IP range. func (gi *GeoIP) GetCountry(ip string) (cc string, netmask int) { if gi.db == nil { return } gi.mu.Lock() defer gi.mu.Unlock() cip := C.CString(ip) defer C.free(unsafe.Pointer(cip)) ccountry := C.GeoIP_country_code_by_addr(gi.db, cip) if ccountry != nil { cc = C.GoString(ccountry) netmask = int(C.GeoIP_last_netmask(gi.db)) return } return } // GetCountry_v6 works the same as GetCountry except for IPv6 addresses, be sure to // load a database with IPv6 data to get any results. func (gi *GeoIP) GetCountry_v6(ip string) (cc string, netmask int) { if gi.db == nil { return } gi.mu.Lock() defer gi.mu.Unlock() cip := C.CString(ip) defer C.free(unsafe.Pointer(cip)) ccountry := C.GeoIP_country_code_by_addr_v6(gi.db, cip) if ccountry != nil { cc = C.GoString(ccountry) netmask = int(C.GeoIP_last_netmask(gi.db)) return } return } golang-github-abh-geoip-dev-0.0~git20150611/geoip_test.go000066400000000000000000000050211253640351700227240ustar00rootroot00000000000000package geoip import ( "fmt" "testing" . "gopkg.in/check.v1" ) // Hook up gocheck into the gotest runner. func Test(t *testing.T) { TestingT(t) } type GeoIPSuite struct { } var _ = Suite(&GeoIPSuite{}) func (s *GeoIPSuite) Testv4(c *C) { gi, err := Open() if gi == nil || err != nil { fmt.Printf("Could not open GeoIP database: %s\n", err) return } c.Check(gi, NotNil) country, netmask := gi.GetCountry("64.17.254.216") c.Check(country, Equals, "US") c.Check(netmask, Equals, 17) country, netmask = gi.GetCountry("222.230.136.0") c.Check(country, Equals, "JP") c.Check(netmask, Equals, 16) } func (s *GeoIPSuite) TestOpenType(c *C) { SetCustomDirectory("test-db") // Open Country database gi, err := OpenType(GEOIP_COUNTRY_EDITION) c.Check(err, IsNil) c.Assert(gi, NotNil) country, _ := gi.GetCountry("81.2.69.160") c.Check(country, Equals, "GB") } func (s *GeoIPSuite) Benchmark_GetCountry(c *C) { gi, err := Open() if gi == nil || err != nil { fmt.Printf("Could not open GeoIP database: %s\n", err) return } for i := 0; i < c.N; i++ { gi.GetCountry("207.171.7.51") } } func (s *GeoIPSuite) Testv4Record(c *C) { gi, err := Open("test-db/GeoIPCity.dat") if gi == nil || err != nil { fmt.Printf("Could not open GeoIP database: %s\n", err) return } c.Check(gi, NotNil) record := gi.GetRecord("66.92.181.240") c.Assert(record, NotNil) c.Check( *record, Equals, GeoIPRecord{ CountryCode: "US", CountryCode3: "USA", CountryName: "United States", Region: "CA", City: "Fremont", PostalCode: "94538", Latitude: 37.5079, Longitude: -121.96, AreaCode: 510, MetroCode: 807, CharSet: 1, ContinentCode: "NA", }, ) } func (s *GeoIPSuite) Benchmark_GetRecord(c *C) { gi, err := Open("db/GeoLiteCity.dat") if gi == nil || err != nil { fmt.Printf("Could not open GeoIP database: %s\n", err) return } for i := 0; i < c.N; i++ { record := gi.GetRecord("207.171.7.51") if record == nil { panic("") } } } func (s *GeoIPSuite) Testv4Region(c *C) { gi, err := Open("test-db/GeoIPRegion.dat") if gi == nil || err != nil { fmt.Printf("Could not open GeoIP database: %s\n", err) return } country, region := gi.GetRegion("64.17.254.223") c.Check(country, Equals, "US") c.Check(region, Equals, "CA") } func (s *GeoIPSuite) TestRegionName(c *C) { regionName := GetRegionName("NL", "07") c.Check(regionName, Equals, "Noord-Holland") regionName = GetRegionName("CA", "ON") c.Check(regionName, Equals, "Ontario") } golang-github-abh-geoip-dev-0.0~git20150611/test-db/000077500000000000000000000000001253640351700215775ustar00rootroot00000000000000golang-github-abh-geoip-dev-0.0~git20150611/test-db/GeoIP.dat000066400000000000000000000063631253640351700232440ustar00rootroot00000000000000ЉЊџџџџџџџџџџ џџ џџ џџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџсџџ ШЩ !ˆ‰"#cd$џџ7џџ%џџ&џџџџ'(џџ)џџ*џџџџ+џџ,џџ-џџ.џџ/џџ0џџ1џџ23џџџџ4џџ56џџџџ89:џџџџNџџ;<џџџџ=џџ>џџ?@џџџџAџџBџџCџџDEџџFџџџџGџџHџџIJџџџџKџџLџџMџџџџOPџџџџQRџџSџџTџџUџџVџџWџџXџџYџџџџZџџ[\џџџџ]^џџџџ_`џџaџџсџџbсџџџџeџџwџџџџfgџџџџhџџiџџjkџџlџџџџmnџџџџoџџpqџџџџrsџџџџtџџuџџvџџxџџџџyzџџџџ{|џџџџ}џџ~џџ€џџџџџџ‚џџƒџџ„…џџ†џџ‡‡єџџєџџџџŠžџџ‹џџŒџџџџŽџџџџџџ‘’џџџџ“џџ”џџ•џџ–џџ—˜џџџџ™џџš›џџœџџџџŸџџџџЕ џџџџЁЂџџџџЃџџЄџџЅІџџЇџџџџЈџџЉџџЊџџЋЌџџџџ­џџЎџџЏАџџБџџџџВГџџДџџџџЖџџЗџџИџџџџЙКџџџџЛМџџНџџџџОџџПРџџџџСТџџУџџФџџџџХџџЦџџЧџџbџџЪџџїЫЬЭџџуџџЮџџЯџџаџџбџџвџџгџџдџџџџежџџзџџиџџџџйкџџлџџџџмџџнџџопџџрџџсџџтџџџџbџџфхџџцџџџџчџџшщџџџџъџџыџџьэџџџџюяџџ№џџџџёџџђџџѓџџєѕџџџџіbџџјџџљџџњџџћџџџџќџџ§ўџџџџџџџџџџџџџџџџџџџџџџџџџ џџ  џџџџ lџџџџdџџPџџџџ()џџџџџџџџџџџџџџџџџџџџџџџџ џџџџ!"џџџџ#џџ$%џџџџ&'џџMџџџџ*џџџџ<џџ+џџ,-џџ.џџ/џџџџ0џџ12џџ3џџ4џџџџ56џџ7џџ8џџџџ9:џџџџ;џџЂџџџџ=>џџ?џџџџ@џџAџџBCџџDџџEџџџџFGџџHџџџџIJџџKџџџџLџџMџџNOџџJџџџџџџQRџџџџSTџџџџUџџVWџџXџџYџџZџџ[џџ\џџ]џџ^џџ_џџџџ`aџџџџbџџcџџ8џџeџџџџfghџџi–џџjџџџџkџџlџџmnџџoџџџџpџџqrџџџџstџџџџuvџџwxyz…†{|‚JџџJџџ}JџџJџџ~JџџJџџ€Jџџ{{JџџJџџƒJџџ„Jџџ{‡ˆ{‰‹ŒŠJџџJџџ{Jџџ{JџџJџџŽJџџ{Jџџ‘•Jџџ’Jџџ“JџџJџџ”Jџџ{{Jџџџџ—˜џџ™џџšџџ›џџœџџџџžџџŸџџџџ ЁџџџџЂЃџџЄџџЅџџџџІџџЇџџЈПџџџџЋџџаџџЌџџџџ­џџЎџџЏАБџџВџџСџџГДџџџџЕџџЖЗџџИџџџџЙџџКџџЛМџџџџНОџџџџПџџР&џџџџџџТУџџџџФџџХЦџџЧџџџџШџџЩџџЪЫџџџџЬЭџџџџЮџџЯщџџџџџџбвгдџџя№еџџжџџзџџџџиџџйкџџџџлџџмџџноџџџџпџџрсџџџџтџџуфџџхџџџџцчџџџџшџџщъыџџьюџџэсџџџџbџџёџџџџђџџѓєџџѕџџіџџџџїјџџљџџџџњџџћџџќ§џџџџўџџџџџџџџџџџџџџџbџџџџџџ џџ џџ џџ џџџџ џџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџџ џџџџ!"џџ#џџ$џџџџ%&џџ'џџoџџoџџgolang-github-abh-geoip-dev-0.0~git20150611/test-db/GeoIPCity.dat000066400000000000000000000077411253640351700240760ustar00rootroot00000000000000ИЙ+++++ + + ++ +++++++++++++,ЮЯ !‹Œ"#ef$+8+%+&++'(+)+*++++,+-+.+/+0+1+23++4+56++7+E9:;++P+<=++>+?+@A++B+C+D+EF+G++H+I+JK++L+M+NO++c+QR++ST+U+V+W+X+Y+Z+[++\+]^++_`++ab+c+d+g+z++hi++j+k+lm+n++op++q+rs++tu++v+w+x+y+ {++|}++~++€++‚ƒ+„++…+†+‡ˆ+‰+ŠŠЛЛ+ЁЂ+Ž+++‘+’“++”•++–+—+˜+™+š›++œ+ž+Ÿ+ ++ХЃ++КЄ++ЅІ++Ї+Ј+ЉЊ+Ћ++Ќ+­+Ў+ЏА++Б+В+ГД+Е++ЖЗ+И+Й++вЛ+М+Н++ОП++РС+Т++У+ФХ++ЦЧ+Ш+Щ++Ъ+Ы+Ь+Ээ++а+џбвг+ъ+д+е+ж+з+и+й+к++лм+н+о++пр+с++т+у+фх+ц+ч+ш++щ ++ыь+э++ю+я№++ё+ђ+ѓє++ѕі+ї++ј+љ+њ+ћќ++§ў+%++++++++++ ++  + + ++++++++@+l+X++01++++ +!++"#+$++%&+'+(++)*++++,-++./+R+2++D+3+45+6+7++8+9:+;+<++=>+?+@++AB++C+d+EF+G++H+I+JK+L+M++NO+P++QR+S++T+U+VW+t++YZ++[\++]+^_+`+a+b+c+d+e+f+g++hi++j+k+…m++nop+qЅ+r++s+t+uv+w++x+yz++{|++}~+€‚‘ƒ„Š‹Ѕ…ЖЅ†Щ‡ЩˆЩ‰ЖЩŒЅЅЖЅЖŽЖЅх’“žŸ”•˜™ЩЖ–ЅЅ—ЅЖћš›Ж*ЖœЖЖ ЄЖЁЅЂ@ЖЃЖ—ŒЅ+ІЇ+Ј+Љ+Њ+Ћ+Ќ+­+Ў++ЏА++БВ+Г+Д++Е+Ж+З\+К+Я+Л++М+Н+ОП++Р+СТ++У+ФХ+Ц++Ч+Ш+ЩЪ++ЫЬ++Э+Юq++абвг+№ёд+е+ж++з+ий++к+л+мн++о+пр++с+ту+ф++хц++ч+шщъ+ыю+ь‹+э+‹я+‹+ђ++ѓ+єѕ+і+ї++јљ+њ++ћ+ќ+§ў++џ+++++++Ё++ + + + + ++++++++++++++С+++++ ++!+"#++$%+&+'++()+*+ля*сPAPittsburghіЂ!iBќСсCAEl Segundo90245Є f юA сSCGreenville29615љШ €ъ8ЊсTXSan Antonio78251?іиh КШ сCAFremont94538g0!0лVR є@w@wс C!0Њ сFLDelray Beachч€h?б^сCAMilpitas95035Ф-!До№Q сILGlenview600257у!™п2 сGADouglasvilleЋ Ыˆтl20FeltreЧ|"HMH9London†S#sЂ12OsloП›$,JA8Lagnysь"с8p?#ажJB4Lille598001#КюJB4Lille1#КюJB4RonchinФ/#њяJB4Fтches-thumesnils/#˜яJB6Villeneuve?ј"ўўJB4Pecquencourt)'#РєJB4TortequesneЉ##ћэJB4Lille590001#КюJB4Marcq-en-baroeul3#,№П16Linkіping'a$Gй&QCVal-d'orj9p1p8ЯЮ"}™сTXHoustonс ъ йp сPAPhiladelphia19108у!*џ"ГсWAMilton98354­"RЭ5€ o40Setagaya-ч TЦ0o40Tokyo2щ FЪ0џџџ+golang-github-abh-geoip-dev-0.0~git20150611/test-db/GeoIPRegion.dat000066400000000000000000000002701253640351700243770ustar00rootroot00000000000000$є$є$є$є$є$є$є$є $є $є $є$є $є$є$є$є$є$є$є$є$є$є$є$є$є$є$є$є$є5$єџџџ