Ability to open from streams

cataphract · cataphract · commit 5aac941d3f5b · 2026-03-11T23:57:40.000Z
diff --git a/libarchive.c b/libarchive.c
@@ -171,7 +171,7 @@ static zend_object *arch_ce_create_object(zend_class_entry *ce)
     arch_object *zobj =
             emalloc(sizeof(*zobj) + zend_object_properties_size(ce));
 
-    zobj->file_location = NULL;
+    zobj->source_kind = ARCH_SOURCE_NONE;
     zobj->archive = NULL;
     zobj->arch_disk = NULL;
     zobj->write_disk_options = 0;
@@ -184,10 +184,17 @@ static zend_object *arch_ce_create_object(zend_class_entry *ce)
 static void arch_oh_free_obj(zend_object *zobj)
 {
     arch_object *obj = arch_object_fetch(zobj);
-    if (obj->file_location) {
-        zend_string_release(obj->file_location);
-        obj->file_location = NULL;
-    }
+    switch (obj->source_kind) {
+        case ARCH_SOURCE_FILE:
+            zend_string_release(obj->source.file_location);
+            break;
+        case ARCH_SOURCE_STREAM:
+            zval_ptr_dtor(&obj->source.stream_zv);
+            break;
+        case ARCH_SOURCE_NONE:
+            break;
+    }
+    obj->source_kind = ARCH_SOURCE_NONE;
     if (obj->archive) {
         archive_read_close(obj->archive);
         obj->archive = NULL;
@@ -210,47 +217,101 @@ PHP_METHOD(libarchive_Archive, __construct)
     }
 
     arch_object *arch_obj = arch_object_from_zv(getThis());
-    arch_obj->file_location = zend_string_copy(file);
+    arch_obj->source_kind = ARCH_SOURCE_FILE;
+    arch_obj->source.file_location = zend_string_copy(file);
     arch_obj->write_disk_options = (int)flags;
 }
 
+static bool arch_obj_open_read_stream(arch_object *arch_obj);
+
 static bool arch_obj_open_read(arch_object *arch_obj)
 {
     php_stream *stream = php_stream_open_wrapper(
-            arch_obj->file_location->val, "rb",
+            arch_obj->source.file_location->val, "rb",
             REPORT_ERRORS | STREAM_WILL_CAST | PHP_STREAM_PREFER_STDIO |
                     STREAM_MUST_SEEK,
             NULL);
 
     if (!stream) {
         zend_throw_exception_ex(except_ce, -1, "Could not open %s",
-                                arch_obj->file_location->val);
+                                arch_obj->source.file_location->val);
         return false;
     }
 
     int fd;
-    int res = php_stream_cast(stream, PHP_STREAM_AS_FD, (void **)&fd, 0);
+    if (php_stream_can_cast(stream, PHP_STREAM_AS_FD) == SUCCESS &&
+            php_stream_cast(stream, PHP_STREAM_AS_FD, (void **)&fd, 0) == SUCCESS) {
+        arch_obj->archive = archive_read_new();
+        archive_read_support_filter_all(arch_obj->archive);
+        archive_read_support_format_all(arch_obj->archive);
+        int res = archive_read_open_fd(arch_obj->archive, fd, 10240);
+        if (res != ARCHIVE_OK) {
+            zend_throw_exception_ex(
+                    except_ce, archive_errno(arch_obj->archive),
+                    "Could not open archive from file descriptor: %s",
+                    archive_error_string(arch_obj->archive));
+            return false;
+        }
+    } else {
+        /* FD cast not supported by this stream wrapper; fall back to FILE*.
+         * Switch the source so arch_obj_open_read_stream can take over and
+         * the stream resource is kept alive for the lifetime of the archive. */
+        zend_string_release(arch_obj->source.file_location);
+        arch_obj->source_kind = ARCH_SOURCE_STREAM;
+        php_stream_to_zval(stream, &arch_obj->source.stream_zv);
+        return arch_obj_open_read_stream(arch_obj);
+    }
+
+    return true;
+}
+
+static bool arch_obj_open_read_stream(arch_object *arch_obj)
+{
+    php_stream *stream;
+    php_stream_from_zval_no_verify(stream, &arch_obj->source.stream_zv);
+    if (!stream) {
+        zend_throw_exception(except_ce, "Invalid stream resource", -1);
+        return false;
+    }
+
+    FILE *fp;
+    int res = php_stream_cast(stream, PHP_STREAM_AS_STDIO, (void **)&fp, REPORT_ERRORS);
     if (res != SUCCESS) {
-        zend_throw_exception_ex(except_ce, -1, "Could not cast stream for %s",
-                                arch_obj->file_location->val);
+        zend_throw_exception(except_ce, "Could not cast stream to FILE*", -1);
         return false;
     }
 
     arch_obj->archive = archive_read_new();
     archive_read_support_filter_all(arch_obj->archive);
     archive_read_support_format_all(arch_obj->archive);
-    res = archive_read_open_fd(arch_obj->archive, fd, 10240);
+    res = archive_read_open_FILE(arch_obj->archive, fp);
     if (res != ARCHIVE_OK) {
         zend_throw_exception_ex(
                 except_ce, archive_errno(arch_obj->archive),
-                "Could not open archive from file descriptor: %s",
+                "Could not open archive from stream: %s",
                 archive_error_string(arch_obj->archive));
         return false;
     }
 
     return true;
 }
 
