Vanliga frågor

Vi erbjuder två olika databasformat (CSV och BIN).

Det första databasformatet är känt som kommaseparerade värden (CSV). Det är en textfil och alla fält är separerade med ett komma med dubbelt citat i varje fält. Varje enskild rad är en databaspost.

Det andra databasformatet är känt som Binary (Binary). Det är en binär fil med databasinformation. Utvecklare har åtkomst till BIN-filerna med IP2Location API tillgängliga på flera språk.

Du kan automatisera IP2Location LITE-databasen med nedladdningsklient eller vanliga HTTP-applikationer som wget eller curl. Vi uppdaterar IP2Location-databaser den första dagen i kalendermånaden. Ladda ner databasen en gång i månaden under en slumpmässig dag från den första veckan i kalendermånaden för att undvika trängsel i nätverket. Vi inaktiverar alla LITE-konton om kontodelning eller massiv nedladdning upptäcks.

./download.pl -package DB11LITE -token DOWNLOAD_TOKEN

Package Code Description
DB11LITE IP2Location LITE DB11 - IPV4 - CSV
DB11LITEBIN IP2Location LITE DB11 - IPV4 - BIN
DB11LITEIPV6 IP2Location LITE DB11 - IPV6 - CSV
DB11LITEBINIPV6 IP2Location LITE DB11 - IPV6 - BIN

IP-adress (IPV4) är uppdelad i fyra delblock. Varje delblock har olika viktnummer som var och en drivs av 256. IP-nummer används i databasen eftersom det är effektivare att söka mellan ett antal nummer i en databas.

Början-IP-numret och slut-IP-numret beräknas utifrån följande formel:

IP Number = 16777216*w + 65536*x + 256*y + z     (1)

where

IP Address = w.x.y.z


For example, if the IP address is "202.186.13.4", then its IP Number will be "3401190660", based on the formula (1).

IP Address = 202.186.13.4

So, w = 202, x = 186, y = 13 and z = 4

IP Number	= 16777216*202 + 65536*186 + 256*13 + 4
			= 3388997632 + 12189696 + 3328 + 4
			= 3401190660

Exempelkod på olika programmeringsspråk

Function Dot2LongIP (ByVal DottedIP)
	Dim i, pos
	Dim PrevPos, num

	If DottedIP = "" Then
		Dot2LongIP = 0
	Else
		For i = 1 To 4
			pos = InStr(PrevPos + 1, DottedIP, ".", 1)

			If i = 4 Then
				pos = Len(DottedIP) + 1
			End If

			num = Int(Mid(DottedIP, PrevPos + 1, pos - PrevPos - 1))
			PrevPos = pos
			Dot2LongIP = ((num Mod 256) * (256 ^ (4 - i))) + Dot2LongIP
		Next
	End If
End Function
function Dot2LongIP($IPaddr)
{
	if ($IPaddr == "") {
		return 0;
	} else {
		$ips = explode(".", "$IPaddr");
		return ($ips[3] + $ips[2] * 256 + $ips[1] * 256 * 256 + $ips[0] * 256 * 256 * 256);
	}
}
long Dot2LongIP(String ipstring) {
	String[] ipAddressInArray = ipstring.split("\\.");
	long result = 0;
	long ip = 0;

	for (int x = 3; x >= 0; x--) {
		ip = Long.parseLong(ipAddressInArray[3 - x]);
		result |= ip << (x << 3);
	}
	return result;
}
function Dot2LongIP(ipAddress)
{
	if (arguments.ipAddress EQ "") {
		return 0;
	} else {
		ips = ListToArray( arguments.ipAddress, "." );
		return( ( 16777216 * ips[1] ) + ( 65536 * ips[2] ) + ( 256 * ips[3] ) + ips[4] );
	}
}
public double Dot2LongIP(string DottedIP)
{
	int i;
	string [] arrDec;
	double num = 0;

	if (DottedIP == "") {
		return 0;
	} else {
		arrDec = DottedIP.Split(".");
		for (i = arrDec.Length - 1; i >= 0 ; i --) {
			num += ((int.Parse(arrDec[i])%256) * Math.Pow(256 ,(3 - i )));
		}

		return num;
	}
}
Public Function Dot2LongIP(ByVal DottedIP As String) As Double
	Dim arrDec() As String
	Dim i As Integer
	Dim intResult As Long

	If DottedIP = "" then
		Dot2LongIP = 0
	Else
		arrDec = DottedIP.Split(".")

		For i = arrDec.Length - 1 To 0 Step -1
			intResult = intResult + ((Int(arrDec(i)) Mod 256) * Math.Pow(256, 3 -i))
		Next

		Dot2LongIP = intResult
	End If
