javonet-ruby-sdk 2.6.7 → 2.6.10

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/LoadLibraryHandler.php

@@ -27,29 +27,38 @@ final class LoadLibraryHandler extends AbstractHandler
     {
         if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
             throw new JavonetArgumentsMismatchException(
-            self::class,
+                self::class,
                 self::REQUIRED_ARGUMENTS_COUNT
             );
         }
 
         $assemblyName = (string) $command->getPayload()[0];
+
         if (!file_exists($assemblyName)) {
             throw new Exception('File not found: ' . $assemblyName);
         }
 
-        if (in_array($assemblyName, self::$loadedLibraries, true)) {
+        // Normalize path first
+        $canonicalPath = realpath($assemblyName);
+        if ($canonicalPath === false) {
+            throw new Exception('Cannot resolve path: ' . $assemblyName);
+        }
+
+        // Already loaded? bail out early
+        if (in_array($canonicalPath, self::$loadedLibraries, true)) {
             return 0;
         }
 
-        if (is_dir($assemblyName)) {
-            $this->loadDirectory($assemblyName);
-        } elseif (pathinfo($assemblyName, PATHINFO_EXTENSION) === 'phar') {
-            $this->loadPharFile($assemblyName);
+        // Use canonical path for type detection as well
+        if (is_dir($canonicalPath)) {
+            $this->loadDirectory($canonicalPath);
+        } elseif (pathinfo($canonicalPath, PATHINFO_EXTENSION) === 'phar') {
+            $this->loadPharFile($canonicalPath);
         } else {
-            $this->loadPhpFile($assemblyName);
+            $this->loadPhpFile($canonicalPath);
         }
 
-        self::$loadedLibraries[] = $assemblyName;
+        self::$loadedLibraries[] = $canonicalPath;
         return 0;
     }
 
@@ -79,51 +88,69 @@ final class LoadLibraryHandler extends AbstractHandler
             throw new Exception('PHAR file is not readable: ' . $pharPath);
         }
 
+        $realPath = realpath($pharPath);
+        if ($realPath === false) {
+            throw new Exception('Cannot resolve PHAR path: ' . $pharPath);
+        }
+
         try {
-            $phar = new Phar($pharPath);
+            $phar = new Phar($realPath);
 
             $currentIncludePath = get_include_path();
-            if (strpos($currentIncludePath, $pharPath) === false) {
-                set_include_path($currentIncludePath . PATH_SEPARATOR . $pharPath);
-                $this->loadedClassPaths[] = $pharPath;
+            if (strpos($currentIncludePath, $realPath) === false) {
+                set_include_path($currentIncludePath . PATH_SEPARATOR . $realPath);
+                $this->loadedClassPaths[] = $realPath;
             }
 
             if (isset($phar['bootstrap.php'])) {
-                include_once 'phar://' . $pharPath . '/bootstrap.php';
+                include_once 'phar://' . $realPath . '/bootstrap.php';
             }
         } catch (Exception $e) {
             throw new Exception(sprintf('Error loading PHAR file %s : %s', $pharPath, $e->getMessage()));
         }
     }
 
+    private static array $loadedPhpFiles = []; // optional extra safeguard
+
     private function loadPhpFile(string $filePath): void
     {
         if (!is_readable($filePath)) {
             throw new Exception('PHP file is not readable: ' . $filePath);
         }
 
-        $fileExtension = pathinfo($filePath, PATHINFO_EXTENSION);
+        $realPath = realpath($filePath);
+        if ($realPath === false) {
+            throw new Exception('Cannot resolve PHP file path: ' . $filePath);
+        }
+
+        $fileExtension = pathinfo($realPath, PATHINFO_EXTENSION);
         if (!in_array($fileExtension, ['php', 'inc'], true)) {
-            throw new Exception('File is not a valid PHP file: ' . $filePath);
+            throw new Exception('File is not a valid PHP file: ' . $realPath);
         }
 
-        $code = file_get_contents($filePath);
+        // OPTIONAL: skip if we already loaded this exact file
+        if (in_array($realPath, self::$loadedPhpFiles, true)) {
+            return;
+        }
+
+        $code = file_get_contents($realPath);
         if ($code === false) {
-            throw new Exception(sprintf('Failed to read php file: %s', $filePath));
+            throw new Exception(sprintf('Failed to read php file: %s', $realPath));
         }
 
         try {
             token_get_all($code, TOKEN_PARSE);
         } catch (ParseError $e) {
-            throw new Exception(sprintf('PHP syntax error in file %s: %s', $filePath, $e->getMessage()));
+            throw new Exception(sprintf('PHP syntax error in file %s: %s', $realPath, $e->getMessage()));
         }
 
         $lastError = error_get_last();
         if ($lastError && $lastError['type'] === E_PARSE) {
-            throw new Exception(sprintf('PHP syntax error in file %s: %s', $filePath, $lastError['message']));
+            throw new Exception(sprintf('PHP syntax error in file %s: %s', $realPath, $lastError['message']));
         }
 
-        include_once $filePath;
+        include_once $realPath;
+        self::$loadedPhpFiles[] = $realPath;
     }
 
     private function autoloadPhpFilesFromDirectory(string $directory): void
