<?php

/**
 * Returns true if $ip is in addresses given in $check array
 *
 * Examples:
 * - check_ip('192.168.1.102', array('192.168.1.*'))
 * - check_ip('2a01:e34:ee89:c060:503f:d19b:b8fa:32fd', array('2a01::*'))
 * - check_ip('2a01:e34:ee89:c060:503f:d19b:b8fa:32fd', array('2a01:e34:ee89:c06::/64'))
 */
function check_ip($ip, $check)
{
    if (empty($check) || !is_array($check))
    {
        throw new BadFunctionCallException('Check argument must be an array');
    }

    if (!inet_pton($ip))
    {
        throw new UnexpectedValueException('IP argument is not a valid IP');
    }

    if (strpos($ip, ':') === false)
    {
        $ipv6 = false;
        $ip = ip2long($ip);
    }
    else
    {
        $ipv6 = true;
        $ip = bin2hex(inet_pton($ip));
    }

    foreach ($check as $c)
    {
        if (strpos($c, ':') === false)
        {
            if ($ipv6)
            {
                continue;
            }

            // Check against mask
            if (strpos($c, '/') !== false)
            {
                list($c, $mask) = explode('/', $c);
                $c = ip2long($c);
                $mask = ~((1 << (32 - $mask)) - 1);

                if (($ip & $mask) == $c)
                {
                    return true;
                }
            }
            elseif (strpos($c, '*') !== false)
            {
                $c = substr($c, 0, -1);
                $mask = substr_count($c, '.');
                $c .= '0' . str_repeat('.0', (3 - $mask));
                $c = ip2long($c);
                $mask = ~((1 << (32 - ($mask * 8))) - 1);

                if (($ip & $mask) == $c)
                {
                    return true;
                }
            }
            else
            {
                if ($ip == ip2long($c))
                {
                    return true;
                }
            }
        }
        else
        {
            if (!$ipv6)
            {
                continue;
            }

            // Check against mask
            if (strpos($c, '/') !== false)
            {
                list($c, $mask) = explode('/', $c);
                $c = bin2hex(inet_pton($c));
                $mask = $mask / 4;
                $c = substr($c, 0, $mask);

                if (substr($ip, 0, $mask) == $c)
                {
                    return true;
                }
            }
            elseif (strpos($c, '*') !== false)
            {
                $c = substr($c, 0, -1);
                $c = bin2hex(inet_pton($c));
                $c = rtrim($c, '0');

                if (substr($ip, 0, strlen($c)) == $c)
                {
                    return true;
                }
            }
            else
            {
                if ($ip == inet_pton($c))
                {
                    return true;
                }
            }
        }
    }

    return false;
}

/**
 * Expand an IPv6 address to long notation.
 *
 * Examples:
 *  -- ::1
 *  -> 0000:0000:0000:0000:0000:0000:0000:0001
 *  -- 2001:db8:85a3::8a2e:370:7334
 *  -> 2001:0db8:85a3:0000:0000:8a2e:0370:7334
 *
 * @param string $ip Input IPv6 address
 * @return string IPv6 address
 */
function expand_ipv6($ip)
{
    return implode(':', str_split(bin2hex(inet_pton($ip), 4)));
}

/**
 * Returns an IPv6 formatted as recommended by RFC 5952 (short notation)
 *
 * @param string $ip Input IPv6 address
 * @return string IPv6 address
 */
function normalize_ipv6($ip)
{
    return inet_ntop(inet_pton($ip));
}

/**
 * Returns a random IP address, either real random a using an existing IP address as a seed.
 *
 * @param bool $ipv6 Set to true to return a IPv6 address, or else will return an IPv4.
 * @param string $from_ip Optional IP address (v4 or v6) for seed.
 * @param bool $filter_reserved If set to true, won't return any reserved or private space IP address.
 *
 * @return string IP address
 */
function get_random_ip($ipv6 = null, $from_ip = null, $filter_reserved = true)
{
    $ip = false;

    if ($from_ip)
    {
        if (!is_int($from_ip))
        {
            if (strpos($from_ip, ':') !== false)
            {
                $from_ip = normalize_ipv6($from_ip);
            }

            // We can't use seeds bigger than 32 bits, so here is a little hack
            $seed = hexdec(substr(md5($from_ip), -8));
        }
        else
        {
            $seed = $from_ip;
        }

        mt_srand($seed);
    }
    else
    {
        mt_srand();
    }

    if ($ipv6)
    {
        $ip = normalize_ipv6(wordwrap('2001' . substr(sha1(mt_rand()), -28), 4, ':', true));
    }
    else
    {
        $ip = long2ip(mt_rand(0, '4294967295'));
    }

    if ($filter_reserved && !filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE))
    {
        // OK here we can't give $from_ip directly or else you will get a infinite loop
        $ip = get_random_ip($ipv6, $from_ip ? $seed + mt_rand(-65535, 65535) : false, $filter_reserved);
    }

    return $ip;
}

function get_random_ip_and_protocol()
{
    mt_srand();
    return get_random_ip(mt_rand(0, 1) ? true : false);
}

/**
 * Filter $_SERVER variables to keep the HTTP client anonymous.
 *
 * Will replace IP addresses from the request client by a random one based on true IP address.
 *
 * @param bool $keep_unique Set to false to have a new IP address generated on each request.
 *  This could be harmful for your applications!
 * @return void
 */
function filter_remote_client($keep_unique = true)
{
    $keys = array('REMOTE_ADDR', 'HTTP_X_FORWARDED_FOR', 'HTTP_CLIENT_IP', 'HTTP_VIA', 'HTTP_X_FORWARDED',
        'HTTP_X_CLUSTER_CLIENT_IP', 'HTTP_FORWARDED_FOR', 'HTTP_FORWARDED', 'HTTP_X_COMING_FROM');

    $_SERVER['X_REMOTE_CLIENT_ID'] = sha1($_SERVER['REMOTE_ADDR']);

    foreach ($keys as $key)
    {
        if (!empty($_SERVER[$key]))
        {
            if (filter_var($_SERVER[$key], FILTER_VALIDATE_IP))
            {
                $ips = array($_SERVER[$key]);
            }
            else
            {
                $ips = explode(',', $_SERVER[$key]);
            }

            foreach ($ips as $k=>$ip)
            {
                $ip = trim($ip);

                if (!filter_var($ip, FILTER_VALIDATE_IP))
                {
                    unset($ips[$k]);
                    continue;
                }

                $ipv6 = filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) ? false : true;
                $seed = $keep_unique ? $ip : false;
                $ips[$k] = get_random_ip($ipv6, $seed);
            }

            $_SERVER[$key] = implode(', ', $ips);
        }
    }

    if (isset($_SERVER['REMOTE_HOST']))
    {
        $_SERVER['REMOTE_HOST'] = isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '';
    }
}

?>