End function
use Socket;

sub dot2LongIP {
	my $ip_address = shift(@_);
	return unpack("N",inet_aton($ip_address));
}
require 'ipaddr'

def dot2LongIP(ip)
ipnum = IPAddr.new(ip)
return ipnum.to_i
end
import ipaddress

def dot2LongIP(ip):
return int(ipaddress.IPv4Address(ip))
uint32_t Dot2LongIP(char* ipstring)
{
	uint32_t ip = inet_addr(ipstring);
	uint8_t *ptr = (uint8_t *) &ip;
	uint32_t a = 0;

	if (ipstring != NULL) {
		a =  (uint8_t)(ptr[3]);
		a += (uint8_t)(ptr[2]) * 256;
		a += (uint8_t)(ptr[1]) * 256 * 256;
		a += (uint8_t)(ptr[0]) * 256 * 256 * 256;
	}

	return a;
}
CREATE FUNCTION Dot2LongIP (ip text)
	RETURNS bigint
	BEGIN
	DECLARE ipnum bigint;
	SET ipnum = (SELECT INET_ATON(ip));
	RETURN ipnum;
END
CREATE FUNCTION [dbo].[Dot2LongIP]( @IP VarChar(15) )
RETURNS BigInt
AS
BEGIN
DECLARE @ipA BigInt,
	@ipB BigInt,
	@ipC BigInt,
	@ipD BigInt,
	@ipE BigInt
SELECT @ipA = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipA) - 1 )

SELECT @ipB = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipB) - 1 )

SELECT @ipC = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipC) - 1 )

SELECT @ipD = @ip
SELECT @ipE = ( @ipA * 256*256*256 ) + ( @ipB * 256*256 ) + ( @ipC * 256 ) + @ipD

RETURN @ipE
END
CREATE OR REPLACE FUNCTION Dot2LongIP(text) RETURNS BIGINT AS '
SELECT
	split_part($1,''.'',1)::int8*(256*256*256)+
	split_part($1,''.'',2)::int8*(256*256)+
	split_part($1,''.'',3)::int8*256+
	split_part($1,''.'',4)::int8;'
LANGUAGE SQL;
Convert IPv4 IP Address to IP Number in Decimal Integer (IPv4 IP Address is in cell A1):
=((VALUE(LEFT(A1, FIND(".", A1)-1)))*256^3)+((VALUE(MID(A1, FIND(".", A1)+1, FIND(".", A1, FIND(".", A1)+1)-FIND(".", A1)-1)))*256^2)+((VALUE(MID(A1, FIND(".", A1, FIND(".", A1)+1)+1, FIND(".", A1, FIND(".", A1, FIND(".", A1)+1)+1)-FIND(".", A1, FIND(".", A1)+1)-1)))*256)+(VALUE(RIGHT(A1, LEN(A1)-FIND(".", A1, FIND(".", A1, FIND(".", A1)+1)+1))))

IP Address = w.x.y.z

To reverse IP number to IP address,

w = int ( IP Number / 16777216 ) % 256
x = int ( IP Number / 65536    ) % 256
y = int ( IP Number / 256      ) % 256
z = int ( IP Number            ) % 256


where
%
is the modulus operator and
int
returns the integer part of the division.

Exempelkod på olika programmeringsspråk

Function Modulus(Value1, Value2)
	Modulus = Value1 - (Int(Value1 / Value2) * Value2)
	End Function

	Function Long2DotIP (ByVal IPNum)
	Long2DotIP = Modulus(Int(IPNum / 16777216), 256) & "." & Modulus(Int(IPNum / 65536), 256) & "." & Modulus(Int(IPNum / 256), 256) & "." & Modulus(IPNum, 256)
