Go package provides a fast lookup of country, region, city, latitude, longitude, ZIP code, time zone, ISP, domain name,

Go Report Card

IP2Location Go Package

This Go package provides a fast lookup of country, region, city, latitude, longitude, ZIP code, time zone, ISP, domain name, connection type, IDD code, area code, weather station code, station name, mcc, mnc, mobile brand, elevation, usage type, address type and IAB category from IP address by using IP2Location database. This package uses a file based database available at IP2Location.com. This database simply contains IP blocks as keys, and other information such as country, region, city, latitude, longitude, ZIP code, time zone, ISP, domain name, connection type, IDD code, area code, weather station code, station name, mcc, mnc, mobile brand, elevation, usage type, address type and IAB category as values. It supports both IP address in IPv4 and IPv6.

This package can be used in many types of projects such as:

  • select the geographically closest mirror
  • analyze your web server logs to determine the countries of your visitors
  • credit card fraud detection
  • software export controls
  • display native language and currency
  • prevent password sharing and abuse of service
  • geotargeting in advertisement

The database will be updated in monthly basis for the greater accuracy. Free LITE databases are available at https://lite.ip2location.com/ upon registration.

The paid databases are available at https://www.ip2location.com under Premium subscription package.

As an alternative, this package can also call the IP2Location Web Service. This requires an API key. If you don't have an existing API key, you can subscribe for one at the below:

https://www.ip2location.com/web-service/ip2location

Installation

go get github.com/ip2location/ip2location-go/v9

QUERY USING THE BIN FILE

Dependencies

This package requires IP2Location BIN data file to function. You may download the BIN data file at

IPv4 BIN vs IPv6 BIN

Use the IPv4 BIN file if you just need to query IPv4 addresses.

Use the IPv6 BIN file if you need to query BOTH IPv4 and IPv6 addresses.

Methods

Below are the methods supported in this package.

Method Name Description
OpenDB Initialize the package with the BIN file.
Get_all Returns the geolocation information in an object.
Get_country_short Returns the country code.
Get_country_long Returns the country name.
Get_region Returns the region name.
Get_city Returns the city name.
Get_isp Returns the ISP name.
Get_latitude Returns the latitude.
Get_longitude Returns the longitude.
Get_domain Returns the domain name.
Get_zipcode Returns the ZIP code.
Get_timezone Returns the time zone.
Get_netspeed Returns the net speed.
Get_iddcode Returns the IDD code.
Get_areacode Returns the area code.
Get_weatherstationcode Returns the weather station code.
Get_weatherstationname Returns the weather station name.
Get_mcc Returns the mobile country code.
Get_mnc Returns the mobile network code.
Get_mobilebrand Returns the mobile brand.
Get_elevation Returns the elevation in meters.
Get_usagetype Returns the usage type.
Get_addresstype Returns the address type.
Get_category Returns the IAB category.
Close Closes BIN file.

Usage

package main

import (
	"fmt"
	"github.com/ip2location/ip2location-go"
)

