php: Allow ForFile users to override filesystem driver (#892)

Allow to pass an optional amphp driver for ForFile() usage.

Use case is Nextcloud, where we need to override the default amphp
driver selection to work around issues. Callers can already provide
their own implementations using ForStream(), but ForFile() has the
benefit of hashing client-side.

Note that while the driver is overriden for uploading only. When
performing SHA256 hashing we use the PHP standard library, which doesn't
allow for custom filesystem drivers like amphp.

Author: GermanCoding

php/src/vaas/Options/ForFileOptions.php

@@ -2,16 +2,19 @@
 
 namespace VaasSdk\Options;
 
+use Amp\File\FilesystemDriver;
+
 class ForFileOptions
 {
-    private const DEFAULT_TIMEOUT = 300;
-    private const DEFAULT_REQUEST_ID = null;
+    public const DEFAULT_TIMEOUT = 300;
+    public const DEFAULT_REQUEST_ID = null;
 
     public function __construct(
-        public bool $useCache = true,
-        public bool $useHashLookup = true,
-        public int $timeout = self::DEFAULT_TIMEOUT,
-        public ?string $vaasRequestId = self::DEFAULT_REQUEST_ID) {}
+        public bool        $useCache = true,
+        public bool        $useHashLookup = true,
+        public int         $timeout = self::DEFAULT_TIMEOUT,
+		public ?FilesystemDriver $filesystemDriver = null,
+        public ?string     $vaasRequestId = self::DEFAULT_REQUEST_ID) {}
 
     public static function fromVaasOptions(VaasOptions $options): self
     {

php/src/vaas/Vaas.php

@@ -23,7 +23,7 @@
 use VaasSdk\Options\ForUrlOptions;
 use VaasSdk\Options\VaasOptions;
 use function Amp\async;
-use function Amp\File\openFile;
+use function Amp\File\filesystem;
 
 class Vaas
 {
@@ -140,8 +140,9 @@ public function forFileAsync(string $path, ?ForFileOptions $options = null, ?Can
     {
         return async(function () use ($path, $options, $cancellation) {
             $this->logger->debug("Requesting verdict for file: $path");
+			$filesystem = filesystem($options->filesystemDriver);
 
-            if (!file_exists($path)) {
+            if (!$filesystem->exists($path)) {
                 $this->logger->error("File does not exist: $path");
                 throw new VaasClientException('File does not exist');
             }
@@ -167,7 +168,7 @@ public function forFileAsync(string $path, ?ForFileOptions $options = null, ?Can
             }
 
             try {
-                $stream = openFile($path, 'r');
+                $stream = $filesystem->openFile($path, 'r');
                 $cancellation?->subscribe(function () use ($stream) { $stream->close(); });
                 $forStreamOptions = new ForStreamOptions($options->useHashLookup, $options->timeout, $options->vaasRequestId);
                 $this->logger->debug("Requesting verdict for $path as file stream");

php/tests/VaasTesting/VaasTest.php

@@ -2,6 +2,9 @@
 
 namespace VaasTesting;
 
+use Amp\File\Driver\BlockingFilesystemDriver;
+use Amp\File\File;
+use Amp\File\FilesystemDriver;
 use Amp\File\FilesystemException;
 use Dotenv\Dotenv;
 use Monolog\Formatter\JsonFormatter;
@@ -14,11 +17,13 @@
 use VaasSdk\Authentication\ClientCredentialsGrantAuthenticator;
 use VaasSdk\Exceptions\InvalidSha256Exception;
 use VaasSdk\Exceptions\VaasClientException;
+use VaasSdk\Options\ForFileOptions;
 use VaasSdk\Options\ForSha256Options;
 use VaasSdk\Options\VaasOptions;
 use VaasSdk\Sha256;
 use VaasSdk\Vaas;
 use VaasSdk\Verdict;
+use function Amp\File\filesystem;
 use function Amp\File\openFile;
 
 final class VaasTest extends TestCase
@@ -274,6 +279,117 @@ public function testForFile_WithInvalidFile_ThrowsVaasClientException(): void
         $this->vaas->forFileAsync(__DIR__ . "/invalid")->await();
     }
 
+	public function testForFile_WithCustomFilesystemDriver_UtilizesDriver(): void
+	{
+		$file = file_get_contents(self::PUP_URL);
+		file_put_contents(__DIR__ . "/PotentiallyUnwantedCustomDriver.exe", $file);
+		$customDriverCalled = false;
+		$customDriver = new class(
+			function () use (&$customDriverCalled) {
+				$customDriverCalled = true;
+			}
+		) implements FileSystemDriver {
+			private $callback;
+
+			public function __construct(callable $callback)
+			{
+				$this->callback = $callback;
+			}
+
+			public function openFile(string $path, string $mode): File
+			{
+				($this->callback)();
+				return filesystem(new BlockingFilesystemDriver())->openFile($path, $mode);
+			}
+
+			public function getStatus(string $path): ?array
+			{
+				return filesystem(new BlockingFilesystemDriver())->getStatus($path);
+			}
+
+			public function getLinkStatus(string $path): ?array
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function createSymlink(string $target, string $link): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function createHardlink(string $target, string $link): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function resolveSymlink(string $target): string
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function move(string $from, string $to): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function deleteFile(string $path): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function createDirectory(string $path, int $mode = 0777): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function createDirectoryRecursively(string $path, int $mode = 0777): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function deleteDirectory(string $path): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function listFiles(string $path): array
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function changePermissions(string $path, int $mode): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function changeOwner(string $path, ?int $uid, ?int $gid): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function touch(string $path, ?int $modificationTime, ?int $accessTime): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function read(string $path): string
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+
+			public function write(string $path, string $contents): void
+			{
+				throw new BadMethodCallException('Not implemented');
+			}
+		};
+
+		$verdict = $this->vaas->forFileAsync(__DIR__ . "/PotentiallyUnwantedCustomDriver.exe", new ForFileOptions(false, false, ForFileOptions::DEFAULT_TIMEOUT, $customDriver))->await();
+
+		unlink(__DIR__ . "/PotentiallyUnwantedCustomDriver.exe");
+		$this->assertEquals(Verdict::PUP, $verdict->verdict);
+		$this->assertTrue($customDriverCalled, "custom driver not called");
+	}
+
     public function testForStream_WithCleanStream_GetsCleanResponse(): void
     {
         try {