End Function
function Long2DotIP ($IPNum)
{
	if ($IPNum == "") {
		return "0.0.0.0";
	} else {
		return (($IPNum / 16777216) % 256) . "." . (($IPNum / 65536) % 256) . "." . (($IPNum / 256) % 256) . "." . ($IPNum % 256);
	}
}
String Long2DotIP(long ipnum) {
	String result = "";
	result = ((ipnum / 16777216) % 256) + "." + ((ipnum / 65536) % 256) + "." + ((ipnum / 256) % 256) + "." + (ipnum % 256);
	return result;
}
function Modulus(value1, value2) {
	return arguments.value1 - (floor(arguments.value1 / arguments.value2) * arguments.value2);
}

function Long2DotIP(ipNum) {
	return (Modulus(floor(arguments.ipNum / 16777216), 256)) & "." & (Modulus(floor(arguments.ipNum / 65536), 256)) & "." & (Modulus(floor(arguments.ipNum / 256), 256)) & "." & (Modulus(floor(arguments.ipNum), 256));
}
public string Long2DotIP(long IPNum)
{
	string result = "";
	result = ((IPNum / 16777216) % 256) + "." + ((IPNum / 65536) % 256) + "." + ((IPNum / 256) % 256) + "." + (IPNum % 256);
	return result;
}
Public Function Long2DotIP(ByVal IPNum As Long) As String
	Dim result As String = ""
	result = (Int(IPNum / 16777216) Mod 256) & "." & (Int(IPNum / 65536) Mod 256) & "." & (Int(IPNum / 256) Mod 256) & "." & (IPNum Mod 256)
	Return result
End Function
use Socket;

sub long2DotIP {
	my $ip_number = shift(@_);
	return inet_ntoa(pack("N*", $ip_number));
}
def long2DotIP(ipnum)
	return ((ipnum / 16777216) % 256).to_s + "." + ((ipnum / 65536) % 256).to_s + "." + ((ipnum / 256) % 256).to_s + "." + (ipnum % 256).to_s
