Whip - Code Metrics - Inspection of "Make constructor able to handle standard header fo..." - Vectorface/whip - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( df8989...bc4c56 )

by Jonathan

created 2016-01-22 20:04 UTC

Whip A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	230
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

98.31%

Importance

Changes	6
Bugs	1	Features	0

Metric	Value
wmc	27
c	6
b	1
f	0
lcom	1
cbo	4
dl	0
loc	230
ccs	58
cts	59
cp	0.9831
rs	10

10 Methods

Rating	Name	Size	Complexity
A	addCustomHeader()	5	1
A	setSource()	6	1
A	getValidIpAddress()	8	3
A	isMethodUsable()	10	3
A	getRequestAdapter()	12	4
A	__construct()	12	3
A	getIpAddress()	15	4
A	normalizeHeaderName()	7	2
A	extractAddressFromHeaders()	10	3
A	coalesceSources()	10	3

<?php

/*
The MIT License (MIT)

Copyright (c) 2015 Vectorface, Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

namespace Vectorface\Whip;

use \Exception;
use Vectorface\Whip\IpRange\IpWhitelist;
use Vectorface\Whip\Request\RequestAdapter;
use Vectorface\Whip\Request\Psr7RequestAdapter;
use Vectorface\Whip\Request\SuperglobalRequestAdapter;
use Psr\Http\Message\ServerRequestInterface;

/**
 * A class for accurately looking up a client's IP address.
 * This class checks a call time configurable list of headers in the $_SERVER
 * superglobal to determine the client's IP address.
 * @copyright Vectorface, Inc 2015
 * @author Daniel Bruce <[email protected]>
 * @author Cory Darby <[email protected]>
 */
class Whip
{

    /** Indicates all header methods will be used. */
    const ALL_METHODS        = 255;
    /** Indicates the REMOTE_ADDR method will be used. */
    const REMOTE_ADDR        = 1;
    /** Indicates a set of possible proxy headers will be used. */
    const PROXY_HEADERS      = 2;
    /** Indicates any CloudFlare specific headers will be used. */
    const CLOUDFLARE_HEADERS = 4;
    /** Indicates any Incapsula specific headers will be used. */
    const INCAPSULA_HEADERS  = 8;
    /** Indicates custom listed headers will be used. */
    const CUSTOM_HEADERS     = 128;

    /** The array of mapped header strings. */
    private static $headers = array(
        self::CUSTOM_HEADERS     => array(),
        self::INCAPSULA_HEADERS  => array(
            'incap-client-ip'
        ),
        self::CLOUDFLARE_HEADERS => array(
            'cf-connecting-ip'
        ),
        self::PROXY_HEADERS      => array(
            'client-ip',
            'x-forwarded-for',
            'x-forwarded',
            'x-cluster-client-ip',
            'forwarded-for',
            'forwarded',
            'x-real-ip',
        ),
    );

    /** the bitmask of enabled methods */
    private $enabled;

    /** the array of IP whitelist ranges to check against */
    private $whitelist;

    /**
     * An object holding the source of addresses we will check
     *
     * @var RequestAdapter
     */
    private $source;

    /**
     * Constructor for the class.
     * @param int $enabled The bitmask of enabled headers.
     * @param array $whitelists The array of IP ranges to be whitelisted.
     * @param mixed $source A supported source of IP data.
     */
    public function __construct($enabled = self::ALL_METHODS, array $whitelists = array(), $source = null)
    {
        $this->enabled   = (int) $enabled;
        if (isset($source)) {
            $this->setSource($source);
        }
        $this->whitelist = array();
        foreach ($whitelists as $header => $ipRanges) {
            $header = $this->normalizeHeaderName($header);
            $this->whitelist[$header] = new IpWhitelist($ipRanges);
        }
    }

    /**
     * Adds a custom header to the list.
     * @param string $header The custom header to add.
     * @return Whip Returns $this.
     */
    public function addCustomHeader($header)
    {
        self::$headers[self::CUSTOM_HEADERS][] = $this->normalizeHeaderName($header);
        return $this;
    }

    /**
     * Sets the source data used to lookup the addresses.
     *
     * @param $source The source array.
     * @return Whip Returns $this.
     */
    public function setSource($source)
    {
        $this->source = $this->getRequestAdapter($source);

        return $this;
    }

    /**
     * Returns the IP address of the client using the given methods.
     * @param mixed $source (optional) The source data. If omitted, the class
     *        will use the value passed to Whip::setSource or fallback to
     *        $_SERVER.
     * @return string Returns the IP address as a string or false if no
     *         IP address could be found.
     */
    public function getIpAddress($source = null)
    {
        $source = $this->getRequestAdapter($this->coalesceSources($source));
        $remoteAddr = $source->getRemoteAddr();
        $requestHeaders = $source->getHeaders();

        foreach (self::$headers as $key => $headers) {
            if (!$this->isMethodUsable($key, $remoteAddr)) {
                continue;
            }
            return $this->extractAddressFromHeaders($requestHeaders, $headers);
        }

        return ($this->enabled & self::REMOTE_ADDR) ? $remoteAddr : false;
    }

    /**
     * Returns the valid IP address or false if no valid IP address was found.
     * @param mixed $source (optional) The source data. If omitted, the class
     *        will use the value passed to Whip::setSource or fallback to
     *        $_SERVER.
     * @return string|false Returns the IP address (as a string) of the client or false
     *         if no valid IP address was found.
     */
    public function getValidIpAddress($source = null)
    {
        $ipAddress = $this->getIpAddress($source);
        if (false === $ipAddress || false === @inet_pton($ipAddress)) {
            return false;
        }
        return $ipAddress;
    }

    /**
     * Normalizes HTTP header name representations.
     *
     * HTTP_MY_HEADER and My-Header would be transformed to my-header.
     *
     * @param string $header The original header name.
     * @return string The normalized header name.
     */
    private function normalizeHeaderName($header)
    {
        if (strpos($header, 'HTTP_') === 0) {
            $header = str_replace('_', '-', substr($header, 5));
        }
        return strtolower($header);
    }

    /**
     * Finds the first element in $headers that is present in $_SERVER and
     * returns the IP address mapped to that value.
     * If the IP address is a list of comma separated values, the last value
     * in the list will be returned.
     * If no IP address is found, we return false.
     * @param array $requestHeaders The request headers to pull data from.
     * @param array $headers The list of headers to check.
     * @return string|false Returns the IP address as a string or false if no IP
     *         IP address was found.
     */
    private function extractAddressFromHeaders($requestHeaders, $headers)
    {
        foreach ($headers as $header) {
            if (!empty($requestHeaders[$header])) {
                $list = explode(',', $requestHeaders[$header]);
                return trim(end($list));
            }
        }
        return false;
    }

    /**
     * Returns whether or not the given method is enabled and usable.
     *
     * This method checks if the method is enabled and whether the method's data
     * is usable given it's IP whitelist.
     *
     * @param string $key The source key.
     * @param string $ipAddress The IP address.
     * @return boolean Returns true if the IP address is whitelisted and false
     *         otherwise. Returns true if the source does not have a whitelist
     *         specified.
     */
    private function isMethodUsable($key, $ipAddress)
    {
        if (!($key & $this->enabled)) {
            return false;
        }
        if (!isset($this->whitelist[$key])) {
            return true;
        }
        return $this->whitelist[$key]->isIpWhitelisted($ipAddress);
    }

    /**
     * Get a source/request adapter for a given source of IP data.
     *
     * @param mixed $source A supported source of request data.
     * @return RequestAdapter A RequestAdapter implementation for the given source.
     */
    private function getRequestAdapter($source)
    {
        if ($source instanceof RequestAdapter) {
            return $source;
        } elseif ($source instanceof ServerRequestInterface) {
            return new Psr7RequestAdapter($source);
        } elseif (is_array($source)) {
            return new SuperglobalRequestAdapter($source);
        }

        throw new \InvalidArgumentException("Unknown IP source.");
    }

    /**
     * Given available sources, get the first available source of IP data.
     *
     * @param mixed $source A source data argument, if available.
     * @return mixed The best available source, after fallbacks.
     */
    private function coalesceSources($source = null)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (isset($source)) {
            return $source;
        } elseif (isset($this->source)) {
            return $this->source;
        }

        return $_SERVER;
    }
}


1		<?php
2
3		/*
4		The MIT License (MIT)
5
6		Copyright (c) 2015 Vectorface, Inc.
7
8		Permission is hereby granted, free of charge, to any person obtaining a copy
9		of this software and associated documentation files (the "Software"), to deal
10		in the Software without restriction, including without limitation the rights
11		to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12		copies of the Software, and to permit persons to whom the Software is
13		furnished to do so, subject to the following conditions:
14
15		The above copyright notice and this permission notice shall be included in
16		all copies or substantial portions of the Software.
17
18		THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19		IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20		FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21		AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22		LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23		OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24		THE SOFTWARE.
25		*/
26
27		namespace Vectorface\Whip;
28
29		use \Exception;
30		use Vectorface\Whip\IpRange\IpWhitelist;
31		use Vectorface\Whip\Request\RequestAdapter;
32		use Vectorface\Whip\Request\Psr7RequestAdapter;
33		use Vectorface\Whip\Request\SuperglobalRequestAdapter;
34		use Psr\Http\Message\ServerRequestInterface;
35
36		/**
37		* A class for accurately looking up a client's IP address.
38		* This class checks a call time configurable list of headers in the $_SERVER
39		* superglobal to determine the client's IP address.
40		* @copyright Vectorface, Inc 2015
41		* @author Daniel Bruce <[email protected]>
42		* @author Cory Darby <[email protected]>
43		*/
44		class Whip
45		{
46
47		/** Indicates all header methods will be used. */
48		const ALL_METHODS = 255;
49		/** Indicates the REMOTE_ADDR method will be used. */
50		const REMOTE_ADDR = 1;
51		/** Indicates a set of possible proxy headers will be used. */
52		const PROXY_HEADERS = 2;
53		/** Indicates any CloudFlare specific headers will be used. */
54		const CLOUDFLARE_HEADERS = 4;
55		/** Indicates any Incapsula specific headers will be used. */
56		const INCAPSULA_HEADERS = 8;
57		/** Indicates custom listed headers will be used. */
58		const CUSTOM_HEADERS = 128;
59
60		/** The array of mapped header strings. */
61		private static $headers = array(
62		self::CUSTOM_HEADERS => array(),
63		self::INCAPSULA_HEADERS => array(
64		'incap-client-ip'
65		),
66		self::CLOUDFLARE_HEADERS => array(
67		'cf-connecting-ip'
68		),
69		self::PROXY_HEADERS => array(
70		'client-ip',
71		'x-forwarded-for',
72		'x-forwarded',
73		'x-cluster-client-ip',
74		'forwarded-for',
75		'forwarded',
76		'x-real-ip',
77		),
78		);
79
80		/** the bitmask of enabled methods */
81		private $enabled;
82
83		/** the array of IP whitelist ranges to check against */
84		private $whitelist;
85
86		/**
87		* An object holding the source of addresses we will check
88		*
89		* @var RequestAdapter
90		*/
91		private $source;
92
93		/**
94		* Constructor for the class.
95		* @param int $enabled The bitmask of enabled headers.
96		* @param array $whitelists The array of IP ranges to be whitelisted.
97		* @param mixed $source A supported source of IP data.
98		*/
99	22	public function __construct($enabled = self::ALL_METHODS, array $whitelists = array(), $source = null)
100		{
101	22	$this->enabled = (int) $enabled;
102	22	if (isset($source)) {
103	16	$this->setSource($source);
104		}
105	21	$this->whitelist = array();
106	21	foreach ($whitelists as $header => $ipRanges) {
107	12	$header = $this->normalizeHeaderName($header);
108	12	$this->whitelist[$header] = new IpWhitelist($ipRanges);
109		}
110	21	}
111
112		/**
113		* Adds a custom header to the list.
114		* @param string $header The custom header to add.
115		* @return Whip Returns $this.
116		*/
117	1	public function addCustomHeader($header)
118		{
119	1	self::$headers[self::CUSTOM_HEADERS][] = $this->normalizeHeaderName($header);
120	1	return $this;
121		}
122
123		/**
124		* Sets the source data used to lookup the addresses.
125		*
126		* @param $source The source array.
127		* @return Whip Returns $this.
128		*/
129	20	public function setSource($source)
130		{
131	20	$this->source = $this->getRequestAdapter($source);
132
133	19	return $this;
134		}
135
136		/**
137		* Returns the IP address of the client using the given methods.
138		* @param mixed $source (optional) The source data. If omitted, the class
139		* will use the value passed to Whip::setSource or fallback to
140		* $_SERVER.
141		* @return string Returns the IP address as a string or false if no
142		* IP address could be found.
143		*/
144	21	public function getIpAddress($source = null)
145		{
146	21	$source = $this->getRequestAdapter($this->coalesceSources($source));
147	21	$remoteAddr = $source->getRemoteAddr();
148	21	$requestHeaders = $source->getHeaders();
149
150	21	foreach (self::$headers as $key => $headers) {
151	21	if (!$this->isMethodUsable($key, $remoteAddr)) {
152	19	continue;
153		}
154	11	return $this->extractAddressFromHeaders($requestHeaders, $headers);
155		}
156
157	10	return ($this->enabled & self::REMOTE_ADDR) ? $remoteAddr : false;
158		}
159
160		/**
161		* Returns the valid IP address or false if no valid IP address was found.
162		* @param mixed $source (optional) The source data. If omitted, the class
163		* will use the value passed to Whip::setSource or fallback to
164		* $_SERVER.
165		* @return string\|false Returns the IP address (as a string) of the client or false
166		* if no valid IP address was found.
167		*/
168	4	public function getValidIpAddress($source = null)
169		{
170	4	$ipAddress = $this->getIpAddress($source);
171	4	if (false === $ipAddress \|\| false === @inet_pton($ipAddress)) {
172	1	return false;
173		}
174	3	return $ipAddress;
175		}
176
177		/**
178		* Normalizes HTTP header name representations.
179		*
180		* HTTP_MY_HEADER and My-Header would be transformed to my-header.
181		*
182		* @param string $header The original header name.
183		* @return string The normalized header name.
184		*/
185	12	private function normalizeHeaderName($header)
186		{
187	12	if (strpos($header, 'HTTP_') === 0) {
188	1	$header = str_replace('_', '-', substr($header, 5));
189		}
190	12	return strtolower($header);
191		}
192
193		/**
194		* Finds the first element in $headers that is present in $_SERVER and
195		* returns the IP address mapped to that value.
196		* If the IP address is a list of comma separated values, the last value
197		* in the list will be returned.
198		* If no IP address is found, we return false.
199		* @param array $requestHeaders The request headers to pull data from.
200		* @param array $headers The list of headers to check.
201		* @return string\|false Returns the IP address as a string or false if no IP
202		* IP address was found.
203		*/
204	11	private function extractAddressFromHeaders($requestHeaders, $headers)
205		{
206	11	foreach ($headers as $header) {
207	10	if (!empty($requestHeaders[$header])) {
208	9	$list = explode(',', $requestHeaders[$header]);
209	10	return trim(end($list));
210		}
211		}
212	2	return false;
213		}
214
215		/**
216		* Returns whether or not the given method is enabled and usable.
217		*
218		* This method checks if the method is enabled and whether the method's data
219		* is usable given it's IP whitelist.
220		*
221		* @param string $key The source key.
222		* @param string $ipAddress The IP address.
223		* @return boolean Returns true if the IP address is whitelisted and false
224		* otherwise. Returns true if the source does not have a whitelist
225		* specified.
226		*/
227	21	private function isMethodUsable($key, $ipAddress)
228		{
229	21	if (!($key & $this->enabled)) {
230	19	return false;
231		}
232	15	if (!isset($this->whitelist[$key])) {
233	3	return true;
234		}
235	12	return $this->whitelist[$key]->isIpWhitelisted($ipAddress);
236		}
237
238		/**
239		* Get a source/request adapter for a given source of IP data.
240		*
241		* @param mixed $source A supported source of request data.
242		* @return RequestAdapter A RequestAdapter implementation for the given source.
243		*/
244	22	private function getRequestAdapter($source)
245		{
246	22	if ($source instanceof RequestAdapter) {
247	19	return $source;
248	1	} elseif ($source instanceof ServerRequestInterface) {
249	1	return new Psr7RequestAdapter($source);
250	21	} elseif (is_array($source)) {
251	20	return new SuperglobalRequestAdapter($source);
252		}
253
254	1	throw new \InvalidArgumentException("Unknown IP source.");
255		}
256
257		/**
258		* Given available sources, get the first available source of IP data.
259		*
260		* @param mixed $source A source data argument, if available.
261		* @return mixed The best available source, after fallbacks.
262		*/
263	21	private function coalesceSources($source = null)
		0 ignored issues – show Coding Style introduced 2015-12-21 03:02 UTC by Report Bug Copy Issue Report `coalesceSources` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
264		{
265	21	if (isset($source)) {
266	1	return $source;
267		} elseif (isset($this->source)) {
268	19	return $this->source;
269		}
270
271	2	return $_SERVER;
272		}
273		}
274

Vectorface / whip

Push — master ( df8989...bc4c56 )

Whip A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

10 Methods

Duplication Side-by-Side

Filter issues like