mirror of https://github.com/django/django.git
Refs #25184 -- Removed contrib.gis.geoip per deprecation timeline.
This commit is contained in:
Tim Graham
parent
a0d166306f
commit
56a5760543
|
|
@ -1,21 +0,0 @@
|
||||||
"""
|
|
||||||
This module houses the GeoIP object, a ctypes wrapper for the MaxMind GeoIP(R)
|
|
||||||
C API (http://www.maxmind.com/app/c). This is an alternative to the GPL
|
|
||||||
licensed Python GeoIP interface provided by MaxMind.
|
|
||||||
|
|
||||||
GeoIP(R) is a registered trademark of MaxMind, LLC of Boston, Massachusetts.
|
|
||||||
|
|
||||||
For IP-based geolocation, this module requires the GeoLite Country and City
|
|
||||||
datasets, in binary format (CSV will not work!). The datasets may be
|
|
||||||
downloaded from MaxMind at http://www.maxmind.com/download/geoip/database/.
|
|
||||||
Grab GeoIP.dat.gz and GeoLiteCity.dat.gz, and unzip them in the directory
|
|
||||||
corresponding to settings.GEOIP_PATH.
|
|
||||||
"""
|
|
||||||
__all__ = ['HAS_GEOIP']
|
|
||||||
|
|
||||||
try:
|
|
||||||
from .base import GeoIP, GeoIPException
|
|
||||||
HAS_GEOIP = True
|
|
||||||
__all__ += ['GeoIP', 'GeoIPException']
|
|
||||||
except RuntimeError: # libgeoip.py raises a RuntimeError if no GeoIP library is found
|
|
||||||
HAS_GEOIP = False
|
|
||||||
|
|
@ -1,292 +0,0 @@
|
||||||
import os
|
|
||||||
import re
|
|
||||||
import warnings
|
|
||||||
from ctypes import c_char_p
|
|
||||||
|
|
||||||
from django.contrib.gis.geoip.libgeoip import GEOIP_SETTINGS
|
|
||||||
from django.contrib.gis.geoip.prototypes import (
|
|
||||||
GeoIP_country_code_by_addr, GeoIP_country_code_by_name,
|
|
||||||
GeoIP_country_name_by_addr, GeoIP_country_name_by_name,
|
|
||||||
GeoIP_database_info, GeoIP_delete, GeoIP_lib_version, GeoIP_open,
|
|
||||||
GeoIP_record_by_addr, GeoIP_record_by_name,
|
|
||||||
)
|
|
||||||
from django.core.validators import ipv4_re
|
|
||||||
from django.utils import six
|
|
||||||
from django.utils.deprecation import RemovedInDjango20Warning
|
|
||||||
from django.utils.encoding import force_bytes, force_text
|
|
||||||
|
|
||||||
# Regular expressions for recognizing the GeoIP free database editions.
|
|
||||||
free_regex = re.compile(r'^GEO-\d{3}FREE')
|
|
||||||
lite_regex = re.compile(r'^GEO-\d{3}LITE')
|
|
||||||
|
|
||||||
|
|
||||||
class GeoIPException(Exception):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class GeoIP(object):
|
|
||||||
# The flags for GeoIP memory caching.
|
|
||||||
# GEOIP_STANDARD - read database from filesystem, uses least memory.
|
|
||||||
#
|
|
||||||
# GEOIP_MEMORY_CACHE - load database into memory, faster performance
|
|
||||||
# but uses more memory
|
|
||||||
#
|
|
||||||
# GEOIP_CHECK_CACHE - check for updated database. If database has been
|
|
||||||
# updated, reload filehandle and/or memory cache. This option
|
|
||||||
# is not thread safe.
|
|
||||||
#
|
|
||||||
# GEOIP_INDEX_CACHE - just cache the most frequently accessed index
|
|
||||||
# portion of the database, resulting in faster lookups than
|
|
||||||
# GEOIP_STANDARD, but less memory usage than GEOIP_MEMORY_CACHE -
|
|
||||||
# useful for larger databases such as GeoIP Organization and
|
|
||||||
# GeoIP City. Note, for GeoIP Country, Region and Netspeed
|
|
||||||
# databases, GEOIP_INDEX_CACHE is equivalent to GEOIP_MEMORY_CACHE
|
|
||||||
#
|
|
||||||
# GEOIP_MMAP_CACHE - load database into mmap shared memory ( not available
|
|
||||||
# on Windows).
|
|
||||||
GEOIP_STANDARD = 0
|
|
||||||
GEOIP_MEMORY_CACHE = 1
|
|
||||||
GEOIP_CHECK_CACHE = 2
|
|
||||||
GEOIP_INDEX_CACHE = 4
|
|
||||||
GEOIP_MMAP_CACHE = 8
|
|
||||||
cache_options = {opt: None for opt in (0, 1, 2, 4, 8)}
|
|
||||||
|
|
||||||
# Paths to the city & country binary databases.
|
|
||||||
_city_file = ''
|
|
||||||
_country_file = ''
|
|
||||||
|
|
||||||
# Initially, pointers to GeoIP file references are NULL.
|
|
||||||
_city = None
|
|
||||||
_country = None
|
|
||||||
|
|
||||||
def __init__(self, path=None, cache=0, country=None, city=None):
|
|
||||||
"""
|
|
||||||
Initializes the GeoIP object, no parameters are required to use default
|
|
||||||
settings. Keyword arguments may be passed in to customize the locations
|
|
||||||
of the GeoIP data sets.
|
|
||||||
|
|
||||||
* path: Base directory to where GeoIP data is located or the full path
|
|
||||||
to where the city or country data files (*.dat) are located.
|
|
||||||
Assumes that both the city and country data sets are located in
|
|
||||||
this directory; overrides the GEOIP_PATH settings attribute.
|
|
||||||
|
|
||||||
* cache: The cache settings when opening up the GeoIP datasets,
|
|
||||||
and may be an integer in (0, 1, 2, 4, 8) corresponding to
|
|
||||||
the GEOIP_STANDARD, GEOIP_MEMORY_CACHE, GEOIP_CHECK_CACHE,
|
|
||||||
GEOIP_INDEX_CACHE, and GEOIP_MMAP_CACHE, `GeoIPOptions` C API
|
|
||||||
settings, respectively. Defaults to 0, meaning that the data is read
|
|
||||||
from the disk.
|
|
||||||
|
|
||||||
* country: The name of the GeoIP country data file. Defaults to
|
|
||||||
'GeoIP.dat'; overrides the GEOIP_COUNTRY settings attribute.
|
|
||||||
|
|
||||||
* city: The name of the GeoIP city data file. Defaults to
|
|
||||||
'GeoLiteCity.dat'; overrides the GEOIP_CITY settings attribute.
|
|
||||||
"""
|
|
||||||
|
|
||||||
warnings.warn(
|
|
||||||
"django.contrib.gis.geoip is deprecated in favor of "
|
|
||||||
"django.contrib.gis.geoip2 and the MaxMind GeoLite2 database "
|
|
||||||
"format.", RemovedInDjango20Warning, 2
|
|
||||||
)
|
|
||||||
|
|
||||||
# Checking the given cache option.
|
|
||||||
if cache in self.cache_options:
|
|
||||||
self._cache = cache
|
|
||||||
else:
|
|
||||||
raise GeoIPException('Invalid GeoIP caching option: %s' % cache)
|
|
||||||
|
|
||||||
# Getting the GeoIP data path.
|
|
||||||
if not path:
|
|
||||||
path = GEOIP_SETTINGS.get('GEOIP_PATH')
|
|
||||||
if not path:
|
|
||||||
raise GeoIPException('GeoIP path must be provided via parameter or the GEOIP_PATH setting.')
|
|
||||||
if not isinstance(path, six.string_types):
|
|
||||||
raise TypeError('Invalid path type: %s' % type(path).__name__)
|
|
||||||
|
|
||||||
if os.path.isdir(path):
|
|
||||||
# Constructing the GeoIP database filenames using the settings
|
|
||||||
# dictionary. If the database files for the GeoLite country
|
|
||||||
# and/or city datasets exist, then try and open them.
|
|
||||||
country_db = os.path.join(path, country or GEOIP_SETTINGS.get('GEOIP_COUNTRY', 'GeoIP.dat'))
|
|
||||||
if os.path.isfile(country_db):
|
|
||||||
self._country = GeoIP_open(force_bytes(country_db), cache)
|
|
||||||
self._country_file = country_db
|
|
||||||
|
|
||||||
city_db = os.path.join(path, city or GEOIP_SETTINGS.get('GEOIP_CITY', 'GeoLiteCity.dat'))
|
|
||||||
if os.path.isfile(city_db):
|
|
||||||
self._city = GeoIP_open(force_bytes(city_db), cache)
|
|
||||||
self._city_file = city_db
|
|
||||||
elif os.path.isfile(path):
|
|
||||||
# Otherwise, some detective work will be needed to figure
|
|
||||||
# out whether the given database path is for the GeoIP country
|
|
||||||
# or city databases.
|
|
||||||
ptr = GeoIP_open(force_bytes(path), cache)
|
|
||||||
info = GeoIP_database_info(ptr)
|
|
||||||
if lite_regex.match(info):
|
|
||||||
# GeoLite City database detected.
|
|
||||||
self._city = ptr
|
|
||||||
self._city_file = path
|
|
||||||
elif free_regex.match(info):
|
|
||||||
# GeoIP Country database detected.
|
|
||||||
self._country = ptr
|
|
||||||
self._country_file = path
|
|
||||||
else:
|
|
||||||
raise GeoIPException('Unable to recognize database edition: %s' % info)
|
|
||||||
else:
|
|
||||||
raise GeoIPException('GeoIP path must be a valid file or directory.')
|
|
||||||
|
|
||||||
def __del__(self):
|
|
||||||
# Cleaning any GeoIP file handles lying around.
|
|
||||||
if GeoIP_delete is None:
|
|
||||||
return
|
|
||||||
if self._country:
|
|
||||||
GeoIP_delete(self._country)
|
|
||||||
if self._city:
|
|
||||||
GeoIP_delete(self._city)
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
version = ''
|
|
||||||
if GeoIP_lib_version is not None:
|
|
||||||
version += ' [v%s]' % force_text(GeoIP_lib_version())
|
|
||||||
return '<%(cls)s%(version)s _country_file="%(country)s", _city_file="%(city)s">' % {
|
|
||||||
'cls': self.__class__.__name__,
|
|
||||||
'version': version,
|
|
||||||
'country': self._country_file,
|
|
||||||
'city': self._city_file,
|
|
||||||
}
|
|
||||||
|
|
||||||
def _check_query(self, query, country=False, city=False, city_or_country=False):
|
|
||||||
"Helper routine for checking the query and database availability."
|
|
||||||
# Making sure a string was passed in for the query.
|
|
||||||
if not isinstance(query, six.string_types):
|
|
||||||
raise TypeError('GeoIP query must be a string, not type %s' % type(query).__name__)
|
|
||||||
|
|
||||||
# Extra checks for the existence of country and city databases.
|
|
||||||
if city_or_country and not (self._country or self._city):
|
|
||||||
raise GeoIPException('Invalid GeoIP country and city data files.')
|
|
||||||
elif country and not self._country:
|
|
||||||
raise GeoIPException('Invalid GeoIP country data file: %s' % self._country_file)
|
|
||||||
elif city and not self._city:
|
|
||||||
raise GeoIPException('Invalid GeoIP city data file: %s' % self._city_file)
|
|
||||||
|
|
||||||
# Return the query string back to the caller. GeoIP only takes bytestrings.
|
|
||||||
return force_bytes(query)
|
|
||||||
|
|
||||||
def city(self, query):
|
|
||||||
"""
|
|
||||||
Returns a dictionary of city information for the given IP address or
|
|
||||||
Fully Qualified Domain Name (FQDN). Some information in the dictionary
|
|
||||||
may be undefined (None).
|
|
||||||
"""
|
|
||||||
enc_query = self._check_query(query, city=True)
|
|
||||||
if ipv4_re.match(query):
|
|
||||||
# If an IP address was passed in
|
|
||||||
return GeoIP_record_by_addr(self._city, c_char_p(enc_query))
|
|
||||||
else:
|
|
||||||
# If a FQDN was passed in.
|
|
||||||
return GeoIP_record_by_name(self._city, c_char_p(enc_query))
|
|
||||||
|
|
||||||
def country_code(self, query):
|
|
||||||
"Returns the country code for the given IP Address or FQDN."
|
|
||||||
enc_query = self._check_query(query, city_or_country=True)
|
|
||||||
if self._country:
|
|
||||||
if ipv4_re.match(query):
|
|
||||||
return GeoIP_country_code_by_addr(self._country, enc_query)
|
|
||||||
else:
|
|
||||||
return GeoIP_country_code_by_name(self._country, enc_query)
|
|
||||||
else:
|
|
||||||
return self.city(query)['country_code']
|
|
||||||
|
|
||||||
def country_name(self, query):
|
|
||||||
"Returns the country name for the given IP Address or FQDN."
|
|
||||||
enc_query = self._check_query(query, city_or_country=True)
|
|
||||||
if self._country:
|
|
||||||
if ipv4_re.match(query):
|
|
||||||
return GeoIP_country_name_by_addr(self._country, enc_query)
|
|
||||||
else:
|
|
||||||
return GeoIP_country_name_by_name(self._country, enc_query)
|
|
||||||
else:
|
|
||||||
return self.city(query)['country_name']
|
|
||||||
|
|
||||||
def country(self, query):
|
|
||||||
"""
|
|
||||||
Returns a dictionary with the country code and name when given an
|
|
||||||
IP address or a Fully Qualified Domain Name (FQDN). For example, both
|
|
||||||
'24.124.1.80' and 'djangoproject.com' are valid parameters.
|
|
||||||
"""
|
|
||||||
# Returning the country code and name
|
|
||||||
return {'country_code': self.country_code(query),
|
|
||||||
'country_name': self.country_name(query),
|
|
||||||
}
|
|
||||||
|
|
||||||
# #### Coordinate retrieval routines ####
|
|
||||||
def coords(self, query, ordering=('longitude', 'latitude')):
|
|
||||||
cdict = self.city(query)
|
|
||||||
if cdict is None:
|
|
||||||
return None
|
|
||||||
else:
|
|
||||||
return tuple(cdict[o] for o in ordering)
|
|
||||||
|
|
||||||
def lon_lat(self, query):
|
|
||||||
"Returns a tuple of the (longitude, latitude) for the given query."
|
|
||||||
return self.coords(query)
|
|
||||||
|
|
||||||
def lat_lon(self, query):
|
|
||||||
"Returns a tuple of the (latitude, longitude) for the given query."
|
|
||||||
return self.coords(query, ('latitude', 'longitude'))
|
|
||||||
|
|
||||||
def geos(self, query):
|
|
||||||
"Returns a GEOS Point object for the given query."
|
|
||||||
ll = self.lon_lat(query)
|
|
||||||
if ll:
|
|
||||||
from django.contrib.gis.geos import Point
|
|
||||||
return Point(ll, srid=4326)
|
|
||||||
else:
|
|
||||||
return None
|
|
||||||
|
|
||||||
# #### GeoIP Database Information Routines ####
|
|
||||||
@property
|
|
||||||
def country_info(self):
|
|
||||||
"Returns information about the GeoIP country database."
|
|
||||||
if self._country is None:
|
|
||||||
ci = 'No GeoIP Country data in "%s"' % self._country_file
|
|
||||||
else:
|
|
||||||
ci = GeoIP_database_info(self._country)
|
|
||||||
return ci
|
|
||||||
|
|
||||||
@property
|
|
||||||
def city_info(self):
|
|
||||||
"Returns information about the GeoIP city database."
|
|
||||||
if self._city is None:
|
|
||||||
ci = 'No GeoIP City data in "%s"' % self._city_file
|
|
||||||
else:
|
|
||||||
ci = GeoIP_database_info(self._city)
|
|
||||||
return ci
|
|
||||||
|
|
||||||
@property
|
|
||||||
def info(self):
|
|
||||||
"Returns information about the GeoIP library and databases in use."
|
|
||||||
info = ''
|
|
||||||
if GeoIP_lib_version:
|
|
||||||
info += 'GeoIP Library:\n\t%s\n' % GeoIP_lib_version()
|
|
||||||
return info + 'Country:\n\t%s\nCity:\n\t%s' % (self.country_info, self.city_info)
|
|
||||||
|
|
||||||
# #### Methods for compatibility w/the GeoIP-Python API. ####
|
|
||||||
@classmethod
|
|
||||||
def open(cls, full_path, cache):
|
|
||||||
return GeoIP(full_path, cache)
|
|
||||||
|
|
||||||
def _rec_by_arg(self, arg):
|
|
||||||
if self._city:
|
|
||||||
return self.city(arg)
|
|
||||||
else:
|
|
||||||
return self.country(arg)
|
|
||||||
region_by_addr = city
|
|
||||||
region_by_name = city
|
|
||||||
record_by_addr = _rec_by_arg
|
|
||||||
record_by_name = _rec_by_arg
|
|
||||||
country_code_by_addr = country_code
|
|
||||||
country_code_by_name = country_code
|
|
||||||
country_name_by_addr = country_name
|
|
||||||
country_name_by_name = country_name
|
|
||||||
|
|
@ -1,34 +0,0 @@
|
||||||
import os
|
|
||||||
from ctypes import CDLL
|
|
||||||
from ctypes.util import find_library
|
|
||||||
|
|
||||||
from django.conf import settings
|
|
||||||
|
|
||||||
# Creating the settings dictionary with any settings, if needed.
|
|
||||||
GEOIP_SETTINGS = {key: getattr(settings, key)
|
|
||||||
for key in ('GEOIP_PATH', 'GEOIP_LIBRARY_PATH', 'GEOIP_COUNTRY', 'GEOIP_CITY')
|
|
||||||
if hasattr(settings, key)}
|
|
||||||
lib_path = GEOIP_SETTINGS.get('GEOIP_LIBRARY_PATH')
|
|
||||||
|
|
||||||
# The shared library for the GeoIP C API. May be downloaded
|
|
||||||
# from http://www.maxmind.com/download/geoip/api/c/
|
|
||||||
if lib_path:
|
|
||||||
lib_name = None
|
|
||||||
else:
|
|
||||||
# TODO: Is this really the library name for Windows?
|
|
||||||
lib_name = 'GeoIP'
|
|
||||||
|
|
||||||
# Getting the path to the GeoIP library.
|
|
||||||
if lib_name:
|
|
||||||
lib_path = find_library(lib_name)
|
|
||||||
if lib_path is None:
|
|
||||||
raise RuntimeError('Could not find the GeoIP library (tried "%s"). '
|
|
||||||
'Try setting GEOIP_LIBRARY_PATH in your settings.' % lib_name)
|
|
||||||
lgeoip = CDLL(lib_path)
|
|
||||||
|
|
||||||
# Getting the C `free` for the platform.
|
|
||||||
if os.name == 'nt':
|
|
||||||
libc = CDLL('msvcrt')
|
|
||||||
else:
|
|
||||||
libc = CDLL(None)
|
|
||||||
free = libc.free
|
|
||||||
|
|
@ -1,132 +0,0 @@
|
||||||
from ctypes import POINTER, Structure, c_char_p, c_float, c_int, string_at
|
|
||||||
|
|
||||||
from django.contrib.gis.geoip.libgeoip import free, lgeoip
|
|
||||||
|
|
||||||
|
|
||||||
# #### GeoIP C Structure definitions ####
|
|
||||||
|
|
||||||
class GeoIPRecord(Structure):
|
|
||||||
_fields_ = [('country_code', c_char_p),
|
|
||||||
('country_code3', c_char_p),
|
|
||||||
('country_name', c_char_p),
|
|
||||||
('region', c_char_p),
|
|
||||||
('city', c_char_p),
|
|
||||||
('postal_code', c_char_p),
|
|
||||||
('latitude', c_float),
|
|
||||||
('longitude', c_float),
|
|
||||||
# TODO: In 1.4.6 this changed from `int dma_code;` to
|
|
||||||
# `union {int metro_code; int dma_code;};`. Change
|
|
||||||
# to a `ctypes.Union` in to accommodate in future when
|
|
||||||
# pre-1.4.6 versions are no longer distributed.
|
|
||||||
('dma_code', c_int),
|
|
||||||
('area_code', c_int),
|
|
||||||
('charset', c_int),
|
|
||||||
('continent_code', c_char_p),
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
geoip_char_fields = [name for name, ctype in GeoIPRecord._fields_ if ctype is c_char_p]
|
|
||||||
GEOIP_DEFAULT_ENCODING = 'iso-8859-1'
|
|
||||||
geoip_encodings = {
|
|
||||||
0: 'iso-8859-1',
|
|
||||||
1: 'utf8',
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
class GeoIPTag(Structure):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
RECTYPE = POINTER(GeoIPRecord)
|
|
||||||
DBTYPE = POINTER(GeoIPTag)
|
|
||||||
|
|
||||||
# #### ctypes function prototypes ####
|
|
||||||
|
|
||||||
# GeoIP_lib_version appeared in version 1.4.7.
|
|
||||||
if hasattr(lgeoip, 'GeoIP_lib_version'):
|
|
||||||
GeoIP_lib_version = lgeoip.GeoIP_lib_version
|
|
||||||
GeoIP_lib_version.argtypes = None
|
|
||||||
GeoIP_lib_version.restype = c_char_p
|
|
||||||
else:
|
|
||||||
GeoIP_lib_version = None
|
|
||||||
|
|
||||||
# For freeing memory allocated within a record
|
|
||||||
GeoIPRecord_delete = lgeoip.GeoIPRecord_delete
|
|
||||||
GeoIPRecord_delete.argtypes = [RECTYPE]
|
|
||||||
GeoIPRecord_delete.restype = None
|
|
||||||
|
|
||||||
|
|
||||||
# For retrieving records by name or address.
|
|
||||||
def check_record(result, func, cargs):
|
|
||||||
if result:
|
|
||||||
# Checking the pointer to the C structure, if valid pull out elements
|
|
||||||
# into a dictionary.
|
|
||||||
rec = result.contents
|
|
||||||
record = {fld: getattr(rec, fld) for fld, ctype in rec._fields_}
|
|
||||||
|
|
||||||
# Now converting the strings to unicode using the proper encoding.
|
|
||||||
encoding = geoip_encodings[record['charset']]
|
|
||||||
for char_field in geoip_char_fields:
|
|
||||||
if record[char_field]:
|
|
||||||
record[char_field] = record[char_field].decode(encoding)
|
|
||||||
|
|
||||||
# Free the memory allocated for the struct & return.
|
|
||||||
GeoIPRecord_delete(result)
|
|
||||||
return record
|
|
||||||
else:
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
def record_output(func):
|
|
||||||
func.argtypes = [DBTYPE, c_char_p]
|
|
||||||
func.restype = RECTYPE
|
|
||||||
func.errcheck = check_record
|
|
||||||
return func
|
|
||||||
|
|
||||||
|
|
||||||
GeoIP_record_by_addr = record_output(lgeoip.GeoIP_record_by_addr)
|
|
||||||
GeoIP_record_by_name = record_output(lgeoip.GeoIP_record_by_name)
|
|
||||||
|
|
||||||
|
|
||||||
# For opening & closing GeoIP database files.
|
|
||||||
GeoIP_open = lgeoip.GeoIP_open
|
|
||||||
GeoIP_open.restype = DBTYPE
|
|
||||||
GeoIP_delete = lgeoip.GeoIP_delete
|
|
||||||
GeoIP_delete.argtypes = [DBTYPE]
|
|
||||||
GeoIP_delete.restype = None
|
|
||||||
|
|
||||||
|
|
||||||
# This is so the string pointer can be freed within Python.
|
|
||||||
class geoip_char_p(c_char_p):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
def check_string(result, func, cargs):
|
|
||||||
if result:
|
|
||||||
s = string_at(result)
|
|
||||||
free(result)
|
|
||||||
else:
|
|
||||||
s = ''
|
|
||||||
return s.decode(GEOIP_DEFAULT_ENCODING)
|
|
||||||
|
|
||||||
|
|
||||||
GeoIP_database_info = lgeoip.GeoIP_database_info
|
|
||||||
GeoIP_database_info.restype = geoip_char_p
|
|
||||||
GeoIP_database_info.errcheck = check_string
|
|
||||||
|
|
||||||
|
|
||||||
# String output routines.
|
|
||||||
def string_output(func):
|
|
||||||
def _err_check(result, func, cargs):
|
|
||||||
if result:
|
|
||||||
return result.decode(GEOIP_DEFAULT_ENCODING)
|
|
||||||
return result
|
|
||||||
func.restype = c_char_p
|
|
||||||
func.errcheck = _err_check
|
|
||||||
return func
|
|
||||||
|
|
||||||
|
|
||||||
GeoIP_country_code_by_addr = string_output(lgeoip.GeoIP_country_code_by_addr)
|
|
||||||
GeoIP_country_code_by_name = string_output(lgeoip.GeoIP_country_code_by_name)
|
|
||||||
GeoIP_country_name_by_addr = string_output(lgeoip.GeoIP_country_name_by_addr)
|
|
||||||
GeoIP_country_name_by_name = string_output(lgeoip.GeoIP_country_name_by_name)
|
|
||||||
|
|
@ -1,223 +0,0 @@
|
||||||
======================
|
|
||||||
Geolocation with GeoIP
|
|
||||||
======================
|
|
||||||
|
|
||||||
.. module:: django.contrib.gis.geoip
|
|
||||||
:synopsis: High-level Python interface for MaxMind's GeoIP C library.
|
|
||||||
|
|
||||||
.. deprecated:: 1.9
|
|
||||||
|
|
||||||
This module is deprecated in favor of :doc:`django.contrib.gis.geoip2
|
|
||||||
</ref/contrib/gis/geoip2>`, which supports IPv6 and the GeoLite2 database
|
|
||||||
format.
|
|
||||||
|
|
||||||
The :class:`GeoIP` object is a ctypes wrapper for the
|
|
||||||
`MaxMind GeoIP C API`__. [#]_
|
|
||||||
|
|
||||||
In order to perform IP-based geolocation, the :class:`GeoIP` object requires
|
|
||||||
the GeoIP C library and either the GeoIP `Country`__ or `City`__
|
|
||||||
datasets in binary format (the CSV files will not work!). These datasets may be
|
|
||||||
`downloaded from MaxMind`__. Grab the ``GeoLiteCountry/GeoIP.dat.gz`` and
|
|
||||||
``GeoLiteCity.dat.gz`` files and unzip them in a directory corresponding to what
|
|
||||||
you set :setting:`GEOIP_PATH` with in your settings. See the example and
|
|
||||||
reference below for more details.
|
|
||||||
|
|
||||||
__ https://www.maxmind.com/app/c
|
|
||||||
__ https://www.maxmind.com/app/country
|
|
||||||
__ https://www.maxmind.com/app/city
|
|
||||||
__ https://www.maxmind.com/download/geoip/database/
|
|
||||||
|
|
||||||
Example
|
|
||||||
=======
|
|
||||||
|
|
||||||
Assuming you have the GeoIP C library installed, here is an example of its
|
|
||||||
usage::
|
|
||||||
|
|
||||||
>>> from django.contrib.gis.geoip import GeoIP
|
|
||||||
>>> g = GeoIP()
|
|
||||||
>>> g.country('google.com')
|
|
||||||
{'country_code': 'US', 'country_name': 'United States'}
|
|
||||||
>>> g.city('72.14.207.99')
|
|
||||||
{'area_code': 650,
|
|
||||||
'city': 'Mountain View',
|
|
||||||
'country_code': 'US',
|
|
||||||
'country_code3': 'USA',
|
|
||||||
'country_name': 'United States',
|
|
||||||
'dma_code': 807,
|
|
||||||
'latitude': 37.419200897216797,
|
|
||||||
'longitude': -122.05740356445312,
|
|
||||||
'postal_code': '94043',
|
|
||||||
'region': 'CA'}
|
|
||||||
>>> g.lat_lon('salon.com')
|
|
||||||
(37.789798736572266, -122.39420318603516)
|
|
||||||
>>> g.lon_lat('uh.edu')
|
|
||||||
(-95.415199279785156, 29.77549934387207)
|
|
||||||
>>> g.geos('24.124.1.80').wkt
|
|
||||||
'POINT (-95.2087020874023438 39.0392990112304688)'
|
|
||||||
|
|
||||||
``GeoIP`` Settings
|
|
||||||
==================
|
|
||||||
|
|
||||||
.. setting:: GEOIP_PATH
|
|
||||||
|
|
||||||
``GEOIP_PATH``
|
|
||||||
--------------
|
|
||||||
|
|
||||||
A string specifying the directory where the GeoIP data files are
|
|
||||||
located. This setting is *required* unless manually specified
|
|
||||||
with ``path`` keyword when initializing the :class:`GeoIP` object.
|
|
||||||
|
|
||||||
.. setting:: GEOIP_LIBRARY_PATH
|
|
||||||
|
|
||||||
``GEOIP_LIBRARY_PATH``
|
|
||||||
----------------------
|
|
||||||
|
|
||||||
A string specifying the location of the GeoIP C library. Typically,
|
|
||||||
this setting is only used if the GeoIP C library is in a non-standard
|
|
||||||
location (e.g., ``/home/sue/lib/libGeoIP.so``).
|
|
||||||
|
|
||||||
.. setting:: GEOIP_COUNTRY
|
|
||||||
|
|
||||||
``GEOIP_COUNTRY``
|
|
||||||
-----------------
|
|
||||||
|
|
||||||
The basename to use for the GeoIP country data file.
|
|
||||||
Defaults to ``'GeoIP.dat'``.
|
|
||||||
|
|
||||||
.. setting:: GEOIP_CITY
|
|
||||||
|
|
||||||
``GEOIP_CITY``
|
|
||||||
--------------
|
|
||||||
|
|
||||||
The basename to use for the GeoIP city data file.
|
|
||||||
Defaults to ``'GeoLiteCity.dat'``.
|
|
||||||
|
|
||||||
``GeoIP`` API
|
|
||||||
=============
|
|
||||||
|
|
||||||
.. class:: GeoIP(path=None, cache=0, country=None, city=None)
|
|
||||||
|
|
||||||
The ``GeoIP`` object does not require any parameters to use the default
|
|
||||||
settings. However, at the very least the :setting:`GEOIP_PATH` setting
|
|
||||||
should be set with the path of the location of your GeoIP data sets. The
|
|
||||||
following initialization keywords may be used to customize any of the
|
|
||||||
defaults.
|
|
||||||
|
|
||||||
=================== =======================================================
|
|
||||||
Keyword Arguments Description
|
|
||||||
=================== =======================================================
|
|
||||||
``path`` Base directory to where GeoIP data is located or the
|
|
||||||
full path to where the city or country data files
|
|
||||||
(.dat) are located. Assumes that both the city and
|
|
||||||
country data sets are located in this directory;
|
|
||||||
overrides the :setting:`GEOIP_PATH` settings attribute.
|
|
||||||
|
|
||||||
``cache`` The cache settings when opening up the GeoIP datasets,
|
|
||||||
and may be an integer in (0, 1, 2, 4) corresponding to
|
|
||||||
the ``GEOIP_STANDARD``, ``GEOIP_MEMORY_CACHE``,
|
|
||||||
``GEOIP_CHECK_CACHE``, and ``GEOIP_INDEX_CACHE``
|
|
||||||
``GeoIPOptions`` C API settings, respectively.
|
|
||||||
Defaults to 0 (``GEOIP_STANDARD``).
|
|
||||||
|
|
||||||
``country`` The name of the GeoIP country data file. Defaults
|
|
||||||
to ``GeoIP.dat``. Setting this keyword overrides the
|
|
||||||
:setting:`GEOIP_COUNTRY` settings attribute.
|
|
||||||
|
|
||||||
``city`` The name of the GeoIP city data file. Defaults to
|
|
||||||
``GeoLiteCity.dat``. Setting this keyword overrides
|
|
||||||
the :setting:`GEOIP_CITY` settings attribute.
|
|
||||||
=================== =======================================================
|
|
||||||
|
|
||||||
``GeoIP`` Methods
|
|
||||||
=================
|
|
||||||
|
|
||||||
Querying
|
|
||||||
--------
|
|
||||||
|
|
||||||
All the following querying routines may take either a string IP address
|
|
||||||
or a fully qualified domain name (FQDN). For example, both
|
|
||||||
``'205.186.163.125'`` and ``'djangoproject.com'`` would be valid query
|
|
||||||
parameters.
|
|
||||||
|
|
||||||
.. method:: GeoIP.city(query)
|
|
||||||
|
|
||||||
Returns a dictionary of city information for the given query. Some
|
|
||||||
of the values in the dictionary may be undefined (``None``).
|
|
||||||
|
|
||||||
.. method:: GeoIP.country(query)
|
|
||||||
|
|
||||||
Returns a dictionary with the country code and country for the given
|
|
||||||
query.
|
|
||||||
|
|
||||||
.. method:: GeoIP.country_code(query)
|
|
||||||
|
|
||||||
Returns only the country code corresponding to the query.
|
|
||||||
|
|
||||||
.. method:: GeoIP.country_name(query)
|
|
||||||
|
|
||||||
Returns only the country name corresponding to the query.
|
|
||||||
|
|
||||||
Coordinate Retrieval
|
|
||||||
--------------------
|
|
||||||
|
|
||||||
.. method:: GeoIP.coords(query)
|
|
||||||
|
|
||||||
Returns a coordinate tuple of (longitude, latitude).
|
|
||||||
|
|
||||||
.. method:: GeoIP.lon_lat(query)
|
|
||||||
|
|
||||||
Returns a coordinate tuple of (longitude, latitude).
|
|
||||||
|
|
||||||
.. method:: GeoIP.lat_lon(query)
|
|
||||||
|
|
||||||
Returns a coordinate tuple of (latitude, longitude),
|
|
||||||
|
|
||||||
.. method:: GeoIP.geos(query)
|
|
||||||
|
|
||||||
Returns a :class:`django.contrib.gis.geos.Point` object corresponding to the query.
|
|
||||||
|
|
||||||
Database Information
|
|
||||||
--------------------
|
|
||||||
|
|
||||||
.. attribute:: GeoIP.country_info
|
|
||||||
|
|
||||||
This property returns information about the GeoIP country database.
|
|
||||||
|
|
||||||
.. attribute:: GeoIP.city_info
|
|
||||||
|
|
||||||
This property returns information about the GeoIP city database.
|
|
||||||
|
|
||||||
.. attribute:: GeoIP.info
|
|
||||||
|
|
||||||
This property returns information about all GeoIP databases (both city
|
|
||||||
and country), and the version of the GeoIP C library (if supported).
|
|
||||||
|
|
||||||
GeoIP-Python API compatibility methods
|
|
||||||
----------------------------------------
|
|
||||||
|
|
||||||
These methods exist to ease compatibility with any code using MaxMind's
|
|
||||||
existing Python API.
|
|
||||||
|
|
||||||
.. classmethod:: GeoIP.open(path, cache)
|
|
||||||
|
|
||||||
This classmethod instantiates the GeoIP object from the given database path
|
|
||||||
and given cache setting.
|
|
||||||
|
|
||||||
.. method:: GeoIP.region_by_addr(query)
|
|
||||||
|
|
||||||
.. method:: GeoIP.region_by_name(query)
|
|
||||||
|
|
||||||
.. method:: GeoIP.record_by_addr(query)
|
|
||||||
|
|
||||||
.. method:: GeoIP.record_by_name(query)
|
|
||||||
|
|
||||||
.. method:: GeoIP.country_code_by_addr(query)
|
|
||||||
|
|
||||||
.. method:: GeoIP.country_code_by_name(query)
|
|
||||||
|
|
||||||
.. method:: GeoIP.country_name_by_addr(query)
|
|
||||||
|
|
||||||
.. method:: GeoIP.country_name_by_name(query)
|
|
||||||
|
|
||||||
.. rubric:: Footnotes
|
|
||||||
.. [#] GeoIP(R) is a registered trademark of MaxMind, LLC of Boston, Massachusetts.
|
|
||||||
|
|
@ -22,7 +22,6 @@ of spatially enabled data.
|
||||||
measure
|
measure
|
||||||
geos
|
geos
|
||||||
gdal
|
gdal
|
||||||
geoip
|
|
||||||
geoip2
|
geoip2
|
||||||
utils
|
utils
|
||||||
commands
|
commands
|
||||||
|
|
|
||||||
|
|
@ -263,3 +263,5 @@ these features.
|
||||||
* ``django.contrib.auth.tests.utils.skipIfCustomUser()`` is removed.
|
* ``django.contrib.auth.tests.utils.skipIfCustomUser()`` is removed.
|
||||||
|
|
||||||
* The ``GeoManager`` and ``GeoQuerySet`` classes are removed.
|
* The ``GeoManager`` and ``GeoQuerySet`` classes are removed.
|
||||||
|
|
||||||
|
* The ``django.contrib.gis.geoip`` module is removed.
|
||||||
|
|
|
||||||
|
|
@ -1,178 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
from __future__ import unicode_literals
|
|
||||||
|
|
||||||
import os
|
|
||||||
import socket
|
|
||||||
import unittest
|
|
||||||
import warnings
|
|
||||||
from unittest import skipUnless
|
|
||||||
|
|
||||||
from django.conf import settings
|
|
||||||
from django.contrib.gis.geoip import HAS_GEOIP
|
|
||||||
from django.contrib.gis.geos import HAS_GEOS, GEOSGeometry
|
|
||||||
from django.test import ignore_warnings
|
|
||||||
from django.utils import six
|
|
||||||
from django.utils.deprecation import RemovedInDjango20Warning
|
|
||||||
from django.utils.encoding import force_text
|
|
||||||
|
|
||||||
if HAS_GEOIP:
|
|
||||||
from django.contrib.gis.geoip import GeoIP, GeoIPException
|
|
||||||
from django.contrib.gis.geoip.prototypes import GeoIP_lib_version
|
|
||||||
|
|
||||||
|
|
||||||
# Note: Requires use of both the GeoIP country and city datasets.
|
|
||||||
# The GEOIP_DATA path should be the only setting set (the directory
|
|
||||||
# should contain links or the actual database files 'GeoIP.dat' and
|
|
||||||
# 'GeoLiteCity.dat'.
|
|
||||||
|
|
||||||
|
|
||||||
@skipUnless(
|
|
||||||
HAS_GEOIP and getattr(settings, "GEOIP_PATH", None),
|
|
||||||
"GeoIP is required along with the GEOIP_PATH setting."
|
|
||||||
)
|
|
||||||
@ignore_warnings(category=RemovedInDjango20Warning)
|
|
||||||
class GeoIPTest(unittest.TestCase):
|
|
||||||
addr = '162.242.220.127'
|
|
||||||
fqdn = 'www.djangoproject.com'
|
|
||||||
|
|
||||||
def _is_dns_available(self, domain):
|
|
||||||
# Naive check to see if there is DNS available to use.
|
|
||||||
# Used to conditionally skip fqdn geoip checks.
|
|
||||||
# See #25407 for details.
|
|
||||||
ErrClass = socket.error if six.PY2 else OSError
|
|
||||||
try:
|
|
||||||
socket.gethostbyname(domain)
|
|
||||||
return True
|
|
||||||
except ErrClass:
|
|
||||||
return False
|
|
||||||
|
|
||||||
def test01_init(self):
|
|
||||||
"Testing GeoIP initialization."
|
|
||||||
g1 = GeoIP() # Everything inferred from GeoIP path
|
|
||||||
path = settings.GEOIP_PATH
|
|
||||||
g2 = GeoIP(path, 0) # Passing in data path explicitly.
|
|
||||||
g3 = GeoIP.open(path, 0) # MaxMind Python API syntax.
|
|
||||||
|
|
||||||
for g in (g1, g2, g3):
|
|
||||||
self.assertTrue(g._country)
|
|
||||||
self.assertTrue(g._city)
|
|
||||||
|
|
||||||
# Only passing in the location of one database.
|
|
||||||
city = os.path.join(path, 'GeoLiteCity.dat')
|
|
||||||
cntry = os.path.join(path, 'GeoIP.dat')
|
|
||||||
g4 = GeoIP(city, country='')
|
|
||||||
self.assertIsNone(g4._country)
|
|
||||||
g5 = GeoIP(cntry, city='')
|
|
||||||
self.assertIsNone(g5._city)
|
|
||||||
|
|
||||||
# Improper parameters.
|
|
||||||
bad_params = (23, 'foo', 15.23)
|
|
||||||
for bad in bad_params:
|
|
||||||
with self.assertRaises(GeoIPException):
|
|
||||||
GeoIP(cache=bad)
|
|
||||||
if isinstance(bad, six.string_types):
|
|
||||||
e = GeoIPException
|
|
||||||
else:
|
|
||||||
e = TypeError
|
|
||||||
with self.assertRaises(e):
|
|
||||||
GeoIP(bad, 0)
|
|
||||||
|
|
||||||
def test02_bad_query(self):
|
|
||||||
"Testing GeoIP query parameter checking."
|
|
||||||
cntry_g = GeoIP(city='<foo>')
|
|
||||||
# No city database available, these calls should fail.
|
|
||||||
with self.assertRaises(GeoIPException):
|
|
||||||
cntry_g.city('google.com')
|
|
||||||
with self.assertRaises(GeoIPException):
|
|
||||||
cntry_g.coords('yahoo.com')
|
|
||||||
|
|
||||||
# Non-string query should raise TypeError
|
|
||||||
with self.assertRaises(TypeError):
|
|
||||||
cntry_g.country_code(17)
|
|
||||||
with self.assertRaises(TypeError):
|
|
||||||
cntry_g.country_name(GeoIP)
|
|
||||||
|
|
||||||
def test03_country(self):
|
|
||||||
"Testing GeoIP country querying methods."
|
|
||||||
g = GeoIP(city='<foo>')
|
|
||||||
|
|
||||||
queries = [self.addr]
|
|
||||||
if self._is_dns_available(self.fqdn):
|
|
||||||
queries.append(self.fqdn)
|
|
||||||
for query in queries:
|
|
||||||
for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
|
|
||||||
self.assertEqual('US', func(query), 'Failed for func %s and query %s' % (func, query))
|
|
||||||
for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
|
|
||||||
self.assertEqual('United States', func(query), 'Failed for func %s and query %s' % (func, query))
|
|
||||||
self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
|
|
||||||
g.country(query))
|
|
||||||
|
|
||||||
@skipUnless(HAS_GEOS, "Geos is required")
|
|
||||||
def test04_city(self):
|
|
||||||
"Testing GeoIP city querying methods."
|
|
||||||
g = GeoIP(country='<foo>')
|
|
||||||
|
|
||||||
queries = [self.addr]
|
|
||||||
if self._is_dns_available(self.fqdn):
|
|
||||||
queries.append(self.fqdn)
|
|
||||||
for query in queries:
|
|
||||||
# Country queries should still work.
|
|
||||||
for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
|
|
||||||
self.assertEqual('US', func(query))
|
|
||||||
for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
|
|
||||||
self.assertEqual('United States', func(query))
|
|
||||||
self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
|
|
||||||
g.country(query))
|
|
||||||
|
|
||||||
# City information dictionary.
|
|
||||||
d = g.city(query)
|
|
||||||
self.assertEqual('USA', d['country_code3'])
|
|
||||||
self.assertEqual('San Antonio', d['city'])
|
|
||||||
self.assertEqual('TX', d['region'])
|
|
||||||
self.assertEqual(210, d['area_code'])
|
|
||||||
geom = g.geos(query)
|
|
||||||
self.assertIsInstance(geom, GEOSGeometry)
|
|
||||||
lon, lat = (-98, 29)
|
|
||||||
lat_lon = g.lat_lon(query)
|
|
||||||
lat_lon = (lat_lon[1], lat_lon[0])
|
|
||||||
for tup in (geom.tuple, g.coords(query), g.lon_lat(query), lat_lon):
|
|
||||||
self.assertAlmostEqual(lon, tup[0], 0)
|
|
||||||
self.assertAlmostEqual(lat, tup[1], 0)
|
|
||||||
|
|
||||||
def test05_unicode_response(self):
|
|
||||||
"Testing that GeoIP strings are properly encoded, see #16553."
|
|
||||||
g = GeoIP()
|
|
||||||
fqdn = "hs-duesseldorf.de"
|
|
||||||
if self._is_dns_available(fqdn):
|
|
||||||
d = g.city(fqdn)
|
|
||||||
self.assertEqual('Düsseldorf', d['city'])
|
|
||||||
d = g.country('200.26.205.1')
|
|
||||||
# Some databases have only unaccented countries
|
|
||||||
self.assertIn(d['country_name'], ('Curaçao', 'Curacao'))
|
|
||||||
|
|
||||||
def test_deprecation_warning(self):
|
|
||||||
with warnings.catch_warnings(record=True) as warns:
|
|
||||||
warnings.simplefilter('always')
|
|
||||||
GeoIP()
|
|
||||||
|
|
||||||
self.assertEqual(len(warns), 1)
|
|
||||||
msg = str(warns[0].message)
|
|
||||||
self.assertIn('django.contrib.gis.geoip is deprecated', msg)
|
|
||||||
|
|
||||||
def test_repr(self):
|
|
||||||
path = settings.GEOIP_PATH
|
|
||||||
g = GeoIP(path=path)
|
|
||||||
country_path = g._country_file
|
|
||||||
city_path = g._city_file
|
|
||||||
if GeoIP_lib_version:
|
|
||||||
expected = '<GeoIP [v%(version)s] _country_file="%(country)s", _city_file="%(city)s">' % {
|
|
||||||
'version': force_text(GeoIP_lib_version()),
|
|
||||||
'country': country_path,
|
|
||||||
'city': city_path,
|
|
||||||
}
|
|
||||||
else:
|
|
||||||
expected = '<GeoIP _country_file="%(country)s", _city_file="%(city)s">' % {
|
|
||||||
'country': country_path,
|
|
||||||
'city': city_path,
|
|
||||||
}
|
|
||||||
self.assertEqual(repr(g), expected)
|
|
||||||
Loading…
Reference in New Issue