end
def long2DotIP(ipnum):
return str(int(ipnum / 16777216) % 256) + "." + str(int(ipnum / 65536) % 256) + "." + str(int(ipnum / 256) % 256) + "." + str(ipnum % 256)
char* Long2DotIP(uint32_t ipnum)
{
	uint8_t bytes[4];
	char* buf = malloc (sizeof (char) * 16);
	bytes[0] = (ipnum >> 24) & 0xFF;
	bytes[1] = (ipnum >> 16) & 0xFF;
	bytes[2] = (ipnum >> 8) & 0xFF;
	bytes[3] = ipnum & 0xFF;

	snprintf(buf, (sizeof (char) * 16), "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);

	return buf;
}
CREATE FUNCTION Long2DotIP (ipnum bigint)
	RETURNS text
	BEGIN
	DECLARE ip text;
	SET ip = (SELECT INET_NTOA(ipnum));
	RETURN ip;
END
CREATE FUNCTION [dbo].[Long2DotIP]( @IPNum BigInt )
	RETURNS VARCHAR(15)
	AS
	BEGIN
	RETURN CAST(((@IPNum / 16777216) % 256) AS VARCHAR(3)) +  + CAST(((@IPNum / 65536) % 256) AS VARCHAR(3)) +  + CAST(((@IPNum / 256) % 256) AS VARCHAR(3)) +  + CAST((@IPNum % 256) AS VARCHAR(3))
END
CREATE OR REPLACE FUNCTION Long2DotIP(BIGINT) RETURNS TEXT AS '
SELECT
CONCAT(($1 >> 24) % 256, ''.'', ($1 >> 16) % 256, ''.'', ($1 >> 8) % 256, ''.'', $1 % 256);'
LANGUAGE SQL;
Convert IP Number in Decimal Integer to IPv4 IP Address (Decimal Integer is in cell A1):
=IF(A1<>"", CONCATENATE(MOD(BITRSHIFT(A1, 24), 256), ".", MOD(BITRSHIFT(A1, 16), 256), ".", MOD(BITRSHIFT(A1, 8), 256), ".", MOD(A1, 256)), "")

IP-adressen (IPv6) är uppdelad i åtta grupper med fyra hexadecimala siffror med ett kolon som en gruppavgränsare. Varje grupp har olika viktnummer som var och en drivs av 65536. IP-nummer används i databasen eftersom det är mer effektivt att söka mellan ett antal nummer i en databas.

Hur konverterar jag ett IP-nummer till en IPv6-adress?

IP Number = (65536^7)*a + (65536^6)*b + (65536^5)*c + (65536^4)*d + (65536^3)*e + (65536^2)*f + 65536*g + h     (1)

where

IP Address = a:b:c:d:e:f:g:h


For example, if the IP address is "2001:0db8:0000:0042:0000:8a2e:0370:7334", then its IP Number will be "42540766411282594074389245746715063092", based on the formula (1).

IP Address (in hexadecimal) = 2001:0db8:0000:0042:0000:8a2e:0370:7334
IP Address (in decimal)     = 8193:3512:0:66:0:35374:880:29492

IP Number = (65536^7)*8193 + (65536^6)*3512 + (65536^5)*0 + (65536^4)*66 + (65536^3)*0 + (65536^2)*35374 + 65536*880 + 29492
          = 5192296858534827628530496329220096*8193 + 79228162514264337593543950336*3512 + 1208925819614629174706176*0 + 18446744073709551616*66 + 281474976710656*0 + 4294967296*35374 + 57671680 + 29492
          = 42540488161975842760550356425300246528 + 278249306750096353628526353580032 + 0 + 1217485108864830406656 + 0 + 151930173128704 + 57671680 + 29492
          = 42540766411282594074389245746715063092

Exempelkod på olika programmeringsspråk

function Dot2LongIP($ipv6) {
	return (string) gmp_import(inet_pton($ipv6));
}
java.math.BigInteger Dot2LongIP(String ipv6) {
	java.net.InetAddress ia = java.net.InetAddress.getByName(ipv6);
	byte byteArr[] = ia.getAddress();

	if (ia instanceof java.net.Inet6Address) {
		java.math.BigInteger ipnumber = new java.math.BigInteger(1, byteArr);
		return ipnumber;
	}
}
function Dot2LongIP(ipv6)
{
	if (arguments.ipv6 eq "") {
		return 0;
	} else {
		IPV6Long = CreateObject("java","java.math.BigInteger");
		IPV6NetAddress = CreateObject("java","java.net.InetAddress");
		newIp = IPV6NetAddress.getByName(arguments.ipv6);
		bytes = newIp.getAddress();
		bigInt = IPV6Long.init(1, bytes).toString();
		return bigInt;
	}
}
public System.Numerics.BigInteger Dot2LongIP(string ipv6)
{
	System.Net.IPAddress address;
	System.Numerics.BigInteger ipnum;

	if (System.Net.IPAddress.TryParse(ipv6, out address)) {
		byte[] addrBytes = address.GetAddressBytes();

		if (System.BitConverter.IsLittleEndian) {
			System.Collections.Generic.List<byte> byteList = new System.Collections.Generic.List<byte>(addrBytes);
			byteList.Reverse();
			addrBytes = byteList.ToArray();
		}

		if (addrBytes.Length > 8) {
			//IPv6
			ipnum = System.BitConverter.ToUInt64(addrBytes, 8);
			ipnum <<= 64;
			ipnum += System.BitConverter.ToUInt64(addrBytes, 0);
		} else {
			//IPv4
			ipnum = System.BitConverter.ToUInt32(addrBytes, 0);
		}
		return ipnum;
	}
}
Public Function Dot2LongIP(ByVal ipv6 As String) As System.Numerics.BigInteger
	Dim address As System.Net.IPAddress
	Dim ipnum As System.Numerics.BigInteger

	If System.Net.IPAddress.TryParse(ipv6, address) Then
		Dim addrBytes() As Byte = address.GetAddressBytes()

		If System.BitConverter.IsLittleEndian Then
			Dim byteList As New System.Collections.Generic.List(Of Byte)(addrBytes)
			byteList.Reverse()
			addrBytes = byteList.ToArray()
		End If

		If addrBytes.Length > 8 Then
			'IPv6
			ipnum = System.BitConverter.ToUInt64(addrBytes, 8)
			ipnum <<= 64
			ipnum += System.BitConverter.ToUInt64(addrBytes, 0)
		Else
			'IPv4
			ipnum = System.BitConverter.ToUInt32(addrBytes, 0)
		End If
	End If
	Dot2LongIP = ipnum
End Function
use NetAddr::IP;

sub dot2LongIP {
	my $ip_address = shift(@_);
	my $ip_number = NetAddr::IP->new($ip_address) or die;
	return $ip_number->bigint;
}
require 'ipaddr'

def dot2LongIP(ipv6)
	ipnum = IPAddr.new(ipv6)
	return ipnum.to_i
end
import ipaddress

def dot2LongIP(ipv6):
	return int(ipaddress.IPv6Address(ipv6))
#include <arpa/inet.h>
#include <inttypes.h>

typedef unsigned __int128 uint128_t;

uint128_t Dot2LongIP(const char* ipv6) {
	struct sockaddr_in6 sa;
	inet_pton(AF_INET6, ipv6, &(sa.sin6_addr));
	uint128_t ipnum = 0;
	uint128_t octet = 0;
	int i;
	for (i = 0; i < (sizeof(sa.sin6_addr.s6_addr) / sizeof(sa.sin6_addr.s6_addr[0])); i++) {
		octet = ((uint128_t)sa.sin6_addr.s6_addr[i] << ((uint128_t)(15 - i) * 8));
		ipnum = ipnum + octet;
	}
	return ipnum;
}

IP Address = a:b:c:d:e:f:g:h

To reverse IP number to IP address,

a = int ( IP Number / (65536^7) ) % 65536
b = int ( IP Number / (65536^6) ) % 65536
c = int ( IP Number / (65536^5) ) % 65536
d = int ( IP Number / (65536^4) ) % 65536
e = int ( IP Number / (65536^3) ) % 65536
f = int ( IP Number / (65536^2) ) % 65536
g = int ( IP Number / 65536 ) % 65536
h = IP Number % 65536


where
%
is the modulus operator and
int
returns the integer part of the division.

NOTE: All parts need to be converted into hexadecimal to be part of the IPv6 address.

Exempelkod på olika programmeringsspråk

function Long2DotIP($integer) {
	return inet_ntop(str_pad(gmp_export($integer), 16, "\0", STR_PAD_LEFT));
}
String Long2DotIP(String integer)
{
	String ipstr = new java.math.BigInteger(integer).toString(16);
	String padding = new String(new char[32 - ipstr.length()]).replace("\0", "0");
	String retval = padding + ipstr;
	retval = retval.replaceAll("(.{4})", "$1:").substring(0, 39);
	return retval;
}
function Long2DotIP(integer)
{
	if (arguments.integer eq "") {
		return 0;
	} else {
		retval = "";
		bigobj = CreateObject("java","java.math.BigInteger");
		intval = bigobj.init(integer).toString(16);
		padding = repeatstring("0", 32 - len(intval));
		retval = padding & intval;
		retval = rereplace(rereplace(retval, "(.{4})", "\1:", "ALL"), ":$", "");
		return retval;
	}
}
public string Long2DotIP(string bigint)
{
	string retval = "";
	System.Numerics.BigInteger intval = System.Numerics.BigInteger.Zero;

	if (System.Numerics.BigInteger.TryParse(bigint, out intval)) {
		retval = intval.ToString("x").PadLeft(32, '0');
		char[] trimme = new[] { ':' };
		retval = System.Text.RegularExpressions.Regex.Replace(retval, "(.{4})", "$1:").TrimEnd(trimme);
	}

	return retval;
}
Public Function Long2DotIP(ByVal bigint As String) As String
	Dim retval As String = ""
	Dim intval As System.Numerics.BigInteger = System.Numerics.BigInteger.Zero

	If System.Numerics.BigInteger.TryParse(bigint, intval) Then
		retval = intval.ToString("x").PadLeft(32, "0"c)
		Dim trimme As Char() = {":"c}
		retval = System.Text.RegularExpressions.Regex.Replace(retval, "(.{4})", "$1:").TrimEnd(trimme)
	End If

	Return retval
End Function
use Math::BigInt;

sub long2DotIP {
	my $ipnumstr = shift(@_);
	my $ipnum = Math::BigInt->new($ipnumstr);
	my $iphex = $ipnum->as_hex();
	$iphex =~ s/^0x//;
	my $ipv6 = ('0' x (32 - length($iphex))) . $iphex;
	$ipv6 =~ s/(.{4})/$1:/g;
	$ipv6 =~ s/:$//;

	return $ipv6;
}
def long2DotIP(integer)
	return integer.to_s(16).rjust(32, '0').gsub(/(.{4})/, "\1:").sub(/:$/, "")
end
import re

def long2DotIP(integer):
	retval = format(integer, 'x')
	retval = retval.zfill(32)
	retval = re.sub(r"(.{4})", r"\1:", retval)
	retval = re.sub(r":$", "", retval)
	return retval
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gmp.h>

char* Long2DotIP(char* ipnum)
{
	mpz_t bigint;
	char* buf = malloc (sizeof (char) * 33);
	char* buf2 = malloc (sizeof (char) * 40);
	int i = 0;
	int parts = 8;
	int partsize = 5;
	char **arr;
	arr = calloc(parts, sizeof *arr);

	for (i = 0; i < parts; i++)
	{
		arr[i] = calloc(partsize, sizeof *arr[i]);
	}
	mpz_init_set_str(bigint, ipnum, 10);
	gmp_snprintf(buf, (sizeof (char) * 33), "%032Zx", bigint);

	for (i = 0; i < parts; i++)
	{
		memcpy(arr[i], buf + (i * 4), 4);
	}

	snprintf(buf2, (sizeof (char) * 40), "%s:%s:%s:%s:%s:%s:%s:%s", arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7]);
	free(buf);
	free(arr);
	return buf2;
}