+PHP_METHOD(libarchive_Archive, fromStream)
+{
+    zval *stream_zv;
+    zend_long flags = 0;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &stream_zv, &flags) ==
+        FAILURE) {
+        return;
+    }
+
+    object_init_ex(return_value, arch_ce);
+    arch_object *arch_obj = arch_object_from_zv(return_value);
+    arch_obj->source_kind = ARCH_SOURCE_STREAM;
+    ZVAL_COPY(&arch_obj->source.stream_zv, stream_zv);
+    arch_obj->write_disk_options = (int)flags;
+}
+
 PHP_METHOD(libarchive_Archive, currentEntryStream)
 {
     ZEND_PARSE_PARAMETERS_NONE();
@@ -396,7 +457,7 @@ static zend_object_iterator *arch_ce_get_iterator(zend_class_entry *ce,
     }
 
     arch_object *arch_obj = arch_object_from_zv(object);
-    if (arch_obj->file_location == NULL) {
+    if (arch_obj->source_kind == ARCH_SOURCE_NONE) {
         php_error_docref(
                 NULL, E_ERROR,
                 "The Archive object has not been properly constructed");
@@ -407,8 +468,14 @@ static zend_object_iterator *arch_ce_get_iterator(zend_class_entry *ce,
                              -1);
         return NULL;
     }
-    if (!arch_obj_open_read(arch_obj)) {
-        return NULL;
+    if (arch_obj->source_kind == ARCH_SOURCE_FILE) {
+        if (!arch_obj_open_read(arch_obj)) {
+            return NULL;
+        }
+    } else {
+        if (!arch_obj_open_read_stream(arch_obj)) {
+            return NULL;
+        }
     }
 
     arch_iterator *it = emalloc(sizeof *it);
diff --git a/libarchive.stub.php b/libarchive.stub.php
@@ -285,6 +285,22 @@ final class Archive implements \IteratorAggregate
          */
         public function __construct(string $file, int $flags = 0) {}
 
+        /**
+         * Create an Archive reader from an already-open PHP stream.
+         *
+         * This method does not seek to the beginning of the stream; reading
+         * starts at the current position.
+         *
+         * The stream is cast to a C {@code FILE *} via {@code
+         * php_stream_cast(PHP_STREAM_AS_STDIO)}, which generally succeeds in
+         * Linux via fopencookie.
+         *
+         * @param resource $stream  An open, readable PHP stream.
+         * @param int      $flags   Bitmask of EXTRACT_* constants forwarded to
+         *                          {@see Archive::extractCurrent()}.
+         */
+        public static function fromStream(mixed $stream, int $flags = 0): static {}
+
         /**
          * Extract the current archive entry to disk.
          *
diff --git a/libarchive_arginfo.h b/libarchive_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: d41c11ce5a6a024796710fff87e0402e77446549 */
+ * Stub hash: e2b78feab80afeed324b595b8e65cfecc5be6d95 */
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_libarchive_Entry___construct, 0, 0, 0)
 ZEND_END_ARG_INFO()
@@ -9,6 +9,11 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_class_libarchive_Archive___construct, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_libarchive_Archive_fromStream, 0, 1, IS_STATIC, 0)
+	ZEND_ARG_TYPE_INFO(0, stream, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0")
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_libarchive_Archive_extractCurrent, 0, 1, IS_VOID, 0)
 	ZEND_ARG_OBJ_INFO(0, entry, libarchive\\Entry, 0)
 ZEND_END_ARG_INFO()
@@ -19,19 +24,29 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_libarchive_Archive_getIterator, 0, 0, Traversable, 0)
 ZEND_END_ARG_INFO()
 
