1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 

<?php
namespace esperecyan\url\lib;

/**
 * @link https://url.spec.whatwg.org/#hosts-(domains-and-ip-addresses) URL Standard
 */
class HostProcessing
{
    use Utility;
    
    /**
     * The regular expression (PCRE) pattern matching a forbidden host code point.
     * @var string
     * @link https://url.spec.whatwg.org/#forbidden-host-code-point URL Standard
     */
    const FORBIDDEN_HOST_CODE_POINTS = '~[\\x00\\t\\n\\r #%/:?@[-\\]]~u';
    
    /**
     * Maximum UTF-8 length of a fatal error does not occur by idn_to_ascii() or idn_to_utf8().
     * @internal
     * @var int
     */
    const PHP_IDN_HANDLEABLE_LENGTH = 254;
    
    /**
     * The domain to ASCII given a domain $domain.
     * @link https://url.spec.whatwg.org/#concept-domain-to-ascii URL Standard
     * @param string $domain A UTF-8 string.
     * @return string|false
     */
    public static function domainToASCII($domain)
    {
        return mb_strlen($domain, 'UTF-8') <= self::PHP_IDN_HANDLEABLE_LENGTH
            ? idn_to_ascii($domain, IDNA_NONTRANSITIONAL_TO_ASCII, INTL_IDNA_VARIANT_UTS46)
            : false;
    }
    
    /**
     * The domain to Unicode given a domain $domain.
     * @link https://url.spec.whatwg.org/#concept-domain-to-unicode URL Standard
     * @param string $domain A UTF-8 string.
     * @return string
     */
    public static function domainToUnicode($domain)
    {
        return mb_strlen($domain, 'UTF-8') <= self::PHP_IDN_HANDLEABLE_LENGTH
            ? idn_to_utf8($domain, 0, INTL_IDNA_VARIANT_UTS46)
            : false;
    }

    /**
     * Returns true if a domain is a valid domain.
     * @link https://url.spec.whatwg.org/#valid-domain URL Standard
     * @param string $domain A UTF-8 string.
     * @return bool
     */
    public static function isValidDomain($domain)
    {
        $valid = mb_strlen($domain, 'UTF-8') <= self::PHP_IDN_HANDLEABLE_LENGTH;

        if ($valid) {
            $result = idn_to_ascii(
                $domain,
                IDNA_USE_STD3_RULES | IDNA_NONTRANSITIONAL_TO_ASCII,
                INTL_IDNA_VARIANT_UTS46
            );

            if (!is_string($result)) {
                $valid = false;
            }
        }
        
        if ($valid) {
            $domainNameLength = strlen($result);
            if ($domainNameLength < 1 || $domainNameLength > 253) {
                $valid = false;
            }
        }
        
        if ($valid) {
            foreach (explode('.', $result) as $label) {
                $labelLength = strlen($label);
                if ($labelLength < 1 || $labelLength > 63) {
                    $valid = false;
                    break;
                }
            }
        }
        
        if ($valid) {
            $result = idn_to_utf8($result, IDNA_USE_STD3_RULES, INTL_IDNA_VARIANT_UTS46, $idna_info);
            if ($idna_info['errors'] !== 0) {
                $valid = false;
            }
        }
        
        return $valid;
    }
    
    /**
     * The host parser.
     * @see \esperecyan\url\lib\HostProcessing::domainToUnicode()
     * @see \esperecyan\url\lib\URL::isSpecial()
     * @link https://url.spec.whatwg.org/#concept-host-parser URL Standard
     * @param string $input A UTF-8 string.
     * @param bool $isSpecial
     * @return string|int|float|int[]
     *      If host is IPv4 address, returns a 32-bit unsigned integer (an integer or float).
     *      If host is IPv6 address, returns an array of a 16-bit unsigned integer.
     */
    public static function parseHost($input, $isSpecial)
    {
        $inputString = (string)$input;
        if ($inputString !== '' && $inputString[0] === '[') {
            $result = substr($inputString, -1) !== ']' ? false : self::parseIPv6(substr($inputString, 1, -1));
        } elseif (!$isSpecial) {
            $result = static::parseOpaqueHost($input);
        } else {
            $domain = Infrastructure::percentDecode($input);
            $asciiDomain = self::domainToASCII($domain);
            $result = $asciiDomain === false || preg_match(static::FORBIDDEN_HOST_CODE_POINTS, $asciiDomain) !== 0
                ? false
                : self::parseIPv4($asciiDomain);
        }
        return $result;
    }
    