Konvertera först IP-adressen till IP-nummerformat. Sök i IP-landsdatabas med hjälp av IP-nummer för att matcha en post som har IP-numret mellan början av IP-numret och det slutande IP-numret.

Till exempel är IP-adressen "72.77.138.60" "1213041212" i IP-nummer. Den matchade följande postuppsättning i databasen.

"1213041208","1213041215","US","UNITED STATES"

IP2Location kommer att visa "-" i landfältet när IP-adressområdet fortfarande inte är allokerat till några länder. Det är också känt som reserverat IP-adressintervall.

Först importerar du denna databas till din MSSQL, MS-ACCESS, PL / SQL, MYSQL eller annan RDMS. Använd en SQL-fråga för att få matchande postuppsättning.

Exempel på SQL-fråga (MSSQL)

SELECT [COUNTRY NAME COLUMN], [REGION NAME COLUMN], [CITY NAME COLUMN], [LATITUDE COLUMN], [LONGITUDE COLUMN], [ZIP CODE COLUMN], [TIME ZONE COLUMN], [ISP COLUMN], [DOMAIN NAME COLUMN], [NETSPEED COLUMN], [IDD CODE COLUMN], [AREA CODE COLUMN], [WEATHER STATION CODE COLUMN], [WEATHER STATION NAME COLUMN], [MCC COLUMN], [MNC COLUMN], [BRAND NAME COLUMN]
FROM [IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE-TIMEZONE-ISP-DOMAIN-NETSPEED-AREACODE-WEATHER-MOBILE TABLE]
WHERE [SEARCH IP NO] BETWEEN [IP FROM COLUMN] AND [IP TO COLUMN]

