Add projects

backend/internal/pluginhost/loader_unix.go

@@ -0,0 +1,232 @@
+//go:build cgo && (linux || darwin || freebsd)
+
+package pluginhost
+
+/*
+#cgo linux LDFLAGS: -ldl
+#cgo freebsd LDFLAGS: -ldl
+#include <dlfcn.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+	void* ptr;
+	size_t len;
+} cliproxy_buffer;
+
+typedef int (*cliproxy_host_call_fn)(void*, const char*, const uint8_t*, size_t, cliproxy_buffer*);
+typedef void (*cliproxy_host_free_fn)(void*, size_t);
+
+typedef struct {
+	uint32_t abi_version;
+	void* host_ctx;
+	cliproxy_host_call_fn call;
+	cliproxy_host_free_fn free_buffer;
+} cliproxy_host_api;
+
+typedef int (*cliproxy_plugin_call_fn)(const char*, const uint8_t*, size_t, cliproxy_buffer*);
+typedef void (*cliproxy_plugin_free_fn)(void*, size_t);
+typedef void (*cliproxy_plugin_shutdown_fn)(void);
+
+typedef struct {
+	uint32_t abi_version;
+	cliproxy_plugin_call_fn call;
+	cliproxy_plugin_free_fn free_buffer;
+	cliproxy_plugin_shutdown_fn shutdown;
+} cliproxy_plugin_api;
+
+typedef int (*cliproxy_plugin_init_fn)(const cliproxy_host_api*, cliproxy_plugin_api*);
+
+extern int cliproxyHostCall(void*, const char*, const uint8_t*, size_t, cliproxy_buffer*);
+extern void cliproxyHostFree(void*, size_t);
+
+static void* cliproxy_dlopen(const char* path) {
+	return dlopen(path, RTLD_NOW | RTLD_LOCAL);
+}
+
+static void* cliproxy_dlsym(void* handle, const char* name) {
+	return dlsym(handle, name);
+}
+
+static const char* cliproxy_dlerror(void) {
+	return dlerror();
+}
+
+static int cliproxy_dlclose(void* handle) {
+	return dlclose(handle);
+}
+
+static int cliproxy_call_init(void* fn, const cliproxy_host_api* host, cliproxy_plugin_api* plugin) {
+	return ((cliproxy_plugin_init_fn)fn)(host, plugin);
+}
+
+static int cliproxy_call_plugin(cliproxy_plugin_call_fn fn, const char* method, const uint8_t* request, size_t request_len, cliproxy_buffer* response) {
+	return fn(method, request, request_len, response);
+}
+
+static void cliproxy_free_plugin_buffer(cliproxy_plugin_free_fn fn, void* ptr, size_t len) {
+	fn(ptr, len);
+}
+
+static void cliproxy_shutdown_plugin(cliproxy_plugin_shutdown_fn fn) {
+	fn();
+}
+
+static void cliproxy_set_host_api(cliproxy_host_api* api, uint32_t abi_version, void* host_ctx) {
+	api->abi_version = abi_version;
+	api->host_ctx = host_ctx;
+	api->call = cliproxyHostCall;
+	api->free_buffer = cliproxyHostFree;
+}
+
+*/
+import "C"
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"unsafe"
+)
+
+var (
+	hostCallbackID      atomic.Uintptr
+	hostCallbackEntries sync.Map
+)
+
+type dynamicLibraryLoader struct{}
+
+type dynamicLibraryClient struct {
+	handle  unsafe.Pointer
+	hostAPI *C.cliproxy_host_api
+	hostCtx unsafe.Pointer
+	api     C.cliproxy_plugin_api
+}
+
+func defaultPluginLoader() pluginLoader {
+	return dynamicLibraryLoader{}
+}
+
+func (dynamicLibraryLoader) Open(file pluginFile, host *Host) (pluginClient, error) {
+	cPath := C.CString(file.Path)
+	defer C.free(unsafe.Pointer(cPath))
+
+	handle := C.cliproxy_dlopen(cPath)
+	if handle == nil {
+		return nil, fmt.Errorf("dlopen %s: %s", file.Path, dlerrorString())
+	}
+
+	cSymbol := C.CString("cliproxy_plugin_init")
+	initSymbol := C.cliproxy_dlsym(handle, cSymbol)
+	C.free(unsafe.Pointer(cSymbol))
+	if initSymbol == nil {
+		C.cliproxy_dlclose(handle)
+		return nil, fmt.Errorf("missing cliproxy_plugin_init: %s", dlerrorString())
+	}
+
+	hostAPI := (*C.cliproxy_host_api)(C.malloc(C.size_t(unsafe.Sizeof(C.cliproxy_host_api{}))))
+	if hostAPI == nil {
+		C.cliproxy_dlclose(handle)
+		return nil, fmt.Errorf("allocate host api")
+	}
+	hostCtx := C.malloc(C.size_t(unsafe.Sizeof(C.uintptr_t(0))))
+	if hostCtx == nil {
+		C.free(unsafe.Pointer(hostAPI))
+		C.cliproxy_dlclose(handle)
+		return nil, fmt.Errorf("allocate host context")
+	}
+	id := hostCallbackID.Add(1)
+	*(*C.uintptr_t)(hostCtx) = C.uintptr_t(id)
+	hostCallbackEntries.Store(id, dynamicHostCallbackEntry{host: host, pluginID: file.ID})
+	C.cliproxy_set_host_api(hostAPI, C.uint32_t(pluginHostABIVersion), hostCtx)
+
+	client := &dynamicLibraryClient{
+		handle:  handle,
+		hostAPI: hostAPI,
+		hostCtx: hostCtx,
+	}
+	rc := C.cliproxy_call_init(initSymbol, hostAPI, &client.api)
+	if rc != 0 {
+		client.Shutdown()
+		return nil, fmt.Errorf("cliproxy_plugin_init returned %d", int(rc))
+	}
+	if uint32(client.api.abi_version) != pluginHostABIVersion {
+		client.Shutdown()
+		return nil, fmt.Errorf("plugin ABI version %d is not supported", uint32(client.api.abi_version))
+	}
+	if client.api.call == nil || client.api.free_buffer == nil {
+		client.Shutdown()
+		return nil, fmt.Errorf("plugin function table is incomplete")
+	}
+	return client, nil
+}
+
+func (c *dynamicLibraryClient) Call(ctx context.Context, method string, request []byte) ([]byte, error) {
+	if c == nil || c.api.call == nil {
+		return nil, fmt.Errorf("plugin client is closed")
+	}
+	if ctx != nil {
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		default:
+		}
+	}
+
+	cMethod := C.CString(method)
+	defer C.free(unsafe.Pointer(cMethod))
+	var cRequest unsafe.Pointer
+	if len(request) > 0 {
+		cRequest = C.CBytes(request)
+		defer C.free(cRequest)
+	}
+	var response C.cliproxy_buffer
+	rc := C.cliproxy_call_plugin(c.api.call, cMethod, (*C.uint8_t)(cRequest), C.size_t(len(request)), &response)
+	var out []byte
+	if response.ptr != nil && response.len > 0 {
+		out = C.GoBytes(response.ptr, C.int(response.len))
+	}
+	if response.ptr != nil {
+		C.cliproxy_free_plugin_buffer(c.api.free_buffer, response.ptr, response.len)
+	}
+	if rc != 0 {
+		if isPluginErrorEnvelope(out) {
+			return out, nil
+		}
+		return nil, fmt.Errorf("plugin call %s returned %d: %s", method, int(rc), string(out))
+	}
+	return out, nil
+}
+
+func (c *dynamicLibraryClient) Shutdown() {
+	if c == nil {
+		return
+	}
+	if c.api.shutdown != nil {
+		C.cliproxy_shutdown_plugin(c.api.shutdown)
+		c.api.shutdown = nil
+	}
+	if c.hostCtx != nil {
+		id := uintptr(*(*C.uintptr_t)(c.hostCtx))
+		hostCallbackEntries.Delete(id)
+		C.free(c.hostCtx)
+		c.hostCtx = nil
+	}
+	if c.hostAPI != nil {
+		C.free(unsafe.Pointer(c.hostAPI))
+		c.hostAPI = nil
+	}
+	if c.handle != nil {
+		C.cliproxy_dlclose(c.handle)
+		c.handle = nil
+	}
+}
+
+func dlerrorString() string {
+	errText := C.cliproxy_dlerror()
+	if errText == nil {
+		return ""
+	}
+	return C.GoString(errText)
+}