devtoolboxuk\ipAddress\Network

Complexity

Total Complexity

50

Size/Duplication

Total Lines	337
Duplicated Lines	0 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	3	1
A	getBlockSize()	0	10	2
A	next()	0	3	1
A	getHosts()	0	13	3
A	count()	0	3	1
B	exclude()	0	47	7
A	getNetwork()	0	3	1
A	netmask2prefix()	0	3	1
A	setIP()	0	7	3
A	prefix2netmask()	0	19	6
A	getWildcard()	0	3	1
A	rewind()	0	3	1
A	valid()	0	3	1
A	parse()	0	15	3
A	getIP()	0	3	1
A	getNetmask()	0	3	1
A	__construct()	0	4	1
A	key()	0	3	1
A	getBroadcast()	0	3	1
A	setNetmask()	0	11	4
A	setPrefixLength()	0	3	1
A	current()	0	3	1
A	getPrefixLength()	0	3	1
A	getLastIP()	0	3	1
A	moveTo()	0	20	4
A	getFirstIP()	0	3	1

<?php

namespace devtoolboxuk\internetaddress;

class Network implements \Iterator
{
    use IpTrait;
    /**
     * @var IP
     */
    private $ip;
    /**
     * @var IP
     */
    private $netmask;
    /**
     * @var int
     */
    private $position = 0;


    public function __construct(IP $ip, IP $netmask)
    {
        $this->setIP($ip);
        $this->setNetmask($netmask);
    }

    /**
     *
     * @return string
     */
    public function __toString()
    {
        return $this->getCIDR();

The method getCIDR() does not exist on devtoolboxuk\internetaddress\Network.

    }

    public function getWildcard()
    {
        return new IP(inet_ntop(~$this->getNetmask()->inAddr()));
    }

    /**
     * @return IP
     */
    public function getNetmask()
    {
        return $this->netmask;
    }

    /**
     * @param IP ip
     * @throws \Exception
     */
    public function setNetmask(IP $ip)
    {
        if (!preg_match('/^1*0*$/', $ip->toBin())) {
            throw new \Exception('Invalid Netmask address format');
        }

        if (isset($this->ip) && $ip->getVersion() !== $this->ip->getVersion()) {
            throw new \Exception('Netmask version is not same as IP version');
        }

        $this->netmask = $ip;
    }