Exempel på SQL-fråga (MYSQL)

SELECT [COUNTRY NAME COLUMN], [REGION NAME COLUMN], [CITY NAME COLUMN], [LATITUDE COLUMN], [LONGITUDE COLUMN], [ZIP CODE COLUMN], [TIME ZONE COLUMN], [ISP COLUMN], [DOMAIN NAME COLUMN], [NETSPEED COLUMN], [IDD CODE COLUMN], [AREA CODE COLUMN], [WEATHER STATION CODE COLUMN], [WEATHER STATION NAME COLUMN], [MCC COLUMN], [MNC COLUMN], [BRAND NAME COLUMN]
FROM [IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE-TIMEZONE-ISP-DOMAIN-NETSPEED-AREACODE-WEATHER-MOBILE TABLE]
WHERE ([IP FROM COLUMN] <= [SEARCH IP NO]) AND ([IP TO COLUMN] <= [SEARCH IP NO])

Utan proxyavkänning
<%
ipaddress = Request.ServerVariables("REMOTE_ADDR")
%>
<?
$ipaddress = getenv('REMOTE_ADDR');
?>
<%
String ipaddress = request.getRemoteAddr();
%>
<CFCOMPONENT>
<CFSET ipaddress="#CGI.Remote_Addr#">
</CFCOMPONENT>
Public Function IpAddress()
	IpAddress = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