func main() {
	db, err := ip2location.OpenDB("./IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE-TIMEZONE-ISP-DOMAIN-NETSPEED-AREACODE-WEATHER-MOBILE-ELEVATION-USAGETYPE-ADDRESSTYPE-CATEGORY.BIN")
	
	if err != nil {
		fmt.Print(err)
		return
	}
	ip := "8.8.8.8"
	results, err := db.Get_all(ip)
	
	if err != nil {
		fmt.Print(err)
		return
	}
	
	fmt.Printf("country_short: %s\n", results.Country_short)
	fmt.Printf("country_long: %s\n", results.Country_long)
	fmt.Printf("region: %s\n", results.Region)
	fmt.Printf("city: %s\n", results.City)
	fmt.Printf("isp: %s\n", results.Isp)
	fmt.Printf("latitude: %f\n", results.Latitude)
	fmt.Printf("longitude: %f\n", results.Longitude)
	fmt.Printf("domain: %s\n", results.Domain)
	fmt.Printf("zipcode: %s\n", results.Zipcode)
	fmt.Printf("timezone: %s\n", results.Timezone)
	fmt.Printf("netspeed: %s\n", results.Netspeed)
	fmt.Printf("iddcode: %s\n", results.Iddcode)
	fmt.Printf("areacode: %s\n", results.Areacode)
	fmt.Printf("weatherstationcode: %s\n", results.Weatherstationcode)
	fmt.Printf("weatherstationname: %s\n", results.Weatherstationname)
	fmt.Printf("mcc: %s\n", results.Mcc)
	fmt.Printf("mnc: %s\n", results.Mnc)
	fmt.Printf("mobilebrand: %s\n", results.Mobilebrand)
	fmt.Printf("elevation: %f\n", results.Elevation)
	fmt.Printf("usagetype: %s\n", results.Usagetype)
	fmt.Printf("addresstype: %s\n", results.Addresstype)
	fmt.Printf("category: %s\n", results.Category)
	fmt.Printf("api version: %s\n", ip2location.Api_version())
	
	db.Close()
}

QUERY USING THE IP2LOCATION WEB SERVICE

Methods

Below are the methods supported in this package.

Method Name Description
OpenWS 3 input parameters:
  1. IP2Location API Key.
  2. Package (WS1 - WS25)
  3. Use HTTPS or HTTP
