Come ottenere l'indirizzo IP del client in PHP?


Come posso ottenere l'indirizzo IP del client usando PHP?

Voglio conservare la registrazione dell'utente che ha effettuato l'accesso al mio sito Web tramite il suo indirizzo IP.




Answers


Qualunque cosa tu faccia, assicurati di non fidarti dei dati inviati dal cliente. $_SERVER['REMOTE_ADDR'] contiene l'indirizzo IP reale della parte connessa. Questo è il valore più affidabile che puoi trovare.

Tuttavia, possono essere dietro un server proxy nel qual caso il proxy potrebbe aver impostato $_SERVER['HTTP_X_FORWARDED_FOR'] , ma questo valore è facilmente falsificato. Ad esempio, può essere impostato da qualcuno senza un proxy o l'IP può essere un IP interno dalla LAN dietro il proxy.

Ciò significa che se vuoi salvare $_SERVER['HTTP_X_FORWARDED_FOR'] , assicurati di salvare anche il valore $_SERVER['REMOTE_ADDR'] . Ad esempio, salvando entrambi i valori in diversi campi nel database.

Se vuoi salvare l'IP in un database come una stringa, assicurati di avere spazio per almeno 45 caratteri . IPv6 è qui per rimanere e quegli indirizzi sono più grandi dei vecchi indirizzi IPv4.

(Si noti che IPv6 solitamente usa al massimo 39 caratteri, ma esiste anche una speciale notazione IPv6 per gli indirizzi IPv4 che nella sua forma completa può avere fino a 45 caratteri. Quindi se sai cosa stai facendo puoi usare 39 caratteri, ma se tu voglio solo settarlo e dimenticarlo, usa 45).




$_SERVER['REMOTE_ADDR'] potrebbe non contenere effettivamente gli indirizzi IP dei client reali, poiché fornirà un indirizzo proxy per i client connessi tramite un proxy, ad esempio. Potrebbe anche essere quello che vuoi veramente, a seconda di cosa stai facendo con gli IP. L'indirizzo RFC1918 privato di qualcuno potrebbe non essere utile se stai dicendo, cercando di vedere da dove proviene il tuo traffico, o ricordando a quale IP l'ultimo utente è connesso, dove l'IP pubblico del proxy o gateway NAT potrebbe essere più appropriato da conservare.

Esistono diverse intestazioni HTTP come X-Forwarded-For che possono o meno essere impostate da vari proxy. Il problema è che quelle sono semplicemente intestazioni HTTP che possono essere impostate da chiunque. Non c'è alcuna garanzia sul loro contenuto. $_SERVER['REMOTE_ADDR'] è l'effettivo indirizzo IP fisico dal quale il server web ha ricevuto la connessione e a cui verrà inviata la risposta. Tutto il resto è solo informazioni arbitrarie e volontarie. C'è solo uno scenario in cui puoi fidarti di queste informazioni: stai controllando il proxy che imposta questa intestazione. Significa solo se si conosce al 100% dove e come è stata impostata l'intestazione se doveste prestare attenzione a qualcosa di importante.

Detto questo, ecco alcuni esempi di codice:

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'];
}

Nota del redattore: l' uso del codice precedente ha implicazioni sulla sicurezza . Il client può impostare tutte le informazioni dell'intestazione HTTP (ad esempio $_SERVER['HTTP_... ) su qualsiasi valore arbitrario che desidera. Pertanto è molto più affidabile utilizzare $_SERVER['REMOTE_ADDR'] , in quanto non può essere impostato dall'utente.

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







Dovrebbe essere contenuto nella variabile $_SERVER['REMOTE_ADDR'] .




Ecco un esempio di codice più pulito di un buon modo per ottenere l'ip dell'utente.

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

Ecco una versione più breve che utilizza l'operatore elvis

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

Ecco una versione che utilizza isset per rimuovere le notifiche (grazie, @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']; 



La mia soluzione preferita è il modo in cui Zend Framework 2 utilizza. Considera anche le proprietà $_SERVER HTTP_X_FORWARDED_FOR , HTTP_CLIENT_IP , REMOTE_ADDR ma dichiara una classe per l'impostazione di alcuni proxy affidabili e restituisce un indirizzo IP non un array. Penso che questa sia la soluzione più vicina ad essa:

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;
    }

    // [...]
}

Vedere il codice completo qui: https://raw.githubusercontent.com/zendframework/zend-http/master/src/PhpEnvironment/RemoteAddress.php




Questo è il metodo più avanzato che ho trovato, già provato in passato. Valido per garantire di ottenere l'indirizzo IP del visitatore (ma si ricorda che qualsiasi hacker può falsificare facilmente l'indirizzo IP).

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;
}

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




