Fix a memory leak issue and a problem parsing MPQ26 headers

src/Compression/DeflateCompression.php

@@ -49,7 +49,7 @@ class DeflateCompression implements Compression {
 	 */
 	public function decompress($data, $length) {
 		$output = @gzinflate(substr($data, 0, $length), $length);
-		if(!is_string($output)) {
+		if($output === false) {
 			throw new InvalidInputDataException('The decompression input data is invalid.', $output);
 		}
 		return $output;

src/Hashing/BaseHashing.php

@@ -42,19 +42,18 @@ abstract class BaseHashing implements Hashing {
 
 	public function hash($string) {
 		$seed1 = 0x7FED7FED;
-		$seed2 = ((0xEEEE << 16) | 0xEEEE);
+		$seed2 = 0xEEEEEEEE;
 		$strLen = strlen($string);
 
 		for ($i = 0;$i < $strLen;$i++) {
 			$next = ord(strtoupper(substr($string, $i, 1)));
 
-			$seed1 = CryptoUtils::$cryptTable[($this->hashType << 8) + $next] ^ (CryptoUtils::uPlus($seed1,$seed2));
-			$seed2 = CryptoUtils::uPlus(CryptoUtils::uPlus(CryptoUtils::uPlus(CryptoUtils::uPlus($next,$seed1),$seed2),$seed2 << 5),3);
+			$seed1 = CryptoUtils::$cryptTable[($this->hashType << 8) + $next] ^ (CryptoUtils::uPlus($seed1,$seed2)) & 0xFFFFFFFF;
+			$seed2 = CryptoUtils::uPlus(CryptoUtils::uPlus(CryptoUtils::uPlus(CryptoUtils::uPlus($next,$seed1),$seed2),$seed2 << 5),3) & 0xFFFFFFFF;
 		}
 		return $seed1;
 	}
 
-
 // function that adds up two integers without allowing them to overflow to floats
 	private function uPlus($o1, $o2) {
 		$o1h = ($o1 >> 16) & 0xFFFF;

src/MPQFile.php

@@ -81,6 +81,10 @@ class MPQFile {
 		$this->stream = $stream;
 	}
 
+    function __destruct() {
+        $this->stream->close();
+    }
+
 	// -----------------------------------------------------------------------------------------------------------------
 
 	public function isParsed() {
@@ -98,9 +102,10 @@ class MPQFile {
 		if($signature == "MPQ27") {
 			$this->userData = UserData::parse($parser);
 			$this->stream->seek($this->getUserDataOffset());
+
+            $signature = $this->parseSignature($parser);
 		}
 
-		$signature = $this->parseSignature($parser);
 		if($signature == "MPQ26") {
 			$this->header = Header::parse($parser);
 		}
@@ -130,13 +135,14 @@ class MPQFile {
 		$parser->seek($this->getUserDataOffset() + $this->getHeader()->getBlockTablePos());
 		$blocks = array();
 
-		$offsetFix = 0;
+//		$offsetFix = 0;
 		for($i = 0; $i<$this->getHeader()->getBlockTableSize(); $i++) {
-			$block = $blocks[$i - $offsetFix] = Block::parse($parser);
-			if($block->getSize() == 0) {
-				$offsetFix++;
-			}
+			$block = $blocks[$i] = Block::parse($parser);
+//			if($block->getSize() == 0) {
+//				$offsetFix++;
+//			}
 		}
+
 		return new BlockTable($blocks);
 	}
 
@@ -151,7 +157,7 @@ class MPQFile {
 
 	// -----------------------------------------------------------------------------------------------------------------
 
-	private function getUserDataOffset() {
+	public function getUserDataOffset() {
 		$userData = $this->getUserData();
 		if($userData === null) {
 			return 0;
@@ -184,6 +190,7 @@ class MPQFile {
 		if($hash == NULL) {
 			return NULL;
 		}
+
 		return $this->getBlockTable()->getBlock($hash->getBlockIndex());
 	}
 
@@ -199,25 +206,14 @@ class MPQFile {
 
 		$sectors = array();
 		if($block->isChecksumed() || !$block->isSingleUnit()) {
-			$blockSize = $block->getCompressedSize();
+			$blockSize = 512 * (1 << $this->getHeader()->getBlockSize());
 			$fileSize  = $block->getSize();
 
-			print_r($this->getBlockTable()->getBlocks());
-
-//			print_r($block);
-//			echo $block->isExisting() ? "true" : "false";
-//			echo "\n";
-//
-//			echo $fileSize."\n";
-//			echo $this->getHeader()->getBlockSize()."\n";
-
 			for ($i = $fileSize; $i > 0; $i -= $blockSize) {
-				echo $i;
 				$sectors[] = $parser->readUInt32();
 				$blockSize -= 4;
 			}
-			print_r($sectors);
-//			$sectors[] = $parser->readUInt32();
+			$sectors[] = $parser->readUInt32();
 		} else {
 			$sectors = array(
 				0,
@@ -268,4 +264,4 @@ class MPQFile {
 		return new MPQFile(new MemoryStream($string));
 	}
 
-}
+}

src/Stream/Block/BlockStream.php

@@ -35,6 +35,7 @@ use Rogiel\MPQ\Exception\Compression\CompressionException;
 use Rogiel\MPQ\Metadata\Block;
 use Rogiel\MPQ\MPQFile;
 use Rogiel\MPQ\Stream\CompressedStream;
+use Rogiel\MPQ\Stream\MemoryStream;
 use Rogiel\MPQ\Stream\Parser\BinaryStreamParser;
 use Rogiel\MPQ\Stream\Stream;
 
@@ -109,7 +110,7 @@ class BlockStream implements Stream {
 	}
 
 	public function readBytes($bytes) {
-		if($this->eof()) {
+	    if($this->eof()) {
 			return false;
 		}
 		if(($this->position + $bytes) > $this->block->getSize()) {
@@ -119,7 +120,11 @@ class BlockStream implements Stream {
 		if($this->buffer === NULL) {
 			$this->buffer = $this->readSector($this->currentSector);
 			$this->positionInSector = 0;
-		} else if($this->positionInSector >= strlen($this->buffer)) {
+        } else if($this->positionInSector >= strlen($this->buffer)) {
+            if(!isset($this->sectors[$this->currentSector->getIndex() + 1])) {
+		        return false;
+            }
+
 			$this->currentSector = $this->sectors[$this->currentSector->getIndex() + 1];
 			$this->buffer = $this->readSector($this->currentSector);
 			$this->positionInSector = 0;
@@ -157,23 +162,28 @@ class BlockStream implements Stream {
 	// -----------------------------------------------------------------------------------------------------------------
 
 	private function readSector(Sector $sector) {
-		$this->stream->seek($this->file->getUserData()->getHeaderOffset()
+		$this->stream->seek($this->file->getUserDataOffset()
 			+ $this->block->getFilePos()
 			+ $sector->getStart());
 
-		$compressedStream = $this->createCompressedStream();
-		return $compressedStream->readBytes($sector->getLength());
+		$compressedStream = $this->createCompressedStream($sector);
+		return $compressedStream->readBytes($this->block->getSize());
 	}
 
-	private function createCompressedStream() {
+	private function createCompressedStream(Sector $sector) {
 		$stream = $this->stream;
 
-		if($this->block->isCompressed() && $this->block->getSize() > $this->block->getCompressedSize()) {
+        if($this->block->isCompressed() && $this->block->getSize() > $this->block->getCompressedSize()) {
 			$parser = new BinaryStreamParser($this->stream);
 			$compressionType = $parser->readByte();
 			switch ($compressionType) {
 				case 0x00: return $stream;
-				case 0x02: return new CompressedStream($stream, new DeflateCompression());
+                case 0x02: {
+                    $len = $parser->readUInt16();
+                    $blockData = $stream->readBytes($len);
+                    return new MemoryStream(gzinflate($blockData));
+                }
+//				case 0x02: return new CompressedStream($stream, new DeflateCompression());
 				case 0x10: return new CompressedStream($stream, new BZIPCompression());
 				default:
 					throw new CompressionException(sprintf('Invalid compression format: %s', $compressionType));

src/Stream/FileStream.php

@@ -40,14 +40,22 @@ class FileStream implements Stream {
 		$this->handle = fopen($file, 'r');
 	}
 
+    public function __clone() {
+        $this->handle = fopen($this->file, 'r');
+    }
+
+    function __destruct() {
+        $this->close();
+    }
+
 	// -----------------------------------------------------------------------------------------------------------------
 
 	/**
 	 * {@inheritdoc}
 	 */
 	public function close() {
-		fclose($this->handle);
-	}
+		@fclose($this->handle);
+    }
 
 	/**
 	 * {@inheritdoc}
@@ -84,10 +92,4 @@ class FileStream implements Stream {
 		return feof($this->handle);
 	}
 
-	// -----------------------------------------------------------------------------------------------------------------
-
-	public function __clone() {
-		return new FileStream($this->file);
-	}
-
 }

src/Stream/Parser/BinaryStreamParser.php

@@ -69,6 +69,17 @@ class BinaryStreamParser {
 		return $this->stream->readBytes($size);
 	}
 
+	public function readCString($debug=false) {
+	    $str = '';
+	    while(true) {
+	        $c = $this->stream->readBytes(1);
+            if($c == "\0") {
+                return $str;
+            }
+            $str .= (string) $c;
+        }
+    }
+
 	public function eof() {
 		return $this->stream->eof();
 	}