Fix win build

Author: cataphract

.github/scripts/build-and-test.sh

@@ -67,7 +67,7 @@ find . -name '*.lo' -o -name '*.o' | xargs rm -f 2>/dev/null || true
 find . -name '.libs' -type d | xargs rm -rf 2>/dev/null || true
 
 phpize
-./configure --with-php-config="$(which php-config)" "$CONFIGURE_LIBARCHIVE"
+./configure --with-php-config="$(which php-config)" "$CONFIGURE_LIBARCHIVE" ${EXTRA_CONFIGURE_FLAGS:-}
 make -f Makefile -j"$(nproc)"
 
 # ── Test ──────────────────────────────────────────────────────────────────────

config.m4

@@ -3,6 +3,12 @@ PHP_ARG_WITH([libarchive],
   [AS_HELP_STRING([[--with-libarchive[=DIR]]],
     [Include libarchive support])])
 
+PHP_ARG_WITH([libarchive-read-callbacks],
+  [whether to use stream read callbacks],
+  [AS_HELP_STRING([[--with-libarchive-read-callbacks]],
+    [Use libarchive read callbacks instead of FILE* for stream sources (required on platforms without fopencookie)])],
+  [no], [no])
+
 if test "$PHP_LIBARCHIVE" != "no"; then
   if test -r $PHP_LIBARCHIVE/include/archive.h; then
     LIBARCHIVE_DIR=$PHP_LIBARCHIVE
@@ -53,6 +59,13 @@ if test "$PHP_LIBARCHIVE" != "no"; then
 
   extra_cflags="-Wall $cflags_null -fvisibility=hidden"
 
+  ext_sources="libarchive.c stream.c"
+  if test "$PHP_LIBARCHIVE_READ_CALLBACKS" != "no"; then
+    AC_DEFINE(HAVE_LIBARCHIVE_STREAM_CALLBACKS, 1,
+              [Use stream read callbacks for archive sources])
+    ext_sources="$ext_sources stream_callbacks.c"
+  fi
+
   PHP_SUBST(ARCHIVE_SHARED_LIBADD)
-  PHP_NEW_EXTENSION(archive, libarchive.c stream.c, $ext_shared,,$extra_cflags)
+  PHP_NEW_EXTENSION(archive, $ext_sources, $ext_shared,,$extra_cflags)
 fi

config.w32

@@ -7,7 +7,7 @@ if (PHP_LIBARCHIVE != "no") {
 		CHECK_HEADER_ADD_INCLUDE("archive.h", "CFLAGS_ARCHIVE",
 			PHP_LIBARCHIVE + "/include;" + PHP_PHP_BUILD + "/include")) {
 
-		EXTENSION("archive", "libarchive.c stream.c", true, "/DLIBARCHIVE_STATIC");
+		EXTENSION("archive", "libarchive.c stream.c stream_callbacks.c", true, "/DLIBARCHIVE_STATIC /Zc:preprocessor");
 
 		// Always-needed Windows system libs.
 		var libs = "bcrypt.lib xmllite.lib crypt32.lib ws2_32.lib";

libarchive.c

@@ -437,9 +437,20 @@ static void arch_oh_free_obj(zend_object *zobj)
         case ARCH_SOURCE_FILE:
             zend_string_release(obj->source.file_location);
             break;
+#ifndef HAVE_LIBARCHIVE_STREAM_CALLBACKS
         case ARCH_SOURCE_STREAM:
             zval_ptr_dtor(&obj->source.stream_zv);
             break;
+#else
+        case ARCH_SOURCE_STREAM_CB:
+            if (obj->archive == NULL) {
+                /* Archive never opened; stream_close_cb won't fire. */
+                zval_ptr_dtor(&obj->source.stream_cb->stream_zv);
+                efree(obj->source.stream_cb);
+            }
+            /* else: archive_read_free below triggers stream_close_cb. */
+            break;
+#endif
         case ARCH_SOURCE_NONE:
             break;
     }
@@ -579,36 +590,63 @@ static bool arch_obj_open_read(arch_object *arch_obj)
          * 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);
