Reader::findMetadataStart() - Code Metrics - Inspection of "Connect geolite2 to Jetpack EU Cookie Law widget" - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — add/gdpr-ads-compliance ( 47ea51...6d1e7f )

unknown

created 2018-04-24 03:46 UTC

Reader::findMetadataStart() B

↳ Parent: Reader

Complexity

Conditions	4
Paths	4

Size

Total Lines	26
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	18
nc	4
nop	1
dl	0
loc	26
rs	8.5806
c	0
b	0
f	0

<?php

namespace MaxMind\Db;

use MaxMind\Db\Reader\Decoder;
use MaxMind\Db\Reader\InvalidDatabaseException;
use MaxMind\Db\Reader\Metadata;
use MaxMind\Db\Reader\Util;

/**
 * Instances of this class provide a reader for the MaxMind DB format. IP
 * addresses can be looked up using the <code>get</code> method.
 */
class Reader
{
    private static $DATA_SECTION_SEPARATOR_SIZE = 16;
    private static $METADATA_START_MARKER = "\xAB\xCD\xEFMaxMind.com";
    private static $METADATA_START_MARKER_LENGTH = 14;
    private static $METADATA_MAX_SIZE = 131072; // 128 * 1024 = 128KB

    private $decoder;
    private $fileHandle;
    private $fileSize;
    private $ipV4Start;
    private $metadata;

    /**
     * Constructs a Reader for the MaxMind DB format. The file passed to it must
     * be a valid MaxMind DB file such as a GeoIp2 database file.
     *
     * @param string $database
     *                         the MaxMind DB file to use
     *
     * @throws \InvalidArgumentException                   for invalid database path or unknown arguments
     * @throws \MaxMind\Db\Reader\InvalidDatabaseException
     *                                                     if the database is invalid or there is an error reading
     *                                                     from it
     */
    public function __construct($database)
    {
        if (func_num_args() !== 1) {
            throw new \InvalidArgumentException(
                'The constructor takes exactly one argument.'
            );
        }

        if (!is_readable($database)) {
            throw new \InvalidArgumentException(
                "The file \"$database\" does not exist or is not readable."
            );
        }
        $this->fileHandle = @fopen($database, 'rb');
        if ($this->fileHandle === false) {
            throw new \InvalidArgumentException(
                "Error opening \"$database\"."
            );
        }
        $this->fileSize = @filesize($database);
        if ($this->fileSize === false) {
            throw new \UnexpectedValueException(
                "Error determining the size of \"$database\"."
            );
        }

        $start = $this->findMetadataStart($database);
        $metadataDecoder = new Decoder($this->fileHandle, $start);
        list($metadataArray) = $metadataDecoder->decode($start);
        $this->metadata = new Metadata($metadataArray);
        $this->decoder = new Decoder(
            $this->fileHandle,
            $this->metadata->searchTreeSize + self::$DATA_SECTION_SEPARATOR_SIZE
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        );
    }

    /**
     * Looks up the <code>address</code> in the MaxMind DB.
     *
     * @param string $ipAddress
     *                          the IP address to look up
     *
     * @throws \BadMethodCallException   if this method is called on a closed database
     * @throws \InvalidArgumentException if something other than a single IP address is passed to the method
     * @throws InvalidDatabaseException
     *                                   if the database is invalid or there is an error reading
     *                                   from it
     *
     * @return array the record for the IP address
     */
    public function get($ipAddress)
    {
        if (func_num_args() !== 1) {
            throw new \InvalidArgumentException(
                'Method takes exactly one argument.'
            );
        }

        if (!is_resource($this->fileHandle)) {
            throw new \BadMethodCallException(
                'Attempt to read from a closed MaxMind DB.'
            );
        }

        if (!filter_var($ipAddress, FILTER_VALIDATE_IP)) {
            throw new \InvalidArgumentException(
                "The value \"$ipAddress\" is not a valid IP address."
            );
        }

        if ($this->metadata->ipVersion === 4 && strrpos($ipAddress, ':')) {
            throw new \InvalidArgumentException(
                "Error looking up $ipAddress. You attempted to look up an"
                . ' IPv6 address in an IPv4-only database.'
            );
        }
        $pointer = $this->findAddressInTree($ipAddress);
        if ($pointer === 0) {
            return null;
        }

        return $this->resolveDataPointer($pointer);
    }

