See Release Notes
Long Term Support Release
<?php> declare(strict_types=1); namespace MaxMind\Db\Reader; >// @codingStandardsIgnoreLine use RuntimeException;< /** < * @ignore < * < * We subtract 1 from the log to protect against precision loss. < */ < \define(__NAMESPACE__ . '\_MM_MAX_INT_BYTES', (log(PHP_INT_MAX, 2) - 1) / 8); <class Decoder {> /** private $fileStream; > * @var resource private $pointerBase; > */private $pointerBaseByteSize;> /** // This is only used for unit testing > * @var int private $pointerTestHack; > */private $switchByteOrder;> /** > * @var float /** @ignore */ > */< // This is only used for unit testing> /** > * This is only used for unit testing. > * > * @var bool > *//** @ignore */> /** const _POINTER = 1; > * @var bool /** @ignore */ > */< /** @ignore */ < const _EXTENDED = 0; < /** @ignore */ < const _POINTER = 1; < /** @ignore */ < const _UTF8_STRING = 2; < /** @ignore */ < const _DOUBLE = 3; < /** @ignore */ < const _BYTES = 4; < /** @ignore */ < const _UINT16 = 5; < /** @ignore */ < const _UINT32 = 6; < /** @ignore */ < const _MAP = 7; < /** @ignore */ < const _INT32 = 8; < /** @ignore */ < const _UINT64 = 9; < /** @ignore */ < const _UINT128 = 10; < /** @ignore */ < const _ARRAY = 11; < /** @ignore */ < const _CONTAINER = 12; < /** @ignore */ < const _END_MARKER = 13; < /** @ignore */ < const _BOOLEAN = 14; < /** @ignore */ < const _FLOAT = 15;> private const _EXTENDED = 0; > private const _POINTER = 1; > private const _UTF8_STRING = 2; > private const _DOUBLE = 3; > private const _BYTES = 4; > private const _UINT16 = 5; > private const _UINT32 = 6; > private const _MAP = 7; > private const _INT32 = 8; > private const _UINT64 = 9; > private const _UINT128 = 10; > private const _ARRAY = 11; > private const _CONTAINER = 12; > private const _END_MARKER = 13; > private const _BOOLEAN = 14; > private const _FLOAT = 15;) {> /** $this->fileStream = $fileStream; > * @param resource $fileStream $this->pointerBase = $pointerBase; > */< $pointerBase = 0, < $pointerTestHack = false> int $pointerBase = 0, > bool $pointerTestHack = false$this->pointerTestHack = $pointerTestHack; $this->switchByteOrder = $this->isPlatformLittleEndian(); }< public function decode($offset)> public function decode(int $offset): array{ $ctrlByte = \ord(Util::read($this->fileStream, $offset, 1)); ++$offset; $type = $ctrlByte >> 5; // Pointers are a special case, we don't read the next $size bytes, we // use the size to determine the length of the pointer and then follow // it. if ($type === self::_POINTER) {< list($pointer, $offset) = $this->decodePointer($ctrlByte, $offset);> [$pointer, $offset] = $this->decodePointer($ctrlByte, $offset);// for unit testing if ($this->pointerTestHack) { return [$pointer]; }< list($result) = $this->decode($pointer);> [$result] = $this->decode($pointer);return [$result, $offset]; } if ($type === self::_EXTENDED) { $nextByte = \ord(Util::read($this->fileStream, $offset, 1)); $type = $nextByte + 7; if ($type < 8) { throw new InvalidDatabaseException( 'Something went horribly wrong in the decoder. An extended type ' . 'resolved to a type number < 8 (' . $type . ')' ); } ++$offset; }< list($size, $offset) = $this->sizeFromCtrlByte($ctrlByte, $offset);> [$size, $offset] = $this->sizeFromCtrlByte($ctrlByte, $offset);return $this->decodeByType($type, $offset, $size); }< private function decodeByType($type, $offset, $size)> private function decodeByType(int $type, int $offset, int $size): array{ switch ($type) { case self::_MAP: return $this->decodeMap($size, $offset);>case self::_ARRAY: return $this->decodeArray($size, $offset);>case self::_BOOLEAN: return [$this->decodeBoolean($size), $offset]; } $newOffset = $offset + $size; $bytes = Util::read($this->fileStream, $offset, $size);>switch ($type) { case self::_BYTES: case self::_UTF8_STRING: return [$bytes, $newOffset];>case self::_DOUBLE: $this->verifySize(8, $size); return [$this->decodeDouble($bytes), $newOffset];>case self::_FLOAT: $this->verifySize(4, $size); return [$this->decodeFloat($bytes), $newOffset];>case self::_INT32: return [$this->decodeInt32($bytes, $size), $newOffset];>case self::_UINT16: case self::_UINT32: case self::_UINT64: case self::_UINT128: return [$this->decodeUint($bytes, $size), $newOffset];>default: throw new InvalidDatabaseException( 'Unknown or unexpected type: ' . $type ); } }< private function verifySize($expected, $actual)> private function verifySize(int $expected, int $actual): void{ if ($expected !== $actual) { throw new InvalidDatabaseException( "The MaxMind DB file's data section contains bad data (unknown data type or corrupt data)" ); } }< private function decodeArray($size, $offset)> private function decodeArray(int $size, int $offset): array{ $array = []; for ($i = 0; $i < $size; ++$i) {< list($value, $offset) = $this->decode($offset); < array_push($array, $value);> [$value, $offset] = $this->decode($offset); > $array[] = $value;} return [$array, $offset]; }< private function decodeBoolean($size)> private function decodeBoolean(int $size): bool{< return $size === 0 ? false : true;> return $size !== 0;}< private function decodeDouble($bits)> private function decodeDouble(string $bytes): float{ // This assumes IEEE 754 doubles, but most (all?) modern platforms // use them.< // < // We are not using the "E" format as that was only added in < // 7.0.15 and 7.1.1. As such, we must switch byte order on < // little endian machines. < list(, $double) = unpack('d', $this->maybeSwitchByteOrder($bits));> [, $double] = unpack('E', $bytes);return $double; }< private function decodeFloat($bits)> private function decodeFloat(string $bytes): float{ // This assumes IEEE 754 floats, but most (all?) modern platforms // use them.< // < // We are not using the "G" format as that was only added in < // 7.0.15 and 7.1.1. As such, we must switch byte order on < // little endian machines. < list(, $float) = unpack('f', $this->maybeSwitchByteOrder($bits));> [, $float] = unpack('G', $bytes);return $float; }< private function decodeInt32($bytes, $size)> private function decodeInt32(string $bytes, int $size): int{ switch ($size) { case 0: return 0;>case 1: case 2: case 3:< $bytes = str_pad($bytes, 4, "\x00", STR_PAD_LEFT);> $bytes = str_pad($bytes, 4, "\x00", \STR_PAD_LEFT); >break;>case 4: break;>default: throw new InvalidDatabaseException( "The MaxMind DB file's data section contains bad data (unknown data type or corrupt data)" ); }< list(, $int) = unpack('l', $this->maybeSwitchByteOrder($bytes));> [, $int] = unpack('l', $this->maybeSwitchByteOrder($bytes));return $int; }< private function decodeMap($size, $offset)> private function decodeMap(int $size, int $offset): array{ $map = []; for ($i = 0; $i < $size; ++$i) {< list($key, $offset) = $this->decode($offset); < list($value, $offset) = $this->decode($offset);> [$key, $offset] = $this->decode($offset); > [$value, $offset] = $this->decode($offset);$map[$key] = $value; } return [$map, $offset]; }< private function decodePointer($ctrlByte, $offset)> private function decodePointer(int $ctrlByte, int $offset): array{ $pointerSize = (($ctrlByte >> 3) & 0x3) + 1; $buffer = Util::read($this->fileStream, $offset, $pointerSize); $offset = $offset + $pointerSize; switch ($pointerSize) { case 1: $packed = \chr($ctrlByte & 0x7) . $buffer;< list(, $pointer) = unpack('n', $packed);> [, $pointer] = unpack('n', $packed);$pointer += $this->pointerBase;>break;>case 2: $packed = "\x00" . \chr($ctrlByte & 0x7) . $buffer;< list(, $pointer) = unpack('N', $packed);> [, $pointer] = unpack('N', $packed);$pointer += $this->pointerBase + 2048;>break;>case 3: $packed = \chr($ctrlByte & 0x7) . $buffer; // It is safe to use 'N' here, even on 32 bit machines as the // first bit is 0.< list(, $pointer) = unpack('N', $packed);> [, $pointer] = unpack('N', $packed);$pointer += $this->pointerBase + 526336;>break;>case 4: // We cannot use unpack here as we might overflow on 32 bit // machines $pointerOffset = $this->decodeUint($buffer, $pointerSize);< $byteLength = $pointerSize + $this->pointerBaseByteSize;> $pointerBase = $this->pointerBase;< if ($byteLength <= _MM_MAX_INT_BYTES) { < $pointer = $pointerOffset + $this->pointerBase; < } elseif (\extension_loaded('gmp')) { < $pointer = gmp_strval(gmp_add($pointerOffset, $this->pointerBase)); < } elseif (\extension_loaded('bcmath')) { < $pointer = bcadd($pointerOffset, $this->pointerBase);> if (\PHP_INT_MAX - $pointerBase >= $pointerOffset) { > $pointer = $pointerOffset + $pointerBase;} else { throw new RuntimeException(< 'The gmp or bcmath extension must be installed to read this database.'> 'The database offset is too large to be represented on your platform.'); }> } > break; > return [$pointer, $offset]; > default: } > throw new InvalidDatabaseException( > 'Unexpected pointer size ' . $pointerSize private function decodeUint($bytes, $byteLength) > );< private function decodeUint($bytes, $byteLength)> // @phpstan-ignore-next-line > private function decodeUint(string $bytes, int $byteLength)if ($byteLength === 0) { return 0; } $integer = 0;> // PHP integers are signed. PHP_INT_SIZE - 1 is the number of for ($i = 0; $i < $byteLength; ++$i) { > // complete bytes that can be converted to an integer. However, $part = \ord($bytes[$i]); > // we can convert another byte if the leading bit is zero. > $useRealInts = $byteLength <= \PHP_INT_SIZE - 1 // We only use gmp or bcmath if the final value is too big > || ($byteLength === \PHP_INT_SIZE && (\ord($bytes[0]) & 0x80) === 0); if ($byteLength <= _MM_MAX_INT_BYTES) { >< if ($byteLength <= _MM_MAX_INT_BYTES) {> if ($useRealInts) {} elseif (\extension_loaded('gmp')) {< $integer = gmp_strval(gmp_add(gmp_mul($integer, 256), $part));> $integer = gmp_strval(gmp_add(gmp_mul((string) $integer, '256'), $part));} elseif (\extension_loaded('bcmath')) {< $integer = bcadd(bcmul($integer, 256), $part);> $integer = bcadd(bcmul((string) $integer, '256'), (string) $part);} else { throw new RuntimeException( 'The gmp or bcmath extension must be installed to read this database.' ); } } return $integer; }< private function sizeFromCtrlByte($ctrlByte, $offset)> private function sizeFromCtrlByte(int $ctrlByte, int $offset): array{< $size = $ctrlByte & 0x1f;> $size = $ctrlByte & 0x1F;if ($size < 29) { return [$size, $offset]; } $bytesToRead = $size - 28; $bytes = Util::read($this->fileStream, $offset, $bytesToRead); if ($size === 29) { $size = 29 + \ord($bytes); } elseif ($size === 30) {< list(, $adjust) = unpack('n', $bytes);> [, $adjust] = unpack('n', $bytes);$size = 285 + $adjust;< } elseif ($size > 30) { < list(, $adjust) = unpack('N', "\x00" . $bytes);> } else { > [, $adjust] = unpack('N', "\x00" . $bytes);$size = $adjust + 65821; } return [$size, $offset + $bytesToRead]; }< private function maybeSwitchByteOrder($bytes)> private function maybeSwitchByteOrder(string $bytes): string{ return $this->switchByteOrder ? strrev($bytes) : $bytes; }< private function isPlatformLittleEndian()> private function isPlatformLittleEndian(): bool{ $testint = 0x00FF; $packed = pack('S', $testint); return $testint === current(unpack('v', $packed)); } }