+
 ZEND_METHOD(libarchive_Entry, __construct);
 ZEND_METHOD(libarchive_Archive, __construct);
+ZEND_METHOD(libarchive_Archive, fromStream);
 ZEND_METHOD(libarchive_Archive, extractCurrent);
 ZEND_METHOD(libarchive_Archive, currentEntryStream);
 ZEND_METHOD(libarchive_Archive, getIterator);
 
+
+static const zend_function_entry class_libarchive_Exception_methods[] = {
+	ZEND_FE_END
+};
+
+
 static const zend_function_entry class_libarchive_Entry_methods[] = {
 	ZEND_ME(libarchive_Entry, __construct, arginfo_class_libarchive_Entry___construct, ZEND_ACC_PRIVATE)
 	ZEND_FE_END
 };
 
+
 static const zend_function_entry class_libarchive_Archive_methods[] = {
 	ZEND_ME(libarchive_Archive, __construct, arginfo_class_libarchive_Archive___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(libarchive_Archive, fromStream, arginfo_class_libarchive_Archive_fromStream, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(libarchive_Archive, extractCurrent, arginfo_class_libarchive_Archive_extractCurrent, ZEND_ACC_PUBLIC)
 	ZEND_ME(libarchive_Archive, currentEntryStream, arginfo_class_libarchive_Archive_currentEntryStream, ZEND_ACC_PUBLIC)
 	ZEND_ME(libarchive_Archive, getIterator, arginfo_class_libarchive_Archive_getIterator, ZEND_ACC_PUBLIC)
@@ -64,8 +79,9 @@ static zend_class_entry *register_class_libarchive_Exception(zend_class_entry *c
 {
 	zend_class_entry ce, *class_entry;
 
-	INIT_NS_CLASS_ENTRY(ce, "libarchive", "Exception", NULL);
-	class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, ZEND_ACC_FINAL);
+	INIT_NS_CLASS_ENTRY(ce, "libarchive", "Exception", class_libarchive_Exception_methods);
+	class_entry = zend_register_internal_class_ex(&ce, class_entry_Exception);
+	class_entry->ce_flags |= ZEND_ACC_FINAL;
 
 	return class_entry;
 }
@@ -75,7 +91,8 @@ static zend_class_entry *register_class_libarchive_Entry(void)
 	zend_class_entry ce, *class_entry;
 
 	INIT_NS_CLASS_ENTRY(ce, "libarchive", "Entry", class_libarchive_Entry_methods);
-	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+	class_entry->ce_flags |= ZEND_ACC_FINAL;
 
 	return class_entry;
 }
@@ -85,7 +102,8 @@ static zend_class_entry *register_class_libarchive_Archive(zend_class_entry *cla
 	zend_class_entry ce, *class_entry;
 
 	INIT_NS_CLASS_ENTRY(ce, "libarchive", "Archive", class_libarchive_Archive_methods);
-	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+	class_entry->ce_flags |= ZEND_ACC_FINAL;
 	zend_class_implements(class_entry, 1, class_entry_IteratorAggregate);
 
 	return class_entry;
diff --git a/php_libarchive.h b/php_libarchive.h
@@ -31,8 +31,18 @@ ZEND_TSRMLS_CACHE_EXTERN()
 #define nullable _Nullable
 #define unspecnull _Null_unspecified
 
+typedef enum {
+    ARCH_SOURCE_NONE,
+    ARCH_SOURCE_FILE,
+    ARCH_SOURCE_STREAM,
+} arch_source_kind;
+
 typedef struct _arch_object {
-    zend_string *nullable file_location;
+    arch_source_kind source_kind;
+    union {
+        zend_string *file_location; /* ARCH_SOURCE_FILE */
+        zval stream_zv;             /* ARCH_SOURCE_STREAM */
+    } source;
     struct archive *nullable archive;
     struct archive *nullable arch_disk;
     int write_disk_options;
diff --git a/tests/from-stream.phpt b/tests/from-stream.phpt
@@ -0,0 +1,44 @@
+--TEST--
+Archive::fromStream() opens from an existing PHP stream resource
+--FILE--
+<?php
+
+include 'lib.inc';
+
+echo "-- fopen'd file --\n";
+$f = fopen(__DIR__ . '/arch/basic.7z', 'rb');
+foreach (libarchive\Archive::fromStream($f) as $e) {
+    echo $e->pathname, ' ', $e->size, "\n";
+}
+fclose($f);
+
+echo "-- php://memory (non-fd stream) --\n";
+$mem = fopen('php://memory', 'rb+');
+fwrite($mem, file_get_contents(__DIR__ . '/arch/basic.7z'));
+rewind($mem);
+foreach (libarchive\Archive::fromStream($mem) as $e) {
+    echo $e->pathname, ' ', $e->size, "\n";
+}
+fclose($mem);
+
+echo "-- current position is honoured (stream at EOF) --\n";
+$f = fopen(__DIR__ . '/arch/basic.7z', 'rb');
+fseek($f, 0, SEEK_END);
+try {
+    foreach (libarchive\Archive::fromStream($f) as $e) {
+        echo $e->pathname, "\n";
+    }
+    echo "no entries\n";
+} catch (libarchive\Exception $e) {
+    echo "Exception caught\n";
+}
+fclose($f);
+
+?>
+--EXPECT--
+-- fopen'd file --
+myfile.txt 35
+-- php://memory (non-fd stream) --
+myfile.txt 35
+-- current position is honoured (stream at EOF) --
+no entries
diff --git a/tests/url-no-fd.phpt b/tests/url-no-fd.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Constructor falls back to FILE* for stream wrappers that cannot be cast to a file descriptor
+--FILE--
+<?php
+
+/* A stream wrapper that delegates reads/seeks to a real file but never
+ * exposes a file descriptor (no stream_cast method). */
+class NoFdWrapper {
+    private $fp;
+
+    public function stream_open(string $path, string $mode,
+                                int $options, ?string &$opened_path): bool {
+        $file = substr($path, strlen('nofd://'));
+        $this->fp = fopen($file, $mode);
+        return $this->fp !== false;
+    }
+
+    public function stream_read(int $count): string|false {
+        return fread($this->fp, $count);
+    }
+
+    public function stream_seek(int $offset, int $whence): bool {
+        return fseek($this->fp, $offset, $whence) === 0;
+    }
+
+    public function stream_tell(): int {
+        return ftell($this->fp);
+    }
+
+    public function stream_eof(): bool {
+        return feof($this->fp);
+    }
+
+    public function stream_close(): void {
+        fclose($this->fp);
+    }
+
+    public function stream_cast(int $cast_as): mixed {
+        return false;
+    }
+}
+
+stream_wrapper_register('nofd', NoFdWrapper::class);
+
+$a = new libarchive\Archive('nofd://' . __DIR__ . '/arch/basic.7z');
+foreach ($a as $e) {
+    echo $e->pathname, ' ', $e->size, "\n";
+}
+
+?>
+--EXPECT--
+myfile.txt 35