+#ifdef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+        arch_stream_cb *d = emalloc(sizeof *d);
+        php_stream_to_zval(stream, &d->stream_zv); /* transfer the only ref */
+        arch_obj->source.stream_cb = d;
+        arch_obj->source_kind = ARCH_SOURCE_STREAM_CB;
+#else
         arch_obj->source_kind = ARCH_SOURCE_STREAM;
         php_stream_to_zval(stream, &arch_obj->source.stream_zv);
+#endif
         return arch_obj_open_read_stream(arch_obj);
     }
 
     return true;
 }
 
+#ifdef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+extern bool arch_open_archive_with_stream_callbacks(arch_object *arch_obj);
+#endif
+
 static bool arch_obj_open_read_stream(arch_object *arch_obj)
 {
     php_stream *stream;
+#ifdef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+    php_stream_from_zval_no_verify(stream, &arch_obj->source.stream_cb->stream_zv);
+#else
     php_stream_from_zval_no_verify(stream, &arch_obj->source.stream_zv);
+#endif
     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(except_ce, "Could not cast stream to FILE*", -1);
-        return false;
-    }
-
     arch_obj->archive = archive_read_new();
     arch_obj_setup_support(arch_obj);
     if (arch_obj->password_fci.size != 0) {
         archive_read_set_passphrase_callback(arch_obj->archive, arch_obj,
                                              arch_passphrase_callback);
     }
+
+#ifdef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+    if (!arch_open_archive_with_stream_callbacks(arch_obj)) {
+        zend_throw_exception_ex(
+                except_ce, archive_errno(arch_obj->archive),
+                "Could not open archive from stream: %s",
+                archive_error_string(arch_obj->archive));
+        return false;
+    }
+    return true;
+#else
+    FILE *fp;
+    int res = php_stream_cast(stream, PHP_STREAM_AS_STDIO, (void **)&fp,
+                              REPORT_ERRORS);
+    if (res != SUCCESS) {
+        zend_throw_exception(except_ce, "Could not cast stream to FILE*", -1);
+        return false;
+    }
+
     res = archive_read_open_FILE(arch_obj->archive, fp);
     if (res != ARCHIVE_OK) {
         zend_throw_exception_ex(
@@ -617,8 +655,8 @@ static bool arch_obj_open_read_stream(arch_object *arch_obj)
                 archive_error_string(arch_obj->archive));
         return false;
     }
-
     return true;
+#endif
 }
 
 PHP_METHOD(libarchive_Archive, fromStream)
@@ -632,8 +670,15 @@ PHP_METHOD(libarchive_Archive, fromStream)
 
     object_init_ex(return_value, arch_ce);
     arch_object *arch_obj = arch_object_from_zv(return_value);
+#ifdef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+    arch_stream_cb *d = emalloc(sizeof *d);
+    ZVAL_COPY(&d->stream_zv, stream_zv);
+    arch_obj->source.stream_cb = d;
+    arch_obj->source_kind = ARCH_SOURCE_STREAM_CB;
+#else
     arch_obj->source_kind = ARCH_SOURCE_STREAM;
     ZVAL_COPY(&arch_obj->source.stream_zv, stream_zv);
+#endif
     arch_obj->write_disk_options = (int)flags;
 }
 

php_libarchive.h

@@ -32,17 +32,39 @@ ZEND_TSRMLS_CACHE_EXTERN()
 #define nullable _Nullable
 #define unspecnull _Null_unspecified
 
+/* On Windows, where fopencookie and similar is unavailable, the callback path
+ * is always available; on other platforms it is enabled when the extension was
+ * built with --with-libarchive-read-callbacks. */
+#if defined(PHP_WIN32) && !defined(HAVE_LIBARCHIVE_STREAM_CALLBACKS)
+#define HAVE_LIBARCHIVE_STREAM_CALLBACKS 1
+#endif
+
 typedef enum {
     ARCH_SOURCE_NONE,
     ARCH_SOURCE_FILE,
+#ifndef HAVE_LIBARCHIVE_STREAM_CALLBACKS
     ARCH_SOURCE_STREAM,
+#else
+    ARCH_SOURCE_STREAM_CB,
+#endif
 } arch_source_kind;
 
