Zend_Validate_Hostname Class Reference

Inheritance diagram for Zend_Validate_Hostname:

Public Member Functions
	__construct ($options=array())
	getOptions ()
	setOptions ($options)
	getIpValidator ()
	setIpValidator (Zend_Validate_Ip $ipValidator=null)
	getAllow ()
	setAllow ($allow)
	getValidateIdn ()
	setValidateIdn ($allowed)
	getValidateTld ()
	setValidateTld ($allowed)
	isValid ($value)
Public Member Functions inherited from Zend_Validate_Abstract
	getMessages ()
	getMessageVariables ()
	getMessageTemplates ()
	setMessage ($messageString, $messageKey=null)
	setMessages (array $messages)
	__get ($property)
	getErrors ()
	setObscureValue ($flag)
	getObscureValue ()
	setTranslator ($translator=null)
	getTranslator ()
	hasTranslator ()
	setDisableTranslator ($flag)
	translatorIsDisabled ()

Data Fields
const	CANNOT_DECODE_PUNYCODE = 'hostnameCannotDecodePunycode'
const	INVALID = 'hostnameInvalid'
const	INVALID_DASH = 'hostnameDashCharacter'
const	INVALID_HOSTNAME = 'hostnameInvalidHostname'
const	INVALID_HOSTNAME_SCHEMA = 'hostnameInvalidHostnameSchema'
const	INVALID_LOCAL_NAME = 'hostnameInvalidLocalName'
const	INVALID_URI = 'hostnameInvalidUri'
const	IP_ADDRESS_NOT_ALLOWED = 'hostnameIpAddressNotAllowed'
const	LOCAL_NAME_NOT_ALLOWED = 'hostnameLocalNameNotAllowed'
const	UNDECIPHERABLE_TLD = 'hostnameUndecipherableTld'
const	UNKNOWN_TLD = 'hostnameUnknownTld'
const	ALLOW_DNS = 1
const	ALLOW_IP = 2
const	ALLOW_LOCAL = 4
const	ALLOW_URI = 8
const	ALLOW_ALL = 15

Protected Member Functions
	decodePunycode ($encoded)
Protected Member Functions inherited from Zend_Validate_Abstract
	_createMessage ($messageKey, $value)
	_implodeRecursive (array $pieces)
	_error ($messageKey, $value=null)
	_setValue ($value)

Protected Attributes
	$_messageTemplates
	$_messageVariables
	$_validTlds
	$_tld
	$_validIdns
	$_idnLength
	$_options
Protected Attributes inherited from Zend_Validate_Abstract
	$_value
	$_messageVariables = array()
	$_messageTemplates = array()
	$_messages = array()
	$_obscureValue = false
	$_errors = array()
	$_translator
	$_translatorDisabled = false

Additional Inherited Members
Static Public Member Functions inherited from Zend_Validate_Abstract
static	setDefaultTranslator ($translator=null)
static	getDefaultTranslator ()
static	hasDefaultTranslator ()
static	getMessageLength ()
static	setMessageLength ($length=-1)
Static Protected Attributes inherited from Zend_Validate_Abstract
static	$_defaultTranslator
static	$_messageLength = -1

Detailed Description

Definition at line 47 of file Hostname.php.

Constructor & Destructor Documentation

__construct()

__construct

(

$options = array()

)

Sets validator options

See also

http://www.iana.org/cctld/specifications-policies-cctlds-01apr02.htm Technical Specifications for ccTLDs

Parameters

array

$options

Validator options

Definition at line 1520 of file Hostname.php.

    {
        if ($options instanceof Zend_Config) {
            $options = $options->toArray();
        } else if (!is_array($options)) {
            $options = func_get_args();
            $temp['allow'] = array_shift($options);
            if (!empty($options)) {
                $temp['idn'] = array_shift($options);
            }

            if (!empty($options)) {
                $temp['tld'] = array_shift($options);
            }

            if (!empty($options)) {
                $temp['ip'] = array_shift($options);
            }

            $options = $temp;
        }

        $options += $this->_options;
        $this->setOptions($options);
    }