End Function
<%
ipaddress = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
if ipaddress = "" then
	ipaddress = Request.ServerVariables("REMOTE_ADDR")
end if
%>
<?
if (getenv('HTTP_X_FORWARDED_FOR')) {
	$ipaddress = getenv('HTTP_X_FORWARDED_FOR');
} else {
	$ipaddress = getenv('REMOTE_ADDR');
}
?>
<%
if (request.getHeader("X_FORWARDED_FOR") == null) {
	String ipaddress = request.getRemoteAddr();
} else {
	String ipaddress = request.getHeader("X_FORWARDED_FOR");
}
%>
<CFCOMPONENT>
<CFIF #CGI.HTTP_X_Forwarded_For# EQ "">
<CFSET ipaddress="#CGI.Remote_Addr#">
<CFELSE>
<CFSET ipaddress="#CGI.HTTP_X_Forwarded_For#">
</CFIF>
</CFCOMPONENT>
public string IpAddress()
{
	string strIp;
	strIp = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];

	if (strIp == null) {
		strIp = Request.ServerVariables["REMOTE_ADDR"];
	}
	return strIp;
}
Public Function IpAddress()
	Dim strIp As String
	strIp = Request.ServerVariables("HTTP_X_FORWARDED_FOR")

	If strIp = "" Then
		strIp = Request.ServerVariables("REMOTE_ADDR")
	End If

	IpAddress = strIp
End Function

Ja, vi skickar meddelandet via e-post när uppdateringen är tillgänglig i nedladdningsområdet.

Besök funktioner Jämförelse för mer information.

Äganderätten till IP-adresser byter händer då och då. Därför måste en liten andel av IP-adressblock uppdateras varje år. Vår databas med fullständig version uppdateras varje månad för att säkerställa att den alltid är korrekt.

Du kan besöka ip2location.com och göra köpet. Alternativt kan du också uppgradera från LITE-utgåvan under kontoområdet. Vi kommer att skapa ett unikt inloggnings- / lösenord så att du kan ladda ner databasen i ett år efter att vi har behandlat din beställning.

Du kommer att få ditt inloggnings- och lösenord via e-post direkt efter att betalningen har godkänts. Du kan när som helst använda dina uppgifter för att ladda ner databasen från vår webbplats. Databasen är i ZIP-komprimerat format för att spara bandbredd och nedladdningstid.

Du kan distribuera en kopia av LITE-databasen med din ansökan med attribution. Du måste dock informera alla användare att registrera sig för en enskild licens i https: //lite.ip2location.com för att ladda ner månatliga uppdateringar. Tredjeparts databasförvar är inte tillåtet.

IP2Location tillhandahåller inte kundsupport för gratis IP2Location LITE-databaser. Om du har programmeringsrelaterade frågor om hur du använder dessa databaser som inte besvaras i vanliga frågor, föreslår vi att du ställer på Stack Overflow.

Sign Up Pop Out

Geolocate Your Visitors Location

Enhance your applications with essential geolocation data by using our FREE databases.