1094462219

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/mlocati/ip-lib/commit/<a class=hub.com/mlocati/ip-lib/commit/606b0dd82b48d4e927f2ac708393ef9e9047bb03">606b0dd82<a href="https://github.com/mlocati/ip-lib/commit/606b0dd82b48d4e927f2ac708393ef9e9047bb03">">Merge </a><a class="double-link" href="https://github.com/mlocati/ip-lib/commit/<a class="double-link" href="https://github.com/mlocati/ip-lib/commit/2f5431f36094ba75e004724c3a7277e6cc9525bb">2f5431f36</a>">2f5431f36</a><a href="https://github.com/mlocati/ip-lib/commit/606b0dd82b48d4e927f2ac708393ef9e9047bb03"> into 2fe91549b">2fe91549b</a>

Pull Request Pull Request #73: Support alternative compact forms

Run Details

142 of 142 new or added lines in 8 files covered. (100.0%)

850 of 863 relevant lines covered (98.49%)

217.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.24

/src/Address/IPv4.php

<?php

namespace IPLib\Address;

use IPLib\ParseStringFlag;
use IPLib\Range\RangeInterface;
use IPLib\Range\Subnet;
use IPLib\Range\Type as RangeType;

/**
 * An IPv4 address.
 */
class IPv4 implements AddressInterface
{
    /**
     * The string representation of the address.
     *
     * @var string
     *
     * @example '127.0.0.1'
     */
    protected $address;

    /**
     * The byte list of the IP address.
     *
     * @var int[]|null
     */
    protected $bytes;

    /**
     * The type of the range of this IP address.
     *
     * @var int|null
     */
    protected $rangeType;

    /**
     * A string representation of this address than can be used when comparing addresses and ranges.
     *
     * @var string
     */
    protected $comparableString;

    /**
     * An array containing RFC designated address ranges.
     *
     * @var array|null
     */
    private static $reservedRanges;

