| test/component<&> | example.com/fork<&> v2.0.0 |
`)
}, opts)
}
@@ -579,6 +595,11 @@ func TestException_worker(t *testing.T) {
testException(t, &testOptions{workerScript: "exception.php"})
}
func testException(t *testing.T, opts *testOptions) {
+ if opts.phpIni == nil {
+ opts.phpIni = map[string]string{}
+ }
+ opts.phpIni["display_errors"] = "1"
+
runTest(t, func(handler func(http.ResponseWriter, *http.Request), _ *httptest.Server, i int) {
body, _ := testGet(fmt.Sprintf("http://example.com/exception.php?i=%d", i), handler, t)
@@ -1228,6 +1249,24 @@ func FuzzResponseHeaders(f *testing.F) {
// fuzzer-controlled, since unbounded native recursion (no depth guard) is
// the interesting bug class here, not the value shapes themselves.
func FuzzPersistZvalRoundtrip(f *testing.F) {
+ // Check the compiled-in hook once, not in every seed's concurrent requests.
+ func() {
+ require.NoError(f, frankenphp.Init())
+ defer frankenphp.Shutdown()
+
+ root, err := fastabs.FastAbs("./testdata")
+ require.NoError(f, err)
+ req := httptest.NewRequest("GET", "http://example.com/fuzz-persist-roundtrip.php", nil)
+ req, err = frankenphp.NewRequestWithContext(req, frankenphp.WithRequestDocumentRoot(root, false))
+ require.NoError(f, err)
+ w := httptest.NewRecorder()
+ require.NoError(f, frankenphp.ServeHTTP(w, req))
+ require.Equal(f, http.StatusOK, w.Code)
+ if w.Body.String() == "SKIP" {
+ f.Skip("FRANKENPHP_TEST not set; skipping persistent_zval roundtrip fuzzing")
+ }
+ }()
+
f.Add(0, 1)
f.Add(1, 1)
f.Add(10, 2)
diff --git a/go.mod b/go.mod
index 552a12442b..381d981e6b 100644
--- a/go.mod
+++ b/go.mod
@@ -12,6 +12,7 @@ require (
github.com/prometheus/client_golang v1.24.1
github.com/stretchr/testify v1.12.1
golang.org/x/net v0.58.0
+ golang.org/x/sys v0.47.0
)
require (
@@ -58,7 +59,6 @@ require (
go.opentelemetry.io/otel/trace v1.45.0 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/crypto v0.55.0 // indirect
- golang.org/x/sys v0.47.0 // indirect
golang.org/x/text v0.41.0 // indirect
google.golang.org/protobuf v1.36.11 // indirect
)
diff --git a/mercure.go b/mercure.go
index 821b057915..ece35fe349 100644
--- a/mercure.go
+++ b/mercure.go
@@ -13,6 +13,10 @@ import (
"github.com/dunglas/mercure"
)
+func init() {
+ AddPHPInfoModule("dunglas/mercure", "github.com/dunglas/mercure")
+}
+
type mercureContext struct {
mercureHub *mercure.Hub
}
diff --git a/phpinfo.go b/phpinfo.go
new file mode 100644
index 0000000000..9b1e839cf1
--- /dev/null
+++ b/phpinfo.go
@@ -0,0 +1,120 @@
+package frankenphp
+
+// #include "frankenphp.h"
+import "C"
+import (
+ "runtime"
+ "runtime/debug"
+ "slices"
+ "sort"
+ "sync"
+ "unsafe"
+)
+
+type phpinfoEntry struct {
+ key, value string
+}
+
+var (
+ phpinfoMu sync.Mutex
+ phpinfoEntries []phpinfoEntry
+ phpinfoModules []phpinfoEntry
+)
+
+// AddPHPInfoEntry adds an entry to the frankenphp section of phpinfo().
+func AddPHPInfoEntry(key, value string) {
+ phpinfoMu.Lock()
+ defer phpinfoMu.Unlock()
+ phpinfoEntries = append(phpinfoEntries, phpinfoEntry{key, value})
+}
+
+// AddPHPInfoModule adds a component's Go module version to the frankenphp section
+// of phpinfo().
+func AddPHPInfoModule(key, modulePath string) {
+ phpinfoMu.Lock()
+ defer phpinfoMu.Unlock()
+ phpinfoModules = append(phpinfoModules, phpinfoEntry{key, modulePath})
+}
+
+func collectPHPInfoEntries(buildInfo *debug.BuildInfo) (entries, modules []phpinfoEntry) {
+ phpinfoMu.Lock()
+ entries = slices.Clone(phpinfoEntries)
+ components := slices.Clone(phpinfoModules)
+ phpinfoMu.Unlock()
+
+ if buildInfo == nil {
+ return entries, nil
+ }
+
+ entries = append(entries, phpinfoEntry{"go", buildInfo.GoVersion})
+ modules = buildGoModuleEntries(buildInfo)
+ versions := make(map[string]string, len(modules))
+ for _, module := range modules {
+ versions[module.key] = module.value
+ }
+ for _, component := range components {
+ if version, ok := versions[component.value]; ok {
+ entries = append(entries, phpinfoEntry{component.key, version})
+ }
+ }
+ return entries, modules
+}
+
+func buildGoModuleEntries(buildInfo *debug.BuildInfo) []phpinfoEntry {
+ entries := make([]phpinfoEntry, 0, len(buildInfo.Deps)+1)
+ if buildInfo.Main.Path != "" {
+ entries = append(entries, phpinfoEntry{buildInfo.Main.Path, goModuleVersion(&buildInfo.Main)})
+ }
+ for _, dep := range buildInfo.Deps {
+ entries = append(entries, phpinfoEntry{dep.Path, goModuleVersion(dep)})
+ }
+ return entries
+}
+
+func goModuleVersion(module *debug.Module) string {
+ if module.Replace == nil {
+ return module.Version
+ }
+
+ if module.Replace.Version == "" {
+ // Replaced by a local directory
+ return module.Replace.Path
+ }
+
+ return module.Replace.Path + " " + module.Replace.Version
+}
+
+//export go_frankenphp_phpinfo
+func go_frankenphp_phpinfo() {
+ buildInfo, _ := debug.ReadBuildInfo()
+ entries, modules := collectPHPInfoEntries(buildInfo)
+
+ // PHP consumes these tables synchronously on the calling PHP thread.
+ // Each call owns its pins, so concurrent phpinfo() calls share no C pointers.
+ var pinner runtime.Pinner
+ defer pinner.Unpin()
+ C.frankenphp_print_phpinfo(pinPHPInfoEntries(entries, &pinner), pinPHPInfoEntries(modules, &pinner))
+}
+
+// pinPHPInfoEntries sorts entries and pins a null-terminated array of key, value
+// pointers, along with the null-terminated strings they point to.
+func pinPHPInfoEntries(entries []phpinfoEntry, pinner *runtime.Pinner) **C.char {
+ if len(entries) == 0 {
+ return nil
+ }
+
+ sort.Slice(entries, func(i, j int) bool {
+ return entries[i].key < entries[j].key
+ })
+
+ arr := make([]*C.char, 2*len(entries)+1)
+ for i, e := range entries {
+ for j, s := range []string{e.key, e.value} {
+ data := unsafe.StringData(s + "\x00")
+ pinner.Pin(data)
+ arr[2*i+j] = (*C.char)(unsafe.Pointer(data))
+ }
+ }
+ pinner.Pin(&arr[0])
+ return &arr[0]
+}
diff --git a/server_test.go b/server_test.go
index f297db7c29..3ad2032bbe 100644
--- a/server_test.go
+++ b/server_test.go
@@ -102,6 +102,7 @@ func TestServer(t *testing.T) {
server2, _ := frankenphp.NewServer(testDataDir)
initServers(
t,
+ frankenphp.WithPhpIni(map[string]string{"display_errors": "1"}),
frankenphp.WithServer(server1),
frankenphp.WithServer(server2),
frankenphp.WithWorkers("counter", testDataDir+"worker-with-counter.php", 1, frankenphp.WithWorkerServerScope(server1)),
diff --git a/testdata/command-detached.php b/testdata/command-detached.php
new file mode 100644
index 0000000000..e40f24a1c9
--- /dev/null
+++ b/testdata/command-detached.php
@@ -0,0 +1,42 @@
+/dev/null 2>&1; set -C; printf ready > "$1" && IFS= read -r result && [ "$result" = survived ]', 'detached', $ready]);
+ exit(1);
+}
+
+printf("CHILD=%d\n", $pid);
+$deadline = microtime(true) + 5;
+do {
+ if (is_file($ready)) {
+ exit(0);
+ }
+ usleep(1000);
+} while (microtime(true) < $deadline);
+
+fwrite(STDERR, "detached child did not exec within 5s\n");
+exit(1);
diff --git a/types_test.go b/types_test.go
index a08f90725e..8024523110 100644
--- a/types_test.go
+++ b/types_test.go
@@ -2,7 +2,11 @@ package frankenphp
import (
"log/slog"
+ "runtime"
+ "runtime/debug"
+ "slices"
"testing"
+ "unsafe"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -145,3 +149,151 @@ func TestNestedMixedArray(t *testing.T) {
assert.Equal(t, originalArray, convertedArray, "nested mixed array should be equal after conversion")
})
}
+
+func TestPinPHPInfoEntries(t *testing.T) {
+ var pinner runtime.Pinner
+ defer pinner.Unpin()
+
+ require.Nil(t, pinPHPInfoEntries(nil, &pinner))
+ entries := []phpinfoEntry{{"z", "last"}, {"a", ""}, {"", "first"}}
+ ptr := pinPHPInfoEntries(entries, &pinner)
+ runtime.GC()
+
+ arr := unsafe.Slice(ptr, 2*len(entries)+1)
+ for i, want := range []string{"", "first", "a", "", "z", "last"} {
+ got := unsafe.Slice((*byte)(unsafe.Pointer(arr[i])), len(want)+1)
+ assert.Equal(t, want+"\x00", string(got))
+ }
+ assert.Nil(t, arr[len(arr)-1])
+}
+
+func TestBuildGoModuleEntries(t *testing.T) {
+ deps := []*debug.Module{
+ {Path: "example.com/dependency", Version: "v1.2.3"},
+ {
+ Path: "example.com/replaced",
+ Version: "v1.0.0",
+ Replace: &debug.Module{Path: "example.com/fork", Version: "v1.4.0"},
+ },
+ {
+ Path: "example.com/local",
+ Version: "v1.0.0",
+ Replace: &debug.Module{Path: "../local"},
+ },
+ }
+ wantDeps := []phpinfoEntry{
+ {"example.com/dependency", "v1.2.3"},
+ {"example.com/replaced", "example.com/fork v1.4.0"},
+ {"example.com/local", "../local"},
+ }
+
+ for _, tt := range []struct {
+ name string
+ info debug.BuildInfo
+ want []phpinfoEntry
+ }{
+ {
+ name: "direct caddy main",
+ info: debug.BuildInfo{
+ Main: debug.Module{Path: "github.com/dunglas/frankenphp/caddy", Version: "v1.12.7"},
+ },
+ want: []phpinfoEntry{{"github.com/dunglas/frankenphp/caddy", "v1.12.7"}},
+ },
+ {
+ name: "development main",
+ info: debug.BuildInfo{Main: debug.Module{Path: "caddy", Version: "(devel)"}},
+ want: []phpinfoEntry{{"caddy", "(devel)"}},
+ },
+ {
+ name: "main without version",
+ info: debug.BuildInfo{Main: debug.Module{Path: "example.com/app"}},
+ want: []phpinfoEntry{{"example.com/app", ""}},
+ },
+ {
+ name: "main absent",
+ },
+ {
+ name: "generated command",
+ info: debug.BuildInfo{Path: "command-line-arguments"},
+ },
+ {
+ name: "main without path",
+ info: debug.BuildInfo{Main: debug.Module{Version: "(devel)"}},
+ },
+ {
+ name: "replaced main",
+ info: debug.BuildInfo{Main: debug.Module{
+ Path: "example.com/app",
+ Version: "v1.0.0",
+ Replace: &debug.Module{Path: "example.com/app-fork", Version: "v1.1.0"},
+ }},
+ want: []phpinfoEntry{{"example.com/app", "example.com/app-fork v1.1.0"}},
+ },
+ {
+ name: "locally replaced main",
+ info: debug.BuildInfo{Main: debug.Module{
+ Path: "example.com/app",
+ Version: "v1.0.0",
+ Replace: &debug.Module{Path: "../app"},
+ }},
+ want: []phpinfoEntry{{"example.com/app", "../app"}},
+ },
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := buildGoModuleEntries(&tt.info); !slices.Equal(got, tt.want) {
+ t.Fatalf("without dependencies: got %v, want %v", got, tt.want)
+ }
+
+ tt.info.Deps = deps
+ want := append(slices.Clone(tt.want), wantDeps...)
+ if got := buildGoModuleEntries(&tt.info); !slices.Equal(got, want) {
+ t.Fatalf("with dependencies: got %v, want %v", got, want)
+ }
+ })
+ }
+}
+
+func TestAddPHPInfoModule(t *testing.T) {
+ // Keep this test serial and isolate registrations from the runtime tests.
+ previousEntries, previousModules := phpinfoEntries, phpinfoModules
+ phpinfoEntries, phpinfoModules = nil, nil
+ t.Cleanup(func() { phpinfoEntries, phpinfoModules = previousEntries, previousModules })
+
+ const key, path = "test/component", "example.com/component"
+ AddPHPInfoEntry("custom", "value")
+ AddPHPInfoModule(key, path)
+ AddPHPInfoModule("missing", "example.com/missing")
+ AddPHPInfoModule("main", "example.com/app")
+
+ entries, modules := collectPHPInfoEntries(nil)
+ require.Equal(t, []phpinfoEntry{{"custom", "value"}}, entries)
+ require.Empty(t, modules)
+
+ for _, tt := range []struct {
+ name string
+ replace *debug.Module
+ want string
+ }{
+ {name: "unreplaced", want: "v1.2.3"},
+ {name: "same module version replacement", replace: &debug.Module{Path: path, Version: "v1.2.4"}, want: path + " v1.2.4"},
+ {name: "fork version replacement", replace: &debug.Module{Path: "example.com/fork", Version: "v2.0.0"}, want: "example.com/fork v2.0.0"},
+ {name: "local path replacement", replace: &debug.Module{Path: "../local-component"}, want: "../local-component"},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ entries, modules := collectPHPInfoEntries(&debug.BuildInfo{
+ GoVersion: "go1.26.0",
+ Main: debug.Module{Path: "example.com/app", Version: "v3.0.0"},
+ Deps: []*debug.Module{
+ {Path: path, Version: "v1.2.3", Replace: tt.replace},
+ {Path: "example.com/other", Version: "v4.0.0"},
+ },
+ })
+ require.Equal(t, []phpinfoEntry{
+ {"custom", "value"}, {"go", "go1.26.0"}, {key, tt.want}, {"main", "v3.0.0"},
+ }, entries)
+ require.Equal(t, []phpinfoEntry{
+ {"example.com/app", "v3.0.0"}, {path, tt.want}, {"example.com/other", "v4.0.0"},
+ }, modules)
+ })
+ }
+}
diff --git a/watcher.go b/watcher.go
index cfe133e5ab..84aa5ad1c4 100644
--- a/watcher.go
+++ b/watcher.go
@@ -9,6 +9,10 @@ import (
watcherGo "github.com/e-dant/watcher/watcher-go"
)
+func init() {
+ AddPHPInfoModule("e-dant/watcher", "github.com/e-dant/watcher")
+}
+
type hotReloadOpt struct {
hotReload []*watcher.PatternGroup
}
diff --git a/worker_test.go b/worker_test.go
index 10c2b669ae..8ef48bc569 100644
--- a/worker_test.go
+++ b/worker_test.go
@@ -76,7 +76,7 @@ func TestCannotCallHandleRequestInNonWorkerMode(t *testing.T) {
body, _ := io.ReadAll(resp.Body)
assert.Contains(t, string(body), "