    /**
     * The IPv4 number parser.
     * @link https://url.spec.whatwg.org/#ipv4-number-parser URL Standard
     * @param string $input A UTF-8 string.
     * @return int|float|false
     */
    public static function parseIPv4Number($input)
    {
        if ($input === '') {
            $number = 0;
        } elseif (preg_match('/^(?:(?<R16>0x[0-9A-F]*)|(?<R8>0[0-7]+)|(?<R10>0|[1-9][0-9]*))$/ui', $input, $matches) === 1) {
            if ($matches['R16'] !== '') {
                $number = hexdec($input);
            } elseif ($matches['R8'] !== '') {
                $number = octdec($input);
            } else {
                $number = (float)$input > PHP_INT_MAX ? (float)$input : (int)$input;
            }
        } else {
            $number = false;
        }
        return $number;
    }
    
    /**
     * The IPv4 parser.
     * @link https://url.spec.whatwg.org/#concept-ipv4-parser URL Standard
     * @param string $input A UTF-8 string.
     * @return int|float|string|false
     */
    public static function parseIPv4($input)
    {
        $parts = explode('.', $input);
        if ($parts[count($parts) - 1] === '') {
            array_pop($parts);
        }
        
        if ($parts === []) {
            $ipv4 = '';
        } elseif (count($parts) > 4) {
            $ipv4 = (string)$input;
        } else {
            $numbers = [];
            foreach ($parts as $i => $part) {
                if ($part === '') {
                    $ipv4 = (string)$input;
                    break;
                }
                $n = self::parseIPv4Number($part);
                if ($n === false) {
                    $ipv4 = (string)$input;
                    break;
                }
                if ($n > 255 && $i !== count($parts) - 1) {
                    $ipv4 = false;
                }
                $numbers[] = $n;
            }
            
            if (!isset($ipv4)) {
                $ipv4 = array_pop($numbers);
                if ($ipv4 >= pow(256, 4 - count($numbers))) {
                    $ipv4 = false;
                } else {
                    foreach ($numbers as $counter => $n) {
                        $ipv4 += $n * pow(256, 3 - $counter);
                    }
                }
            }
        }
        
        return $ipv4;
    }
    
    /**
     * The IPv6 parser.
     * @link https://url.spec.whatwg.org/#concept-ipv6-parser URL Standard
     * @param string $input A UTF-8 string.
     * @return int[] An array of a 16-bit unsigned integer.
     */
    public static function parseIPv6($input)
    {
        return filter_var($input, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)
            ? array_values(unpack('n*', inet_pton($input)))
            : false;
    }
    
    /**
     * The opaque-host parser.
     * @link https://url.spec.whatwg.org/#concept-opaque-host-parser URL Standard
     * @param string $input A UTF-8 string.
     * @return string|false
     */
    public static function parseOpaqueHost($input)
    {
        return preg_match(str_replace('%', '', static::FORBIDDEN_HOST_CODE_POINTS), $input) === 0
            ? Infrastructure::percentEncodeCodePoints(Infrastructure::C0_CONTROL_PERCENT_ENCODE_SET, $input)
            : false;
    }
    
    /**
     * The host serializer.
     * @link https://url.spec.whatwg.org/#concept-host-serializer URL Standard
     * @param string|int|float|int[] $host
     *      A domain, IPv4 address (an integer or float) or IPv6 address (an array of a 16-bit unsigned integer).
     * @return string
     */
    public static function serializeHost($host)
    {
        if (is_int($host) || is_float($host)) {
            $string = self::serializeIPv4($host);
        } elseif (is_array($host)) {
            $string = '[' . self::serializeIPv6($host) . ']';
        } else {
            $string = (string)$host;
        }
        return $string;
    }
    
    /**
     * The IPv4 serializer.
     * @link https://url.spec.whatwg.org/#concept-ipv4-serializer URL Standard
     * @param int|float $address An integer or float in the range 0 to 0xFFFFFFFF.
     * @return string
     */
    public static function serializeIPv4($address)
    {
        return long2ip($address);
    }
    
    /**
     * The IPv6 serializer.
     * @link https://url.spec.whatwg.org/#concept-ipv6-serializer URL Standard
     * @param int[] $address An array of a 16-bit unsigned integer.
     * @return string
     */
    public static function serializeIPv6($address)
    {
        $output = inet_ntop(call_user_func_array('pack', array_merge(['n*'], $address)));
        return strpos($output, '.') !== false
            ? '::ffff:' . strtolower(dechex($address[6]) . ':' . dechex($address[7]))
            : $output;
    }
}