    private function findAddressInTree($ipAddress)
    {
        // XXX - could simplify. Done as a byte array to ease porting
        $rawAddress = array_merge(unpack('C*', inet_pton($ipAddress)));

        $bitCount = count($rawAddress) * 8;

        // The first node of the tree is always node 0, at the beginning of the
        // value
        $node = $this->startNode($bitCount);

        for ($i = 0; $i < $bitCount; $i++) {
            if ($node >= $this->metadata->nodeCount) {
                break;
            }
            $tempBit = 0xFF & $rawAddress[$i >> 3];
            $bit = 1 & ($tempBit >> 7 - ($i % 8));

            $node = $this->readNode($node, $bit);
        }
        if ($node === $this->metadata->nodeCount) {
            // Record is empty
            return 0;
        } elseif ($node > $this->metadata->nodeCount) {
            // Record is a data pointer
            return $node;
        }
        throw new InvalidDatabaseException('Something bad happened');
    }

    private function startNode($length)
    {
        // Check if we are looking up an IPv4 address in an IPv6 tree. If this
        // is the case, we can skip over the first 96 nodes.
        if ($this->metadata->ipVersion === 6 && $length === 32) {
            return $this->ipV4StartNode();
        }
        // The first node of the tree is always node 0, at the beginning of the
        // value
        return 0;
    }

    private function ipV4StartNode()
    {
        // This is a defensive check. There is no reason to call this when you
        // have an IPv4 tree.
        if ($this->metadata->ipVersion === 4) {
            return 0;
        }

        if ($this->ipV4Start) {
            return $this->ipV4Start;
        }
        $node = 0;

        for ($i = 0; $i < 96 && $node < $this->metadata->nodeCount; $i++) {
            $node = $this->readNode($node, 0);
        }
        $this->ipV4Start = $node;

        return $node;
    }

    private function readNode($nodeNumber, $index)
    {
        $baseOffset = $nodeNumber * $this->metadata->nodeByteSize;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

        // XXX - probably could condense this.
        switch ($this->metadata->recordSize) {
            case 24:
                $bytes = Util::read($this->fileHandle, $baseOffset + $index * 3, 3);
                list(, $node) = unpack('N', "\x00" . $bytes);

                return $node;
            case 28:
                $middleByte = Util::read($this->fileHandle, $baseOffset + 3, 1);
                list(, $middle) = unpack('C', $middleByte);
                if ($index === 0) {
                    $middle = (0xF0 & $middle) >> 4;
                } else {
                    $middle = 0x0F & $middle;
                }
                $bytes = Util::read($this->fileHandle, $baseOffset + $index * 4, 3);
                list(, $node) = unpack('N', chr($middle) . $bytes);

                return $node;
            case 32:
                $bytes = Util::read($this->fileHandle, $baseOffset + $index * 4, 4);
                list(, $node) = unpack('N', $bytes);

                return $node;
            default:
                throw new InvalidDatabaseException(
                    'Unknown record size: '
                    . $this->metadata->recordSize
                );
        }
    }

    private function resolveDataPointer($pointer)
    {
        $resolved = $pointer - $this->metadata->nodeCount
            + $this->metadata->searchTreeSize;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        if ($resolved > $this->fileSize) {
            throw new InvalidDatabaseException(
                "The MaxMind DB file's search tree is corrupt"
            );
        }

        list($data) = $this->decoder->decode($resolved);

        return $data;
    }

    /*
     * This is an extremely naive but reasonably readable implementation. There
     * are much faster algorithms (e.g., Boyer-Moore) for this if speed is ever
     * an issue, but I suspect it won't be.
     */
    private function findMetadataStart($filename)
    {
        $handle = $this->fileHandle;
        $fstat = fstat($handle);
        $fileSize = $fstat['size'];
        $marker = self::$METADATA_START_MARKER;
        $markerLength = self::$METADATA_START_MARKER_LENGTH;
        $metadataMaxLengthExcludingMarker
            = min(self::$METADATA_MAX_SIZE, $fileSize) - $markerLength;

        for ($i = 0; $i <= $metadataMaxLengthExcludingMarker; $i++) {
            for ($j = 0; $j < $markerLength; $j++) {
                fseek($handle, $fileSize - $i - $j - 1);
                $matchBit = fgetc($handle);
                if ($matchBit !== $marker[$markerLength - $j - 1]) {
                    continue 2;
                }
            }

            return $fileSize - $i;
        }
        throw new InvalidDatabaseException(
            "Error opening database file ($filename). " .
            'Is this a valid MaxMind DB file?'
        );
    }