Member Function Documentation

decodePunycode()

decodePunycode (   $encoded )

protected

Decodes a punycode encoded string to it's original utf8 string In case of a decoding failure the original string is returned

Parameters

string

$encoded

Punycode encoded string to decode

Returns

string

Definition at line 1903 of file Hostname.php.

    {
        if (!preg_match('/^[a-z0-9-]+$/i', $encoded)) {
            // no punycode encoded string
            $this->_error(self::CANNOT_DECODE_PUNYCODE);
            return false;
        }

        $decoded = array();
        $separator = strrpos($encoded, '-');
        if ($separator > 0) {
            for ($x = 0; $x < $separator; ++$x) {
                // prepare decoding matrix
                $decoded[] = ord($encoded[$x]);
            }
        }

        $lengthd = count($decoded);
        $lengthe = strlen($encoded);

        // decoding
        $init  = true;
        $base  = 72;
        $index = 0;
        $char  = 0x80;

        for ($indexe = ($separator) ? ($separator + 1) : 0; $indexe < $lengthe; ++$lengthd) {
            for ($old_index = $index, $pos = 1, $key = 36; 1 ; $key += 36) {
                $hex   = ord($encoded[$indexe++]);
                $digit = ($hex - 48 < 10) ? $hex - 22
                    : (($hex - 65 < 26) ? $hex - 65
                        : (($hex - 97 < 26) ? $hex - 97
                            : 36));

                $index += $digit * $pos;
                $tag    = ($key <= $base) ? 1 : (($key >= $base + 26) ? 26 : ($key - $base));
                if ($digit < $tag) {
                    break;
                }

                $pos = (int) ($pos * (36 - $tag));
            }

            $delta   = intval($init ? (($index - $old_index) / 700) : (($index - $old_index) / 2));
            $delta  += intval($delta / ($lengthd + 1));
            for ($key = 0; $delta > 910 / 2; $key += 36) {
                $delta = intval($delta / 35);
            }

            $base   = intval($key + 36 * $delta / ($delta + 38));
            $init   = false;
            $char  += (int) ($index / ($lengthd + 1));
            $index %= ($lengthd + 1);
            if ($lengthd > 0) {
                for ($i = $lengthd; $i > $index; $i--) {
                    $decoded[$i] = $decoded[($i - 1)];
                }
            }

            $decoded[$index++] = $char;
        }

        // convert decoded ucs4 to utf8 string
        foreach ($decoded as $key => $value) {
            if ($value < 128) {
                $decoded[$key] = chr($value);
            } elseif ($value < (1 << 11)) {
                $decoded[$key]  = chr(192 + ($value >> 6));
                $decoded[$key] .= chr(128 + ($value & 63));
            } elseif ($value < (1 << 16)) {
                $decoded[$key]  = chr(224 + ($value >> 12));
                $decoded[$key] .= chr(128 + (($value >> 6) & 63));
                $decoded[$key] .= chr(128 + ($value & 63));
            } elseif ($value < (1 << 21)) {
                $decoded[$key]  = chr(240 + ($value >> 18));
                $decoded[$key] .= chr(128 + (($value >> 12) & 63));
                $decoded[$key] .= chr(128 + (($value >> 6) & 63));
                $decoded[$key] .= chr(128 + ($value & 63));
            } else {
                $this->_error(self::CANNOT_DECODE_PUNYCODE);
                return false;
            }
        }

        return implode($decoded);
    }

getAllow()

getAllow

(

)

Returns the allow option

Returns

integer

Definition at line 1612 of file Hostname.php.

    {
        return $this->_options['allow'];
    }

getIpValidator()

getIpValidator

(

)

Returns the set ip validator

Returns

Zend_Validate_Ip

Definition at line 1588 of file Hostname.php.

    {
        return $this->_options['ip'];
    }

getOptions()

getOptions

(

)

Returns all set options

Returns

array

Definition at line 1551 of file Hostname.php.

    {
        return $this->_options;
    }

getValidateIdn()

getValidateIdn

(

)

Returns the set idn option

Returns

boolean

Definition at line 1634 of file Hostname.php.

    {
        return $this->_options['idn'];
    }

getValidateTld()

getValidateTld

(

)

Returns the set tld option

Returns

boolean

Definition at line 1658 of file Hostname.php.

    {
        return $this->_options['tld'];
    }

isValid()

isValid

(

$value

)

Defined by Zend_Validate_Interface

Returns true if and only if the $value is a valid hostname with respect to the current allow option

Parameters

string

$value

Exceptions

Zend_Validate_Exception

if a fatal error occurs for validation process

Returns

boolean

Match against IDN hostnames Note: Keep label regex short to avoid issues with long patterns when matching IDN hostnames

See also

Zend_Validate_Hostname_Interface

Implements Zend_Validate_Interface.

Definition at line 1686 of file Hostname.php.

    {
        if (!is_string($value)) {
            $this->_error(self::INVALID);
            return false;
        }

        $this->_setValue($value);
        // Check input against IP address schema
        if (preg_match('/^[0-9a-f:.]*$/i', $value) &&
            $this->_options['ip']->setTranslator($this->getTranslator())->isValid($value)) {
            if (!($this->_options['allow'] & self::ALLOW_IP)) {
                $this->_error(self::IP_ADDRESS_NOT_ALLOWED);
                return false;
            } else {
                return true;
            }
        }

        // RFC3986 3.2.2 states:
        //
        //     The rightmost domain label of a fully qualified domain name
        //     in DNS may be followed by a single "." and should be if it is
        //     necessary to distinguish between the complete domain name and
        //     some local domain.
        //
        // (see ZF-6363)

        // Local hostnames are allowed to be partitial (ending '.')
        if ($this->_options['allow'] & self::ALLOW_LOCAL) {
            if (substr($value, -1) === '.') {
                $value = substr($value, 0, -1);
                if (substr($value, -1) === '.') {
                    // Empty hostnames (ending '..') are not allowed
                    $this->_error(self::INVALID_LOCAL_NAME);
                    return false;
                }
            }
        }

        $domainParts = explode('.', $value);

        // Prevent partitial IP V4 adresses (ending '.')
        if ((count($domainParts) == 4) && preg_match('/^[0-9.a-e:.]*$/i', $value) &&
            $this->_options['ip']->setTranslator($this->getTranslator())->isValid($value)) {
            $this->_error(self::INVALID_LOCAL_NAME);
        }

        // Check input against DNS hostname schema
        if ((count($domainParts) > 1) && (strlen($value) >= 4) && (strlen($value) <= 254)) {
            $status = false;

            $origenc = PHP_VERSION_ID < 50600
                ? iconv_get_encoding('internal_encoding')
                : ini_get('default_charset');
            if (PHP_VERSION_ID < 50600) {
                iconv_set_encoding('internal_encoding', 'UTF-8');
            } else {
                ini_set('default_charset', 'UTF-8');
            }
            do {
                // First check TLD
                $matches = array();
                if (preg_match('/([^.]{2,63})$/iu', end($domainParts), $matches)
                    || (array_key_exists(end($domainParts), $this->_validIdns))) {
                    reset($domainParts);

                    // Hostname characters are: *(label dot)(label dot label); max 254 chars
                    // label: id-prefix [*ldh{61} id-prefix]; max 63 chars
                    // id-prefix: alpha / digit
                    // ldh: alpha / digit / dash

                    // Match TLD against known list
                    $this->_tld = $matches[1];
                    if ($this->_options['tld']) {
                        if (!in_array(strtolower($this->_tld), $this->_validTlds)
                            && !in_array($this->_tld, $this->_validTlds)) {
                            $this->_error(self::UNKNOWN_TLD);
                            $status = false;
                            break;
                        }
                        // We have already validated that the TLD is fine. We don't want it to go through the below
                        // checks as new UTF-8 TLDs will incorrectly fail if there is no IDN regex for it.
                        array_pop($domainParts);
                    }

                    $regexChars = array(0 => '/^[a-z0-9\x2d]{1,63}$/i');
                    if ($this->_options['idn'] &&  isset($this->_validIdns[strtoupper($this->_tld)])) {
                        if (is_string($this->_validIdns[strtoupper($this->_tld)])) {
                            $regexChars += include($this->_validIdns[strtoupper($this->_tld)]);
                        } else {
                            $regexChars += $this->_validIdns[strtoupper($this->_tld)];
                        }
                    }

                    // Check each hostname part
                    $check = 0;
                    foreach ($domainParts as $domainPart) {
                        // If some domain part is empty (i.e. zend..com), it's invalid
                        if (empty($domainPart) && $domainPart !== '0') {
                            $this->_error(self::INVALID_HOSTNAME);
                            return false;
                        }

                        // Decode Punycode domainnames to IDN
                        if (strpos($domainPart, 'xn--') === 0) {
                            $domainPart = $this->decodePunycode(substr($domainPart, 4));
                            if ($domainPart === false) {
                                return false;
                            }
                        }

                        // Check dash (-) does not start, end or appear in 3rd and 4th positions
                        if ((strpos($domainPart, '-') === 0)
                            || ((strlen($domainPart) > 2) && (strpos($domainPart, '-', 2) == 2) && (strpos($domainPart, '-', 3) == 3))
                            || (strpos($domainPart, '-') === (strlen($domainPart) - 1))) {
                            $this->_error(self::INVALID_DASH);
                            $status = false;
                            break 2;
                        }

                        // Check each domain part
                        $checked = false;
                        foreach($regexChars as $regexKey => $regexChar) {
                            $status = preg_match($regexChar, $domainPart);
                            if ($status > 0) {
                                $length = 63;
                                if (array_key_exists(strtoupper($this->_tld), $this->_idnLength)
                                    && (array_key_exists($regexKey, $this->_idnLength[strtoupper($this->_tld)]))) {
                                    $length = $this->_idnLength[strtoupper($this->_tld)];
                                }

                                if (iconv_strlen($domainPart, 'UTF-8') > $length) {
                                    $this->_error(self::INVALID_HOSTNAME);
                                } else {
                                    $checked = true;
                                    break;
                                }
                            }
                        }

                        if ($checked) {
                            ++$check;
                        }
                    }

                    // If one of the labels doesn't match, the hostname is invalid
                    if ($check !== count($domainParts)) {
                        $this->_error(self::INVALID_HOSTNAME_SCHEMA);
                        $status = false;
                    }
                } else {
                    // Hostname not long enough
                    $this->_error(self::UNDECIPHERABLE_TLD);
                    $status = false;
                }
            } while (false);

            if (PHP_VERSION_ID < 50600) {
                iconv_set_encoding('internal_encoding', $origenc);
            } else {
                ini_set('default_charset', $origenc);
            }
            // If the input passes as an Internet domain name, and domain names are allowed, then the hostname
            // passes validation
            if ($status && ($this->_options['allow'] & self::ALLOW_DNS)) {
                return true;
            }
        } else if ($this->_options['allow'] & self::ALLOW_DNS) {
            $this->_error(self::INVALID_HOSTNAME);
        }

        // Check for URI Syntax (RFC3986)
        if ($this->_options['allow'] & self::ALLOW_URI) {
            if (preg_match("/^([a-zA-Z0-9-._~!$&\'()*+,;=]|%[[:xdigit:]]{2}){1,254}$/i", $value)) {
                return true;
            } else {
                $this->_error(self::INVALID_URI);
            }
        }

        // Check input against local network name schema; last chance to pass validation
        $regexLocal = '/^(([a-zA-Z0-9\x2d]{1,63}\x2e)*[a-zA-Z0-9\x2d]{1,63}[\x2e]{0,1}){1,254}$/';
        $status = @preg_match($regexLocal, $value);

        // If the input passes as a local network name, and local network names are allowed, then the
        // hostname passes validation
        $allowLocal = $this->_options['allow'] & self::ALLOW_LOCAL;
        if ($status && $allowLocal) {
            return true;
        }

        // If the input does not pass as a local network name, add a message
        if (!$status) {
            $this->_error(self::INVALID_LOCAL_NAME);
        }

        // If local network names are not allowed, add a message
        if ($status && !$allowLocal) {
            $this->_error(self::LOCAL_NAME_NOT_ALLOWED);
        }

        return false;
    }