    /**
     * @return Range
     * @throws \Exception
     */
    public function getHosts()
    {
        $firstHost = $this->getNetwork();
        $lastHost = $this->getBroadcast();

        if ($this->ip->getVersion() === IPv4::version) {
            if ($this->getBlockSize() > 2) {
                $firstHost = IP::parseBin(substr($firstHost->toBin(), 0, $firstHost->getMaxPrefixLength() - 1) . '1');
                $lastHost = IP::parseBin(substr($lastHost->toBin(), 0, $lastHost->getMaxPrefixLength() - 1) . '0');
            }
        }

        return new Range($firstHost, $lastHost);

The type devtoolboxuk\internetaddress\Range was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    public function getNetwork()
    {
        return new IP(inet_ntop($this->getIP()->inAddr() & $this->getNetmask()->inAddr()));

Are you sure you want to use the bitwise & or did you mean &&?

    }

    /**
     * @return IP
     */
    public function getIP()
    {
        return $this->ip;
    }

    /**
     * @param IP ip
     * @throws \Exception
     */
    public function setIP(IP $ip)
    {
        if (isset($this->netmask) && $this->netmask->getVersion() !== $ip->getVersion()) {
            throw new \Exception('IP version is not same as Netmask version');
        }

        $this->ip = $ip;
    }

    /**
     * @return IP
     * @throws \Exception
     */
    public function getBroadcast()
    {
        return new IP(inet_ntop($this->getNetwork()->inAddr() | ~$this->getNetmask()->inAddr()));

Are you sure you want to use the bitwise | or did you mean ||?

    }

    /**
     * @return int|string
     */
    public function getBlockSize()
    {
        $maxPrefixLength = $this->ip->getMaxPrefixLength();
        $prefixLength = $this->getPrefixLength();

        if ($this->ip->getVersion() === IP::v6) {

The constant devtoolboxuk\internetaddress\IP::v6 was not found. Maybe you did not declare it correctly or list all dependencies?

            return bcpow('2', (string)($maxPrefixLength - $prefixLength));
        }

        return pow(2, $maxPrefixLength - $prefixLength);
    }

    /**
     * @return int
     */
    public function getPrefixLength()
    {
        return self::netmask2prefix($this->getNetmask());

The method devtoolboxuk\internetaddress\Network::netmask2prefix() is not static, but was called statically.

    }

    /**
     * @param IP ip
     * @return int
     */
    public function netmask2prefix(IP $ip)
    {
        return strlen(rtrim($ip->toBin(), 0));
    }

    /**
     * @param IP|Network $exclude
     * @return Network[]
     * @throws \Exception
     */
    public function exclude($exclude)
    {
        $exclude = self::parse($exclude);

        if (strcmp($exclude->getFirstIP()->inAddr(), $this->getLastIP()->inAddr()) > 0
            || strcmp($exclude->getLastIP()->inAddr(), $this->getFirstIP()->inAddr()) < 0
        ) {
            throw new \Exception('Exclude subnet not within target network');
        }

        $networks = array();

        $newPrefixLength = $this->getPrefixLength() + 1;
        if ($newPrefixLength > $this->ip->getMaxPrefixLength()) {
            return $networks;
        }

        $lower = clone $this;
        $lower->setPrefixLength($newPrefixLength);

        $upper = clone $lower;
        $upper->setIP($lower->getLastIP()->next());

        while ($newPrefixLength <= $exclude->getPrefixLength()) {
            $range = new Range($lower->getFirstIP(), $lower->getLastIP());
            if ($range->contains($exclude)) {
                $matched = $lower;
                $unmatched = $upper;
            } else {
                $matched = $upper;
                $unmatched = $lower;
            }

            $networks[] = clone $unmatched;

            if (++$newPrefixLength > $this->getNetwork()->getMaxPrefixLength()) {
                break;
            }

            $matched->setPrefixLength($newPrefixLength);
            $unmatched->setPrefixLength($newPrefixLength);
            $unmatched->setIP($matched->getLastIP()->next());
        }

        sort($networks);

        return $networks;
    }

    public static function parse($data)
    {
        if (preg_match('~^(.+?)/(\d+)$~', $data, $matches)) {
            $ip = IP::parse($matches[1]);
            $netmask = self::prefix2netmask((int)$matches[2], $ip->getVersion());
        } elseif (strpos($data, ' ')) {
            list($ip, $netmask) = explode(' ', $data, 2);
            $ip = IP::parse($ip);
            $netmask = IP::parse($netmask);
        } else {
            $ip = IP::parse($data);
            $netmask = self::prefix2netmask($ip->getMaxPrefixLength(), $ip->getVersion());
        }

        return new self($ip, $netmask);
    }

    /**
     * @param int $prefixLength
     * @param string $version
     * @return IP
     * @throws \Exception
     */
    public static function prefix2netmask($prefixLength, $version)
    {
        if (!in_array($version, array(IPv4::version, IPv6::version))) {
            throw new \Exception("Wrong IP version");
        }

        $maxPrefixLength = $version === IPv4::version
            ? IPv4::length
            : IP::v6Length;

The constant devtoolboxuk\internetaddress\IP::v6Length was not found. Maybe you did not declare it correctly or list all dependencies?

        if (!is_numeric($prefixLength)

The condition is_numeric($prefixLength) is always true.

            || !($prefixLength >= 0 && $prefixLength <= $maxPrefixLength)
        ) {
            throw new \Exception('Invalid prefix length');
        }

        $binIP = str_pad(str_pad('', (int)$prefixLength, '1'), $maxPrefixLength, '0');

        return IP::parseBin($binIP);
    }

    /**
     * @return IP
     */
    public function getFirstIP()
    {
        return $this->getNetwork();
    }

    /**
     * @return IP
     * @throws \Exception
     */
    public function getLastIP()
    {
        return $this->getBroadcast();
    }

    public function setPrefixLength($prefixLength)
    {
        $this->setNetmask(self::prefix2netmask((int)$prefixLength, $this->ip->getVersion()));
    }

    /**
     * @param int $prefixLength
     * @return Network[]
     * @throws \Exception
     */
    public function moveTo($prefixLength)
    {
        $maxPrefixLength = $this->ip->getMaxPrefixLength();

        if ($prefixLength <= $this->getPrefixLength() || $prefixLength > $maxPrefixLength) {
            throw new \Exception('Invalid prefix length ');
        }

        $netmask = self::prefix2netmask($prefixLength, $this->ip->getVersion());
        $networks = array();

        $subnet = clone $this;
        $subnet->setPrefixLength($prefixLength);

        while ($subnet->ip->inAddr() <= $this->getLastIP()->inAddr()) {
            $networks[] = $subnet;
            $subnet = new self($subnet->getLastIP()->next(), $netmask);
        }

        return $networks;
    }

    /**
     * @return IP|mixed
     * @throws \Exception
     */
    public function current()
    {
        return $this->getFirstIP()->next($this->position);
    }

    /**
     * @return int|mixed
     */
    public function key()
    {
        return $this->position;
    }

    public function next()
    {
        ++$this->position;
    }

    public function rewind()
    {
        $this->position = 0;
    }

    /**
     * @return bool
     * @throws \Exception
     */
    public function valid()
    {
        return strcmp($this->getFirstIP()->next($this->position)->inAddr(), $this->getLastIP()->inAddr()) <= 0;
    }

    /**
     * @return int
     */
    public function count()
    {
        return (integer)$this->getBlockSize();
    }

}