    /**
     * @throws \InvalidArgumentException if arguments are passed to the method
     * @throws \BadMethodCallException   if the database has been closed
     *
     * @return Metadata object for the database
     */
    public function metadata()
    {
        if (func_num_args()) {
            throw new \InvalidArgumentException(
                'Method takes no arguments.'
            );
        }

        // Not technically required, but this makes it consistent with
        // C extension and it allows us to change our implementation later.
        if (!is_resource($this->fileHandle)) {
            throw new \BadMethodCallException(
                'Attempt to read from a closed MaxMind DB.'
            );
        }

        return $this->metadata;
    }

    /**
     * Closes the MaxMind DB and returns resources to the system.
     *
     * @throws \Exception
     *                    if an I/O error occurs
     */
    public function close()
    {
        if (!is_resource($this->fileHandle)) {
            throw new \BadMethodCallException(
                'Attempt to close a closed MaxMind DB.'
            );
        }
        fclose($this->fileHandle);
    }
}


1		<?php
2
3		namespace MaxMind\Db;
4
5		use MaxMind\Db\Reader\Decoder;
6		use MaxMind\Db\Reader\InvalidDatabaseException;
7		use MaxMind\Db\Reader\Metadata;
8		use MaxMind\Db\Reader\Util;
9
10		/**
11		* Instances of this class provide a reader for the MaxMind DB format. IP
12		* addresses can be looked up using the <code>get</code> method.
13		*/
14		class Reader
15		{
16		private static $DATA_SECTION_SEPARATOR_SIZE = 16;
17		private static $METADATA_START_MARKER = "\xAB\xCD\xEFMaxMind.com";
18		private static $METADATA_START_MARKER_LENGTH = 14;
19		private static $METADATA_MAX_SIZE = 131072; // 128 * 1024 = 128KB
20
21		private $decoder;
22		private $fileHandle;
23		private $fileSize;
24		private $ipV4Start;
25		private $metadata;
26
27		/**
28		* Constructs a Reader for the MaxMind DB format. The file passed to it must
29		* be a valid MaxMind DB file such as a GeoIp2 database file.
30		*
31		* @param string $database
32		* the MaxMind DB file to use
33		*
34		* @throws \InvalidArgumentException for invalid database path or unknown arguments
35		* @throws \MaxMind\Db\Reader\InvalidDatabaseException
36		* if the database is invalid or there is an error reading
37		* from it
38		*/
39		public function __construct($database)
40		{
41		if (func_num_args() !== 1) {
42		throw new \InvalidArgumentException(
43		'The constructor takes exactly one argument.'
44		);
45		}
46
47		if (!is_readable($database)) {
48		throw new \InvalidArgumentException(
49		"The file \"$database\" does not exist or is not readable."
50		);
51		}
52		$this->fileHandle = @fopen($database, 'rb');
53		if ($this->fileHandle === false) {
54		throw new \InvalidArgumentException(
55		"Error opening \"$database\"."
56		);
57		}
58		$this->fileSize = @filesize($database);
59		if ($this->fileSize === false) {
60		throw new \UnexpectedValueException(
61		"Error determining the size of \"$database\"."
62		);
63		}
64
65		$start = $this->findMetadataStart($database);
66		$metadataDecoder = new Decoder($this->fileHandle, $start);
67		list($metadataArray) = $metadataDecoder->decode($start);
68		$this->metadata = new Metadata($metadataArray);
69		$this->decoder = new Decoder(
70		$this->fileHandle,
71		$this->metadata->searchTreeSize + self::$DATA_SECTION_SEPARATOR_SIZE
		0 ignored issues – show Documentation introduced 2018-04-24 03:55 UTC by Report Bug Copy Issue Report The property `$searchTreeSize` is declared private in `MaxMind\Db\Reader\Metadata`. Since you implemented `__get()`, maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion. Since your code implements the magic setter `_set`, this function will be called for any write access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } Since the property has write access only, you can use the @property-write annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
72		);
73		}
74
75		/**
76		* Looks up the <code>address</code> in the MaxMind DB.
77		*
78		* @param string $ipAddress
79		* the IP address to look up
80		*
81		* @throws \BadMethodCallException if this method is called on a closed database
82		* @throws \InvalidArgumentException if something other than a single IP address is passed to the method
83		* @throws InvalidDatabaseException
84		* if the database is invalid or there is an error reading
85		* from it
86		*
87		* @return array the record for the IP address
88		*/
89		public function get($ipAddress)
90		{
91		if (func_num_args() !== 1) {
92		throw new \InvalidArgumentException(
93		'Method takes exactly one argument.'
94		);
95		}
96
97		if (!is_resource($this->fileHandle)) {
98		throw new \BadMethodCallException(
99		'Attempt to read from a closed MaxMind DB.'
100		);
101		}
102
103		if (!filter_var($ipAddress, FILTER_VALIDATE_IP)) {
104		throw new \InvalidArgumentException(
105		"The value \"$ipAddress\" is not a valid IP address."
106		);
107		}
108
109		if ($this->metadata->ipVersion === 4 && strrpos($ipAddress, ':')) {
110		throw new \InvalidArgumentException(
111		"Error looking up $ipAddress. You attempted to look up an"
112		. ' IPv6 address in an IPv4-only database.'
113		);
114		}
115		$pointer = $this->findAddressInTree($ipAddress);
116		if ($pointer === 0) {
117		return null;
118		}
119
120		return $this->resolveDataPointer($pointer);
121		}
122
123		private function findAddressInTree($ipAddress)
124		{
125		// XXX - could simplify. Done as a byte array to ease porting
126		$rawAddress = array_merge(unpack('C*', inet_pton($ipAddress)));
127
128		$bitCount = count($rawAddress) * 8;
129
130		// The first node of the tree is always node 0, at the beginning of the
131		// value
132		$node = $this->startNode($bitCount);
133
134		for ($i = 0; $i < $bitCount; $i++) {
135		if ($node >= $this->metadata->nodeCount) {
136		break;
137		}
138		$tempBit = 0xFF & $rawAddress[$i >> 3];
139		$bit = 1 & ($tempBit >> 7 - ($i % 8));
140
141		$node = $this->readNode($node, $bit);
142		}
143		if ($node === $this->metadata->nodeCount) {
144		// Record is empty
145		return 0;
146		} elseif ($node > $this->metadata->nodeCount) {
147		// Record is a data pointer
148		return $node;
149		}
150		throw new InvalidDatabaseException('Something bad happened');
151		}
152
153		private function startNode($length)
154		{
155		// Check if we are looking up an IPv4 address in an IPv6 tree. If this
156		// is the case, we can skip over the first 96 nodes.
157		if ($this->metadata->ipVersion === 6 && $length === 32) {
158		return $this->ipV4StartNode();
159		}
160		// The first node of the tree is always node 0, at the beginning of the
161		// value
162		return 0;
163		}
164
165		private function ipV4StartNode()
166		{
167		// This is a defensive check. There is no reason to call this when you
168		// have an IPv4 tree.
169		if ($this->metadata->ipVersion === 4) {
170		return 0;
171		}
172
173		if ($this->ipV4Start) {
174		return $this->ipV4Start;
175		}
176		$node = 0;
177
178		for ($i = 0; $i < 96 && $node < $this->metadata->nodeCount; $i++) {
179		$node = $this->readNode($node, 0);
180		}
181		$this->ipV4Start = $node;
182
183		return $node;
184		}
185
186		private function readNode($nodeNumber, $index)
187		{
188		$baseOffset = $nodeNumber * $this->metadata->nodeByteSize;
		0 ignored issues – show Documentation introduced 2018-04-24 03:55 UTC by Report Bug Copy Issue Report The property `$nodeByteSize` is declared private in `MaxMind\Db\Reader\Metadata`. Since you implemented `__get()`, maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion. Since your code implements the magic setter `_set`, this function will be called for any write access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } Since the property has write access only, you can use the @property-write annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
