IpAccess

Complexity

Total Complexity

30

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	5
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setIp()	0	4	1
A	getAllowedIps()	0	8	2
A	isEnabled()	0	4	1
B	hasAccess()	0	8	6
A	respondNoAccess()	0	8	3
A	matchExact()	0	4	2
B	matchRange()	0	21	6
A	matchCIDR()	0	15	4
A	matchWildCard()	0	14	4

<?php

/**
 * Check Access based on remote IP address
 *
 * @Example entries :
 * 192.168.178.8
 * 192.168.178.0/24
 * 192.168.178.0-50
 * 192.168.178.*
 * 192.168.*
 * @return false || string : entry the ip address was matched against
 */
class IpAccess extends Object

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    /**
     * @var array
     */
    public $allowedIps = array();

    /**
     * @config
     * @var array
     */
    private static $allowed_ips = array();

The property $allowed_ips is not used and could be removed.

    /**
     * @var string
     */
    private $ip = '';

    /**
     * IpAccess constructor.
     *
     * @param string $ip
     * @param array $allowedIps
     */
    public function __construct($ip = '', $allowedIps = array())
    {
        parent::__construct();
        $this->ip = $ip;

        self::config()->allowed_ips = $allowedIps;
    }

    /**
     * @param $ip
     */
    public function setIp($ip)
    {
        $this->ip = $ip;
    }

    /**
     * @return array
     */
    public function getAllowedIps()
    {
        if (!empty($this->allowedIps)) {
            Deprecation::notice('1.1', 'Use the "IpAccess.allowed_ips" config setting instead');
            self::config()->allowed_ips = $this->allowedIps;
        }
        return (array)self::config()->allowed_ips;
    }

    /**
     * @return bool
     */
    public function isEnabled()
    {
        return (bool)Config::inst()->get('IpAccess', 'enabled');
    }

    /**
     * @return bool
     */
    public function hasAccess()
    {
        if(!$this->isEnabled() || empty($this->getAllowedIps())) {
            return true;
        }

        return ($this->matchExact() || $this->matchRange() || $this->matchCIDR() || $this->matchWildCard());
    }

    /**
     * @param Controller $controller
     * @throws SS_HTTPResponse_Exception
     */
    public function respondNoAccess(Controller $controller)
    {
        $response = null;
        if (class_exists('ErrorPage', true)) {
            $response = ErrorPage::response_for(403);
        }
        $controller->httpError(403, $response ? $response : 'The requested page could not be found.');
    }

    /**
     * @return string
     */
    public function matchExact()
    {
        return in_array($this->ip, $this->getAllowedIps()) ? $this->ip : '';
    }

    /**
     * Try to match against a ip range
     *
     * Example : 192.168.1.50-100
     *
     * @return string
     */
    public function matchRange()
    {
        $ranges = array_filter($this->getAllowedIps(), function ($ip) {
            return strstr($ip, '-');
        });

        if (!$ranges) {

The expression $ranges of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return '';
        }

        $ipFirstPart = substr($this->ip, 0, strrpos($this->ip, '.') + 1);
        $ipLastpart  = substr(strrchr($this->ip, '.'), 1);

        foreach ($ranges as $range) {
            $rangeFirstPart = substr($range, 0, strrpos($range, '.') + 1);
            list ($start, $end) = explode('-', substr(strrchr($range, '.'), 1));
            if($ipFirstPart === $rangeFirstPart && $ipLastpart >= $start && $ipLastpart <= $end) {
                return $range;
            }
        }
    }

    /**
     * Try to match cidr range
     *
     * Example : 192.168.1.0/24
     *
     * @return string
     */
    public function matchCIDR()
    {
        if ($ranges = array_filter($this->getAllowedIps(), function ($ip) {
            return strstr($ip, '/');
        })
        ) {
            foreach ($ranges as $cidr) {
                list ($net, $mask) = explode('/', $cidr);
                if ((ip2long($this->ip) & ~((1 << (32 - $mask)) - 1)) == ip2long($net)) {
                    return $cidr;
                }
            }
        }
        return '';
    }

    /**
     * Try to match against a range that ends with a wildcard *
     *
     * Example : 192.168.1.*
     * Example : 192.168.*
     *
     * @return string
     */
    public function matchWildCard()
    {
        if ($ranges = array_filter($this->getAllowedIps(), function ($ip) {
            return substr($ip, -1) === '*';
        })
        ) {
            foreach ($ranges as $range) {
                if (substr($this->ip, 0, strlen(substr($range, 0, -1))) === substr($range, 0, -1)) {
                    return $range;
                }
            }
        }
        return '';
    }

}