setAllow()

setAllow

(

$allow

)

Sets the allow option

Parameters

integer

$allow

Returns

Zend_Validate_Hostname Provides a fluent interface

Definition at line 1623 of file Hostname.php.

    {
        $this->_options['allow'] = $allow;
        return $this;
    }

setIpValidator()

setIpValidator

(

Zend_Validate_Ip

$ipValidator = null

)

Parameters

Zend_Validate_Ip

$ipValidator

OPTIONAL

Returns

Zend_Validate_Hostname

Definition at line 1597 of file Hostname.php.

    {
        if ($ipValidator === null) {
            $ipValidator = new Zend_Validate_Ip();
        }

        $this->_options['ip'] = $ipValidator;
        return $this;
    }

setOptions()

setOptions

(

$options

)

Sets the options for this validator

Parameters

array

$options

Returns

Zend_Validate_Hostname

Definition at line 1562 of file Hostname.php.

    {
        if (array_key_exists('allow', $options)) {
            $this->setAllow($options['allow']);
        }

        if (array_key_exists('idn', $options)) {
            $this->setValidateIdn($options['idn']);
        }

        if (array_key_exists('tld', $options)) {
            $this->setValidateTld($options['tld']);
        }

        if (array_key_exists('ip', $options)) {
            $this->setIpValidator($options['ip']);
        }

        return $this;
    }

