pax_global_header00006660000000000000000000000064132657727600014531gustar00rootroot0000000000000052 comment=a76d67c31c366a386fa6c5d9aea76e126935e7e3 django-ipware-2.1.0/000077500000000000000000000000001326577276000142605ustar00rootroot00000000000000django-ipware-2.1.0/.gitignore000066400000000000000000000012761326577276000162560ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] # C extensions *.so # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *,cover # Translations *.mo *.pot # Django stuff: *.log # Sphinx documentation docs/_build/ # PyBuilder target/ django-ipware-2.1.0/.travis.yml000066400000000000000000000013261326577276000163730ustar00rootroot00000000000000sudo: false language: python python: - "3.7-dev" - "3.6" - "3.5" - "3.4" - "2.7" - "pypy" - "pypy3" env: - DJANGO="django==2.0.4" - DJANGO="django==1.11.12" install: - pip install $DJANGO - pip install -e . - pip install pycodestyle - pip install https://github.com/un33k/pyflakes/tarball/master - pip install coveralls before_script: - "pycodestyle --exclude=migrations,tests --ignore=E501,E241,E225,E128 ." - if [[ $TRAVIS_PYTHON_VERSION == '2.7' ]]; then pyflakes -x W ipware; fi matrix: exclude: - python: "2.7" env: DJANGO="django==2.0.4" - python: "pypy" env: DJANGO="django==2.0.4" script: coverage run --source=ipware manage.py test after_success: coveralls django-ipware-2.1.0/CHANGELOG.md000066400000000000000000000042051326577276000160720ustar00rootroot00000000000000## 2.1.0 Enhancement: - Added more non-routable ip blocks (@wking) ## 2.0.2 Enhancement: - Added the ability to private the request precedence order on each call ## 2.0.1 Enhancement: - Added more private IP blocks to the default list ## 2.0.0 Fix: - Update Django versions (@illagrenan) - Update Readme (@sabueso) - Added proxy count - Moved version one readme to /docs ## 1.1.6 Fix: - Fix trusted proxies Right2Left + Test & Bumped Django versions (@felixxm) - Changed licensing to MIT ## 1.1.5 Feature: - Added support for trusted proxy configuration ## 1.1.4 Enhancement: - Added support for proxies with `underscores_in_headers off;` - Handling hyphen as delimiter - ex: `X-FORWARDED-FOR` instead of `X_FORWARDED_FOR` - Up version Django version in .travis.yml ## 1.1.3 Fix: - Fix read me file updating `IPWARE_META_PRECEDENCE_ORDER` reference. ## 1.1.2 Updates: - Added support for Django 1.8.6 and Python 3.5. - Dropped support for Django 1.4.x and Python 2.6 and 3.2 ## 1.1.1 Enhancement: - Added support for X_FORWARDED_FOR ## 1.1.0 Enhancement: - Added support for 1.0.0.0/8 and 2.0.0.0/8 blocks ## 1.0.0 Enhancement: - Promoting to production grade ## 0.1.1 Enhancement: - Support for Left2Right or Right2Left Proxy IP Lookup ## 0.1.0 Enhancement: - pypy support - PY3.4 support ## 0.0.9 Enhancement: - Django 1.7 official support - First non-loopback private IP match is best matched now. ## 0.0.8 Enhancement: - Django 1.7 support - PEP8 Compliance - Bump Alpha to Beta ## 0.0.6 Enhancement: - Converted print statements to new format. (Python 3.x) - Replaced deprecated unit test APIs ## 0.0.5 Enhancement: - Added Python 3.2 and 3.3 support ## 0.0.4 Enhancement: - Added changelog file - Added more private ip prefixes ## 0.0.3 Features: - Added get_ip() to return the best-matched IP - Removed get_ip_address_from_request() Bugfixes: - Expended the private IP range ## 0.0.2 Features: - IPv6 support - Added get_real_ip(), the shorter version of get_ip_address_from_request() ## 0.0.1 Features: - Initial Release django-ipware-2.1.0/LICENSE000066400000000000000000000021171326577276000152660ustar00rootroot00000000000000The MIT License Copyright (c) Val Neekman @ Neekware Inc. http://neekware.com 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. django-ipware-2.1.0/README.md000066400000000000000000000222041326577276000155370ustar00rootroot00000000000000Django IPware ==================== **A Django application to retrieve client's IP address** [![status-image]][status-link] [![version-image]][version-link] [![coverage-image]][coverage-link] Overview ==================== **Best attempt** to get client's IP address while keeping it **DRY**. Notice ==================== There is not a good `out-of-the-box` solution against fake IP addresses, aka `IP Address Spoofing`. You are encouraged to read the ([Advanced users](README.md#advanced-users)) section of this page and use `trusted_proxies_ips` and/or `proxy_count` features to match your needs, especially `if` you are planning to include `ipware` in any authentication, security or `anti-fraud` related architecture. How to install ==================== 1. easy_install django-ipware 2. pip install django-ipware 3. git clone http://github.com/un33k/django-ipware a. cd django-ipware b. run python setup.py install 4. wget https://github.com/un33k/django-ipware/zipball/master a. unzip the downloaded file b. cd into django-ipware-* directory c. run python setup.py install How to use ==================== ```python # In a view or a middleware where the `request` object is available from ipware import get_client_ip client_ip, is_routable = get_client_ip(request) if client_ip is None: # Unable to get the client's IP address else: # We got the client's IP address if is_routable: # The client's IP address is publicly routable on the Internet else: # The client's IP address is private # Order of precedence is (Public, Private, Loopback, None) ``` Advanced users: ==================== - ### Precedence Order The default meta precedence order is top to bottom. However, you may customize the order by providing your own `IPWARE_META_PRECEDENCE_ORDER` by adding it to your project's settings.py ```python # The default meta precedence order IPWARE_META_PRECEDENCE_ORDER = ( 'HTTP_X_FORWARDED_FOR', 'X_FORWARDED_FOR', # , , 'HTTP_CLIENT_IP', 'HTTP_X_REAL_IP', 'HTTP_X_FORWARDED', 'HTTP_X_CLUSTER_CLIENT_IP', 'HTTP_FORWARDED_FOR', 'HTTP_FORWARDED', 'HTTP_VIA', 'REMOTE_ADDR', ) ``` **Alternativley**, you can provide your custom `request header meta precedence order` when calling `get_client_ip()`. ```python get_client_ip(request, request_header_order=['X_FORWARDED_FOR']) get_client_ip(request, request_header_order=['X_FORWARDED_FOR', 'HTTP_X_FORWARDED_FOR']) ``` - ### Private Prefixes You may customize the prefixes to indicate an IP addresses private. This is done by adding your own `IPWARE_PRIVATE_IP_PREFIX` to your project's settings.py. IP addresses matching the following prefixes are considered `private` & are **not** publicly routable. ```python # The default private IP prefixes IPWARE_PRIVATE_IP_PREFIX = getattr(settings, 'IPWARE_PRIVATE_IP_PREFIX', ( '0.', # messages to software '10.', # class A private block '100.64.', '100.65.', '100.66.', '100.67.', '100.68.', '100.69.', '100.70.', '100.71.', '100.72.', '100.73.', '100.74.', '100.75.', '100.76.', '100.77.', '100.78.', '100.79.', '100.80.', '100.81.', '100.82.', '100.83.', '100.84.', '100.85.', '100.86.', '100.87.', '100.88.', '100.89.', '100.90.', '100.91.', '100.92.', '100.93.', '100.94.', '100.95.', '100.96.', '100.97.', '100.98.', '100.99.', '100.100.', '100.101.', '100.102.', '100.103.', '100.104.', '100.105.', '100.106.', '100.107.', '100.108.', '100.109.', '100.110.', '100.111.', '100.112.', '100.113.', '100.114.', '100.115.', '100.116.', '100.117.', '100.118.', '100.119.', '100.120.', '100.121.', '100.122.', '100.123.', '100.124.', '100.125.', '100.126.', '100.127.', # carrier-grade NAT '169.254.', # link-local block '172.16.', '172.17.', '172.18.', '172.19.', '172.20.', '172.21.', '172.22.', '172.23.', '172.24.', '172.25.', '172.26.', '172.27.', '172.28.', '172.29.', '172.30.', '172.31.', # class B private blocks '192.0.0.', # reserved for IANA special purpose address registry '192.0.2.', # reserved for documentation and example code '192.168.', # class C private block '198.18.', '198.19.', # reserved for inter-network communications between two separate subnets '198.51.100.', # reserved for documentation and example code '203.0.113.', # reserved for documentation and example code '224.', '225.', '226.', '227.', '228.', '229.', '230.', '231.', '232.', '233.', '234.', '235.', '236.', '237.', '238.', '239.', # multicast '240.', '241.', '242.', '243.', '244.', '245.', '246.', '247.', '248.', '249.', '250.', '251.', '252.', '253.', '254.', '255.', # reserved ) + ( '::', # Unspecified address '::ffff:', '2001:10:', '2001:20:' # messages to software '2001::', # TEREDO '2001:2::', # benchmarking '2001:db8:', # reserved for documentation and example code 'fc00:', # IPv6 private block 'fe80:', # link-local unicast 'ff00:', # IPv6 multicast ) ) ``` - ### Trusted Proxies If your Django server is behind one or more known proxy server(s), you can filter out unwanted requests by providing the `trusted` proxy list when calling `get_client_ip(request, proxy_trusted_ips=['177.139.233.133'])`. In the following example, your load balancer (LB) can be seen as a `trusted` proxy. ``` `Real` Client <---> LB (Server) <--------> Django Server ^ | `Fake` Client <---> LB (Server) ---^ ``` ```python # In the above scenario, use your load balancer's IP address as a way to filter out unwanted requests. client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.233.133']) # If you have multiple proxies, simply add them to the list client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.233.133', '177.139.233.134']) # For proxy servers with fixed sub-domain and dynamic IP, use the following pattern. client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.', '177.140']) client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.233.', '177.139.240']) ``` - ### Proxy Count If your Django server is behind a `known` number of proxy server(s), you can filter out unwanted requests by providing the `number` of proxies when calling `get_client_ip(request, proxy_count=1)`. In the following example, your load balancer (LB) can be seen as the `only` proxy. ``` `Real` Client <---> LB (Server) <--------> Django Server ^ | `Fake` Client ---^ ``` ```python # In the above scenario, the total number of proxies can be used as a way to filter out unwanted requests. client_ip, is_routable = get_client_ip(request, proxy_count=1) # The above may be very useful in cases where your proxy server's IP address is assigned dynamically. # However, If you have the proxy IP address, you can use it in combination to the proxy count. client_ip, is_routable = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['177.139.233.133']) ``` - ### Originating Request If your proxy server is configured such that the right most IP address is that of the originating client, you can indicate `right-most` as your `proxy_order` when calling `get_client_ip(request, proxy_order="right-most")`. Please note that the [de-facto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For) standard for the originating client IP address is the `left-most` as per `, , `. Running the tests ==================== To run the tests against the current environment: python manage.py test License ==================== Released under a ([MIT](LICENSE)) license. Version ==================== X.Y.Z Version `MAJOR` version -- when you make incompatible API changes, `MINOR` version -- when you add functionality in a backwards-compatible manner, and `PATCH` version -- when you make backwards-compatible bug fixes. [status-image]: https://secure.travis-ci.org/un33k/django-ipware.png?branch=master [status-link]: http://travis-ci.org/un33k/django-ipware?branch=master [version-image]: https://img.shields.io/pypi/v/django-ipware.svg [version-link]: https://pypi.python.org/pypi/django-ipware [coverage-image]: https://coveralls.io/repos/un33k/django-ipware/badge.svg [coverage-link]: https://coveralls.io/r/un33k/django-ipware [download-image]: https://img.shields.io/pypi/dm/django-ipware.svg [download-link]: https://pypi.python.org/pypi/django-ipware django-ipware-2.1.0/docs/000077500000000000000000000000001326577276000152105ustar00rootroot00000000000000django-ipware-2.1.0/docs/README-VER1.md000066400000000000000000000120251326577276000172020ustar00rootroot00000000000000Django IPware (Deprecated) ==================== **A Django application to retrieve user's IP address** Overview ==================== **Best attempt** to get user's (client's) real ip-address while keeping it **DRY**. Notice ==================== There is no good `out-of-the-box` solution against fake IP addresses, aka `IP Address Spoofing`. You are encouraged to read the ([Advanced users](README.md#advanced-users)) section of this page and set `IPWARE_TRUSTED_PROXY_LIST` to match your needs `if` you are planning to include `ipware` in any authentication, security or `anti-fraud` related architecture. How to install ==================== 1. easy_install django-ipware 2. pip install django-ipware 3. git clone http://github.com/un33k/django-ipware a. cd django-ipware b. run python setup.py 4. wget https://github.com/un33k/django-ipware/zipball/master a. unzip the downloaded file b. cd into django-ipware-* directory c. run python setup.py How to use ==================== ```python # If your web server is publicly accessible on the Internet # ========================================================= # To get the `real` IP address of the client. # Where: # `Real IP` = an IP address that is route-able on the Internet from ipware.ip import get_real_ip ip = get_real_ip(request) if ip is not None: # we have a real, public ip address for user else: # we don't have a real, public ip address for user # If your web server is NOT publicly accessible on the Internet # ============================================================= # To get the `best matched` IP address of the client. # Where: # `Best Matched IP` = The first matched public IP if found, else the first matched non-public IP. from ipware.ip import get_ip ip = get_ip(request) if ip is not None: # we have an ip address for user else: # we don't have an ip address for user # By default the left most address in the `HTTP_X_FORWARDED_FOR` is returned. However, depending on your # preference and needs, you can change this behavior by passing the `right_most_proxy=True` to the API. # Please note that not all proxies are equal. So left to right or right to left is not a rule that all # proxy servers follow. from ipware.ip import get_ip ip = get_ip(request, right_most_proxy=True) # OR ip = get_real_ip(request, right_most_proxy=True) ``` Advanced users: ==================== ```python # you can provide your own meta precedence order by # including IPWARE_META_PRECEDENCE_ORDER in your project's # settings.py. The check is done from top to bottom IPWARE_META_PRECEDENCE_ORDER = ( 'HTTP_X_FORWARDED_FOR', 'X_FORWARDED_FOR', # client, proxy1, proxy2 'HTTP_CLIENT_IP', 'HTTP_X_REAL_IP', 'HTTP_X_FORWARDED', 'HTTP_X_CLUSTER_CLIENT_IP', 'HTTP_FORWARDED_FOR', 'HTTP_FORWARDED', 'HTTP_VIA', 'REMOTE_ADDR', ) # you can provide your own private IP prefixes by # including IPWARE_PRIVATE_IP_PREFIX in your project's setting.py # IPs that start with items listed below are ignored # and are not considered a `real` IP address IPWARE_PRIVATE_IP_PREFIX = ( '0.', # externally non-routable '10.', # class A private block '169.254.', # link-local block '172.16.', '172.17.', '172.18.', '172.19.', '172.20.', '172.21.', '172.22.', '172.23.', '172.24.', '172.25.', '172.26.', '172.27.', '172.28.', '172.29.', '172.30.', '172.31.', # class B private blocks '192.0.2.', # reserved for documentation and example code '192.168.', # class C private block '255.255.255.', # IPv4 broadcast address ) + ( '2001:db8:', # reserved for documentation and example code 'fc00:', # IPv6 private block 'fe80:', # link-local unicast 'ff00:', # IPv6 multicast ) # if you plan to use `ipware` in any authentication, security or `anti-fraud` related # architecture, you should configure it to only `trust` one or more `known` proxy server(s)). # simply include `IPWARE_TRUSTED_PROXY_LIST` in your project's settings.py IPWARE_TRUSTED_PROXY_LIST = ['23.91.45.15', '23.91.45.16'] # exact proxies # -- OR -- IPWARE_TRUSTED_PROXY_LIST = ['23.91.45'] # any proxy within a specific subnet # alternatively, you may pass the `trusted` proxy list on demand on each call # example: ip = get_trusted_ip(request, trusted_proxies=['23.91.45.15']) ``` Running the tests ==================== To run the tests against the current environment: python manage.py test License ==================== Released under a ([MIT](LICENSE)) license. Version ==================== X.Y.Z Version `MAJOR` version -- when you make incompatible API changes, `MINOR` version -- when you add functionality in a backwards-compatible manner, and `PATCH` version -- when you make backwards-compatible bug fixes. django-ipware-2.1.0/ipware/000077500000000000000000000000001326577276000155475ustar00rootroot00000000000000django-ipware-2.1.0/ipware/__init__.py000066400000000000000000000003461326577276000176630ustar00rootroot00000000000000from .ip2 import get_client_ip default_app_config = 'ipware.apps.IPwareConfig' __author__ = 'Val Neekman @ Neekware Inc. [@vneekman]' __description__ = "A Django application to retrieve user's IP address" __version__ = '2.1.0' django-ipware-2.1.0/ipware/apps.py000066400000000000000000000003731326577276000170670ustar00rootroot00000000000000from django.apps import AppConfig from django.utils.translation import ugettext_lazy as _ class IPwareConfig(AppConfig): """ Configuration entry point for the ipware app """ label = name = 'ipware' verbose_name = _("ipware app") django-ipware-2.1.0/ipware/defaults.py000066400000000000000000000070651326577276000177400ustar00rootroot00000000000000from django.conf import settings # Search for the real IP address in the following order # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For # X-Forwarded-For: , , # Configurable via settings.py IPWARE_META_PRECEDENCE_ORDER = getattr(settings, 'IPWARE_META_PRECEDENCE_ORDER', ( 'HTTP_X_FORWARDED_FOR', 'X_FORWARDED_FOR', 'HTTP_CLIENT_IP', 'HTTP_X_REAL_IP', 'HTTP_X_FORWARDED', 'HTTP_X_CLUSTER_CLIENT_IP', 'HTTP_FORWARDED_FOR', 'HTTP_FORWARDED', 'HTTP_VIA', 'REMOTE_ADDR', ) ) # Private IP addresses # http://en.wikipedia.org/wiki/List_of_assigned_/8_IPv4_address_blocks # https://en.wikipedia.org/wiki/Reserved_IP_addresses # https://www.ietf.org/rfc/rfc1112.txt (IPv4 multicast) # http://www.ietf.org/rfc/rfc3330.txt (IPv4) # http://www.ietf.org/rfc/rfc5156.txt (IPv6) # https://www.ietf.org/rfc/rfc6890.txt # Regex would be ideal here, but this is keeping it simple # Configurable via settings.py IPWARE_PRIVATE_IP_PREFIX = getattr(settings, 'IPWARE_PRIVATE_IP_PREFIX', ( '0.', # messages to software '10.', # class A private block '100.64.', '100.65.', '100.66.', '100.67.', '100.68.', '100.69.', '100.70.', '100.71.', '100.72.', '100.73.', '100.74.', '100.75.', '100.76.', '100.77.', '100.78.', '100.79.', '100.80.', '100.81.', '100.82.', '100.83.', '100.84.', '100.85.', '100.86.', '100.87.', '100.88.', '100.89.', '100.90.', '100.91.', '100.92.', '100.93.', '100.94.', '100.95.', '100.96.', '100.97.', '100.98.', '100.99.', '100.100.', '100.101.', '100.102.', '100.103.', '100.104.', '100.105.', '100.106.', '100.107.', '100.108.', '100.109.', '100.110.', '100.111.', '100.112.', '100.113.', '100.114.', '100.115.', '100.116.', '100.117.', '100.118.', '100.119.', '100.120.', '100.121.', '100.122.', '100.123.', '100.124.', '100.125.', '100.126.', '100.127.', # carrier-grade NAT '169.254.', # link-local block '172.16.', '172.17.', '172.18.', '172.19.', '172.20.', '172.21.', '172.22.', '172.23.', '172.24.', '172.25.', '172.26.', '172.27.', '172.28.', '172.29.', '172.30.', '172.31.', # class B private blocks '192.0.0.', # reserved for IANA special purpose address registry '192.0.2.', # reserved for documentation and example code '192.168.', # class C private block '198.18.', '198.19.', # reserved for inter-network communications between two separate subnets '198.51.100.', # reserved for documentation and example code '203.0.113.', # reserved for documentation and example code '224.', '225.', '226.', '227.', '228.', '229.', '230.', '231.', '232.', '233.', '234.', '235.', '236.', '237.', '238.', '239.', # multicast '240.', '241.', '242.', '243.', '244.', '245.', '246.', '247.', '248.', '249.', '250.', '251.', '252.', '253.', '254.', '255.', # reserved ) + ( '::', # Unspecified address '::ffff:', '2001:10:', '2001:20:' # messages to software '2001::', # TEREDO '2001:2::', # benchmarking '2001:db8:', # reserved for documentation and example code 'fc00:', # IPv6 private block 'fe80:', # link-local unicast 'ff00:', # IPv6 multicast ) ) IPWARE_LOOPBACK_PREFIX = ( '127.', # IPv4 loopback device (Host) '::1', # IPv6 loopback device (Host) ) IPWARE_NON_PUBLIC_IP_PREFIX = IPWARE_PRIVATE_IP_PREFIX + IPWARE_LOOPBACK_PREFIX django-ipware-2.1.0/ipware/ip.py000066400000000000000000000046061326577276000165370ustar00rootroot00000000000000from django.conf import settings from .utils import is_valid_ip from . import defaults as defs NON_PUBLIC_IP_PREFIX = tuple([ip.lower() for ip in defs.IPWARE_NON_PUBLIC_IP_PREFIX]) TRUSTED_PROXY_LIST = tuple([ip.lower() for ip in getattr(settings, 'IPWARE_TRUSTED_PROXY_LIST', [])]) def get_ip(request, real_ip_only=False, right_most_proxy=False): """ Returns client's best-matched ip-address, or None @deprecated - Do not edit """ best_matched_ip = None for key in defs.IPWARE_META_PRECEDENCE_ORDER: value = request.META.get(key, request.META.get(key.replace('_', '-'), '')).strip() if value is not None and value != '': ips = [ip.strip().lower() for ip in value.split(',')] if right_most_proxy and len(ips) > 1: ips = reversed(ips) for ip_str in ips: if ip_str and is_valid_ip(ip_str): if not ip_str.startswith(NON_PUBLIC_IP_PREFIX): return ip_str if not real_ip_only: loopback = defs.IPWARE_LOOPBACK_PREFIX if best_matched_ip is None: best_matched_ip = ip_str elif best_matched_ip.startswith(loopback) and not ip_str.startswith(loopback): best_matched_ip = ip_str return best_matched_ip def get_real_ip(request, right_most_proxy=False): """ Returns client's best-matched `real` `externally-routable` ip-address, or None @deprecated - Do not edit """ return get_ip(request, real_ip_only=True, right_most_proxy=right_most_proxy) def get_trusted_ip(request, right_most_proxy=False, trusted_proxies=TRUSTED_PROXY_LIST): """ Returns client's ip-address from `trusted` proxy server(s) or None @deprecated - Do not edit """ if trusted_proxies: meta_keys = ['HTTP_X_FORWARDED_FOR', 'X_FORWARDED_FOR'] for key in meta_keys: value = request.META.get(key, request.META.get(key.replace('_', '-'), '')).strip() if value: ips = [ip.strip().lower() for ip in value.split(',')] if len(ips) > 1: if right_most_proxy: ips.reverse() for proxy in trusted_proxies: if proxy in ips[-1]: return ips[0] return None django-ipware-2.1.0/ipware/ip2.py000066400000000000000000000036461326577276000166240ustar00rootroot00000000000000from . import utils as util from . import defaults as defs def get_client_ip( request, proxy_order='left-most', proxy_count=None, proxy_trusted_ips=None, request_header_order=None, ): client_ip = None routable = False if proxy_count is None: proxy_count = -1 if proxy_trusted_ips is None: proxy_trusted_ips = [] if request_header_order is None: request_header_order = defs.IPWARE_META_PRECEDENCE_ORDER for key in request_header_order: value = util.get_request_meta(request, key) if value: ips, ip_count = util.get_ips_from_string(value) if ip_count < 1: # we are expecting at least one IP address to process continue if proxy_count == 0 and ip_count > 1: # we are not expecting requests via any proxies continue if proxy_count > 0 and proxy_count != ip_count - 1: # we are expecting requests via `proxy_count` number of proxies continue if proxy_trusted_ips and ip_count < 2: # we are expecting requests via at least one trusted proxy continue if proxy_order == 'right-most' and ip_count > 1: # we are expecting requests via proxies to be custom as per `, , ` ips.reverse() if proxy_trusted_ips: for proxy in proxy_trusted_ips: if proxy in ips[-1]: client_ip, routable = util.get_ip_info(ips[0]) if client_ip and routable: return client_ip, routable else: client_ip, routable = util.get_ip_info(util.get_best_ip(client_ip, ips[0])) if client_ip and routable: return client_ip, routable return client_ip, routable django-ipware-2.1.0/ipware/tests/000077500000000000000000000000001326577276000167115ustar00rootroot00000000000000django-ipware-2.1.0/ipware/tests/__init__.py000066400000000000000000000000001326577276000210100ustar00rootroot00000000000000django-ipware-2.1.0/ipware/tests/tests_common.py000066400000000000000000000046541326577276000220060ustar00rootroot00000000000000# -*- coding: utf-8 -*- from django.conf import settings from django.http import HttpRequest from django.test import TestCase from .. import utils as util class IPv4TestCase(TestCase): """IP address Test""" def test_is_valid_ip(self): ip = '177.139.233.139' self.assertTrue(util.is_valid_ip(ip)) ip = '3ffe:1900:4545:3:200:f8ff:fe21:67cf' self.assertTrue(util.is_valid_ip(ip)) def test_is_invalid_ip(self): ip = '177.139.233.139x' self.assertFalse(util.is_valid_ip(ip)) ip = '3ffe:1900:4545:3:200:f8ff:fe21:67cz' self.assertFalse(util.is_valid_ip(ip)) def test_is_private_ip(self): ip = '127.0.0.1' self.assertTrue(util.is_private_ip(ip)) ip = '::1/128' self.assertTrue(util.is_private_ip(ip)) def test_is_public_ip(self): ip = '177.139.233.139' self.assertTrue(util.is_public_ip(ip)) ip = '74dc::02ba' self.assertTrue(util.is_public_ip(ip)) def test_is_loopback_ip(self): ip = '127.0.0.1' self.assertTrue(util.is_loopback_ip(ip)) ip = '177.139.233.139' self.assertFalse(util.is_loopback_ip(ip)) ip = '10.0.0.1' self.assertFalse(util.is_loopback_ip(ip)) ip = '::1/128' self.assertTrue(util.is_loopback_ip(ip)) ip = '74dc::02ba' self.assertFalse(util.is_loopback_ip(ip)) ip = '2001:db8:' self.assertFalse(util.is_loopback_ip(ip)) def test_http_request_meta_headers(self): request = HttpRequest() ip_str = '192.168.255.182, 10.0.0.0, 127.0.0.1, 198.84.193.157, 177.139.233.139,' request.META = { 'HTTP_X_FORWARDED_FOR': ip_str } value = util.get_request_meta(request, 'HTTP_X_FORWARDED_FOR') self.assertEqual(value, ip_str) def test_ips_from_strings(self): request = HttpRequest() ip_str = '192.168.255.182, 198.84.193.157, 177.139.233.139 ,' result = util.get_ips_from_string(ip_str) self.assertEqual(result, (['192.168.255.182', '198.84.193.157', '177.139.233.139'], 3)) def test_get_ip_info(self): ip = '127.0.0.1' result = util.get_ip_info(ip) self.assertTrue(result, (ip, False)) ip = '10.0.01' result = util.get_ip_info(ip) self.assertTrue(result, (ip, False)) ip = '74dc::02ba' result = util.get_ip_info(ip) self.assertTrue(result, (ip, True)) django-ipware-2.1.0/ipware/tests/tests_ipv4.py000066400000000000000000000223421326577276000213720ustar00rootroot00000000000000# -*- coding: utf-8 -*- from django.conf import settings from django.http import HttpRequest from django.test import TestCase from ipware import get_client_ip class IPv4TestCase(TestCase): """IP address Test""" def test_meta_none(self): request = HttpRequest() request.META = {} ip, routable = get_client_ip(request) self.assertIsNone(ip) self.assertFalse(routable) def test_meta_single(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True)) def test_meta_multi(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True)) def test_meta_multi_precedence_order(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True)) def test_meta_proxy_order_left_most(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_order='left-most') self.assertEqual(result, ("177.139.233.139", True)) def test_meta_proxy_order_right_most(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_order='right-most') self.assertEqual(result, ("198.84.193.158", True)) def test_meta_multi_precedence_private_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '10.0.0.0, 10.0.0.1, 10.0.0.2', 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.138", True)) def test_meta_multi_precedence_invalid_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 10.0.0.1, 10.0.0.2', 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.138", True)) def test_meta_error_only(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request) self.assertEqual(result, (None, False)) def test_meta_error_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 177.139.233.139, 198.84.193.157, 198.84.193.158', 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.138", True)) def test_meta_singleton(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True)) def test_meta_singleton_proxy_count(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139', } result = get_client_ip(request, proxy_count=1) self.assertEqual(result, (None, False)) def test_meta_singleton_proxy_count_private(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '10.0.0.0', 'HTTP_X_REAL_IP': '177.139.233.139', } result = get_client_ip(request, proxy_count=1) self.assertEqual(result, (None, False)) def test_meta_singleton_private_fallback(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '10.0.0.0', 'HTTP_X_REAL_IP': '177.139.233.139', } result = get_client_ip(request) self.assertEqual(result, ("177.139.233.139", True)) def test_meta_proxy_trusted_ips(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_trusted_ips=['198.84.193.158']) self.assertEqual(result, ("177.139.233.139", True)) def test_meta_proxy_trusted_ips_proxy_count(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_count=2, proxy_trusted_ips=['198.84.193.158']) self.assertEqual(result, ("177.139.233.139", True)) def test_meta_proxy_trusted_ips_proxy_count_less_error(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.158', } result = get_client_ip(request, proxy_count=2, proxy_trusted_ips=['198.84.193.158']) self.assertEqual(result, (None, False)) def test_meta_proxy_trusted_ips_proxy_count_more_error(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } result = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['198.84.193.158']) self.assertEqual(result, (None, False)) def test_meta_proxy_trusted_ips_proxy_count_more_error_fallback(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', 'HTTP_X_REAL_IP': '177.139.233.139', } result = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['198.84.193.158']) self.assertEqual(result, (None, False)) def test_best_matched_ip(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '192.168.1.1', 'REMOTE_ADDR': '177.31.233.133', } ip = get_client_ip(request) self.assertEqual(ip, ("177.31.233.133", True)) def test_best_matched_ip_public(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '177.31.233.122', 'REMOTE_ADDR': '177.31.233.133', } ip = get_client_ip(request) self.assertEqual(ip, ("177.31.233.122", True)) def test_best_matched_ip_private(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '192.168.1.1', 'REMOTE_ADDR': '127.0.0.1', } ip = get_client_ip(request) self.assertEqual(ip, ("192.168.1.1", False)) def test_best_matched_ip_private_precedence(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '127.0.0.1', 'REMOTE_ADDR': '192.168.1.1', } ip = get_client_ip(request) self.assertEqual(ip, ("192.168.1.1", False)) def test_100_low_range_public(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '100.63.0.9', } ip = get_client_ip(request) self.assertEqual(ip, ("100.63.0.9", True)) def test_100_block_private(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '100.76.0.9', } ip = get_client_ip(request) self.assertEqual(ip, ("100.76.0.9", False)) def test_100_high_range_public(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '100.128.0.9', } ip = get_client_ip(request) self.assertEqual(ip, ("100.128.0.9", True)) def test_request_header_order_specific(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '192.168.1.1', 'REMOTE_ADDR': '177.139.233.139', 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', } ip = get_client_ip(request, request_header_order=['HTTP_X_FORWARDED_FOR']) self.assertEqual(ip, ("177.139.233.139", True)) def test_request_header_order_multiple(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 198.84.193.157, 198.84.193.158', 'X_FORWARDED_FOR': '177.139.233.138, 198.84.193.157, 198.84.193.158', 'REMOTE_ADDR': '177.139.233.133', } ip = get_client_ip(request, request_header_order=['X_FORWARDED_FOR', 'HTTP_X_FORWARDED_FOR']) self.assertEqual(ip, ("177.139.233.138", True)) django-ipware-2.1.0/ipware/tests/tests_ipv6.py000066400000000000000000000156071326577276000214020ustar00rootroot00000000000000# -*- coding: utf-8 -*- from django.conf import settings from django.http import HttpRequest from django.test import TestCase from ipware import get_client_ip class IPv4TestCase(TestCase): """IP address Test""" def test_meta_none(self): request = HttpRequest() request.META = {} ip, routable = get_client_ip(request) self.assertIsNone(ip) self.assertFalse(routable) def test_meta_single(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_multi(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'REMOTE_ADDR': '74dc::02bc', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_multi_precedence_order(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '74dc::02be, 74dc::02bf', 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'REMOTE_ADDR': '74dc::02bc', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_proxy_order_left_most(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request, proxy_order='left-most') self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_proxy_order_right_most(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request, proxy_order='right-most') self.assertEqual(result, ("74dc::02bb", True)) def test_meta_multi_precedence_private_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '2001:db8:, ::1', 'X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'REMOTE_ADDR': '74dc::02bc', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_multi_precedence_invalid_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 2001:db8:, ::1', 'X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'REMOTE_ADDR': '74dc::02bc', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_error_only(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown, 3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request) self.assertEqual(result, (None, False)) def test_meta_error_first(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_singleton(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_singleton_proxy_count(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', 'HTTP_X_REAL_IP': '74dc::02ba', } result = get_client_ip(request, proxy_count=1) self.assertEqual(result, (None, False)) def test_meta_singleton_proxy_count_private(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '::1', 'HTTP_X_REAL_IP': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } result = get_client_ip(request, proxy_count=1) self.assertEqual(result, (None, False)) def test_meta_singleton_private_fallback(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '::1', 'HTTP_X_REAL_IP': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } result = get_client_ip(request) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_proxy_trusted_ips(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request, proxy_trusted_ips=['74dc::02bb']) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_proxy_trusted_ips_proxy_count(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request, proxy_count=2, proxy_trusted_ips=['74dc::02bb']) self.assertEqual(result, ("3ffe:1900:4545:3:200:f8ff:fe21:67cf", True)) def test_meta_proxy_trusted_ips_proxy_count_less_error(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02bb', } result = get_client_ip(request, proxy_count=2, proxy_trusted_ips=['74dc::02bb']) self.assertEqual(result, (None, False)) def test_meta_proxy_trusted_ips_proxy_count_more_error(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', } result = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['74dc::02bb']) self.assertEqual(result, (None, False)) def test_meta_proxy_trusted_ips_proxy_count_more_error_ignore_fallback(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba, 74dc::02bb', 'HTTP_X_REAL_IP': '74dc::02bb', } result = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['74dc::02bb']) self.assertEqual(result, (None, False)) django-ipware-2.1.0/ipware/tests/tests_v1/000077500000000000000000000000001326577276000204615ustar00rootroot00000000000000django-ipware-2.1.0/ipware/tests/tests_v1/__init__.py000066400000000000000000000000171326577276000225700ustar00rootroot00000000000000# Legacy Tests django-ipware-2.1.0/ipware/tests/tests_v1/tests_ipv4.py000066400000000000000000000343201326577276000231410ustar00rootroot00000000000000# -*- coding: utf-8 -*- from django.conf import settings from django.http import HttpRequest from django.test import TestCase from ipware.ip import get_ip from ipware.ip import get_real_ip from ipware.ip import get_trusted_ip class IPv4TestCase(TestCase): """IP address Test""" def test_meta_none(self): request = HttpRequest() request.META = { } ip = get_real_ip(request) self.assertIsNone(ip) def test_http_x_forwarded_for_multiple(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '192.168.255.182, 10.0.0.0, 127.0.0.1, 198.84.193.157, 177.139.233.139', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_multiple_left_most_ip(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '192.168.255.182, 198.84.193.157, 10.0.0.0, 127.0.0.1, 177.139.233.139', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_multiple_right_most_ip(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '192.168.255.182, 198.84.193.157, 10.0.0.0, 127.0.0.1, 177.139.233.139', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request, right_most_proxy=True) self.assertEqual(ip, "177.139.233.139") def test_http_x_forwarded_for_multiple_right_most_ip_private(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '192.168.255.182, 198.84.193.157, 10.0.0.0, 127.0.0.1, 177.139.233.139', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request, right_most_proxy=True) self.assertEqual(ip, "177.139.233.139") def test_http_x_forwarded_for_multiple_bad_address(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, 192.168.255.182, 10.0.0.0, 127.0.0.1, 198.84.193.157, 177.139.233.139', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_singleton(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.139") def test_http_x_forwarded_for_singleton_private_address(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '192.168.255.182', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.132") def test_bad_http_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown 177.139.233.139', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.132") def test_empty_http_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '177.139.233.132', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.132") def test_empty_http_x_forwarded_for_empty_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_empty_http_x_forwarded_for_private_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '192.168.255.182', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_private_http_x_forward_for_ip_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '127.0.0.1', 'HTTP_X_REAL_IP': '', 'REMOTE_ADDR': '', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_private_remote_addr_for_ip_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'REMOTE_ADDR': '127.0.0.1', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_missing_x_forwarded(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_missing_x_forwarded_missing_real_ip(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_best_matched_real_ip(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '127.0.0.1', 'REMOTE_ADDR': '177.31.233.133', } ip = get_ip(request) self.assertEqual(ip, "177.31.233.133") def test_best_matched_private_ip(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '127.0.0.1', 'REMOTE_ADDR': '192.31.233.133', } ip = get_ip(request) self.assertEqual(ip, "192.31.233.133") def test_best_matched_private_ip_2(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '192.31.233.133', 'REMOTE_ADDR': '127.0.0.1', } ip = get_ip(request) self.assertEqual(ip, "192.31.233.133") def test_x_forwarded_for_multiple(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '192.168.255.182, 10.0.0.0, 127.0.0.1, 198.84.193.157, 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "198.84.193.157") def test_x_forwarded_for_multiple_left_most_ip(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '192.168.255.182, 198.84.193.157, 10.0.0.0, 127.0.0.1, 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "198.84.193.157") def test_x_forwarded_for_multiple_right_most_ip(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '192.168.255.182, 198.84.193.157, 10.0.0.0, 127.0.0.1, 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request, right_most_proxy=True) self.assertEqual(ip, "177.139.233.139") def test_x_forwarded_for_multiple_right_most_ip_private(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '192.168.255.182, 198.84.193.157, 10.0.0.0, 127.0.0.1, 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request, right_most_proxy=True) self.assertEqual(ip, "177.139.233.139") def test_x_forwarded_for_multiple_bad_address(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown, 192.168.255.182, 10.0.0.0, 127.0.0.1, 198.84.193.157, 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "198.84.193.157") def test_x_forwarded_for_singleton(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.139") def test_x_forwarded_for_singleton_private_address(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '192.168.255.182', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_bad_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown 177.139.233.139', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_empty_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_empty_x_forwarded_for_empty_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_empty_x_forwarded_for_private_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '', 'REMOTE_ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.133") def test_private_x_forward_for_ip_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '127.0.0.1', 'REMOTE_ADDR': '', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_x_forwarded_for_singleton_hyphen_as_delimiter(self): request = HttpRequest() request.META = { 'X-FORWARDED-FOR': '177.139.233.139', 'REMOTE-ADDR': '177.139.233.133', } ip = get_real_ip(request) self.assertEqual(ip, "177.139.233.139") class IPv4TrustedProxiesTestCase(TestCase): """Trusted Proxies - IP address Test""" def test_meta_none(self): request = HttpRequest() request.META = { } ip = get_trusted_ip(request) self.assertIsNone(ip) def test_http_x_forwarded_for_conf_settings(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.100', } ip = get_trusted_ip(request) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_no_proxy(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=[]) self.assertIsNone(ip) def test_http_x_forwarded_for_single_proxy(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=['177.139.233.139']) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_single_proxy_with_right_most(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '177.139.233.139, 177.139.200.139, 198.84.193.157', } ip = get_trusted_ip(request, right_most_proxy=True, trusted_proxies=['177.139.233.139']) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_multi_proxy(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=['177.139.233.138', '177.139.233.139']) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_all_proxies_in_subnet(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=['177.139.233']) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_all_proxies_in_subnet_2(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=['177.139']) self.assertEqual(ip, "198.84.193.157") def test_x_forwarded_for_single_proxy(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=['177.139.233.139']) self.assertEqual(ip, "198.84.193.157") def test_x_forwarded_for_single_proxy_hyphens(self): request = HttpRequest() request.META = { 'X-FORWARDED-FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=['177.139.233.139']) self.assertEqual(ip, "198.84.193.157") def test_http_x_forwarded_for_and_x_forward_for_single_proxy(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '198.84.193.156, 177.139.200.139, 177.139.233.139', 'X_FORWARDED_FOR': '198.84.193.157, 177.139.200.139, 177.139.233.139', } ip = get_trusted_ip(request, trusted_proxies=['177.139.233.139']) self.assertEqual(ip, "198.84.193.156") django-ipware-2.1.0/ipware/tests/tests_v1/tests_ipv6.py000066400000000000000000000222671326577276000231520ustar00rootroot00000000000000# -*- coding: utf-8 -*- from django.conf import settings from django.http import HttpRequest from django.test import TestCase from django.test import override_settings from ipware.ip import get_ip from ipware.ip import get_real_ip from ipware.ip import get_trusted_ip class IPv6TestCase(TestCase): """IP address Test""" def test_http_x_forwarded_for_multiple(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba', 'HTTP_X_REAL_IP': '74dc::02ba', 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "3ffe:1900:4545:3:200:f8ff:fe21:67cf") def test_http_x_forwarded_for_multiple_bad_address(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown, ::1/128, 74dc::02ba', 'HTTP_X_REAL_IP': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_http_x_forwarded_for_singleton(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '74dc::02ba', 'HTTP_X_REAL_IP': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_http_x_forwarded_for_singleton_private_address(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '::1/128', 'HTTP_X_REAL_IP': '74dc::02ba', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_bad_http_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': 'unknown ::1/128', 'HTTP_X_REAL_IP': '74dc::02ba', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_empty_http_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '74dc::02ba', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_empty_http_x_forwarded_for_empty_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '', 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_empty_http_x_forwarded_for_private_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '::1/128', 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_private_http_x_forward_for_ip_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '::1/128', 'HTTP_X_REAL_IP': '', 'REMOTE_ADDR': '', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_private_real_ip_for_ip_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '::1/128', 'REMOTE_ADDR': '', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_private_remote_addr_for_ip_addr(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '', 'HTTP_X_REAL_IP': '', 'REMOTE_ADDR': '::1/128', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_missing_x_forwarded(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '74dc::02ba', 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_missing_x_forwarded_missing_real_ip(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_missing_x_forwarded_missing_real_ip_mix_case(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': '74DC::02BA', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_private_remote_address(self): request = HttpRequest() request.META = { 'REMOTE_ADDR': 'fe80::02ba', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_best_matched_real_ip(self): request = HttpRequest() request.META = { 'HTTP_X_REAL_IP': '::1', 'REMOTE_ADDR': 'fe80::02ba', } ip = get_ip(request) self.assertEqual(ip, "fe80::02ba") def test_x_forwarded_for_multiple(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba', 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "3ffe:1900:4545:3:200:f8ff:fe21:67cf") def test_x_forwarded_for_multiple_bad_address(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown, ::1/128, 74dc::02ba', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_x_forwarded_for_singleton(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '74dc::02ba', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_x_forwarded_for_singleton_private_address(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '::1/128', 'HTTP_X_REAL_IP': '74dc::02ba', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_bad_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': 'unknown ::1/128', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "3ffe:1900:4545:3:200:f8ff:fe21:67cf") def test_empty_x_forwarded_for_fallback_on_x_real_ip(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '', 'REMOTE_ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "3ffe:1900:4545:3:200:f8ff:fe21:67cf") def test_empty_x_forwarded_for_empty_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '', 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_empty_x_forwarded_for_private_x_real_ip_fallback_on_remote_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '', 'REMOTE_ADDR': '74dc::02ba', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") def test_private_x_forward_for_ip_addr(self): request = HttpRequest() request.META = { 'X_FORWARDED_FOR': '::1/128', 'REMOTE_ADDR': '', } ip = get_real_ip(request) self.assertEqual(ip, None) def test_x_forwarded_for_singleton_hyphen_as_delimiter(self): request = HttpRequest() request.META = { 'X-FORWARDED-FOR': '74dc::02ba', 'REMOTE-ADDR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf', } ip = get_real_ip(request) self.assertEqual(ip, "74dc::02ba") class IPv6TrustedProxiesTestCase(TestCase): """Trusted Proxies - IP address Test""" def test_http_x_forwarded_for_no_proxy(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba', } ip = get_trusted_ip(request, trusted_proxies=[]) self.assertIsNone(ip) def test_http_x_forwarded_for_single_proxy(self): request = HttpRequest() request.META = { 'HTTP_X_FORWARDED_FOR': '3ffe:1900:4545:3:200:f8ff:fe21:67cf, 74dc::02ba', } ip = get_trusted_ip(request, trusted_proxies=['74dc::02ba']) self.assertEqual(ip, "3ffe:1900:4545:3:200:f8ff:fe21:67cf") django-ipware-2.1.0/ipware/tests/testsettings.py000066400000000000000000000004021326577276000220170ustar00rootroot00000000000000DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': ':memory:', }, } SECRET_KEY = "un33k" INSTALLED_APPS = ['ipware'] MIDDLEWARE_CLASSES = [] # Version 1 support IPWARE_TRUSTED_PROXY_LIST = ['177.139.233.100'] django-ipware-2.1.0/ipware/utils.py000066400000000000000000000053221326577276000172630ustar00rootroot00000000000000import socket from . import defaults as defs def is_valid_ipv4(ip_str): """ Check the validity of an IPv4 address """ try: socket.inet_pton(socket.AF_INET, ip_str) except AttributeError: # pragma: no cover try: # Fall-back on legacy API or False socket.inet_aton(ip_str) except (AttributeError, socket.error): return False return ip_str.count('.') == 3 except socket.error: return False return True def is_valid_ipv6(ip_str): """ Check the validity of an IPv6 address """ try: socket.inet_pton(socket.AF_INET6, ip_str) except socket.error: return False return True def is_valid_ip(ip_str): """ Check the validity of an IP address """ return is_valid_ipv4(ip_str) or is_valid_ipv6(ip_str) def is_private_ip(ip_str): """ Returns true of ip_str is private & not routable, else return false """ return ip_str.startswith(defs.IPWARE_NON_PUBLIC_IP_PREFIX) def is_public_ip(ip_str): """ Returns true of ip_str is public & routable, else return false """ return not is_private_ip(ip_str) def is_loopback_ip(ip_str): """ Returns true of ip_str is public & routable, else return false """ return ip_str.startswith(defs.IPWARE_LOOPBACK_PREFIX) def get_request_meta(request, key): """ Given a key, it returns a cleaned up version of the value from request.META, or None """ value = request.META.get(key, request.META.get(key.replace('_', '-'), '')).strip() if value == '': return None return value def get_ips_from_string(ip_str): """ Given a string, it returns a list of one or more valid IP addresses """ ip_list = [] for ip in ip_str.split(','): clean_ip = ip.strip().lower() if clean_ip: ip_list.append(clean_ip) ip_count = len(ip_list) if ip_count > 0: if is_valid_ip(ip_list[0]) and is_valid_ip(ip_list[-1]): return ip_list, ip_count return [], 0 def get_ip_info(ip_str): """ Given a string, it returns a tuple of (IP, Routable). """ ip = None is_routable_ip = False if is_valid_ip(ip_str): ip = ip_str is_routable_ip = is_public_ip(ip) return ip, is_routable_ip def get_best_ip(last_ip, next_ip): """ Given two IP addresses, it returns the the best match ip. Order of precedence is (Public, Private, Loopback, None) Right-most IP is returned """ if last_ip is None: return next_ip if is_public_ip(last_ip) and not is_public_ip(next_ip): return last_ip if is_private_ip(last_ip) and is_loopback_ip(next_ip): return last_ip return next_ip django-ipware-2.1.0/manage.py000077500000000000000000000004031326577276000160620ustar00rootroot00000000000000#!/usr/bin/env python import os import sys if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ipware.tests.testsettings") from django.core.management import execute_from_command_line execute_from_command_line(sys.argv) django-ipware-2.1.0/pycodestyle.sh000077500000000000000000000004531326577276000171650ustar00rootroot00000000000000#!/bin/bash # Ignoring autogenerated files # -- Migration directories # Ignoring error codes # -- E128 continuation line under-indented for visual indent # -- E225 missing whitespace around operator # -- E501 line too long pycodestyle --exclude=migrations,tests --ignore=E128,E225,E241,E501 . django-ipware-2.1.0/setup.py000077500000000000000000000047151326577276000160040ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- from setuptools import setup import re import os import sys name = 'django-ipware' package = 'ipware' description = "A Django utility application that returns client's real IP address" url = 'https://github.com/un33k/django-ipware' author = 'Val Neekman' author_email = 'info@neekware.com' license = 'MIT' install_requires = [''] classifiers = [ 'Development Status :: 5 - Production/Stable', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Topic :: Utilities' ] def get_version(package): """ Return package version as listed in `__version__` in `init.py`. """ init_py = open(os.path.join(package, '__init__.py')).read() return re.search("^__version__ = ['\"]([^'\"]+)['\"]", init_py, re.MULTILINE).group(1) def get_packages(package): """ Return root package and all sub-packages. """ return [dirpath for dirpath, dirnames, filenames in os.walk(package) if os.path.exists(os.path.join(dirpath, '__init__.py'))] def get_package_data(package): """ Return all files under the root package, that are not in a package themselves. """ walk = [(dirpath.replace(package + os.sep, '', 1), filenames) for dirpath, dirnames, filenames in os.walk(package) if not os.path.exists(os.path.join(dirpath, '__init__.py'))] filepaths = [] for base, filenames in walk: filepaths.extend([os.path.join(base, filename) for filename in filenames]) return {package: filepaths} if sys.argv[-1] == 'publish': os.system("python setup.py sdist upload") args = {'version': get_version(package)} print("You probably want to also tag the version now:") print(" git tag -a %(version)s -m 'version %(version)s' && git push --tags" % args) sys.exit() setup( name=name, version=get_version(package), url=url, license=license, description=description, author=author, author_email=author_email, packages=get_packages(package), package_data=get_package_data(package), install_requires=install_requires, classifiers=classifiers )