+#ifdef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+typedef struct {
+    zval stream_zv;
+    char buf[65536];
+} arch_stream_cb;
+#endif
+
 typedef struct _arch_object {
     arch_source_kind source_kind;
     union {
-        zend_string *file_location; /* ARCH_SOURCE_FILE */
-        zval stream_zv;             /* ARCH_SOURCE_STREAM */
+        zend_string    *file_location; /* ARCH_SOURCE_FILE */
+#ifndef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+        zval            stream_zv;     /* ARCH_SOURCE_STREAM */
+#else
+        arch_stream_cb *stream_cb;     /* ARCH_SOURCE_STREAM_CB */
+#endif
     } source;
     struct archive *nullable archive;
     struct archive *nullable arch_disk;

stream_callbacks.c

@@ -0,0 +1,84 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef HAVE_LIBARCHIVE_STREAM_CALLBACKS
+#error "stream_callbacks.c compiled without HAVE_LIBARCHIVE_STREAM_CALLBACKS"
+#endif
+
+#include <php.h>
+#include <archive.h>
+#include <stdbool.h>
+#include "php_libarchive.h"
+
+#define STREAM_BLOCK_SIZE sizeof(((arch_stream_cb *)0)->buf)
+
+static la_ssize_t stream_read_cb(struct archive *a, void *client_data,
+                                 const void **buffer)
+{
+    arch_stream_cb *d = (arch_stream_cb *)client_data;
+    php_stream *stream;
+    size_t n;
+
+    (void)a;
+    php_stream_from_zval_no_verify(stream, &d->stream_zv);
+    *buffer = d->buf;
+    n = php_stream_read(stream, d->buf, STREAM_BLOCK_SIZE);
+    return (la_ssize_t)n; /* 0 signals EOF to libarchive */
+}
+
+static la_int64_t stream_skip_cb(struct archive *a, void *client_data,
+                                 la_int64_t request)
+{
+    arch_stream_cb *d = (arch_stream_cb *)client_data;
+    php_stream *stream;
+
+    (void)a;
+    php_stream_from_zval_no_verify(stream, &d->stream_zv);
+    if (php_stream_seek(stream, (zend_off_t)request, SEEK_CUR) == 0) {
+        return request;
+    }
+    return 0; /* tell libarchive to use read-and-discard */
+}
+
+static la_int64_t stream_seek_cb(struct archive *a, void *client_data,
+                                 la_int64_t offset, int whence)
+{
+    arch_stream_cb *d = (arch_stream_cb *)client_data;
+    php_stream *stream;
+    zend_off_t pos;
+
+    (void)a;
+    php_stream_from_zval_no_verify(stream, &d->stream_zv);
+    if (php_stream_seek(stream, (zend_off_t)offset, whence) != 0) {
+        return ARCHIVE_FAILED;
+    }
+    pos = php_stream_tell(stream);
+    if (pos < 0) {
+        return ARCHIVE_FAILED;
+    }
+    return (la_int64_t)pos;
+}
+
+static int stream_close_cb(struct archive *a, void *client_data)
+{
+    arch_stream_cb *d = (arch_stream_cb *)client_data;
+
+    (void)a;
+    zval_ptr_dtor(&d->stream_zv);
+    efree(d);
+    return ARCHIVE_OK;
+}
+
+bool arch_open_archive_with_stream_callbacks(arch_object *arch_obj)
+{
+    arch_stream_cb *d = arch_obj->source.stream_cb;
+
+    archive_read_set_read_callback(arch_obj->archive, stream_read_cb);
+    archive_read_set_skip_callback(arch_obj->archive, stream_skip_cb);
+    archive_read_set_seek_callback(arch_obj->archive, stream_seek_cb);
+    archive_read_set_close_callback(arch_obj->archive, stream_close_cb);
+    archive_read_set_callback_data(arch_obj->archive, d);
+
+    return archive_read_open1(arch_obj->archive) == ARCHIVE_OK;
+}