189
190		// XXX - probably could condense this.
191		switch ($this->metadata->recordSize) {
192	View Code Duplication	case 24:
193		$bytes = Util::read($this->fileHandle, $baseOffset + $index * 3, 3);
194		list(, $node) = unpack('N', "\x00" . $bytes);
195
196		return $node;
197		case 28:
198		$middleByte = Util::read($this->fileHandle, $baseOffset + 3, 1);
199		list(, $middle) = unpack('C', $middleByte);
200		if ($index === 0) {
201		$middle = (0xF0 & $middle) >> 4;
202		} else {
203		$middle = 0x0F & $middle;
204		}
205		$bytes = Util::read($this->fileHandle, $baseOffset + $index * 4, 3);
206		list(, $node) = unpack('N', chr($middle) . $bytes);
207
208		return $node;
209	View Code Duplication	case 32:
210		$bytes = Util::read($this->fileHandle, $baseOffset + $index * 4, 4);
211		list(, $node) = unpack('N', $bytes);
212
213		return $node;
214		default:
215		throw new InvalidDatabaseException(
216		'Unknown record size: '
217		. $this->metadata->recordSize
218		);
219		}
220		}
221
222		private function resolveDataPointer($pointer)
223		{
224		$resolved = $pointer - $this->metadata->nodeCount
225		+ $this->metadata->searchTreeSize;
		0 ignored issues – show Documentation introduced 2018-04-24 03:55 UTC by Report Bug Copy Issue Report The property `$searchTreeSize` is declared private in `MaxMind\Db\Reader\Metadata`. Since you implemented `__get()`, maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion. Since your code implements the magic setter `_set`, this function will be called for any write access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } Since the property has write access only, you can use the @property-write annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
