IpAccess

Complexity

Total Complexity

29

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	3
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setIp()	0	4	1
A	getAllowedIps()	0	8	2
B	hasAccess()	0	14	7
A	respondNoAccess()	0	8	3
A	matchExact()	0	4	2
B	matchRange()	0	19	5
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 ($this->allowedIps) {

The expression $this->allowedIps 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.

            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 hasAccess()
    {
        if (!(bool)Config::inst()->get('IpAccess', 'enabled')

This if statement, and the following return statement can be replaced with return !(bool) \Config::inst()->get('IpAccess', 'enabled') || empty($this->getAllowedIps()) || $this->matchExact() || $this->matchRange() || $this->matchCIDR() || $this->matchWildCard();.

            || empty($this->getAllowedIps())
            || $this->matchExact()
            || $this->matchRange()
            || $this->matchCIDR()
            || $this->matchWildCard())
        {
            return true;
        }

        return false;
    }

    /**
     * @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()
    {
        if ($ranges = array_filter($this->getAllowedIps(), function ($ip) {
            return strstr($ip, '-');
        })
        ) {
            foreach ($ranges as $range) {
                $first = substr($range, 0, strrpos($range, '.') + 1);
                $last  = substr(strrchr($range, '.'), 1);
                list ($start, $end) = explode('-', $last);
                for ($i = $start; $i <= $end; $i++) {
                    if ($this->ip === $first . $i) {
                        return $range;
                    }
                }
            }
        }
        return '';
    }

    /**
     * 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 '';
    }

}