geoip2-golang: github.com/oschwald/geoip2-golang Index | Examples | Files

package geoip2

import "github.com/oschwald/geoip2-golang"

Package geoip2 provides an easy-to-use API for the MaxMind GeoIP2 and GeoLite2 databases; this package does not support GeoIP Legacy databases.

The structs provided by this package match the internal structure of the data in the MaxMind databases.

See github.com/oschwald/maxminddb-golang for more advanced used cases.

Example provides a basic example of using the API. Use of the Country method is analogous to that of the City method.

Code:

db, err := Open("test-data/test-data/GeoIP2-City-Test.mmdb")
if err != nil {
    log.Fatal(err)
}
defer db.Close()
// If you are using strings that may be invalid, check that ip is not nil
ip := net.ParseIP("81.2.69.142")
record, err := db.City(ip)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Portuguese (BR) city name: %v\n", record.City.Names["pt-BR"])
fmt.Printf("English subdivision name: %v\n", record.Subdivisions[0].Names["en"])
fmt.Printf("Russian country name: %v\n", record.Country.Names["ru"])
fmt.Printf("ISO country code: %v\n", record.Country.IsoCode)
fmt.Printf("Time zone: %v\n", record.Location.TimeZone)
fmt.Printf("Coordinates: %v, %v\n", record.Location.Latitude, record.Location.Longitude)

Output:

Portuguese (BR) city name: Londres
English subdivision name: England
Russian country name: Великобритания
ISO country code: GB
Time zone: Europe/London
Coordinates: 51.5142, -0.0931

Index

Examples

Package Files

reader.go

type AnonymousIP Uses

type AnonymousIP struct {
    IsAnonymous       bool `maxminddb:"is_anonymous"`
    IsAnonymousVPN    bool `maxminddb:"is_anonymous_vpn"`
    IsHostingProvider bool `maxminddb:"is_hosting_provider"`
    IsPublicProxy     bool `maxminddb:"is_public_proxy"`
    IsTorExitNode     bool `maxminddb:"is_tor_exit_node"`
}

The AnonymousIP struct corresponds to the data in the GeoIP2 Anonymous IP database.

type City Uses