226		if ($resolved > $this->fileSize) {
227		throw new InvalidDatabaseException(
228		"The MaxMind DB file's search tree is corrupt"
229		);
230		}
231
232		list($data) = $this->decoder->decode($resolved);
233
234		return $data;
235		}
236
237		/*
238		* This is an extremely naive but reasonably readable implementation. There
239		* are much faster algorithms (e.g., Boyer-Moore) for this if speed is ever
240		* an issue, but I suspect it won't be.
241		*/
242		private function findMetadataStart($filename)
243		{
244		$handle = $this->fileHandle;
245		$fstat = fstat($handle);
246		$fileSize = $fstat['size'];
247		$marker = self::$METADATA_START_MARKER;
248		$markerLength = self::$METADATA_START_MARKER_LENGTH;
249		$metadataMaxLengthExcludingMarker
250		= min(self::$METADATA_MAX_SIZE, $fileSize) - $markerLength;
251
252		for ($i = 0; $i <= $metadataMaxLengthExcludingMarker; $i++) {
253		for ($j = 0; $j < $markerLength; $j++) {
254		fseek($handle, $fileSize - $i - $j - 1);
255		$matchBit = fgetc($handle);
256		if ($matchBit !== $marker[$markerLength - $j - 1]) {
257		continue 2;
258		}
259		}
260
261		return $fileSize - $i;
262		}
263		throw new InvalidDatabaseException(
264		"Error opening database file ($filename). " .
265		'Is this a valid MaxMind DB file?'
266		);
267		}
268
269		/**
270		* @throws \InvalidArgumentException if arguments are passed to the method
271		* @throws \BadMethodCallException if the database has been closed
272		*
273		* @return Metadata object for the database
274		*/
275		public function metadata()
276		{
277		if (func_num_args()) {
278		throw new \InvalidArgumentException(
279		'Method takes no arguments.'
280		);
281		}
282
283		// Not technically required, but this makes it consistent with
284		// C extension and it allows us to change our implementation later.
285		if (!is_resource($this->fileHandle)) {
286		throw new \BadMethodCallException(
287		'Attempt to read from a closed MaxMind DB.'
288		);
289		}
290
291		return $this->metadata;
292		}
293
294		/**
295		* Closes the MaxMind DB and returns resources to the system.
296		*
297		* @throws \Exception
298		* if an I/O error occurs
299		*/
300		public function close()
301		{
302		if (!is_resource($this->fileHandle)) {
303		throw new \BadMethodCallException(
304		'Attempt to close a closed MaxMind DB.'
305		);
306		}
307		fclose($this->fileHandle);
308		}
309		}
310

Automattic / jetpack

Push — add/gdpr-ads-compliance ( 47ea51...6d1e7f )

Reader::findMetadataStart() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like