setValidateIdn()

setValidateIdn

(

$allowed

)

Set whether IDN domains are validated

This only applies when DNS hostnames are validated

Parameters

boolean

$allowed

Set allowed to true to validate IDNs, and false to not validate them

Returns

$this

Definition at line 1647 of file Hostname.php.

    {
        $this->_options['idn'] = (bool) $allowed;
        return $this;
    }

setValidateTld()

setValidateTld

(

$allowed

)

Set whether the TLD element of a hostname is validated

This only applies when DNS hostnames are validated

Parameters

boolean

$allowed

Set allowed to true to validate TLDs, and false to not validate them

Returns

$this

Definition at line 1671 of file Hostname.php.

    {
        $this->_options['tld'] = (bool) $allowed;
        return $this;
    }

Field Documentation

$_idnLength

$_idnLength

protected

Initial value:

= array(
        'BIZ' => array(5 => 17, 11 => 15, 12 => 20),
        'CN'  => array(1 => 20),
        'COM' => array(3 => 17, 5 => 20),
        'HK'  => array(1 => 15),
        'INFO'=> array(4 => 17),
        'KR'  => array(1 => 17),
        'NET' => array(3 => 17, 5 => 20),
        'ORG' => array(6 => 17),
        'TW'  => array(1 => 20),
        'ایران' => array(1 => 30),
        '中国' => array(1 => 20),
        '公司' => array(1 => 20),
        '网络' => array(1 => 20),
    )

Definition at line 1491 of file Hostname.php.

$_messageTemplates

$_messageTemplates

protected

Initial value:

= array(
        self::CANNOT_DECODE_PUNYCODE  => "'%value%' appears to be a DNS hostname but the given punycode notation cannot be decoded",
        self::INVALID                 => "Invalid type given. String expected",
        self::INVALID_DASH            => "'%value%' appears to be a DNS hostname but contains a dash in an invalid position",
        self::INVALID_HOSTNAME        => "'%value%' does not match the expected structure for a DNS hostname",
        self::INVALID_HOSTNAME_SCHEMA => "'%value%' appears to be a DNS hostname but cannot match against hostname schema for TLD '%tld%'",
        self::INVALID_LOCAL_NAME      => "'%value%' does not appear to be a valid local network name",
        self::INVALID_URI             => "'%value%' does not appear to be a valid URI hostname",
        self::IP_ADDRESS_NOT_ALLOWED  => "'%value%' appears to be an IP address, but IP addresses are not allowed",
        self::LOCAL_NAME_NOT_ALLOWED  => "'%value%' appears to be a local network name but local network names are not allowed",
        self::UNDECIPHERABLE_TLD      => "'%value%' appears to be a DNS hostname but cannot extract TLD part",
        self::UNKNOWN_TLD             => "'%value%' appears to be a DNS hostname but cannot match TLD against known list",
    )

Definition at line 64 of file Hostname.php.

$_messageVariables

$_messageVariables

protected

Initial value:

= array(
        'tld' => '_tld'
    )

Definition at line 81 of file Hostname.php.

$_options

$_options

protected

Initial value:

= array(
        'allow' => self::ALLOW_DNS,
        'idn'   => true,
        'tld'   => true,
        'ip'    => null
    )

Definition at line 1507 of file Hostname.php.

$_tld

$_tld

protected

Definition at line 1305 of file Hostname.php.

$_validIdns

$_validIdns

protected

Definition at line 1360 of file Hostname.php.

$_validTlds

$_validTlds

protected

Definition at line 119 of file Hostname.php.

ALLOW_ALL

const ALLOW_ALL = 15

Allows all types of hostnames

Definition at line 108 of file Hostname.php.

ALLOW_DNS

const ALLOW_DNS = 1

Allows Internet domain names (e.g., example.com)

Definition at line 88 of file Hostname.php.

ALLOW_IP

const ALLOW_IP = 2

Allows IP addresses

Definition at line 93 of file Hostname.php.

ALLOW_LOCAL

const ALLOW_LOCAL = 4

Allows local network names (e.g., localhost, www.localdomain)

Definition at line 98 of file Hostname.php.

ALLOW_URI

const ALLOW_URI = 8

Allows all types of hostnames

Definition at line 103 of file Hostname.php.

CANNOT_DECODE_PUNYCODE

const CANNOT_DECODE_PUNYCODE = 'hostnameCannotDecodePunycode'

Definition at line 49 of file Hostname.php.

INVALID

const INVALID = 'hostnameInvalid'

Definition at line 50 of file Hostname.php.

INVALID_DASH

const INVALID_DASH = 'hostnameDashCharacter'

Definition at line 51 of file Hostname.php.

INVALID_HOSTNAME

const INVALID_HOSTNAME = 'hostnameInvalidHostname'

Definition at line 52 of file Hostname.php.

INVALID_HOSTNAME_SCHEMA

const INVALID_HOSTNAME_SCHEMA = 'hostnameInvalidHostnameSchema'

Definition at line 53 of file Hostname.php.

INVALID_LOCAL_NAME

const INVALID_LOCAL_NAME = 'hostnameInvalidLocalName'

Definition at line 54 of file Hostname.php.

INVALID_URI

const INVALID_URI = 'hostnameInvalidUri'

Definition at line 55 of file Hostname.php.

IP_ADDRESS_NOT_ALLOWED

const IP_ADDRESS_NOT_ALLOWED = 'hostnameIpAddressNotAllowed'

Definition at line 56 of file Hostname.php.

LOCAL_NAME_NOT_ALLOWED

const LOCAL_NAME_NOT_ALLOWED = 'hostnameLocalNameNotAllowed'

Definition at line 57 of file Hostname.php.

UNDECIPHERABLE_TLD

const UNDECIPHERABLE_TLD = 'hostnameUndecipherableTld'

Definition at line 58 of file Hostname.php.

UNKNOWN_TLD

const UNKNOWN_TLD = 'hostnameUnknownTld'

Definition at line 59 of file Hostname.php.

---

The documentation for this class was generated from the following file:

• vendor/magento/zendframework1/library/Zend/Validate/Hostname.php