type City struct {
    City struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"city"`
    Continent struct {
        Code      string            `maxminddb:"code"`
        GeoNameID uint              `maxminddb:"geoname_id"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"continent"`
    Country struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        IsoCode   string            `maxminddb:"iso_code"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"country"`
    Location struct {
        AccuracyRadius uint16  `maxminddb:"accuracy_radius"`
        Latitude       float64 `maxminddb:"latitude"`
        Longitude      float64 `maxminddb:"longitude"`
        MetroCode      uint    `maxminddb:"metro_code"`
        TimeZone       string  `maxminddb:"time_zone"`
    }   `maxminddb:"location"`
    Postal struct {
        Code string `maxminddb:"code"`
    }   `maxminddb:"postal"`
    RegisteredCountry struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        IsoCode   string            `maxminddb:"iso_code"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"registered_country"`
    RepresentedCountry struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        IsoCode   string            `maxminddb:"iso_code"`
        Names     map[string]string `maxminddb:"names"`
        Type      string            `maxminddb:"type"`
    }   `maxminddb:"represented_country"`
    Subdivisions []struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        IsoCode   string            `maxminddb:"iso_code"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"subdivisions"`
    Traits struct {
        IsAnonymousProxy    bool `maxminddb:"is_anonymous_proxy"`
        IsSatelliteProvider bool `maxminddb:"is_satellite_provider"`
    }   `maxminddb:"traits"`
}

The City struct corresponds to the data in the GeoIP2/GeoLite2 City databases.

type ConnectionType Uses

type ConnectionType struct {
    ConnectionType string `maxminddb:"connection_type"`
}

The ConnectionType struct corresponds to the data in the GeoIP2 Connection-Type database.

type Country Uses

type Country struct {
    Continent struct {
        Code      string            `maxminddb:"code"`
        GeoNameID uint              `maxminddb:"geoname_id"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"continent"`
    Country struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        IsoCode   string            `maxminddb:"iso_code"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"country"`
    RegisteredCountry struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        IsoCode   string            `maxminddb:"iso_code"`
        Names     map[string]string `maxminddb:"names"`
    }   `maxminddb:"registered_country"`
    RepresentedCountry struct {
        GeoNameID uint              `maxminddb:"geoname_id"`
        IsoCode   string            `maxminddb:"iso_code"`
        Names     map[string]string `maxminddb:"names"`
        Type      string            `maxminddb:"type"`
    }   `maxminddb:"represented_country"`
    Traits struct {
        IsAnonymousProxy    bool `maxminddb:"is_anonymous_proxy"`
        IsSatelliteProvider bool `maxminddb:"is_satellite_provider"`
    }   `maxminddb:"traits"`
}

The Country struct corresponds to the data in the GeoIP2/GeoLite2 Country databases.

type Domain Uses

type Domain struct {
    Domain string `maxminddb:"domain"`
}

The Domain struct corresponds to the data in the GeoIP2 Domain database.

type ISP Uses

type ISP struct {
    AutonomousSystemNumber       uint   `maxminddb:"autonomous_system_number"`
    AutonomousSystemOrganization string `maxminddb:"autonomous_system_organization"`
    ISP                          string `maxminddb:"isp"`
    Organization                 string `maxminddb:"organization"`
}

The ISP struct corresponds to the data in the GeoIP2 ISP database.

type InvalidMethodError Uses

type InvalidMethodError struct {
    Method       string
    DatabaseType string
}

InvalidMethodError is returned when a lookup method is called on a database that it does not support. For instance, calling the ISP method on a City database.

func (InvalidMethodError) Error Uses

func (e InvalidMethodError) Error() string

type Reader Uses

type Reader struct {
    // contains filtered or unexported fields
}

Reader holds the maxminddb.Reader struct. It can be created using the Open and FromBytes functions.

func FromBytes Uses

func FromBytes(bytes []byte) (*Reader, error)

FromBytes takes a byte slice corresponding to a GeoIP2/GeoLite2 database file and returns a Reader struct or an error. Note that the byte slice is use directly; any modification of it after opening the database will result in errors while reading from the database.

func Open Uses

func Open(file string) (*Reader, error)

Open takes a string path to a file and returns a Reader struct or an error. The database file is opened using a memory map. Use the Close method on the Reader object to return the resources to the system.

func (*Reader) AnonymousIP Uses

func (r *Reader) AnonymousIP(ipAddress net.IP) (*AnonymousIP, error)

AnonymousIP takes an IP address as a net.IP struct and returns a AnonymousIP struct and/or an error.

func (*Reader) City Uses

func (r *Reader) City(ipAddress net.IP) (*City, error)

City takes an IP address as a net.IP struct and returns a City struct and/or an error. Although this can be used with other databases, this method generally should be used with the GeoIP2 or GeoLite2 City databases.

func (*Reader) Close Uses

func (r *Reader) Close() error

Close unmaps the database file from virtual memory and returns the resources to the system.

func (*Reader) ConnectionType Uses

func (r *Reader) ConnectionType(ipAddress net.IP) (*ConnectionType, error)

ConnectionType takes an IP address as a net.IP struct and returns a ConnectionType struct and/or an error

func (*Reader) Country Uses

func (r *Reader) Country(ipAddress net.IP) (*Country, error)

Country takes an IP address as a net.IP struct and returns a Country struct and/or an error. Although this can be used with other databases, this method generally should be used with the GeoIP2 or GeoLite2 Country databases.

func (*Reader) Domain Uses

func (r *Reader) Domain(ipAddress net.IP) (*Domain, error)

Domain takes an IP address as a net.IP struct and returns a Domain struct and/or an error

func (*Reader) ISP Uses

func (r *Reader) ISP(ipAddress net.IP) (*ISP, error)

ISP takes an IP address as a net.IP struct and returns a ISP struct and/or an error

func (*Reader) Metadata Uses

func (r *Reader) Metadata() maxminddb.Metadata

Metadata takes no arguments and returns a struct containing metadata about the MaxMind database in use by the Reader.

type UnknownDatabaseTypeError Uses

type UnknownDatabaseTypeError struct {
    DatabaseType string
}

UnknownDatabaseTypeError is returned when an unknown database type is opened.

func (UnknownDatabaseTypeError) Error Uses

func (e UnknownDatabaseTypeError) Error() string

Package geoip2 imports 3 packages (graph) and is imported by 34 packages. Updated 2017-03-14. Refresh now. Tools for package owners.