LookUp Query IP address. This method returns an object containing the geolocation info.
  • country_code
  • country_name
  • region_name
  • city_name
  • latitude
  • longitude
  • zip_code
  • time_zone
  • isp
  • domain
  • net_speed
  • idd_code
  • area_code
  • weather_station_code
  • weather_station_name
  • mcc
  • mnc
  • mobile_brand
  • elevation
  • usage_type
  • address_type
  • category
  • continent
    • name
    • code
    • hemisphere
    • translations
  • country
    • name
    • alpha3_code
    • numeric_code
    • demonym
    • flag
    • capital
    • total_area
    • population
    • currency
      • code
      • name
      • symbol
    • language
      • code
      • name
    • idd_code
    • tld
    • is_eu
    • translations
  • region
    • name
    • code
    • translations
  • city
    • name
    • translations
  • geotargeting
    • metro
  • country_groupings
  • time_zone_info
    • olson
    • current_time
    • gmt_offset
    • is_dst
    • sunrise
    • sunset
    GetCredit This method returns the web service credit balance in an object.

    Usage

    Name: %s\n", res.Continent.Name) fmt.Printf("Continent => Code: %s\n", res.Continent.Code) fmt.Printf("Continent => Hemisphere: %+v\n", res.Continent.Hemisphere) // country addon fmt.Printf("Country => Name: %s\n", res.Country.Name) fmt.Printf("Country => Alpha3Code: %s\n", res.Country.Alpha3Code) fmt.Printf("Country => NumericCode: %s\n", res.Country.NumericCode) fmt.Printf("Country => Demonym: %s\n", res.Country.Demonym) fmt.Printf("Country => Flag: %s\n", res.Country.Flag) fmt.Printf("Country => Capital: %s\n", res.Country.Capital) fmt.Printf("Country => TotalArea: %s\n", res.Country.TotalArea) fmt.Printf("Country => Population: %s\n", res.Country.Population) fmt.Printf("Country => IddCode: %s\n", res.Country.IddCode) fmt.Printf("Country => Tld: %s\n", res.Country.Tld) fmt.Printf("Country => IsEu: %t\n", res.Country.IsEu) fmt.Printf("Country => Currency => Code: %s\n", res.Country.Currency.Code) fmt.Printf("Country => Currency => Name: %s\n", res.Country.Currency.Name) fmt.Printf("Country => Currency => Symbol: %s\n", res.Country.Currency.Symbol) fmt.Printf("Country => Language => Code: %s\n", res.Country.Language.Code) fmt.Printf("Country => Language => Name: %s\n", res.Country.Language.Name) // region addon fmt.Printf("Region => Name: %s\n", res.Region.Name) fmt.Printf("Region => Code: %s\n", res.Region.Code) // city addon fmt.Printf("City => Name: %s\n", res.City.Name) // geotargeting addon fmt.Printf("Geotargeting => Metro: %s\n", res.Geotargeting.Metro) // country_groupings addon for i, s := range res.CountryGroupings { fmt.Printf("CountryGroupings => #%d => Acronym: %s\n", i, s.Acronym) fmt.Printf("CountryGroupings => #%d => Name: %s\n", i, s.Name) } // time_zone_info addon fmt.Printf("TimeZoneInfo => Olson: %s\n", res.TimeZoneInfo.Olson) fmt.Printf("TimeZoneInfo => CurrentTime: %s\n", res.TimeZoneInfo.CurrentTime) fmt.Printf("TimeZoneInfo => GmtOffset: %d\n", res.TimeZoneInfo.GmtOffset) fmt.Printf("TimeZoneInfo => IsDst: %s\n", res.TimeZoneInfo.IsDst) fmt.Printf("TimeZoneInfo => Sunrise: %s\n", res.TimeZoneInfo.Sunrise) fmt.Printf("TimeZoneInfo => Sunset: %s\n", res.TimeZoneInfo.Sunset) } res2, err := ws.GetCredit() if err != nil { fmt.Print(err) return } fmt.Printf("Credit Balance: %d\n", res2.Response) } ">
    package main
    
    import (
    	"github.com/ip2location/ip2location-go"
    	"fmt"
    )
    
    func main() {
    	apikey := "YOUR_API_KEY"
    	apipackage := "WS25"
    	usessl := true
    	addon := "continent,country,region,city,geotargeting,country_groupings,time_zone_info" // leave blank if no need
    	lang := "en" // leave blank if no need
    	
    	ws, err := ip2location.OpenWS(apikey, apipackage, usessl)
    	
    	if err != nil {
    		fmt.Print(err)
    		return
    	}
    	ip := "8.8.8.8"
    	res, err := ws.LookUp(ip, addon, lang)
    
    	if err != nil {
    		fmt.Print(err)
    		return
    	}
    
    	if res.Response != "OK" {
    		fmt.Printf("Error: %s\n", res.Response)
    	} else {
    		// standard results
    		fmt.Printf("Response: %s\n", res.Response)
    		fmt.Printf("CountryCode: %s\n", res.CountryCode)
    		fmt.Printf("CountryName: %s\n", res.CountryName)
    		fmt.Printf("RegionName: %s\n", res.RegionName)
    		fmt.Printf("CityName: %s\n", res.CityName)
    		fmt.Printf("Latitude: %f\n", res.Latitude)
    		fmt.Printf("Longitude: %f\n", res.Longitude)
    		fmt.Printf("ZipCode: %s\n", res.ZipCode)
    		fmt.Printf("TimeZone: %s\n", res.TimeZone)
    		fmt.Printf("Isp: %s\n", res.Isp)
    		fmt.Printf("Domain: %s\n", res.Domain)
    		fmt.Printf("NetSpeed: %s\n", res.NetSpeed)
    		fmt.Printf("IddCode: %s\n", res.IddCode)
    		fmt.Printf("AreaCode: %s\n", res.AreaCode)
    		fmt.Printf("WeatherStationCode: %s\n", res.WeatherStationCode)
    		fmt.Printf("WeatherStationName: %s\n", res.WeatherStationName)
    		fmt.Printf("Mcc: %s\n", res.Mcc)
    		fmt.Printf("Mnc: %s\n", res.Mnc)
    		fmt.Printf("MobileBrand: %s\n", res.MobileBrand)
    		fmt.Printf("Elevation: %d\n", res.Elevation)
    		fmt.Printf("UsageType: %s\n", res.UsageType)
    		fmt.Printf("AddressType: %s\n", res.AddressType)
    		fmt.Printf("Category: %s\n", res.Category)
    		fmt.Printf("CategoryName: %s\n", res.CategoryName)
    		fmt.Printf("CreditsConsumed: %d\n", res.CreditsConsumed)
    		
    		// continent addon
    		fmt.Printf("Continent => Name: %s\n", res.Continent.Name)
    		fmt.Printf("Continent => Code: %s\n", res.Continent.Code)
    		fmt.Printf("Continent => Hemisphere: %+v\n", res.Continent.Hemisphere)
    		
    		// country addon
    		fmt.Printf("Country => Name: %s\n", res.Country.Name)
    		fmt.Printf("Country => Alpha3Code: %s\n", res.Country.Alpha3Code)
    		fmt.Printf("Country => NumericCode: %s\n", res.Country.NumericCode)
    		fmt.Printf("Country => Demonym: %s\n", res.Country.Demonym)
    		fmt.Printf("Country => Flag: %s\n", res.Country.Flag)
    		fmt.Printf("Country => Capital: %s\n", res.Country.Capital)
    		fmt.Printf("Country => TotalArea: %s\n", res.Country.TotalArea)
    		fmt.Printf("Country => Population: %s\n", res.Country.Population)
    		fmt.Printf("Country => IddCode: %s\n", res.Country.IddCode)
    		fmt.Printf("Country => Tld: %s\n", res.Country.Tld)
    		fmt.Printf("Country => IsEu: %t\n", res.Country.IsEu)
    		
    		fmt.Printf("Country => Currency => Code: %s\n", res.Country.Currency.Code)
    		fmt.Printf("Country => Currency => Name: %s\n", res.Country.Currency.Name)
    		fmt.Printf("Country => Currency => Symbol: %s\n", res.Country.Currency.Symbol)
    		
    		fmt.Printf("Country => Language => Code: %s\n", res.Country.Language.Code)
    		fmt.Printf("Country => Language => Name: %s\n", res.Country.Language.Name)
    		
    		// region addon
    		fmt.Printf("Region => Name: %s\n", res.Region.Name)
    		fmt.Printf("Region => Code: %s\n", res.Region.Code)
    		
    		// city addon
    		fmt.Printf("City => Name: %s\n", res.City.Name)
    		
    		// geotargeting addon
    		fmt.Printf("Geotargeting => Metro: %s\n", res.Geotargeting.Metro)
    		
    		// country_groupings addon
    		for i, s := range res.CountryGroupings {
    			fmt.Printf("CountryGroupings => #%d => Acronym: %s\n", i, s.Acronym)
    			fmt.Printf("CountryGroupings => #%d => Name: %s\n", i, s.Name)
    		}
    		
    		// time_zone_info addon
    		fmt.Printf("TimeZoneInfo => Olson: %s\n", res.TimeZoneInfo.Olson)
    		fmt.Printf("TimeZoneInfo => CurrentTime: %s\n", res.TimeZoneInfo.CurrentTime)
    		fmt.Printf("TimeZoneInfo => GmtOffset: %d\n", res.TimeZoneInfo.GmtOffset)
    		fmt.Printf("TimeZoneInfo => IsDst: %s\n", res.TimeZoneInfo.IsDst)
    		fmt.Printf("TimeZoneInfo => Sunrise: %s\n", res.TimeZoneInfo.Sunrise)
    		fmt.Printf("TimeZoneInfo => Sunset: %s\n", res.TimeZoneInfo.Sunset)
    	}
    
    	res2, err := ws.GetCredit()
    
    	if err != nil {
    		fmt.Print(err)
    		return
    	}
    	
    	fmt.Printf("Credit Balance: %d\n", res2.Response)
    }
    Owner
    IP2Location
    IP geolocation solution. Determine geographical location information such as county, city, zipcode, mobile network information by IP address.
    IP2Location
    Comments
    • Timezone is empty and EOF is always an error

      Timezone is empty and EOF is always an error

      Hi, using the recent documentation and a recent lite version with timezone. I am always getting an EOF error but the data is actually there so it is a minor issue, however, the Timezone is always empty.

      Thanks.

    • Reduce GC pressure

      Reduce GC pressure

      Hi

      I added benchmark to my local branch, found these GC performance issues

      1. in readuint32() method, binary.Read ~~uses reflection and~~ will allocate more memory then binary.LittleEndian.Uint32() , here are the benchmarks
      # err = binary.Read(buf, binary.LittleEndian, &retval)
      BenchmarkGetAll1-16        14084             84946 ns/op           10161 B/op        696 allocs/op
      
      # using retval = binary.LittleEndian.Uint32(data[:])
      BenchmarkGetAllOld-16              15841             75894 ns/op            5569 B/op        450 allocs/op
      
      1. math/big provides arbitrary precision, which allocates more memory, we could use a Uint128 library such as lukechampine.com/uint128 to store ipv4 and ipv6 as Uint128, here is the benchmark using Uint128
      BenchmarkGetAllOld-16              17890             67029 ns/op            1776 B/op        276 allocs/op
      

      Total performance improvement is 27%, and allocs/op decreases 60%.

      Can I send a PR? If so I will need to add some tests, I only test it with ipv4 data.

      My local commit

      1. binary.LittleEndian.Uint32
      2. Uint128
    • Re-write in idiomatic Go?

      Re-write in idiomatic Go?

      TL;DR: Could you have an actual Go programmer look over the library?

      This library is not at all Go-ish.

      Functions are not named idiomatically, and more importantly they should return any errors that occur, not print and ignore them. That is very poor form in Go. For example:

      var (
      	ErrInvalidAddress = errors.New("invalid IP address")
      	ErrBadFile        = errors.New("invalid database file")
      	ErrNotSupported   = errors.New("parameter not supported: database upgrade required")
      )
      
      // Open the ip2location .bin database. You must call Close() to close the database file.
      Open(filename string) error  // not Open(dbpath string)
      
      // All returns a record populated with all fields supported by the current database.
      All(ip string) (Record, error)  // not Get_all(ipaddress string) IP2Locationrecord
      

      Arguably, the Get_* functions should be combined in a single call that accepts a bitmask:

      // Lookup returns a Record populated with the specified fields. ErrNotSupported is returned
      // if any of the requested fields are not present in the current database.
      Lookup(ip string, fields uint32) (Record, error)
      // e.g.
      r, err := ip2location.Lookup("127.0.0.1", ip2location.All)
      r, err := ip2location.Lookup("127.0.0.1", ip2location.CountryShort|ip2location.Region|ip2location.City)
      

      or one that accepts a variable number of field arguments:

      // Lookup returns a Record populated with the specified fields. ErrNotSupported is returned
      // if any of the requested fields are not present in the current database.
      Lookup(ip string, fields ...uint32) (Record, error)
      // e.g.
      r, err := ip2location.Lookup("127.0.0.1")  // defaults to "All"
      r, err := ip2location.Lookup("127.0.0.1", ip2location.CountryShort, ip2location.Region, ip2location.City)
      
    • Seperate ip2location.go into smaller files and update method/variable naming to suit golang conventions

      Seperate ip2location.go into smaller files and update method/variable naming to suit golang conventions

      Started using this library and saw that things was a bit off from golang perspective and because of that created a suggestion PR to show another way to handle/split code

      This MR provides:

      • Split code into smaller files which helps with readability (also in the future it would be a bi easier to create test files)
      • Renamed variables and methods to make them look more "go way"

      Ideas for the future:

      • Tests could be added to this package
      • Constants for values such as UsageType (because on your website you are specifying what kind of usage types are available)
      • Global database option could be just removed because all of its methods already has deprecation tags (most probably it's a bad thing that I modified that part of the code)
    • Idiomatic Go

      Idiomatic Go

      Please make this package properly follow Go convention and operate like how a Go package should.

      If you need assistance, I can do it within a day for a fee: Here are my other packages: https://github.com/rocketlaunchr

      Currently, I can't even with confidence know when a ip address can/cant be converted. I can't even Open and Close the database on a (http) per-request basis.

    • This client doesn't support IP2Proxy database

      This client doesn't support IP2Proxy database

      I'm using the IP2Proxy database here: https://lite.ip2location.com/database/px2-ip-proxytype-country to parse the proxy type from the IP: 8.8.8.8. But the result is clearly wrong:

      File read failed: EOF
      country_short: DCH
      country_long: PUBSESTORVPNWEB                                                    
      region: This parameter is unavailable for selected data file. Please upgrade the data file.
      city: This parameter is unavailable for selected data file. Please upgrade the data file.
      isp: -
      latitude: 0.000000
      longitude: 0.000000
      domain: This parameter is unavailable for selected data file. Please upgrade the data file.
      zipcode: This parameter is unavailable for selected data file. Please upgrade the data file.
      timezone: This parameter is unavailable for selected data file. Please upgrade the data file.
      netspeed: This parameter is unavailable for selected data file. Please upgrade the data file.
      iddcode: This parameter is unavailable for selected data file. Please upgrade the data file.
      areacode: This parameter is unavailable for selected data file. Please upgrade the data file.
      weatherstationcode: This parameter is unavailable for selected data file. Please upgrade the data file.
      weatherstationname: This parameter is unavailable for selected data file. Please upgrade the data file.
      mcc: This parameter is unavailable for selected data file. Please upgrade the data file.
      mnc: This parameter is unavailable for selected data file. Please upgrade the data file.
      mobilebrand: This parameter is unavailable for selected data file. Please upgrade the data file.
      elevation: 0.000000
      usagetype: This parameter is unavailable for selected data file. Please upgrade the data file.
      api version: 8.0.3
      --- PASS: TestIp2Location (0.00s)
      PASS
      
      Process finished with exit code 0
      

      I guess this client only supports ip2location db instead of ip2proxy. Can you support ip2proxy? Thanks.

    • Open the DB with a reader interface

      Open the DB with a reader interface

      For use with myriad file packers that pack files into the binary, this allows for handing an interface that adheres to io.ReadCloser and io.ReaderAt directly to ip2location as another option for initializing the DB. Does not break existing API.

    • Added db type

      Added db type

      The library as it stands has a number of issues which makes it difficult to use concurrently. I’ve moved all the db related members into its own type and exposed them to the caller, which allows the caller to have more control over how the db is used. This is also a partial fix for the issue mentioned in #6

    • New library

      New library

      I've written a new library for querying IP2Location and IP2Proxy databases, github.com/pg9182/ip2x. I'm currently refactoring the code generation and refining the library interface, but it's more or less feature-complete.

      • It supports Go 1.18+.
      • It supports querying using Go 1.18's new net/netip.Addr type, which is much more efficient than parsing the IP from a string every time.
      • It uses native integer types instead of big.Int, which is also much more efficient.
      • It's about 11x faster than this library when querying a single field, and 2x faster for all fields, while making a fraction of the number of allocations (2 for init, 1 for each lookup, plus 1 for each typed field get, or 2 for an untyped one).
      • It has comprehensive built-in documentation, including automatically-generated information about which fields are available in different product types.
      • It supports querying information about the database itself, for example, whether it supports IPv6, and which fields are available.
      • It has a more fluent and flexible API (e.g., record.Get(ip2x.Latitude), record.GetString(ip2x.Latitude), record.GetFloat(ip2x.Latitude))
      • It has built-in support for pretty-printing records as strings or JSON.
      • It supports both IP2Location databases in a single package with a unified API.
      • It uses code generation to simplify adding new products/types/fields/documentation while reducing the likelihood of bugs (input, docs).
      • It's written in idiomatic Go: correct error handling (rather than stuffing error strings into the record struct), useful zero values (an empty record will work properly), proper type names, etc.
      • There are tests to ensure the output is consistent with this library, that a range of IPv4 (and their possible IPv6-mappings) address work correctly, and other things. There are also fuzz tests to ensure IPs can't crash the library and are IPv4/v6-mapped correctly.

      This library is already being used in production at Northstar for game server geolocation and log analysis.


      $ cd test && go test -bench=. -benchmem .
      db: IP2Location DB11 2022-10-29 [city,country_code,country_name,latitude,longitude,region,time_zone,zip_code] (IPv4+IPv6)
      goos: linux
      goarch: amd64
      pkg: github.com/pg9182/ip2x/test
      cpu: AMD Ryzen 5 5600G with Radeon Graphics         
      BenchmarkIP2x_Init-12                       	17850333	        67.91 ns/op	     128 B/op	       2 allocs/op
      BenchmarkIP2x_LookupOnly-12                 	18722506	        61.36 ns/op	      48 B/op	       1 allocs/op
      BenchmarkIP2x_GetAll-12                     	 1522696	       812.2 ns/op	    1688 B/op	      14 allocs/op
      BenchmarkIP2x_GetOneString-12               	 7839385	       144.1 ns/op	     304 B/op	       2 allocs/op
      BenchmarkIP2x_GetOneFloat-12                	14312419	        84.16 ns/op	      48 B/op	       1 allocs/op
      BenchmarkIP2x_GetTwoString-12               	 4243560	       244.9 ns/op	     560 B/op	       3 allocs/op
      BenchmarkIP2x_GetTwoFloat-12                	12198259	       101.1 ns/op	      48 B/op	       1 allocs/op
      BenchmarkIP2x_GetNonexistent-12             	14834245	        79.85 ns/op	      48 B/op	       1 allocs/op
      BenchmarkIP2LocationV9_Init-12              	  602967	      2191 ns/op	     400 B/op	       7 allocs/op
      BenchmarkIP2LocationV9_LookupOnly-12        	 1473849	       782.6 ns/op	     672 B/op	      24 allocs/op
      BenchmarkIP2LocationV9_GetAll-12            	  819900	      1324 ns/op	    2268 B/op	      36 allocs/op
      BenchmarkIP2LocationV9_GetOneString-12      	 1346534	       889.2 ns/op	     936 B/op	      26 allocs/op
      BenchmarkIP2LocationV9_GetOneFloat-12       	 1441219	       795.0 ns/op	     672 B/op	      24 allocs/op
      BenchmarkIP2LocationV9_GetTwoString-12      	  546868	      1866 ns/op	    1883 B/op	      53 allocs/op
      BenchmarkIP2LocationV9_GetTwoFloat-12       	  693019	      1561 ns/op	    1345 B/op	      49 allocs/op
      BenchmarkIP2LocationV9_GetNonexistent-12    	 1399872	       795.5 ns/op	     672 B/op	      24 allocs/op
      
    A C/S Tool to Download Torrent Remotely and Retrieve Files Back Over HTTP at Full Speed without ISP Torrent Limitation.

    remote-torrent Download Torrent Remotely and Retrieve Files Over HTTP at Full Speed without ISP Torrent Limitation. This repository is an extension to

    Sep 30, 2022
    Anaximander is an ISP probing tool implementing several reduction techniques to cut down the number of probes launched in order to map an Autonomous System
    Anaximander is an ISP probing tool implementing several reduction techniques to cut down the number of probes launched in order to map an Autonomous System

    Anaximander is an ISP probing tool implementing several reduction techniques to cut down the number of probes launched in order to map an Autonomous System, while still keeping high discovery levels.

    Jun 21, 2022
    Dotcel - Domain name application built on top of celestia

    dotcel dotcel is a blockchain built using Cosmos SDK and Tendermint and created

    Feb 7, 2022
    TLDs finder: check domain name availability across all valid top-level domains

    TLD:er TLDs finder — check domain name availability across all valid top-level d

    Oct 31, 2022
    A CLI tool to get Certificate Transparency logs of a domain name.
    A CLI tool to get Certificate Transparency logs of a domain name.

    crt crt is a CLI tool to get Certificate Transparency logs of a domain name. It can also enumerate subdomains. Installation If you have Go installed:

    Dec 17, 2022
    Fast IP to CIDR lookup in Golang
    Fast IP to CIDR lookup in Golang

    cidranger Fast IP to CIDR block(s) lookup using trie in Golang, inspired by IPv4 route lookup linux. Possible use cases include detecting if a IP addr

    Dec 30, 2022
    llb - It's a very simple but quick backend for proxy servers. Can be useful for fast redirection to predefined domain with zero memory allocation and fast response.

    llb What the f--k it is? It's a very simple but quick backend for proxy servers. You can setup redirect to your main domain or just show HTTP/1.1 404

    Sep 27, 2022
    DNS lookup service with golang
    DNS lookup service with golang

    dns-lookup-service Dev Setup git clone https://github.com/philip1986/dns-lookup-service.git cd dns-lookup-service docker-compose up --build Load the

    Nov 18, 2022
    Jswhois - Whois lookup results in json format

    jswhois -- whois lookup results in json format jswhois(1) is a tool to look up a

    Nov 30, 2022
    Dofind - Dofind is fast domain related finder made with golang

    Dofind is fast domain related finder made with golang. ██████╗░░█████╗░███████╗

    Feb 16, 2022
    JPRQ Customizer is a customizer that helps to use the JPRQ server code and make it compatible with your own server with custom subdomain and domain
    JPRQ Customizer is a customizer that helps to use the JPRQ server code and make it compatible with your own server with custom subdomain and domain

    JPRQ Customizer is a customizer that helps to use the JPRQ server code and make it compatible with your own server with custom subdomain and domain.You can upload the generated directory to your web server and expose user localhost to public internet. You can use this to make your local machine a command center for your ethical hacking purpose ;)

    Jan 19, 2022
    Ephemeral One Time/Build-Time gRPC TLS PKI system.

    PkiSauce Ephemeral Build Time TLS PKI saucing for your intra services GRPC (or not) communications. Description A simple attempt to avoid deploying co

    Jul 4, 2022
    The repository provides supplementary Go time packages

    Go Time This repository provides supplementary Go time packages. Download/Install The easiest way to install is to run go get -u golang.org/x/time. Yo

    Nov 23, 2021
    Ananas is an experimental project for kubernetes CSI (Container Storage Interface) by using azure disk. Likewise, Ananas is the name of my cute british shorthair.

    ananas Ananas is an experimental project for kubernetes CSI (Container Storage Interface) by using azure disk. Likewise, Ananas is the name of my cute

    Aug 4, 2021
    A small tool used to correspond to the IP address according to the name, id, and network alias of the docker container, which can be run as a DNS server

    A small tool used to correspond to the IP address according to the name, id, and network alias of the docker container, which can be run as a DNS server

    Apr 4, 2022
    A name sniper for Minecraft (Leaked)

    DismalSniper A name sniper for Minecraft (Leaked) Preface Let this be a lesson to you Liza, if you're going to insult me and the rest of the community

    May 16, 2022
    Header Block is a middleware plugin for Traefik to block request and response headers which regex matched by their name and/or value

    Header Block is a middleware plugin for Traefik to block request and response headers which regex matched by their name and/or value Conf

    May 24, 2022
    App with CRUD for user, with palindrome checker for user's first and last name

    Run db container first, so that app does not connect to db while db has not started yet docker-compose up -d db docker-compose up -d app CRUD endpoint

    Dec 9, 2021
    Dynamic dns for name.com

    name-ddns Dynamic DNS for Name.com using v4 name.com API Usage docker run --rm \ -e "NAME_DDNS_USER=namecom-user" \ -e "NAME_DDNS_TOKEN=namecom-toke

    Aug 17, 2022