BenoitCier
/
Opendistrib
派生自 Laclic/Souke
关注 1
点赞 0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
350 提交
2 分支
目录树: 9590a8337f
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 '9590a8337f'
${ noResults }
Opendistrib/vendor/yiisoft/yii2/validators/IpValidator.php

623 行
21KB
原始文件 Blame 文件历史 

  1. <?php

  2. /**

  3.  * @link http://www.yiiframework.com/

  4.  * @copyright Copyright (c) 2008 Yii Software LLC

  5.  * @license http://www.yiiframework.com/license/

  6.  */

  7. 

  8. namespace yii\validators;

  9. 

  10. use Yii;

  11. use yii\base\InvalidConfigException;

  12. use yii\helpers\Html;

  13. use yii\helpers\Json;

  14. use yii\web\JsExpression;

  15. 

  16. /**

  17.  * The validator checks if the attribute value is a valid IPv4/IPv6 address or subnet.

  18.  *

  19.  * It also may change attribute's value if normalization of IPv6 expansion is enabled.

  20.  *

  21.  * The following are examples of validation rules using this validator:

  22.  *

  23.  * ```php

  24.  * ['ip_address', 'ip'], // IPv4 or IPv6 address

  25.  * ['ip_address', 'ip', 'ipv6' => false], // IPv4 address (IPv6 is disabled)

  26.  * ['ip_address', 'ip', 'subnet' => true], // requires a CIDR prefix (like 10.0.0.1/24) for the IP address

  27.  * ['ip_address', 'ip', 'subnet' => null], // CIDR prefix is optional

  28.  * ['ip_address', 'ip', 'subnet' => null, 'normalize' => true], // CIDR prefix is optional and will be added when missing

  29.  * ['ip_address', 'ip', 'ranges' => ['192.168.0.0/24']], // only IP addresses from the specified subnet are allowed

  30.  * ['ip_address', 'ip', 'ranges' => ['!192.168.0.0/24', 'any']], // any IP is allowed except IP in the specified subnet

  31.  * ['ip_address', 'ip', 'expandIPv6' => true], // expands IPv6 address to a full notation format

  32.  * ```

  33.  *

  34.  * @property array $ranges The IPv4 or IPv6 ranges that are allowed or forbidden. See [[setRanges()]] for

  35.  * detailed description.

  36.  *

  37.  * @author Dmitry Naumenko <d.naumenko.a@gmail.com>

  38.  * @since 2.0.7

  39.  */

  40. class IpValidator extends Validator

  41. {

  42.     /**

  43.      * The length of IPv6 address in bits

  44.      */

  45.     const IPV6_ADDRESS_LENGTH = 128;

  46.     /**

  47.      * The length of IPv4 address in bits

  48.      */

  49.     const IPV4_ADDRESS_LENGTH = 32;

  50.     /**

  51.      * Negation char. Used to negate [[ranges]] or [[networks]]

  52.      * or to negate validating value when [[negation]] is set to `true`

  53.      * @see negation

  54.      * @see networks

  55.      * @see ranges

  56.      */

  57.     const NEGATION_CHAR = '!';

  58. 

  59.     /**

  60.      * @var array The network aliases, that can be used in [[ranges]].

  61.      *  - key - alias name

  62.      *  - value - array of strings. String can be an IP range, IP address or another alias. String can be

  63.      *    negated with [[NEGATION_CHAR]] (independent of `negation` option).

  64.      *

  65.      * The following aliases are defined by default:

  66.      *  - `*`: `any`

  67.      *  - `any`: `0.0.0.0/0, ::/0`

  68.      *  - `private`: `10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fd00::/8`

  69.      *  - `multicast`: `224.0.0.0/4, ff00::/8`

  70.      *  - `linklocal`: `169.254.0.0/16, fe80::/10`

  71.      *  - `localhost`: `127.0.0.0/8', ::1`

  72.      *  - `documentation`: `192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24, 2001:db8::/32`

  73.      *  - `system`: `multicast, linklocal, localhost, documentation`

  74.      *

  75.      */

  76.     public $networks = [

  77.         '*' => ['any'],

  78.         'any' => ['0.0.0.0/0', '::/0'],

  79.         'private' => ['10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16', 'fd00::/8'],

  80.         'multicast' => ['224.0.0.0/4', 'ff00::/8'],

  81.         'linklocal' => ['169.254.0.0/16', 'fe80::/10'],

  82.         'localhost' => ['127.0.0.0/8', '::1'],

  83.         'documentation' => ['192.0.2.0/24', '198.51.100.0/24', '203.0.113.0/24', '2001:db8::/32'],

  84.         'system' => ['multicast', 'linklocal', 'localhost', 'documentation'],

  85.     ];

  86.     /**

  87.      * @var boolean whether the validating value can be an IPv6 address. Defaults to `true`.

  88.      */

  89.     public $ipv6 = true;

  90.     /**

  91.      * @var boolean whether the validating value can be an IPv4 address. Defaults to `true`.

  92.      */

  93.     public $ipv4 = true;

  94.     /**

  95.      * @var boolean whether the address can be an IP with CIDR subnet, like `192.168.10.0/24`.

  96.      * The following values are possible:

  97.      *

  98.      * - `false` - the address must not have a subnet (default).

  99.      * - `true` - specifying a subnet is required.

  100.      * - `null` - specifying a subnet is optional.

  101.      */

  102.     public $subnet = false;

  103.     /**

  104.      * @var boolean whether to add the CIDR prefix with the smallest length (32 for IPv4 and 128 for IPv6) to an

  105.      * address without it. Works only when `subnet` is not `false`. For example:

  106.      *  - `10.0.1.5` will normalized to `10.0.1.5/32`

  107.      *  - `2008:db0::1` will be normalized to `2008:db0::1/128`

  108.      *    Defaults to `false`.

  109.      * @see subnet

  110.      */

  111.     public $normalize = false;

  112.     /**

  113.      * @var boolean whether address may have a [[NEGATION_CHAR]] character at the beginning.

  114.      * Defaults to `false`.

  115.      */

  116.     public $negation = false;

  117.     /**

  118.      * @var boolean whether to expand an IPv6 address to the full notation format.

  119.      * Defaults to `false`.

  120.      */

  121.     public $expandIPv6 = false;

  122.     /**

  123.      * @var string Regexp-pattern to validate IPv4 address

  124.      */

  125.     public $ipv4Pattern = '/^(?:(?:2(?:[0-4][0-9]|5[0-5])|[0-1]?[0-9]?[0-9])\.){3}(?:(?:2([0-4][0-9]|5[0-5])|[0-1]?[0-9]?[0-9]))$/';

  126.     /**

  127.      * @var string Regexp-pattern to validate IPv6 address

  128.      */

  129.     public $ipv6Pattern = '/^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/';

  130.     /**

  131.      * @var string user-defined error message is used when validation fails due to the wrong IP address format.

  132.      *

  133.      * You may use the following placeholders in the message:

  134.      *

  135.      * - `{attribute}`: the label of the attribute being validated

  136.      * - `{value}`: the value of the attribute being validated

  137.      */

  138.     public $message;

  139.     /**

  140.      * @var string user-defined error message is used when validation fails due to the disabled IPv6 validation.

  141.      *

  142.      * You may use the following placeholders in the message:

  143.      *

  144.      * - `{attribute}`: the label of the attribute being validated

  145.      * - `{value}`: the value of the attribute being validated

  146.      *

  147.      * @see ipv6

  148.      */

  149.     public $ipv6NotAllowed;

  150.     /**

  151.      * @var string user-defined error message is used when validation fails due to the disabled IPv4 validation.

  152.      *

  153.      * You may use the following placeholders in the message:

  154.      *

  155.      * - `{attribute}`: the label of the attribute being validated

  156.      * - `{value}`: the value of the attribute being validated

  157.      *

  158.      * @see ipv4

  159.      */

  160.     public $ipv4NotAllowed;

  161.     /**

  162.      * @var string user-defined error message is used when validation fails due to the wrong CIDR.

  163.      *

  164.      * You may use the following placeholders in the message:

  165.      *

  166.      * - `{attribute}`: the label of the attribute being validated

  167.      * - `{value}`: the value of the attribute being validated

  168.      * @see subnet

  169.      */

  170.     public $wrongCidr;

  171.     /**

  172.      * @var string user-defined error message is used when validation fails due to subnet [[subnet]] set to 'only',

  173.      * but the CIDR prefix is not set.

  174.      *

  175.      * You may use the following placeholders in the message:

  176.      *

  177.      * - `{attribute}`: the label of the attribute being validated

  178.      * - `{value}`: the value of the attribute being validated

  179.      *

  180.      * @see subnet

  181.      */

  182.     public $noSubnet;

  183.     /**

  184.      * @var string user-defined error message is used when validation fails

  185.      * due to [[subnet]] is false, but CIDR prefix is present.

  186.      *

  187.      * You may use the following placeholders in the message:

  188.      *

  189.      * - `{attribute}`: the label of the attribute being validated

  190.      * - `{value}`: the value of the attribute being validated

  191.      *

  192.      * @see subnet

  193.      */

  194.     public $hasSubnet;

  195.     /**

  196.      * @var string user-defined error message is used when validation fails due to IP address

  197.      * is not not allowed by [[ranges]] check.

  198.      *

  199.      * You may use the following placeholders in the message:

  200.      *

  201.      * - `{attribute}`: the label of the attribute being validated

  202.      * - `{value}`: the value of the attribute being validated

  203.      *

  204.      * @see ranges

  205.      */

  206.     public $notInRange;

  207. 

  208.     /**

  209.      * @var array

  210.      */

  211.     private $_ranges = [];

  212. 

  213. 

  214.     /**

  215.      * @inheritdoc

  216.      */

  217.     public function init()

  218.     {

  219.         parent::init();

  220. 

  221.         if (!$this->ipv4 && !$this->ipv6) {

  222.             throw new InvalidConfigException('Both IPv4 and IPv6 checks can not be disabled at the same time');

  223.         }

  224. 

  225.         if (!defined('AF_INET6') && $this->ipv6) {

  226.             throw new InvalidConfigException('IPv6 validation can not be used. PHP is compiled without IPv6');

  227.         }

  228. 

  229.         if ($this->message === null) {

  230.             $this->message = Yii::t('yii', '{attribute} must be a valid IP address.');

  231.         }

  232.         if ($this->ipv6NotAllowed === null) {

  233.             $this->ipv6NotAllowed = Yii::t('yii', '{attribute} must not be an IPv6 address.');

  234.         }

  235.         if ($this->ipv4NotAllowed === null) {

  236.             $this->ipv4NotAllowed = Yii::t('yii', '{attribute} must not be an IPv4 address.');

  237.         }

  238.         if ($this->wrongCidr === null) {

  239.             $this->wrongCidr = Yii::t('yii', '{attribute} contains wrong subnet mask.');

  240.         }

  241.         if ($this->noSubnet === null) {

  242.             $this->noSubnet = Yii::t('yii', '{attribute} must be an IP address with specified subnet.');

  243.         }

  244.         if ($this->hasSubnet === null) {

  245.             $this->hasSubnet = Yii::t('yii', '{attribute} must not be a subnet.');

  246.         }

  247.         if ($this->notInRange === null) {

  248.             $this->notInRange = Yii::t('yii', '{attribute} is not in the allowed range.');

  249.         }

  250.     }

  251. 

  252.     /**

  253.      * Set the IPv4 or IPv6 ranges that are allowed or forbidden.

  254.      *

  255.      * The following preparation tasks are performed:

  256.      *

  257.      * - Recursively substitutes aliases (described in [[networks]]) with their values.

  258.      * - Removes duplicates

  259.      *

  260.      * @property array the IPv4 or IPv6 ranges that are allowed or forbidden.

  261.      * See [[setRanges()]] for detailed description.

  262.      * @param array $ranges the IPv4 or IPv6 ranges that are allowed or forbidden.

  263.      *

  264.      * When the array is empty, or the option not set, all IP addresses are allowed.

  265.      *

  266.      * Otherwise, the rules are checked sequentially until the first match is found.

  267.      * An IP address is forbidden, when it has not matched any of the rules.

  268.      *

  269.      * Example:

  270.      *

  271.      * ```php

  272.      * [

  273.      *      'ranges' => [

  274.      *          '192.168.10.128'

  275.      *          '!192.168.10.0/24',

  276.      *          'any' // allows any other IP addresses

  277.      *      ]

  278.      * ]

  279.      * ```

  280.      *

  281.      * In this example, access is allowed for all the IPv4 and IPv6 addresses excluding the `192.168.10.0/24` subnet.

  282.      * IPv4 address `192.168.10.128` is also allowed, because it is listed before the restriction.

  283.      */

  284.     public function setRanges($ranges)

  285.     {

  286.         $this->_ranges = $this->prepareRanges((array) $ranges);

  287.     }

  288. 

  289.     /**

  290.      * @return array The IPv4 or IPv6 ranges that are allowed or forbidden.

  291.      */

  292.     public function getRanges()

  293.     {

  294.         return $this->_ranges;

  295.     }

  296. 

  297.     /**

  298.      * @inheritdoc

  299.      */

  300.     protected function validateValue($value)

  301.     {

  302.         $result = $this->validateSubnet($value);

  303.         if (is_array($result)) {

  304.             $result[1] = array_merge(['ip' => is_array($value) ? 'array()' : $value], $result[1]);

  305.             return $result;

  306.         } else {

  307.             return null;

  308.         }

  309.     }

  310. 

  311.     /**

  312.      * @inheritdoc

  313.      */

  314.     public function validateAttribute($model, $attribute)

  315.     {

  316.         $value = $model->$attribute;

  317. 

  318.         $result = $this->validateSubnet($value);

  319.         if (is_array($result)) {

  320.             $result[1] = array_merge(['ip' => is_array($value) ? 'array()' : $value], $result[1]);

  321.             $this->addError($model, $attribute, $result[0], $result[1]);

  322.         } else {

  323.             $model->$attribute = $result;

  324.         }

  325.     }

  326. 

  327.     /**

  328.      * Validates an IPv4/IPv6 address or subnet

  329.      *

  330.      * @param $ip string

  331.      * @return string|array

  332.      * string - the validation was successful;

  333.      * array  - an error occurred during the validation.

  334.      * Array[0] contains the text of an error, array[1] contains values for the placeholders in the error message

  335.      */

  336.     private function validateSubnet($ip)

  337.     {

  338.         if (!is_string($ip)) {

  339.             return [$this->message, []];

  340.         }

  341. 

  342.         $negation = null;

  343.         $cidr = null;

  344.         $isCidrDefault = false;

  345. 

  346.         if (preg_match($this->getIpParsePattern(), $ip, $matches)) {

  347.             $negation = ($matches[1] !== '') ? $matches[1] : null;

  348.             $ip = $matches[2];

  349.             $cidr = isset($matches[4]) ? $matches[4] : null;

  350.         }

  351. 

  352.         if ($this->subnet === true && $cidr === null) {

  353.             return [$this->noSubnet, []];

  354.         }

  355.         if ($this->subnet === false && $cidr !== null) {

  356.             return [$this->hasSubnet, []];

  357.         }

  358.         if ($this->negation === false && $negation !== null) {

  359.             return [$this->message, []];

  360.         }

  361. 

  362.         if ($this->getIpVersion($ip) == 6) {

  363.             if ($cidr !== null) {

  364.                 if ($cidr > static::IPV6_ADDRESS_LENGTH || $cidr < 0) {

  365.                     return [$this->wrongCidr, []];

  366.                 }

  367.             } else {

  368.                 $isCidrDefault = true;

  369.                 $cidr = static::IPV6_ADDRESS_LENGTH;

  370.             }

  371. 

  372.             if (!$this->ipv6) {

  373.                 return [$this->ipv6NotAllowed, []];

  374.             }

  375.             if (!$this->validateIPv6($ip)) {

  376.                 return [$this->message, []];

  377.             }

  378. 

  379.             if ($this->expandIPv6) {

  380.                 $ip = $this->expandIPv6($ip);

  381.             }

  382.         } else {

  383.             if ($cidr !== null) {

  384.                 if ($cidr > static::IPV4_ADDRESS_LENGTH || $cidr < 0) {

  385.                     return [$this->wrongCidr, []];

  386.                 }

  387.             } else {

  388.                 $isCidrDefault = true;

  389.                 $cidr = static::IPV4_ADDRESS_LENGTH;

  390.             }

  391. 

  392.             if (!$this->ipv4) {

  393.                 return [$this->ipv4NotAllowed, []];

  394.             }

  395.             if (!$this->validateIPv4($ip)) {

  396.                 return [$this->message, []];

  397.             }

  398.         }

  399. 

  400.         if (!$this->isAllowed($ip, $cidr)) {

  401.             return [$this->notInRange, []];

  402.         }

  403. 

  404.         $result = $negation . $ip;

  405. 

  406.         if ($this->subnet !== false && (!$isCidrDefault || $isCidrDefault && $this->normalize)) {

  407.             $result .= "/$cidr";

  408.         }

  409. 

  410.         return $result;

  411.     }

  412. 

  413.     /**

  414.      * Expands an IPv6 address to it's full notation. For example `2001:db8::1` will be

  415.      * expanded to `2001:0db8:0000:0000:0000:0000:0000:0001`

  416.      *

  417.      * @param string $ip the original IPv6

  418.      * @return string the expanded IPv6

  419.      */

  420.     private function expandIPv6($ip)

  421.     {

  422.         $hex = unpack('H*hex', inet_pton($ip));

  423.         return substr(preg_replace('/([a-f0-9]{4})/i', '$1:', $hex['hex']), 0, -1);

  424.     }

  425. 

  426.     /**

  427.      * The method checks whether the IP address with specified CIDR is allowed according to the [[ranges]] list.

  428.      *

  429.      * @param string $ip

  430.      * @param integer $cidr

  431.      * @return boolean

  432.      * @see ranges

  433.      */

  434.     private function isAllowed($ip, $cidr)

  435.     {

  436.         if (empty($this->ranges)) {

  437.             return true;

  438.         }

  439. 

  440.         foreach ($this->ranges as $string) {

  441.             list($isNegated, $range) = $this->parseNegatedRange($string);

  442.             if ($this->inRange($ip, $cidr, $range)) {

  443.                 return !$isNegated;

  444.             }

  445.         }

  446. 

  447.         return false;

  448.     }

  449. 

  450.     /**

  451.      * Parses IP address/range for the negation with [[NEGATION_CHAR]].

  452.      *

  453.      * @param $string

  454.      * @return array `[0 => boolean, 1 => string]`

  455.      *  - boolean: whether the string is negated

  456.      *  - string: the string without negation (when the negation were present)

  457.      */

  458.     private function parseNegatedRange($string)

  459.     {

  460.         $isNegated = strpos($string, static::NEGATION_CHAR) === 0;

  461.         return [$isNegated, $isNegated ? substr($string, strlen(static::NEGATION_CHAR)) : $string];

  462.     }

  463. 

  464.     /**

  465.      * Prepares array to fill in [[ranges]]:

  466.      *  - Recursively substitutes aliases, described in [[networks]] with their values

  467.      *  - Removes duplicates

  468.      *

  469.      *

  470.      * @param $ranges

  471.      * @return array

  472.      * @see networks

  473.      */

  474.     private function prepareRanges($ranges)

  475.     {

  476.         $result = [];

  477.         foreach ($ranges as $string) {

  478.             list($isRangeNegated, $range) = $this->parseNegatedRange($string);

  479.             if (isset($this->networks[$range])) {

  480.                 $replacements = $this->prepareRanges($this->networks[$range]);

  481.                 foreach ($replacements as &$replacement) {

  482.                     list($isReplacementNegated, $replacement) = $this->parseNegatedRange($replacement);

  483.                     $result[] = ($isRangeNegated && !$isReplacementNegated ? static::NEGATION_CHAR : '') . $replacement;

  484.                 }

  485.             } else {

  486.                 $result[] = $string;

  487.             }

  488.         }

  489.         return array_unique($result);

  490.     }

  491. 

  492.     /**

  493.      * Validates IPv4 address

  494.      *

  495.      * @param string $value

  496.      * @return boolean

  497.      */

  498.     protected function validateIPv4($value)

  499.     {

  500.         return preg_match($this->ipv4Pattern, $value) !== 0;

  501.     }

  502. 

  503.     /**

  504.      * Validates IPv6 address

  505.      *

  506.      * @param string $value

  507.      * @return boolean

  508.      */

  509.     protected function validateIPv6($value)

  510.     {

  511.         return preg_match($this->ipv6Pattern, $value) !== 0;

  512.     }

  513. 

  514.     /**

  515.      * Gets the IP version

  516.      *

  517.      * @param string $ip

  518.      * @return integer

  519.      */

  520.     private function getIpVersion($ip)

  521.     {

  522.         return strpos($ip, ':') === false ? 4 : 6;

  523.     }

  524. 

  525.     /**

  526.      * Used to get the Regexp pattern for initial IP address parsing

  527.      * @return string

  528.      */

  529.     private function getIpParsePattern()

  530.     {

  531.         return '/^(' . preg_quote(static::NEGATION_CHAR) . '?)(.+?)(\/(\d+))?$/';

  532.     }

  533. 

  534.     /**

  535.      * Checks whether the IP is in subnet range

  536.      *

  537.      * @param string $ip an IPv4 or IPv6 address

  538.      * @param integer $cidr

  539.      * @param string $range subnet in CIDR format e.g. `10.0.0.0/8` or `2001:af::/64`

  540.      * @return boolean

  541.      */

  542.     private function inRange($ip, $cidr, $range)

  543.     {

  544.         $ipVersion = $this->getIpVersion($ip);

  545.         $binIp = $this->ip2bin($ip);

  546. 

  547.         $parts = explode('/', $range);

  548.         $net = array_shift($parts);

  549.         $range_cidr = array_shift($parts);

  550. 

  551. 

  552.         $netVersion = $this->getIpVersion($net);

  553.         if ($ipVersion !== $netVersion) {

  554.             return false;

  555.         }

  556.         if ($range_cidr === null) {

  557.             $range_cidr = $netVersion === 4 ? static::IPV4_ADDRESS_LENGTH : static::IPV6_ADDRESS_LENGTH;

  558.         }

  559. 

  560.         $binNet = $this->ip2bin($net);

  561.         return substr($binIp, 0, $range_cidr) === substr($binNet, 0, $range_cidr) && $cidr >= $range_cidr;

  562.     }

  563. 

  564.     /**

  565.      * Converts IP address to bits representation

  566.      *

  567.      * @param string $ip

  568.      * @return string bits as a string

  569.      */

  570.     private function ip2bin($ip)

  571.     {

  572.         if ($this->getIpVersion($ip) === 4) {

  573.             return str_pad(base_convert(ip2long($ip), 10, 2), static::IPV4_ADDRESS_LENGTH, '0', STR_PAD_LEFT);

  574.         } else {

  575.             $unpack = unpack('A16', inet_pton($ip));

  576.             $binStr = array_shift($unpack);

  577.             $bytes = static::IPV6_ADDRESS_LENGTH / 8; // 128 bit / 8 = 16 bytes

  578.             $result = '';

  579.             while ($bytes-- > 0) {

  580.                 $result = sprintf('%08b', isset($binStr[$bytes]) ? ord($binStr[$bytes]) : '0') . $result;

  581.             }

  582.             return $result;

  583.         }

  584.     }

  585. 

  586.     /**

  587.      * @inheritdoc

  588.      */

  589.     public function clientValidateAttribute($model, $attribute, $view)

  590.     {

  591.         $messages = [

  592.             'ipv6NotAllowed' => $this->ipv6NotAllowed,

  593.             'ipv4NotAllowed' => $this->ipv4NotAllowed,

  594.             'message' => $this->message,

  595.             'noSubnet' => $this->noSubnet,

  596.             'hasSubnet' => $this->hasSubnet,

  597.         ];

  598.         foreach ($messages as &$message) {

  599.             $message = Yii::$app->getI18n()->format($message, [

  600.                 'attribute' => $model->getAttributeLabel($attribute),

  601.             ], Yii::$app->language);

  602.         }

  603. 

  604.         $options = [

  605.             'ipv4Pattern' => new JsExpression(Html::escapeJsRegularExpression($this->ipv4Pattern)),

  606.             'ipv6Pattern' => new JsExpression(Html::escapeJsRegularExpression($this->ipv6Pattern)),

  607.             'messages' => $messages,

  608.             'ipv4' => (boolean)$this->ipv4,

  609.             'ipv6' => (boolean)$this->ipv6,

  610.             'ipParsePattern' => new JsExpression(Html::escapeJsRegularExpression($this->getIpParsePattern())),

  611.             'negation' => $this->negation,

  612.             'subnet' => $this->subnet,

  613.         ];

  614.         if ($this->skipOnEmpty) {

  615.             $options['skipOnEmpty'] = 1;

  616.         }

  617. 

  618.         ValidationAsset::register($view);

  619. 

  620.         return 'yii.validation.ip(value, messages, ' . Json::htmlEncode($options) . ');';

  621.     }

  622. }