Janitor\Excluder\IP

Complexity

Total Complexity

26

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	10
Bugs	3	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	isExcluded()	0	12	3
C	determineCurrentIp()	0	32	8
A	getIpFromServerParams()	0	11	3
A	isValidIp()	0	4	1
B	__construct()	0	18	5
A	addIP()	0	12	3
A	addTrustedProxy()	0	12	3

<?php
/**
 * Effortless maintenance management (http://juliangut.com/janitor)
 *
 * @link https://github.com/juliangut/janitor for the canonical source repository
 *
 * @license https://github.com/juliangut/janitor/blob/master/LICENSE
 */

namespace Janitor\Excluder;

use Janitor\Excluder as ExcluderInterface;
use Psr\Http\Message\ServerRequestInterface;

/**
 * Maintenance excluder by route
 */
class IP implements ExcluderInterface
{
    /**
     * List of IPs to be excluded.
     *
     * @var array
     */
    protected $ips = [];

    /**
     * Allowed proxies.
     *
     * @var array
     */
    protected $trustedProxies = [];

    /**
     * @param string|array|null $ips
     * @param string|array|null $trustedProxies
     *
     * @throws \InvalidArgumentException
     */
    public function __construct($ips = null, $trustedProxies = null)
    {
        if (!is_array($ips)) {
            $ips = [$ips];
        }

        foreach ($ips as $ipAddress) {
            $this->addIP($ipAddress);
        }

        if (!is_array($trustedProxies)) {
            $trustedProxies = [$trustedProxies];
        }

        foreach ($trustedProxies as $ipAddress) {
            $this->addTrustedProxy($ipAddress);
        }
    }

    /**
     * Add IP.
     *
     * @param string $ipAddress
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function addIP($ipAddress)
    {
        if (trim($ipAddress) !== '') {
            if (!$this->isValidIp($ipAddress)) {
                throw new \InvalidArgumentException(sprintf('"%s" is not a valid IP address', $ipAddress));
            }

            $this->ips[] = $ipAddress;
        }

        return $this;
    }

    /**
     * Add Trusted proxy.
     *
     * @param string $ipAddress
     *
     * @throws \InvalidArgumentException
     *
     * @return $this
     */
    public function addTrustedProxy($ipAddress)
    {
        if (trim($ipAddress) !== '') {
            if (!$this->isValidIp($ipAddress)) {
                throw new \InvalidArgumentException(sprintf('"%s" is not a valid IP address', $ipAddress));
            }

            $this->trustedProxies[] = $ipAddress;
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function isExcluded(ServerRequestInterface $request)
    {
        $currentIP = $this->determineCurrentIp($request);

        foreach ($this->ips as $ipAddress) {
            if ($ipAddress === $currentIP) {
                return true;
            }
        }

        return false;
    }

    /**
     * Find client's IP.
     *
     * @param ServerRequestInterface $request
     *
     * @return string|null
     */
    protected function determineCurrentIp(ServerRequestInterface $request)
    {
        $inspectionHeaders = [
            'X-Forwarded-For',
            'X-Forwarded',
            'X-Cluster-Client-Ip',
            'Client-Ip',
        ];

        $currentIp = $this->getIpFromServerParams($request);

        if (!count($this->trustedProxies) || in_array($currentIp, $this->trustedProxies, true)) {
            $trustedIp = null;

            $headers = $inspectionHeaders;
            while ($trustedIp === null && $header = array_shift($headers)) {
                if ($request->hasHeader($header)) {
                    $ipAddress = trim(current(explode(',', $request->getHeaderLine($header))));

                    if ($this->isValidIp($ipAddress)) {
                        $trustedIp = $ipAddress;
                    }
                }
            }

            if ($trustedIp !== null) {
                $currentIp = $trustedIp;
            }
        }

        return $currentIp;
    }

    /**
     * Return current IP retrieved from server parameters.
     *
     * @param ServerRequestInterface $request
     *
     * @return string|null
     */
    private function getIpFromServerParams(ServerRequestInterface $request)
    {
        $currentIp = null;

        $serverParams = $request->getServerParams();
        if (isset($serverParams['REMOTE_ADDR']) && $this->isValidIp($serverParams['REMOTE_ADDR'])) {
            $currentIp = $serverParams['REMOTE_ADDR'];
        }

        return $currentIp;
    }

    /**
     * Check IP validity.
     *
     * @param string $ipAddress
     *
     * @return bool
     */
    private function isValidIp($ipAddress)
    {
        return filter_var($ipAddress, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4 | FILTER_FLAG_IPV6) !== false;
    }
}