La risposta è usare la variabile $_SERVER . Ad esempio, $_SERVER["REMOTE_ADDR"] restituirà l'indirizzo IP del client.




Ci sono diversi tipi di utenti dietro Internet, quindi vogliamo prendere l'indirizzo IP da pozioni diverse. Che sono,

1. $_SERVER['REMOTE_ADDR'] - Questo contiene l'indirizzo IP reale del client. Questo è il valore più affidabile che puoi trovare dall'utente.

2. $_SERVER['REMOTE_HOST'] - Questo $_SERVER['REMOTE_HOST'] il nome dell'host da cui l'utente sta visualizzando la pagina corrente. Ma per far funzionare questo script, è necessario configurare Hostname Lookups all'interno di httpd.conf.

3. $_SERVER['HTTP_CLIENT_IP'] - Questo $_SERVER['HTTP_CLIENT_IP'] l'indirizzo IP quando l'utente proviene da servizi Internet condivisi.

4. $_SERVER['HTTP_X_FORWARDED_FOR'] - Questo recupererà l'indirizzo IP dall'utente quando è dietro il proxy

Quindi possiamo usare questa seguente funzione combinata per ottenere l'indirizzo IP reale dagli utenti che stanno visualizzando in posizioni diverse,

// 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;
}



Come so Il modo più semplice per ottenere l'indirizzo IP del visitatore / client è utilizzare le variabili $ _SERVER ['REMOTE_ADDR'] o $ _SERVER ['REMOTE_HOST'] .

Tuttavia, a volte questo non restituisce l'indirizzo IP corretto del visitatore, quindi possiamo usare alcune altre variabili del server per ottenere l'indirizzo IP.

Le due funzioni seguenti sono equivalenti con la differenza solo in come e da dove vengono recuperati i valori.

getenv() è usato per ottenere il valore di una variabile d'ambiente in PHP.

// 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 è un array che contiene variabili del server create dal server web.

// 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;
}



Questo è il metodo che utilizzo e convalida un input IPv4 :

// 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;



Mi piace questo codenippet:

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'];

prova questo




Bene, questo può essere fatto semplicemente usando la variabile GLOBAL chiamata $_SERVER .

$_SERVER è un array con nomi di attributi REMOTE_ADDR .

$userIp = $_SERVER['REMOTE_ADDR']; come $userIp = $_SERVER['REMOTE_ADDR'];

o usarlo direttamente come echo $_SERVER['REMOTE_ADDR']; o echo ($_SERVER['REMOTE_ADDR']);




Come tutti gli altri hanno detto prima puoi usare $_SERVER['REMOTE_ADDR']; per ottenere l'indirizzo IP del client.

Inoltre, se hai bisogno di maggiori informazioni su un utente, puoi usare questo:

<?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>";
?>

Le informazioni più specifiche del cliente vanno in $ clientDetails.
È possibile recuperare gli elementi di JSON memorizzati nella variabile $ clientDetails in questo modo: $ clientDettagli-> Codice postale / nomehost / regione / loc ...

Sto usando ipinfo.io per ottenere informazioni extra.

Spero possa essere d'aiuto.




La seguente funzione determina tutte le possibilità e restituisce il valore in una virgola separata (ip, ip, ecc.).

Ha anche funzione di convalida opzionale come (primo parametro disabilitato di default) per convalidare l'indirizzo IP contro (Intervallo privato e Intervallo prenotato).

<?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;
  }
} 



Questa funzione è compatta e puoi usarla ovunque. Ma !

Non dimenticarlo! In questo tipo di funzioni o blocchi di codice non è garantito per registrare l'IP reale dell'utente perché alcuni utenti possono utilizzare proxy o altri gateway in modo sicuro per essere invisibili o non possono tracciare

Funzione Php:

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;
}

Uso:

$IP = GetIP(); o direttamente 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;
} 



Come quello????

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;
}

Tutte le intestazioni che iniziano con "HTTP_" o "X-" possono essere rispettivamente spoof definite dall'utente. Se si desidera tenere traccia dell'uso, usare i cooies ecc.




Ecco una semplice fodera

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

MODIFICARE:

Sopra codice può restituire indirizzi riservati (come 10.0.0.1), un elenco di indirizzi di tutti i server proxy sulla strada, ecc. Per gestire questi casi utilizzare il seguente codice:

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'];

Esempio:

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'];
}