    /**
     * Initializes the instance.
     *
     * @param string $address
     */
    protected function __construct($address)
    {
        $this->address = $address;
        $this->bytes = null;
        $this->rangeType = null;
        $this->comparableString = null;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::__toString()
     */
    public function __toString()
    {
        return $this->address;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getNumberOfBits()
     */
    public static function getNumberOfBits()
    {
        return 32;
    }

    /**
     * @deprecated since 1.17.0: use the parseString() method instead.
     * For upgrading:
     * - if $mayIncludePort is true, use the ParseStringFlag::MAY_INCLUDE_PORT flag
     * - if $supportNonDecimalIPv4 is true, use the ParseStringFlag::IPV4_MAYBE_NON_DECIMAL flag
     *
     * @param string|mixed $address the address to parse
     * @param bool $mayIncludePort
     * @param bool $supportNonDecimalIPv4
     *
     * @return static|null
     *
     * @see \IPLib\Address\IPv4::parseString()
     * @since 1.1.0 added the $mayIncludePort argument
     * @since 1.10.0 added the $supportNonDecimalIPv4 argument
     */
    public static function fromString($address, $mayIncludePort = true, $supportNonDecimalIPv4 = false)
    {
        return static::parseString($address, 0 | ($mayIncludePort ? ParseStringFlag::MAY_INCLUDE_PORT : 0) | ($supportNonDecimalIPv4 ? ParseStringFlag::IPV4_MAYBE_NON_DECIMAL : 0));
    }

    /**
     * Parse a string and returns an IPv4 instance if the string is valid, or null otherwise.
     *
     * @param string|mixed $address the address to parse
     * @param int $flags A combination or zero or more flags
     *
     * @return static|null
     *
     * @see \IPLib\ParseStringFlag
     * @since 1.17.0
     */
    public static function parseString($address, $flags = 0)
    {
        if (!is_string($address)) {
            return null;
        }
        $flags = (int) $flags;
        if ($flags & ParseStringFlag::IPV4ADDRESS_MAYBE_NON_QUAD_DOTTED) {
            if (strpos($address, '.') === 0) {
                return null;
            }
            $lengthNonHex = '{1,11}';
            $lengthHex = '{1,8}';
            $chunk234Optional = true;
        } else {
            if (!strpos($address, '.')) {
                return null;
            }
            $lengthNonHex = '{1,3}';
            $lengthHex = '{1,2}';
            $chunk234Optional = false;
        }
        $rxChunk1 = "0?[0-9]{$lengthNonHex}";
        if ($flags & ParseStringFlag::IPV4_MAYBE_NON_DECIMAL) {
            $rxChunk1 = "(?:0[Xx]0*[0-9A-Fa-f]{$lengthHex})|(?:{$rxChunk1})";
            $onlyDecimal = false;
        } else {
            $onlyDecimal = true;
        }
        $rxChunk1 = "0*?({$rxChunk1})";
        $rxChunk234 = "\.{$rxChunk1}";
        if ($chunk234Optional) {
            $rxChunk234 = "(?:{$rxChunk234})?";
        }
        $rx = "{$rxChunk1}{$rxChunk234}{$rxChunk234}{$rxChunk234}";
        if ($flags & ParseStringFlag::MAY_INCLUDE_PORT) {
            $rx .= '(?::\d+)?';
        }
        $matches = null;
        if (!preg_match('/^' . $rx . '$/', $address, $matches)) {
            return null;
        }
        $math = new \IPLib\Service\UnsignedIntegerMath();
        $nums = array();
        $maxChunkIndex = count($matches) - 1;
        for ($i = 1; $i <= $maxChunkIndex; $i++) {
            $numBytes = $i === $maxChunkIndex ? 5 - $i : 1;
            $chunkBytes = $math->getBytes($matches[$i], $numBytes, $onlyDecimal);
            if ($chunkBytes === null) {
                return null;
            }
            $nums = array_merge($nums, $chunkBytes);
        }

        return new static(implode('.', $nums));
    }

    /**
     * Parse an array of bytes and returns an IPv4 instance if the array is valid, or null otherwise.
     *
     * @param int[]|array $bytes
     *
     * @return static|null
     */
    public static function fromBytes(array $bytes)
    {
        $result = null;
        if (count($bytes) === 4) {
            $chunks = array_map(
                function ($byte) {
                    return (is_int($byte) && $byte >= 0 && $byte <= 255) ? (string) $byte : false;
                },
                $bytes
            );
            if (in_array(false, $chunks, true) === false) {
                $result = new static(implode('.', $chunks));
            }
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::toString()
     */
    public function toString($long = false)
    {
        if ($long) {
            return $this->getComparableString();
        }

        return $this->address;
    }

    /**
     * Get the octal representation of this IP address.
     *
     * @param bool $long
     *
     * @return string
     *
     * @since 1.10.0
     *
     * @example if $long == false: if the decimal representation is '0.7.8.255': '0.7.010.0377'
     * @example if $long == true: if the decimal representation is '0.7.8.255': '0000.0007.0010.0377'
     */
    public function toOctal($long = false)
    {
        $chunks = array();
        foreach ($this->getBytes() as $byte) {
            if ($long) {
                $chunks[] = sprintf('%04o', $byte);
            } else {
                $chunks[] = '0' . decoct($byte);
            }
        }

        return implode('.', $chunks);
    }

    /**
     * Get the hexadecimal representation of this IP address.
     *
     * @param bool $long
     *
     * @return string
     *
     * @since 1.10.0
     *
     * @example if $long == false: if the decimal representation is '0.9.10.255': '0.9.0xa.0xff'
     * @example if $long == true: if the decimal representation is '0.9.10.255': '0x00.0x09.0x0a.0xff'
     */
    public function toHexadecimal($long = false)
    {
        $chunks = array();
        foreach ($this->getBytes() as $byte) {
            if ($long) {
                $chunks[] = sprintf('0x%02x', $byte);
            } else {
                $chunks[] = '0x' . dechex($byte);
            }
        }

        return implode('.', $chunks);
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getBytes()
     */
    public function getBytes()
    {
        if ($this->bytes === null) {
            $this->bytes = array_map(
                function ($chunk) {
                    return (int) $chunk;
                },
                explode('.', $this->address)
            );
        }

        return $this->bytes;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getBits()
     */
    public function getBits()
    {
        $parts = array();
        foreach ($this->getBytes() as $byte) {
            $parts[] = sprintf('%08b', $byte);
        }

        return implode('', $parts);
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getAddressType()
     */
    public function getAddressType()
    {
        return Type::T_IPv4;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getDefaultReservedRangeType()
     */
    public static function getDefaultReservedRangeType()
    {
        return RangeType::T_PUBLIC;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getReservedRanges()
     */
    public static function getReservedRanges()
    {
        if (self::$reservedRanges === null) {
            $reservedRanges = array();
            foreach (array(
                // RFC 5735
                '0.0.0.0/8' => array(RangeType::T_THISNETWORK, array('0.0.0.0/32' => RangeType::T_UNSPECIFIED)),
                // RFC 5735
                '10.0.0.0/8' => array(RangeType::T_PRIVATENETWORK),
                // RFC 6598
                '100.64.0.0/10' => array(RangeType::T_CGNAT),
                // RFC 5735
                '127.0.0.0/8' => array(RangeType::T_LOOPBACK),
                // RFC 5735
                '169.254.0.0/16' => array(RangeType::T_LINKLOCAL),
                // RFC 5735
                '172.16.0.0/12' => array(RangeType::T_PRIVATENETWORK),
                // RFC 5735
                '192.0.0.0/24' => array(RangeType::T_RESERVED),
                // RFC 5735
                '192.0.2.0/24' => array(RangeType::T_RESERVED),
                // RFC 5735
                '192.88.99.0/24' => array(RangeType::T_ANYCASTRELAY),
                // RFC 5735
                '192.168.0.0/16' => array(RangeType::T_PRIVATENETWORK),
                // RFC 5735
                '198.18.0.0/15' => array(RangeType::T_RESERVED),
                // RFC 5735
                '198.51.100.0/24' => array(RangeType::T_RESERVED),
                // RFC 5735
                '203.0.113.0/24' => array(RangeType::T_RESERVED),
                // RFC 5735
                '224.0.0.0/4' => array(RangeType::T_MULTICAST),
                // RFC 5735
                '240.0.0.0/4' => array(RangeType::T_RESERVED, array('255.255.255.255/32' => RangeType::T_LIMITEDBROADCAST)),
            ) as $range => $data) {
                $exceptions = array();
                if (isset($data[1])) {
                    foreach ($data[1] as $exceptionRange => $exceptionType) {
                        $exceptions[] = new AssignedRange(Subnet::parseString($exceptionRange), $exceptionType);
                    }
                }
                $reservedRanges[] = new AssignedRange(Subnet::parseString($range), $data[0], $exceptions);
            }
            self::$reservedRanges = $reservedRanges;
        }

        return self::$reservedRanges;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getRangeType()
     */
    public function getRangeType()
    {
        if ($this->rangeType === null) {
            $rangeType = null;
            foreach (static::getReservedRanges() as $reservedRange) {
                $rangeType = $reservedRange->getAddressType($this);
                if ($rangeType !== null) {
                    break;
                }
            }
            $this->rangeType = $rangeType === null ? static::getDefaultReservedRangeType() : $rangeType;
        }

        return $this->rangeType;
    }

    /**
     * Create an IPv6 representation of this address (in 6to4 notation).
     *
     * @return \IPLib\Address\IPv6
     */
    public function toIPv6()
    {
        $myBytes = $this->getBytes();

        return IPv6::parseString('2002:' . sprintf('%02x', $myBytes[0]) . sprintf('%02x', $myBytes[1]) . ':' . sprintf('%02x', $myBytes[2]) . sprintf('%02x', $myBytes[3]) . '::');
    }

    /**
     * Create an IPv6 representation of this address (in IPv6 IPv4-mapped notation).
     *
     * @return \IPLib\Address\IPv6
     *
     * @since 1.11.0
     */
    public function toIPv6IPv4Mapped()
    {
        return IPv6::fromBytes(array_merge(array(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff), $this->getBytes()));
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getComparableString()
     */
    public function getComparableString()
    {
        if ($this->comparableString === null) {
            $chunks = array();
            foreach ($this->getBytes() as $byte) {
                $chunks[] = sprintf('%03d', $byte);
            }
            $this->comparableString = implode('.', $chunks);
        }

        return $this->comparableString;
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::matches()
     */
    public function matches(RangeInterface $range)
    {
        return $range->contains($this);
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getAddressAtOffset()
     */
    public function getAddressAtOffset($n)
    {
        if (!is_int($n)) {
            return null;
        }

        $boundary = 256;
        $mod = $n;
        $bytes = $this->getBytes();
        for ($i = count($bytes) - 1; $i >= 0; $i--) {
            $tmp = ($bytes[$i] + $mod) % $boundary;
            $mod = (int) floor(($bytes[$i] + $mod) / $boundary);
            if ($tmp < 0) {
                $tmp += $boundary;
            }

            $bytes[$i] = $tmp;
        }

        if ($mod !== 0) {
            return null;
        }

        return static::fromBytes($bytes);
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getNextAddress()
     */
    public function getNextAddress()
    {
        return $this->getAddressAtOffset(1);
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getPreviousAddress()
     */
    public function getPreviousAddress()
    {
        return $this->getAddressAtOffset(-1);
    }

    /**
     * {@inheritdoc}
     *
     * @see \IPLib\Address\AddressInterface::getReverseDNSLookupName()
     */
    public function getReverseDNSLookupName()
    {
        return implode(
            '.',
            array_reverse($this->getBytes())
        ) . '.in-addr.arpa';
    }
}

1	<?php
2
3	namespace IPLib\Address;
4
5	use IPLib\ParseStringFlag;
6	use IPLib\Range\RangeInterface;
7	use IPLib\Range\Subnet;
8	use IPLib\Range\Type as RangeType;
9
10	/**
11	* An IPv4 address.
12	*/
13	class IPv4 implements AddressInterface
14	{
15	/**
16	* The string representation of the address.
17	*
18	* @var string
19	*
20	* @example '127.0.0.1'
21	*/
22	protected $address;
23
24	/**
25	* The byte list of the IP address.
26	*
27	* @var int[]\|null
28	*/
29	protected $bytes;
30
31	/**
32	* The type of the range of this IP address.
33	*
34	* @var int\|null
35	*/
36	protected $rangeType;
37
38	/**
39	* A string representation of this address than can be used when comparing addresses and ranges.
40	*
41	* @var string
42	*/
43	protected $comparableString;
44
45	/**
46	* An array containing RFC designated address ranges.
47	*
48	* @var array\|null
49	*/
50	private static $reservedRanges;
51
52	/**
53	* Initializes the instance.
54	*
55	* @param string $address
56	*/
57	protected function __construct($address)
58	{
59	$this->address = $address;	793✔
60	$this->bytes = null;	793✔
61	$this->rangeType = null;	793✔
62	$this->comparableString = null;	793✔
63	}	793✔
64
65	/**
66	* {@inheritdoc}
67	*
68	* @see \IPLib\Address\AddressInterface::__toString()
69	*/
70	public function __toString()
71	{
72	return $this->address;	105✔
73	}
74
75	/**
76	* {@inheritdoc}
77	*
78	* @see \IPLib\Address\AddressInterface::getNumberOfBits()
79	*/
80	public static function getNumberOfBits()
81	{
82	return 32;	36✔
83	}
84
85	/**
86	* @deprecated since 1.17.0: use the parseString() method instead.
87	* For upgrading:
88	* - if $mayIncludePort is true, use the ParseStringFlag::MAY_INCLUDE_PORT flag
89	* - if $supportNonDecimalIPv4 is true, use the ParseStringFlag::IPV4_MAYBE_NON_DECIMAL flag
90	*
91	* @param string\|mixed $address the address to parse
92	* @param bool $mayIncludePort
93	* @param bool $supportNonDecimalIPv4
94	*
95	* @return static\|null
96	*
97	* @see \IPLib\Address\IPv4::parseString()
98	* @since 1.1.0 added the $mayIncludePort argument
99	* @since 1.10.0 added the $supportNonDecimalIPv4 argument
100	*/
101	public static function fromString($address, $mayIncludePort = true, $supportNonDecimalIPv4 = false)
102	{
103	return static::parseString($address, 0 \| ($mayIncludePort ? ParseStringFlag::MAY_INCLUDE_PORT : 0) \| ($supportNonDecimalIPv4 ? ParseStringFlag::IPV4_MAYBE_NON_DECIMAL : 0));	20✔
104	}
105
106	/**
107	* Parse a string and returns an IPv4 instance if the string is valid, or null otherwise.
108	*
109	* @param string\|mixed $address the address to parse
110	* @param int $flags A combination or zero or more flags
111	*
112	* @return static\|null
113	*
114	* @see \IPLib\ParseStringFlag
115	* @since 1.17.0
116	*/
117	public static function parseString($address, $flags = 0)
118	{
119	if (!is_string($address)) {	1,327✔
120	return null;	3✔
121	}
122	$flags = (int) $flags;	1,324✔
123	if ($flags & ParseStringFlag::IPV4ADDRESS_MAYBE_NON_QUAD_DOTTED) {	1,324✔
124	if (strpos($address, '.') === 0) {	12✔
125	return null;	×
126	}
127	$lengthNonHex = '{1,11}';	12✔
128	$lengthHex = '{1,8}';	12✔
129	$chunk234Optional = true;	12✔
130	} else {
131	if (!strpos($address, '.')) {	1,312✔
132	return null;	526✔
133	}
134	$lengthNonHex = '{1,3}';	802✔
135	$lengthHex = '{1,2}';	802✔
136	$chunk234Optional = false;	802✔
137	}
138	$rxChunk1 = "0?[0-9]{$lengthNonHex}";	814✔
139	if ($flags & ParseStringFlag::IPV4_MAYBE_NON_DECIMAL) {	814✔
140	$rxChunk1 = "(?:0[Xx]0*[0-9A-Fa-f]{$lengthHex})\|(?:{$rxChunk1})";	44✔
141	$onlyDecimal = false;	44✔
142	} else {
143	$onlyDecimal = true;	782✔
144	}
145	$rxChunk1 = "0*?({$rxChunk1})";	814✔
146	$rxChunk234 = "\.{$rxChunk1}";	814✔
147	if ($chunk234Optional) {	814✔
148	$rxChunk234 = "(?:{$rxChunk234})?";	12✔
149	}
150	$rx = "{$rxChunk1}{$rxChunk234}{$rxChunk234}{$rxChunk234}";	814✔
151	if ($flags & ParseStringFlag::MAY_INCLUDE_PORT) {	814✔
152	$rx .= '(?::\d+)?';	455✔
153	}
154	$matches = null;	814✔
155	if (!preg_match('/^' . $rx . '$/', $address, $matches)) {	814✔
156	return null;	37✔
157	}
158	$math = new \IPLib\Service\UnsignedIntegerMath();	790✔
159	$nums = array();	790✔
160	$maxChunkIndex = count($matches) - 1;	790✔
161	for ($i = 1; $i <= $maxChunkIndex; $i++) {	790✔
162	$numBytes = $i === $maxChunkIndex ? 5 - $i : 1;	790✔
163	$chunkBytes = $math->getBytes($matches[$i], $numBytes, $onlyDecimal);	790✔
164	if ($chunkBytes === null) {	790✔
165	return null;	12✔
166	}
167	$nums = array_merge($nums, $chunkBytes);	784✔
168	}
169
170	return new static(implode('.', $nums));	778✔
171	}
172
173	/**
174	* Parse an array of bytes and returns an IPv4 instance if the array is valid, or null otherwise.
175	*
176	* @param int[]\|array $bytes
177	*
178	* @return static\|null
179	*/
180	public static function fromBytes(array $bytes)
181	{
182	$result = null;	706✔
183	if (count($bytes) === 4) {	706✔
184	$chunks = array_map(	406✔
185	function ($byte) {
186	return (is_int($byte) && $byte >= 0 && $byte <= 255) ? (string) $byte : false;	406✔
187	},	406✔
188	$bytes	406✔
189	);
190	if (in_array(false, $chunks, true) === false) {	406✔
191	$result = new static(implode('.', $chunks));	406✔
192	}
193	}
194
195	return $result;	706✔
196	}
197
198	/**
199	* {@inheritdoc}
200	*
201	* @see \IPLib\Address\AddressInterface::toString()
202	*/
203	public function toString($long = false)
204	{
205	if ($long) {	632✔
206	return $this->getComparableString();	22✔
207	}
208
209	return $this->address;	632✔
210	}
211
212	/**
213	* Get the octal representation of this IP address.
214	*
215	* @param bool $long
216	*
217	* @return string
218	*
219	* @since 1.10.0
220	*
221	* @example if $long == false: if the decimal representation is '0.7.8.255': '0.7.010.0377'
222	* @example if $long == true: if the decimal representation is '0.7.8.255': '0000.0007.0010.0377'
223	*/
224	public function toOctal($long = false)
225	{
226	$chunks = array();	12✔
227	foreach ($this->getBytes() as $byte) {	12✔
228	if ($long) {	12✔
229	$chunks[] = sprintf('%04o', $byte);	12✔
230	} else {
231	$chunks[] = '0' . decoct($byte);	12✔
232	}
233	}
234
235	return implode('.', $chunks);	12✔
236	}
237
238	/**
239	* Get the hexadecimal representation of this IP address.
240	*
241	* @param bool $long
242	*
243	* @return string
244	*
245	* @since 1.10.0
246	*
247	* @example if $long == false: if the decimal representation is '0.9.10.255': '0.9.0xa.0xff'
248	* @example if $long == true: if the decimal representation is '0.9.10.255': '0x00.0x09.0x0a.0xff'
249	*/
250	public function toHexadecimal($long = false)
251	{
252	$chunks = array();	12✔
253	foreach ($this->getBytes() as $byte) {	12✔
254	if ($long) {	12✔
255	$chunks[] = sprintf('0x%02x', $byte);	12✔
256	} else {
257	$chunks[] = '0x' . dechex($byte);	12✔
258	}
259	}
260
261	return implode('.', $chunks);	12✔
262	}
263
264	/**
265	* {@inheritdoc}
266	*
267	* @see \IPLib\Address\AddressInterface::getBytes()
268	*/
269	public function getBytes()
270	{
271	if ($this->bytes === null) {	597✔
272	$this->bytes = array_map(	597✔
273	function ($chunk) {
274	return (int) $chunk;	597✔
275	},	597✔
276	explode('.', $this->address)	597✔
277	);
278	}
279
280	return $this->bytes;	597✔
281	}
282
283	/**
284	* {@inheritdoc}
285	*
286	* @see \IPLib\Address\AddressInterface::getBits()
287	*/
288	public function getBits()
289	{
290	$parts = array();	30✔
291	foreach ($this->getBytes() as $byte) {	30✔
292	$parts[] = sprintf('%08b', $byte);	30✔
293	}
294
295	return implode('', $parts);	30✔
296	}
297
298	/**
299	* {@inheritdoc}
300	*
301	* @see \IPLib\Address\AddressInterface::getAddressType()
302	*/
303	public function getAddressType()
304	{
305	return Type::T_IPv4;	587✔
306	}
307
308	/**
309	* {@inheritdoc}
310	*
311	* @see \IPLib\Address\AddressInterface::getDefaultReservedRangeType()
312	*/
313	public static function getDefaultReservedRangeType()
314	{
315	return RangeType::T_PUBLIC;	173✔
316	}
317
318	/**
319	* {@inheritdoc}
320	*
321	* @see \IPLib\Address\AddressInterface::getReservedRanges()
322	*/
323	public static function getReservedRanges()
324	{
325	if (self::$reservedRanges === null) {	341✔
326	$reservedRanges = array();	1✔
327	foreach (array(
328	// RFC 5735
329	'0.0.0.0/8' => array(RangeType::T_THISNETWORK, array('0.0.0.0/32' => RangeType::T_UNSPECIFIED)),	1✔
330	// RFC 5735
331	'10.0.0.0/8' => array(RangeType::T_PRIVATENETWORK),
332	// RFC 6598
333	'100.64.0.0/10' => array(RangeType::T_CGNAT),
334	// RFC 5735
335	'127.0.0.0/8' => array(RangeType::T_LOOPBACK),
336	// RFC 5735
337	'169.254.0.0/16' => array(RangeType::T_LINKLOCAL),
338	// RFC 5735
339	'172.16.0.0/12' => array(RangeType::T_PRIVATENETWORK),
340	// RFC 5735
341	'192.0.0.0/24' => array(RangeType::T_RESERVED),
342	// RFC 5735
343	'192.0.2.0/24' => array(RangeType::T_RESERVED),
344	// RFC 5735
345	'192.88.99.0/24' => array(RangeType::T_ANYCASTRELAY),
346	// RFC 5735
347	'192.168.0.0/16' => array(RangeType::T_PRIVATENETWORK),
348	// RFC 5735
349	'198.18.0.0/15' => array(RangeType::T_RESERVED),
350	// RFC 5735
351	'198.51.100.0/24' => array(RangeType::T_RESERVED),
352	// RFC 5735
353	'203.0.113.0/24' => array(RangeType::T_RESERVED),
354	// RFC 5735
355	'224.0.0.0/4' => array(RangeType::T_MULTICAST),
356	// RFC 5735
357	'240.0.0.0/4' => array(RangeType::T_RESERVED, array('255.255.255.255/32' => RangeType::T_LIMITEDBROADCAST)),
358	) as $range => $data) {
359	$exceptions = array();	1✔
360	if (isset($data[1])) {	1✔
361	foreach ($data[1] as $exceptionRange => $exceptionType) {	1✔
362	$exceptions[] = new AssignedRange(Subnet::parseString($exceptionRange), $exceptionType);	1✔
363	}
364	}
365	$reservedRanges[] = new AssignedRange(Subnet::parseString($range), $data[0], $exceptions);	1✔
366	}
367	self::$reservedRanges = $reservedRanges;	1✔
368	}
369
370	return self::$reservedRanges;	341✔
371	}
372
373	/**
374	* {@inheritdoc}
375	*
376	* @see \IPLib\Address\AddressInterface::getRangeType()
377	*/
378	public function getRangeType()
379	{
380	if ($this->rangeType === null) {	171✔
381	$rangeType = null;	171✔
382	foreach (static::getReservedRanges() as $reservedRange) {	171✔
383	$rangeType = $reservedRange->getAddressType($this);	171✔
384	if ($rangeType !== null) {	171✔
385	break;	168✔
386	}
387	}
388	$this->rangeType = $rangeType === null ? static::getDefaultReservedRangeType() : $rangeType;	171✔
389	}
390
391	return $this->rangeType;	171✔
392	}
393
394	/**
395	* Create an IPv6 representation of this address (in 6to4 notation).
396	*
397	* @return \IPLib\Address\IPv6
398	*/
399	public function toIPv6()
400	{
401	$myBytes = $this->getBytes();	4✔
402
403	return IPv6::parseString('2002:' . sprintf('%02x', $myBytes[0]) . sprintf('%02x', $myBytes[1]) . ':' . sprintf('%02x', $myBytes[2]) . sprintf('%02x', $myBytes[3]) . '::');	4✔
404	}
405
406	/**
407	* Create an IPv6 representation of this address (in IPv6 IPv4-mapped notation).
408	*
409	* @return \IPLib\Address\IPv6
410	*
411	* @since 1.11.0
412	*/
413	public function toIPv6IPv4Mapped()
414	{
415	return IPv6::fromBytes(array_merge(array(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff), $this->getBytes()));	4✔
416	}
417
418	/**
419	* {@inheritdoc}
420	*
421	* @see \IPLib\Address\AddressInterface::getComparableString()
422	*/
423	public function getComparableString()
424	{
425	if ($this->comparableString === null) {	423✔
426	$chunks = array();	423✔
427	foreach ($this->getBytes() as $byte) {	423✔
428	$chunks[] = sprintf('%03d', $byte);	423✔
429	}
430	$this->comparableString = implode('.', $chunks);	423✔
431	}
432
433	return $this->comparableString;	423✔
434	}
435
436	/**
437	* {@inheritdoc}
438	*
439	* @see \IPLib\Address\AddressInterface::matches()
440	*/
441	public function matches(RangeInterface $range)
442	{
443	return $range->contains($this);	11✔
444	}
445
446	/**
447	* {@inheritdoc}
448	*
449	* @see \IPLib\Address\AddressInterface::getAddressAtOffset()
450	*/
451	public function getAddressAtOffset($n)
452	{
453	if (!is_int($n)) {	29✔
454	return null;	1✔
455	}
456
457	$boundary = 256;	28✔
458	$mod = $n;	28✔
459	$bytes = $this->getBytes();	28✔
460	for ($i = count($bytes) - 1; $i >= 0; $i--) {	28✔
461	$tmp = ($bytes[$i] + $mod) % $boundary;	28✔
462	$mod = (int) floor(($bytes[$i] + $mod) / $boundary);	28✔
463	if ($tmp < 0) {	28✔
464	$tmp += $boundary;	13✔
465	}
466
467	$bytes[$i] = $tmp;	28✔
468	}
469
470	if ($mod !== 0) {	28✔
471	return null;	8✔
472	}
473
474	return static::fromBytes($bytes);	22✔
475	}
476
477	/**
478	* {@inheritdoc}
479	*
480	* @see \IPLib\Address\AddressInterface::getNextAddress()
481	*/
482	public function getNextAddress()
483	{
484	return $this->getAddressAtOffset(1);	9✔
485	}
486
487	/**
488	* {@inheritdoc}
489	*
490	* @see \IPLib\Address\AddressInterface::getPreviousAddress()
491	*/
492	public function getPreviousAddress()
493	{
494	return $this->getAddressAtOffset(-1);	9✔
495	}
496
497	/**
498	* {@inheritdoc}
499	*
500	* @see \IPLib\Address\AddressInterface::getReverseDNSLookupName()
501	*/
502	public function getReverseDNSLookupName()
503	{
504	return implode(	14✔
505	'.',	14✔
506	array_reverse($this->getBytes())	14✔
507	) . '.in-addr.arpa';	14✔
508	}
509	}

mlocati / ip-lib / 1094462219

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous