Wie bekomme ich die Client-IP-Adresse in PHP?


Wie kann ich die Client-IP-Adresse mit PHP erhalten?

Ich möchte den Benutzer aufzeichnen, der sich über seine IP-Adresse in meine Website eingeloggt hat.




Answers


Was auch immer Sie tun, stellen Sie sicher, dass Sie keine vom Client gesendeten Daten vertrauen. $_SERVER['REMOTE_ADDR'] enthält die echte IP-Adresse der Verbindungspartei. Das ist der zuverlässigste Wert, den Sie finden können.

Sie können sich jedoch hinter einem Proxy-Server befinden. In diesem Fall hat der Proxy möglicherweise den $_SERVER['HTTP_X_FORWARDED_FOR'] , aber dieser Wert wird leicht gefälscht. Zum Beispiel kann es von jemandem ohne einen Proxy eingestellt werden, oder die IP kann eine interne IP aus dem LAN hinter dem Proxy sein.

Wenn Sie also den $_SERVER['HTTP_X_FORWARDED_FOR'] speichern, müssen Sie auch den $_SERVER['REMOTE_ADDR'] . ZB indem Sie beide Werte in verschiedenen Feldern in Ihrer Datenbank speichern.

Wenn Sie die IP-Adresse in einer Datenbank als Zeichenfolge speichern möchten, stellen Sie sicher, dass Platz für mindestens 45 Zeichen vorhanden ist . IPv6 wird bleiben und diese Adressen sind größer als die älteren IPv4-Adressen.

(Beachten Sie, dass IPv6 normalerweise maximal 39 Zeichen verwendet, aber es gibt auch eine spezielle IPv6-Notation für IPv4-Adressen, die in ihrer vollständigen Form bis zu 45 Zeichen lang sein kann. Wenn Sie also wissen, was Sie tun, können Sie 39 Zeichen verwenden will einfach nur einstellen und vergessen, benutze 45).




$_SERVER['REMOTE_ADDR'] möglicherweise keine echten Client-IP-Adressen, da Sie beispielsweise eine Proxy-Adresse für Clients erhalten, die über einen Proxy verbunden sind. Das kann gut sein, was Sie wirklich wollen, abhängig davon, was Sie mit den IPs machen. Die private RFC1918-Adresse von jemandem hilft Ihnen möglicherweise nicht, wenn Sie sagen, dass Sie herausfinden möchten, woher Ihr Datenverkehr stammt oder an welche IP-Adresse der Benutzer zuletzt angeschlossen hat, wo die öffentliche IP des Proxy- oder NAT-Gateways die bessere sein könnte angemessen zu speichern.

Es gibt mehrere HTTP-Header wie X-Forwarded-For die von verschiedenen Proxies gesetzt werden können oder nicht. Das Problem ist, dass das nur HTTP-Header sind, die von jedem gesetzt werden können. Es gibt keine Garantie für ihren Inhalt. $_SERVER['REMOTE_ADDR'] ist die tatsächliche physische IP-Adresse, von der der Webserver die Verbindung erhalten hat und an die die Antwort gesendet wird. Alles andere ist nur willkürliche und freiwillige Information. Es gibt nur ein Szenario, in dem Sie diesen Informationen vertrauen können: Sie steuern den Proxy, der diesen Header festlegt. Das bedeutet nur, wenn Sie 100% wissen, wo und wie der Header gesetzt wurde, sollten Sie es für etwas Wichtiges beachten.

Nachdem das gesagt wurde, hier ein Beispielcode:

if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
    $ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
    $ip = $_SERVER['REMOTE_ADDR'];
}

Anmerkung des Herausgebers: Die Verwendung des obigen Codes hat Auswirkungen auf die Sicherheit . Der Client kann alle HTTP-Header-Informationen (z. $_SERVER['HTTP_... ) auf einen beliebigen beliebigen Wert setzen. Daher ist es wesentlich zuverlässiger, $_SERVER['REMOTE_ADDR'] , da dies vom Benutzer nicht festgelegt werden kann.

Von: http://roshanbh.com.np/2007/12/getting-real-ip-address-in-php.html







Es sollte in der Variablen $_SERVER['REMOTE_ADDR'] .




Hier ist ein saubereres Codebeispiel für eine gute Möglichkeit, die IP des Benutzers zu erhalten.

$ip = $_SERVER['HTTP_CLIENT_IP']?$_SERVER['HTTP_CLIENT_IP']:($_SERVER['HTTP_X_FORWARDE‌​D_FOR']?$_SERVER['HTTP_X_FORWARDED_FOR']:$_SERVER['REMOTE_ADDR']);

Hier ist eine kürzere Version, die den elvis-Operator verwendet

$_SERVER['HTTP_CLIENT_IP']?:($_SERVER['HTTP_X_FORWARDE‌​D_FOR']?:$_SERVER['REMOTE_ADDR']);

Hier ist eine Version, die isset verwendet, um Benachrichtigungen zu entfernen (Danke, @shasi kanth)

$ip = isset($_SERVER['HTTP_CLIENT_IP'])?$_SERVER['HTTP_CLIENT_IP']‌:isset($_SERVER['HTT‌​P_X_FORWARDE‌​D_FOR'‌​])?$_SERVER['HTTP_X_‌​FORWARDED_FOR']:$_SE‌​RVER['REMOTE_ADDR']; 



Meine Lieblingslösung ist die Art, wie Zend Framework 2 verwendet wird. Es berücksichtigt auch die $_SERVER Eigenschaften HTTP_X_FORWARDED_FOR , HTTP_CLIENT_IP , REMOTE_ADDR aber es deklariert eine Klasse, um einige vertrauenswürdige Proxys zu setzen, und es gibt eine IP-Adresse und kein Array zurück. Ich denke, das ist die Lösung, die ihr am nächsten kommt:

class RemoteAddress
{
    /**
     * Whether to use proxy addresses or not.
     *
     * As default this setting is disabled - IP address is mostly needed to increase
     * security. HTTP_* are not reliable since can easily be spoofed. It can be enabled
     * just for more flexibility, but if user uses proxy to connect to trusted services
     * it's his/her own risk, only reliable field for IP address is $_SERVER['REMOTE_ADDR'].
     *
     * @var bool
     */
    protected $useProxy = false;

    /**
     * List of trusted proxy IP addresses
     *
     * @var array
     */
    protected $trustedProxies = array();

    /**
     * HTTP header to introspect for proxies
     *
     * @var string
     */
    protected $proxyHeader = 'HTTP_X_FORWARDED_FOR';

    // [...]

    /**
     * Returns client IP address.
     *
     * @return string IP address.
     */
    public function getIpAddress()
    {
        $ip = $this->getIpAddressFromProxy();
        if ($ip) {
            return $ip;
        }

        // direct IP address
        if (isset($_SERVER['REMOTE_ADDR'])) {
            return $_SERVER['REMOTE_ADDR'];
        }

        return '';
    }

    /**
     * Attempt to get the IP address for a proxied client
     *
     * @see http://tools.ietf.org/html/draft-ietf-appsawg-http-forwarded-10#section-5.2
     * @return false|string
     */
    protected function getIpAddressFromProxy()
    {
        if (!$this->useProxy
            || (isset($_SERVER['REMOTE_ADDR']) && !in_array($_SERVER['REMOTE_ADDR'], $this->trustedProxies))
        ) {
            return false;
        }

        $header = $this->proxyHeader;
        if (!isset($_SERVER[$header]) || empty($_SERVER[$header])) {
            return false;
        }

        // Extract IPs
        $ips = explode(',', $_SERVER[$header]);
        // trim, so we can compare against trusted proxies properly
        $ips = array_map('trim', $ips);
        // remove trusted proxy IPs
        $ips = array_diff($ips, $this->trustedProxies);

        // Any left?
        if (empty($ips)) {
            return false;
        }

        // Since we've removed any known, trusted proxy servers, the right-most
        // address represents the first IP we do not know about -- i.e., we do
        // not know if it is a proxy server, or a client. As such, we treat it
        // as the originating IP.
        // @see http://en.wikipedia.org/wiki/X-Forwarded-For
        $ip = array_pop($ips);
        return $ip;
    }

    // [...]
}

Den vollständigen Code finden Sie hier: https://raw.githubusercontent.com/zendframework/zend-http/master/src/PhpEnvironment/RemoteAddress.php




Dies ist die fortschrittlichste Methode, die ich gefunden habe, bereits einige andere in der Vergangenheit versucht. Gültig, um die IP-Adresse des Besuchers zu erhalten (aber bitte beachten Sie, dass jeder Hacker die IP-Adresse leicht verfälschen könnte).

function get_ip_address() {
    // check for shared internet/ISP IP
    if (!empty($_SERVER['HTTP_CLIENT_IP']) && validate_ip($_SERVER['HTTP_CLIENT_IP'])) {
        return $_SERVER['HTTP_CLIENT_IP'];
    }

    // check for IPs passing through proxies
    if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
        // check if multiple ips exist in var
        if (strpos($_SERVER['HTTP_X_FORWARDED_FOR'], ',') !== false) {
            $iplist = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);
            foreach ($iplist as $ip) {
                if (validate_ip($ip))
                    return $ip;
            }
        } else {
            if (validate_ip($_SERVER['HTTP_X_FORWARDED_FOR']))
                return $_SERVER['HTTP_X_FORWARDED_FOR'];
        }
    }
    if (!empty($_SERVER['HTTP_X_FORWARDED']) && validate_ip($_SERVER['HTTP_X_FORWARDED']))
        return $_SERVER['HTTP_X_FORWARDED'];
    if (!empty($_SERVER['HTTP_X_CLUSTER_CLIENT_IP']) && validate_ip($_SERVER['HTTP_X_CLUSTER_CLIENT_IP']))
        return $_SERVER['HTTP_X_CLUSTER_CLIENT_IP'];
    if (!empty($_SERVER['HTTP_FORWARDED_FOR']) && validate_ip($_SERVER['HTTP_FORWARDED_FOR']))
        return $_SERVER['HTTP_FORWARDED_FOR'];
    if (!empty($_SERVER['HTTP_FORWARDED']) && validate_ip($_SERVER['HTTP_FORWARDED']))
        return $_SERVER['HTTP_FORWARDED'];

    // return unreliable ip since all else failed
    return $_SERVER['REMOTE_ADDR'];
}

/**
 * Ensures an ip address is both a valid IP and does not fall within
 * a private network range.
 */
function validate_ip($ip) {
    if (strtolower($ip) === 'unknown')
        return false;

    // generate ipv4 network address
    $ip = ip2long($ip);

    // if the ip is set and not equivalent to 255.255.255.255
    if ($ip !== false && $ip !== -1) {
        // make sure to get unsigned long representation of ip
        // due to discrepancies between 32 and 64 bit OSes and
        // signed numbers (ints default to signed in PHP)
        $ip = sprintf('%u', $ip);
        // do private network range checking
        if ($ip >= 0 && $ip <= 50331647) return false;
        if ($ip >= 167772160 && $ip <= 184549375) return false;
        if ($ip >= 2130706432 && $ip <= 2147483647) return false;
        if ($ip >= 2851995648 && $ip <= 2852061183) return false;
        if ($ip >= 2886729728 && $ip <= 2887778303) return false;
        if ($ip >= 3221225984 && $ip <= 3221226239) return false;
        if ($ip >= 3232235520 && $ip <= 3232301055) return false;
        if ($ip >= 4294967040) return false;
    }
    return true;
}

Quelle: http://blackbe.lt/advanced-method-to-obtain-the-client-ip-in-php/




Die Antwort besteht darin, die Variable $_SERVER zu verwenden. Beispielsweise würde $_SERVER["REMOTE_ADDR"] die IP-Adresse des Clients zurückgeben.




Es gibt verschiedene Arten von Benutzern hinter dem Internet, also wollen wir die IP-Adresse von verschiedenen Tränken abfangen. Das sind,

1. $_SERVER['REMOTE_ADDR'] - Enthält die echte IP-Adresse des Clients. Das ist der zuverlässigste Wert, den Sie vom Benutzer finden können.

2. $_SERVER['REMOTE_HOST'] - Dies $_SERVER['REMOTE_HOST'] den Host-Namen ab, von dem der Benutzer die aktuelle Seite sieht. Damit dieses Skript funktioniert, müssen Hostname-Lookups in der Datei httpd.conf konfiguriert werden.

3. $_SERVER['HTTP_CLIENT_IP'] - Dies $_SERVER['HTTP_CLIENT_IP'] die IP-Adresse ab, wenn der Benutzer von den Shared Internet-Diensten kommt.

4. $_SERVER['HTTP_X_FORWARDED_FOR'] - Dies wird die IP-Adresse vom Benutzer holen, wenn er hinter dem Proxy ist

So können wir diese folgende kombinierte Funktion verwenden, um die echte IP-Adresse von Benutzern zu erhalten, die sich in verschiedenen Positionen befinden,

// Function to get the user IP address
function getUserIP() {
    $ipaddress = '';
    if (isset($_SERVER['HTTP_CLIENT_IP']))
        $ipaddress = $_SERVER['HTTP_CLIENT_IP'];
    else if(isset($_SERVER['HTTP_X_FORWARDED_FOR']))
        $ipaddress = $_SERVER['HTTP_X_FORWARDED_FOR'];
    else if(isset($_SERVER['HTTP_X_FORWARDED']))
        $ipaddress = $_SERVER['HTTP_X_FORWARDED'];
    else if(isset($_SERVER['HTTP_X_CLUSTER_CLIENT_IP']))
        $ipaddress = $_SERVER['HTTP_X_CLUSTER_CLIENT_IP'];
    else if(isset($_SERVER['HTTP_FORWARDED_FOR']))
        $ipaddress = $_SERVER['HTTP_FORWARDED_FOR'];
    else if(isset($_SERVER['HTTP_FORWARDED']))
        $ipaddress = $_SERVER['HTTP_FORWARDED'];
    else if(isset($_SERVER['REMOTE_ADDR']))
        $ipaddress = $_SERVER['REMOTE_ADDR'];
    else
        $ipaddress = 'UNKNOWN';
    return $ipaddress;
}



Wie ich weiß Die einfachste Möglichkeit, die IP-Adresse des Besuchers / Kunden zu erhalten, ist die Verwendung der Variablen $ _SERVER ['REMOTE_ADDR'] oder $ _SERVER ['REMOTE_HOST'] .

Manchmal gibt dies jedoch nicht die korrekte IP-Adresse des Besuchers zurück, so dass wir einige andere Servervariablen verwenden können, um die IP-Adresse zu erhalten.

Die folgenden beiden Funktionen sind äquivalent mit dem Unterschied nur in wie und woher die Werte abgerufen werden.

getenv() wird verwendet, um den Wert einer Umgebungsvariablen in PHP zu erhalten.

// Function to get the client IP address

    function get_client_ip() {
    $ipaddress = '';
    if (getenv('HTTP_CLIENT_IP'))
        $ipaddress = getenv('HTTP_CLIENT_IP');
    else if(getenv('HTTP_X_FORWARDED_FOR'))
        $ipaddress = getenv('HTTP_X_FORWARDED_FOR');
    else if(getenv('HTTP_X_FORWARDED'))
        $ipaddress = getenv('HTTP_X_FORWARDED');
    else if(getenv('HTTP_FORWARDED_FOR'))
        $ipaddress = getenv('HTTP_FORWARDED_FOR');
    else if(getenv('HTTP_FORWARDED'))
       $ipaddress = getenv('HTTP_FORWARDED');
    else if(getenv('REMOTE_ADDR'))
        $ipaddress = getenv('REMOTE_ADDR');
    else
        $ipaddress = 'UNKNOWN';
    return $ipaddress;
}

$ _SERVER ist ein Array, das Servervariablen enthält, die vom Webserver erstellt wurden.

// Function to get the client IP address

    function get_client_ip() {
    $ipaddress = '';
    if (isset($_SERVER['HTTP_CLIENT_IP']))
        $ipaddress = $_SERVER['HTTP_CLIENT_IP'];
    else if(isset($_SERVER['HTTP_X_FORWARDED_FOR']))
        $ipaddress = $_SERVER['HTTP_X_FORWARDED_FOR'];
    else if(isset($_SERVER['HTTP_X_FORWARDED']))
        $ipaddress = $_SERVER['HTTP_X_FORWARDED'];
    else if(isset($_SERVER['HTTP_FORWARDED_FOR']))
        $ipaddress = $_SERVER['HTTP_FORWARDED_FOR'];
    else if(isset($_SERVER['HTTP_FORWARDED']))
        $ipaddress = $_SERVER['HTTP_FORWARDED'];
    else if(isset($_SERVER['REMOTE_ADDR']))
        $ipaddress = $_SERVER['REMOTE_ADDR'];
    else
        $ipaddress = 'UNKNOWN';
    return $ipaddress;
}



Dies ist die Methode, die ich verwende, und sie validiert eine IPv4- Eingabe:

// Get user IP address
if ( isset($_SERVER['HTTP_CLIENT_IP']) && ! empty($_SERVER['HTTP_CLIENT_IP'])) {
    $ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif ( isset($_SERVER['HTTP_X_FORWARDED_FOR']) && ! empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
    $ip = (isset($_SERVER['REMOTE_ADDR'])) ? $_SERVER['REMOTE_ADDR'] : '0.0.0.0';
}

$ip = filter_var($ip, FILTER_VALIDATE_IP);
$ip = ($ip === false) ? '0.0.0.0' : $ip;



Ich mag diesen Codesnippet:

function getClientIP() {

    if (isset($_SERVER)) {

        if (isset($_SERVER["HTTP_X_FORWARDED_FOR"]))
            return $_SERVER["HTTP_X_FORWARDED_FOR"];

        if (isset($_SERVER["HTTP_CLIENT_IP"]))
            return $_SERVER["HTTP_CLIENT_IP"];

        return $_SERVER["REMOTE_ADDR"];
    }

    if (getenv('HTTP_X_FORWARDED_FOR'))
        return getenv('HTTP_X_FORWARDED_FOR');

    if (getenv('HTTP_CLIENT_IP'))
        return getenv('HTTP_CLIENT_IP');

    return getenv('REMOTE_ADDR');
}



$ip = "";

if (!empty($_SERVER["HTTP_CLIENT_IP"]))
{
 //check for ip from share internet
 $ip = $_SERVER["HTTP_CLIENT_IP"];
}
elseif (!empty($_SERVER["HTTP_X_FORWARDED_FOR"]))
{
 // Check for the Proxy User
 $ip = $_SERVER["HTTP_X_FORWARDED_FOR"];
}
else
{
 $ip = $_SERVER["REMOTE_ADDR"];
}
echo $ip;



 $_SERVER['REMOTE_ADDR'];

Probier diese




Nun, dies kann einfach mit der GLOBAL Variablen namens $_SERVER .

Der $_SERVER ist ein Array mit dem Attributnamen REMOTE_ADDR .

$userIp = $_SERVER['REMOTE_ADDR']; es einfach wie $userIp = $_SERVER['REMOTE_ADDR'];

oder benutze es direkt wie echo $_SERVER['REMOTE_ADDR']; oder echo ($_SERVER['REMOTE_ADDR']);




Wie alle anderen zuvor gesagt haben, können Sie $_SERVER['REMOTE_ADDR']; um die Client-IP-Adresse zu erhalten.

Wenn Sie weitere Informationen zu einem Benutzer benötigen, können Sie Folgendes verwenden:

<?php
    $ip='0.0.0.0';
    $ip=$_SERVER['REMOTE_ADDR'];
    $clientDetails = json_decode(file_get_contents("http://ipinfo.io/$ip/json"));
    echo "You're logged in from: <b>" . $clientDetails->country . "</b>";
?>

Die spezifischeren Informationen des Kunden gehen in $ clientDetails.
Sie können JSON-Elemente, die in der Variablen $ clientDetails gespeichert sind, folgendermaßen abrufen: $ clientDetails-> PostalCode / hostname / region / loc ...

Ich verwende ipinfo.io , um zusätzliche Informationen zu erhalten.

Ich hoffe, es hilft.




Die folgende Funktion bestimmt alle Möglichkeiten und gibt den Wert in Komma getrennt zurück (IP, IP, etc).

Es hat auch optionale Validierungsfunktion als (erster Parameter, der standardmäßig deaktiviert ist), um die IP-Adresse gegen (Privater Bereich und Reservierter Bereich) zu validieren.

<?php
echo GetClientIP(true);

function GetClientIP($validate = False){
  $ipkeys = array(
  'REMOTE_ADDR', 
  'HTTP_CLIENT_IP', 
  'HTTP_X_FORWARDED_FOR', 
  'HTTP_X_FORWARDED', 
  'HTTP_FORWARDED_FOR', 
  'HTTP_FORWARDED', 
  'HTTP_X_CLUSTER_CLIENT_IP'
  );

  /*
  now we check each key against $_SERVER if contain such value
  */
  $ip = array();
  foreach($ipkeys as $keyword){
    if( isset($_SERVER[$keyword]) ){
      if($validate){
        if( ValidatePublicIP($_SERVER[$keyword]) ){
          $ip[] = $_SERVER[$keyword];
        }
      }else{
        $ip[] = $_SERVER[$keyword];
      }
    }
  }

  $ip = ( empty($ip) ? 'Unknown' : implode(", ", $ip) );
  return $ip;

}
function ValidatePublicIP($ip){
  if(filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
    return true;
  }
  else {
    return false;
  }
} 



Diese Funktion ist kompakt und Sie können sie überall verwenden. Aber !

Vergiss das nicht! Bei dieser Art von Funktionen oder Code-Blöcken nicht für die Aufnahme der User Real IP garantieren, weil einige Benutzer Proxy oder eine andere sichere Gateways für unsichtbar sein können oder nicht verfolgen können

PHP Funktion:

function GetIP()
{
    if ( getenv("HTTP_CLIENT_IP") ) {
        $ip = getenv("HTTP_CLIENT_IP");
    } elseif ( getenv("HTTP_X_FORWARDED_FOR") ) {
        $ip = getenv("HTTP_X_FORWARDED_FOR");
        if ( strstr($ip, ',') ) {
            $tmp = explode(',', $ip);
            $ip = trim($tmp[0]);
        }
    } else {
        $ip = getenv("REMOTE_ADDR");
    }
    return $ip;
}

Verwendung :

$IP = GetIP(); oder direkt GetIP();




function get_client_ip() 
{
   $ipaddress = '';
    if (getenv('HTTP_CLIENT_IP'))
        $ipaddress = getenv('HTTP_CLIENT_IP');
    else if(getenv('HTTP_X_FORWARDED_FOR'))
        $ipaddress = getenv('HTTP_X_FORWARDED_FOR');
    else if(getenv('HTTP_X_FORWARDED'))
        $ipaddress = getenv('HTTP_X_FORWARDED');
    else if(getenv('HTTP_FORWARDED_FOR'))
        $ipaddress = getenv('HTTP_FORWARDED_FOR');
    else if(getenv('HTTP_FORWARDED'))
       $ipaddress = getenv('HTTP_FORWARDED');
    else if(getenv('REMOTE_ADDR'))
        $ipaddress = getenv('REMOTE_ADDR');
    else
        $ipaddress = 'UNKNOWN';

   return $ipaddress;
} 



So wie das????

if(($ip=filter_input(INPUT_SERVER,'REMOTE_ADDR',validate_ip))===false or empty($ip)){
  exit;
  }
echo $ip;

PS

if(($ip=filter_input(INPUT_SERVER,'REMOTE_ADDR',FILTER_VALIDATE_IP|FILTER_FLAG_NO_PRIV_RANGE|FILTER_FLAG_NO_RES_RANGE))===false){
  header('HTTP/1.0 400 Bad Request');
  exit;
}

Alle Kopfzeilen, die mit "HTTP_" oder "X-" beginnen, können gefälscht bzw. benutzerdefiniert sein. Wenn Sie den Überblick behalten möchten, verwenden Sie cookies usw.




Hier ist ein einfacher Liner

$ip = $_SERVER['HTTP_X_FORWARDED_FOR']?: $_SERVER['HTTP_CLIENT_IP']?: $_SERVER['REMOTE_ADDR'];

BEARBEITEN:

Der obige Code kann reservierte Adressen (wie 10.0.0.1), eine Liste von Adressen aller Proxy-Server auf dem Weg usw. zurückgeben. Um diese Fälle zu behandeln, verwenden Sie den folgenden Code:

function valid_ip($ip) {
    // for list of reserved IP addresses, see https://en.wikipedia.org/wiki/Reserved_IP_addresses
    return $ip && substr($ip, 0, 4) != '127.' && substr($ip, 0, 4) != '127.' && substr($ip, 0, 3) != '10.' && substr($ip, 0, 2) != '0.' ? $ip : false;
}

function get_client_ip() {
    // using explode to get only client ip from list of forwarders. see https://en.wikipedia.org/wiki/X-Forwarded-For
    return
    @$_SERVER['HTTP_X_FORWARDED_FOR'] ? explode(',', $_SERVER['HTTP_X_FORWARDED_FOR'], 2)[0] :
    @$_SERVER['HTTP_CLIENT_IP'] ? explode(',', $_SERVER['HTTP_CLIENT_IP'], 2)[0] :
    valid_ip(@$_SERVER['REMOTE_ADDR']) ?:
    'UNKNOWN';
}

echo get_client_ip();



$_SERVER['REMOTE_ADDR'];

Beispiel:

if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
    $ip = $_SERVER['HTTP_CLIENT_IP'];
} elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
    $ip = $_SERVER['REMOTE_ADDR'];
}