@@ -134,7 +161,15 @@ final class LoadLibraryHandler extends AbstractHandler
 
         foreach ($iterator as $file) {
             if ($file->isFile() && $file->getExtension() === 'php') {
-                include_once $file->getPathname();
+                $realPath = $file->getRealPath() ?: $file->getPathname();
+
+                // Optional: same guard as loadPhpFile
+                if (in_array($realPath, self::$loadedPhpFiles, true)) {
+                    continue;
+                }
+
+                include_once $realPath;
+                self::$loadedPhpFiles[] = $realPath;
             }
         }
     }

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/interpreter/Interpreter.php

@@ -44,7 +44,7 @@ final class Interpreter
             return $responseByteArray;
         }
 
-        $response = (new CommandDeserializer($responseByteArray))->deserialize();
+        $response = CommandDeserializer::deserialize($responseByteArray);
         if ($this->debugMode === 'TRUE') {
             echo 'Received command: ' . $response;
             MessageHelper::getInstance()->sendMessageToAppInsights('ReceivedCommand', $response->toString());
@@ -89,7 +89,7 @@ final class Interpreter
 
     public function process(array $byteArray): CommandInterface
     {
-        $receivedCommand = (new CommandDeserializer($byteArray))->deserialize();
+        $receivedCommand = CommandDeserializer::deserialize($byteArray);
         if ($this->debugMode === 'TRUE') {
             echo 'Received command: ' . $receivedCommand;
             MessageHelper::getInstance()->sendMessageToAppInsights('ReceivedCommand', $receivedCommand->toString());

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/protocol/CommandDeserializer.php

@@ -14,81 +14,90 @@ use utils\type\JType;
 
 final class CommandDeserializer
 {
-    private int $position;
-    private Command $command;
-    private array $buffer;
-
-    public function __construct(
-         array $buffer
-    ) {
-        $this->command = new Command(
-            new RuntimeName($buffer[0]),
-            new CommandType($buffer[10])
-        );
-        $this->buffer = $buffer;
-        $this->position = 11;
-    }
-
-    private function isNotEnd(): bool
+    private function __construct()
     {
-        return $this->position < count($this->buffer);
     }
 
-    public function deserialize(): CommandInterface
+    /**
+     * @param int[] $buffer
+     */
+    public static function deserialize(array $buffer): CommandInterface
     {
-        while ($this->isNotEnd()) {
-            $this->command = $this->command->addArgToPayload($this->readObject($this->buffer[$this->position]));
+        $position = 11;
+        $bufferLength = count($buffer);
+
+        $runtimeName = new RuntimeName($buffer[0]);
+        $commandType = new CommandType($buffer[10]);
+        $payload = [];
+
+        while ($position < $bufferLength) {
+            $payload[] = self::readObject($buffer, $position);
         }
 
-        return $this->command;
+        // Single Command instance created once with full payload
+        return new Command($runtimeName, $commandType, $payload);
     }
 
-    private function readObject(int $typeNum)
+    /**
+     * @param int[] $buffer
+     * @return mixed
+     */
+    private static function readObject(array $buffer, int &$position)
     {
-        $typeByte = new JType($typeNum);
+        $typeByte = new JType($buffer[$position]);
 
         switch ($typeByte->getValue()) {
             case JType::JAVONET_COMMAND:
-                return $this->readCommand();
+                return self::readCommand($buffer, $position);
             case JType::JAVONET_STRING:
-                return $this->readString();
+                return self::readString($buffer, $position);
             case JType::JAVONET_INTEGER:
-                return $this->readInt();
+                return self::readInt($buffer, $position);
             case JType::JAVONET_BOOLEAN:
-                return $this->readBool();
+                return self::readBool($buffer, $position);
             case JType::JAVONET_FLOAT:
-                return $this->readFloat();
+                return self::readFloat($buffer, $position);
             case JType::JAVONET_BYTE:
-                return $this->readByte();
+                return self::readByte($buffer, $position);
             case JType::JAVONET_CHAR:
-                return $this->readChar();
+                return self::readChar($buffer, $position);
             case JType::JAVONET_LONG:
-                return $this->readLong();
+                return self::readLong($buffer, $position);
             case JType::JAVONET_DOUBLE:
-                return $this->readDouble();
+                return self::readDouble($buffer, $position);
             case JType::JAVONET_UNSIGNED_LONG_LONG:
-                return $this->readUnsignedLong();
+                return self::readUnsignedLong($buffer, $position);
             case JType::JAVONET_UNSIGNED_INTEGER:
-                return $this->readUnsignedInteger();
+                return self::readUnsignedInteger($buffer, $position);
             case JType::JAVONET_NULL:
-                return $this->readNull();
+                return self::readNull($buffer, $position);
             default:
-                throw new TypeByteNotSupportedException($typeNum);
+                throw new TypeByteNotSupportedException($buffer[$position]);
         }
     }
 
-    protected function readCommand(): CommandInterface
+    /**
+     * @param int[] $buffer
+     */
+    protected static function readCommand(array $buffer, int &$position): CommandInterface
     {
-        $p = $this->position;
-        $numberOfElementsInPayload = TypeDeserializer::deserializeInt(array_slice($this->buffer, $p + 1, 4));
-        $runtime = $this->buffer[$p + 5];
-        $commandType = $this->buffer[$p + 6];
+        $p = $position;
+
+        $numberOfElementsInPayload = TypeDeserializer::deserializeInt([
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+        ]);
+
+        $runtime     = $buffer[$p + 5];
+        $commandType = $buffer[$p + 6];
 
-        $this->position += 7;
+        $position += 7;
 
         $payload = [];
         for ($i = 0; $i < $numberOfElementsInPayload; $i++) {
-            $payload[$i] = $this->readObject($this->buffer[$this->position]);
+            $payload[$i] = self::readObject($buffer, $position);
         }
 
         return new Command(
@@ -98,114 +107,218 @@ final class CommandDeserializer
         );
     }
 
-    private function readString(): string
+    /**
+     * @param int[] $buffer
+     */
+    private static function readString(array $buffer, int &$position): string
     {
-        $p = $this->position;
-        $stringEncodingMode = new StringEncodingMode($this->buffer[$p + 1]);
-        $size = TypeDeserializer::deserializeInt(array_slice($this->buffer, $p + 2, 4));
-        $this->position += 6;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeString($stringEncodingMode, array_slice($this->buffer, $p, $size));
+        $p = $position;
+
+        $stringEncodingMode = new StringEncodingMode($buffer[$p + 1]);
+
+        $size = TypeDeserializer::deserializeInt([
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+        ]);
+
+        $position += 6;
+        $p = $position;
+        $position += $size;
+
+        // For strings, size can be large, so array_slice is acceptable here.
+        $bytes = array_slice($buffer, $p, $size);
+
+        return TypeDeserializer::deserializeString($stringEncodingMode, $bytes);
     }
 
-    private function readInt(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readInt(array $buffer, int &$position): int
     {
         $size = 4;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeInt(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+        ];
+
+        return TypeDeserializer::deserializeInt($bytes);
     }
 
-    private function readBool(): bool
+    /**
+     * @param int[] $buffer
+     */
+    private static function readBool(array $buffer, int &$position): bool
     {
         $size = 1;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        // Keep passing array to match existing TypeDeserializer signature
+        $bytes = [$buffer[$p]];
 
-        return TypeDeserializer::deserializeBool(array_slice($this->buffer, $p, $size));
+        return TypeDeserializer::deserializeBool($bytes);
     }
 
-    private function readFloat(): float
+    /**
+     * @param int[] $buffer
+     */
+    private static function readFloat(array $buffer, int &$position): float
     {
         $size = 4;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeFloat(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+        ];
+
+        return TypeDeserializer::deserializeFloat($bytes);
     }
 
-    private function readByte(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readByte(array $buffer, int &$position): int
     {
         $size = 1;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
+        $position += 2;
+        $p = $position;
+        $position += $size;
 
-        return TypeDeserializer::deserializeByte($this->buffer[$p]);
+        return TypeDeserializer::deserializeByte($buffer[$p]);
     }
 
-    private function readChar(): string
+    /**
+     * @param int[] $buffer
+     */
+    private static function readChar(array $buffer, int &$position): string
     {
         $size = 1;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
+        $position += 2;
+        $p = $position;
+        $position += $size;
 
-        return TypeDeserializer::deserializeChar($this->buffer[$p]);
+        return TypeDeserializer::deserializeChar($buffer[$p]);
     }
 
-    private function readLong(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readLong(array $buffer, int &$position): int
     {
         $size = 8;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeLong(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+            $buffer[$p + 6],
+            $buffer[$p + 7],
+        ];
+
+        return TypeDeserializer::deserializeLong($bytes);
     }
 
-    private function readDouble(): float
+    /**
+     * @param int[] $buffer
+     */
+    private static function readDouble(array $buffer, int &$position): float
     {
         $size = 8;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeDouble(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+            $buffer[$p + 6],
+            $buffer[$p + 7],
+        ];
+
+        return TypeDeserializer::deserializeDouble($bytes);
     }
 
-    private function readUnsignedLong(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readUnsignedLong(array $buffer, int &$position): int
     {
         $size = 8;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeLong(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+            $buffer[$p + 6],
+            $buffer[$p + 7],
+        ];
+
+        return TypeDeserializer::deserializeLong($bytes);
     }
 
-    private function readUnsignedInteger(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readUnsignedInteger(array $buffer, int &$position): int
     {
         $size = 4;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeInt(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+        ];
+
+        return TypeDeserializer::deserializeInt($bytes);
     }
 
-    private function readNull()
+    /**
+     * @param int[] $buffer
+     * @return mixed
+     */
+    private static function readNull(array $buffer, int &$position)
     {
         $size = 1;
-        $this->position += 2;
-        $this->position += $size;
+        $position += 2;
+        $position += $size;
 
+        // Current TypeDeserializer::deserializeNull() in your PHP version
+        // takes no args; keep that behavior.
         return TypeDeserializer::deserializeNull();
     }
 }