WIP - embedding configuration

Author: MasonRemaley

build.zig

@@ -90,6 +90,7 @@ pub fn build(b: *std.Build) void {
             .flags = flags,
         });
 
+        // XXX: don't install this, embed it
         // Build and install the library configuration
         {
             const generate_conf = b.addExecutable(.{
@@ -342,6 +343,7 @@ pub fn build(b: *std.Build) void {
         const run_step = b.step("video-play", "Run the video-play example");
 
         const run_cmd = b.addRunArtifact(video_play);
+        // XXX: cwd...
         run_cmd.setCwd(.{ .cwd_relative = b.getInstallPath(.bin, "") });
         run_step.dependOn(&run_cmd.step);
 
@@ -397,6 +399,13 @@ const flags: []const []const u8 = &.{
     "-Ddlerror=__wrap_dlerror",
     "-Ddlinfo=__wrap_dlinfo",
     "-Dstat=__wrap_stat",
+    "-Daccess=__wrap_access",
+    "-Dopen=__wrap_open",
+    "-Dclose=__wrap_close",
+
+    // Since `spa_autoclose` points to a function defined in a header, its close doesn't get
+    // wrapped. Wrap it manually.
+    "-Dspa_autoclose=__attribute__((__cleanup__(__wrap_close)))",
 };
 
 pub const PluginAndModuleCtx = struct {

build.zig.zon

@@ -12,8 +12,10 @@
             .hash = "N-V-__8AAMV2BgB9aKHnchADe5onASuvEqAeRRO7Ai1oTuzW",
         },
         .upstream = .{
-            .url = "git+https://gitlab.freedesktop.org/pipewire/pipewire.git#1.5.81",
-            .hash = "N-V-__8AAKYw2AD301ZQsWszbYSWZQF5y-q4WXJif0UGRvFh",
+            // XXX: ...
+            // .url = "git+https://gitlab.freedesktop.org/pipewire/pipewire.git#1.5.81",
+            // .hash = "N-V-__8AAKYw2AD301ZQsWszbYSWZQF5y-q4WXJif0UGRvFh",
+            .path = "../pipewire",
         },
         // Used by the examples
         .sdl = .{

src/wrap.zig

@@ -21,11 +21,7 @@ const c = @cImport({
 export fn __wrap_dlopen(path: ?[*:0]const u8, mode: std.c.RTLD) callconv(.c) ?*anyopaque {
     const span = if (path) |p| std.mem.span(p) else Lib.main_program_name;
     const lib = if (libs.getIndex(span)) |index| &libs.kvs.values[index] else null;
-    log.debug("dlopen(\"{f}\", {f}) -> {?f}", .{
-        std.zig.fmtString(span),
-        FmtFlags(std.c.RTLD).init(mode),
-        lib,
-    });
+    log.debug("dlopen(\"{f}\", {f}) -> {?f}", .{ std.zig.fmtString(span), fmtFlags(mode), lib });
     return @ptrCast(@constCast(lib));
 }
 
@@ -38,7 +34,10 @@ export fn __wrap_dlclose(handle: ?*anyopaque) callconv(.c) c_int {
 
 /// Since `dlopen` just returns handles from `libs`, `dlsym` retrieves symbols from the correct part
 /// of that table.
-export fn __wrap_dlsym(noalias handle: ?*anyopaque, noalias name: [*:0]u8) ?*anyopaque {
+export fn __wrap_dlsym(
+    noalias handle: ?*anyopaque,
+    noalias name: [*:0]u8,
+) callconv(.c) ?*anyopaque {
     const lib: *const Lib = @ptrCast(@alignCast(handle.?));
     const span = std.mem.span(name);
     var msg: ?[:0]const u8 = null;
@@ -65,7 +64,7 @@ export fn __wrap_dlsym(noalias handle: ?*anyopaque, noalias name: [*:0]u8) ?*any
 /// Since `dlopen` is allowed to return null on success if the symbol is zero, `dlerror` is a
 /// necessary part of the `dlopen` interface.
 var err: ?[*:0]const u8 = null;
-export fn __wrap_dlerror() ?[*:0]const u8 {
+export fn __wrap_dlerror() callconv(.c) ?[*:0]const u8 {
     const result = err;
     err = null;
     return result;
@@ -76,7 +75,7 @@ export fn __wrap_dlinfo(
     noalias handle: ?*anyopaque,
     request: c_int,
     noalias info: ?*anyopaque,
-) c_int {
+) callconv(.c) c_int {
     const lib: *const Lib = @ptrCast(@alignCast(handle.?));
     log.debug("dlinfo({f}, {}, {x})", .{ lib, request, @intFromPtr(info) });
     @panic("unimplemented");
@@ -86,9 +85,8 @@ export fn __wrap_dlinfo(
 /// exist, we wrap `stat` to pretend that they do so it doesn't fail prematurely.
 ///
 /// We do this by faking any stat calls whose paths end with `.so`. All other stat calls from
-/// pipewire are forwarded to the standard implementation as is, though in practice, there probably
-/// shouldn't be any others.
-export fn __wrap_stat(pathname_c: [*:0]const u8, statbuf: *std.os.linux.Stat) usize {
+/// pipewire are forwarded to the standard implementation as is.
+export fn __wrap_stat(pathname_c: [*:0]const u8, statbuf: *std.os.linux.Stat) callconv(.c) usize {
     const pathname = std.mem.span(pathname_c);
     const result, const strategy = b: {
         if (std.mem.endsWith(u8, pathname, ".so")) {
@@ -102,12 +100,111 @@ export fn __wrap_stat(pathname_c: [*:0]const u8, statbuf: *std.os.linux.Stat) us
         std.zig.fmtString(pathname),
         statbuf,
         result,
-        FmtFlags(std.os.linux.Stat).init(statbuf.*),
+        fmtFlags(statbuf.*),
+        strategy,
+    });
+    return result;
+}
+
+/// The path pipewire looks for client config at.
+const client_config_path = "pipewire-0.3/confdata/client.conf";
+var client_config_fd: usize = 0;
+
+/// Pipewire uses `access` to check for the presence of `client.conf`. We stub this out so that
+/// pipewire believes it exists expected path, allowing us to later provide it directly instead of
+/// requiring it be available on the user's computer or at a path relative to the working directory.
+export fn __wrap_access(path_c: [*:0]const u8, mode: u32) callconv(.c) usize {
+    const path = std.mem.span(path_c);
+
+    const result, const strategy = b: {
+        if (mode == std.os.linux.R_OK and
+            std.mem.eql(u8, path, client_config_path))
+        {
+            break :b .{ 0, "faked" };
+        } else {
+            break :b .{ std.os.linux.access(path, mode), "real" };
+        }
+    };
+    log.debug("access(\"{f}\", {}) -> {} ({s})", .{
+        std.zig.fmtString(path),
+        mode,
+        result,
+        strategy,
+    });
+    return result;
+}
+
+// XXX: wait is this usize or c_int? i think it's supposed to be cint, i think in general the linux
+// namespace functions may ahve different types due to just being the syscalls...
+// XXX: not getting called...
+/// Pipewire uses `open` to open the client config file. If it requests that path we fake the call,
+/// otherwise we pass it through as is. See `__wrap_access` for more information.
+export fn __wrap_open(
+    path_c: [*:0]const u8,
+    flags: std.os.linux.O,
+    mode: std.os.linux.mode_t,
+) callconv(.c) usize {
+    const path = std.mem.span(path_c);
+
+    const result, const strategy = b: {
+        if (std.mem.eql(u8, path, client_config_path)) {
+            if (client_config_fd != 0) @panic("client_config_path already open");
+            client_config_fd = std.os.linux.open("/dev/null", flags, mode);
+            break :b .{ client_config_fd, "faked" };
+        } else {
+            break :b .{ std.os.linux.open(path_c, flags, mode), "real" };
+        }
+    };
+    // XXX: change to debug
+    log.info("open(\"{f}\", {f}, {}) -> {} ({s})", .{
+        std.zig.fmtString(path),
+        fmtFlags(flags),
+        mode,
+        result,
         strategy,
     });
     return result;
 }
 
+// XXX: get list of wrapped functions or defines from this file in the build script autoamtically? could
+// even just find stuff prefixed iwth __wrap if we wanted
+// XXX: make exports public too cause why not?
+/// We wrap close just to null out `client_config_fd` when closed. See `__wrap_access` for more
+/// info.
+export fn __wrap_close(fd: i32) callconv(.c) usize {
+    if (fd == client_config_fd) client_config_fd = 0;
+    const result = std.os.linux.close(fd);
+    // XXX: change to debug
+    log.err("close({}) -> {}", .{ fd, result });
+    return result;
+}
+
+// XXX: wrap close to close client config fd
+
+// XXX: ...
+// /// Pipewire uses `fstat` to check a second time if a config file exists, after already having
+// /// checked it with `access`. We stub this out as well.
+// export fn fstat(fd: i32, stat_buf: *std.os.linux.Stat) usize
+//     const path = std.mem.span(path_c);
+
+//     const result, const strategy = b: {
+//         if (mode == std.os.linux.R_OK and
+//             std.mem.eql(u8, path, "pipewire-0.3/confdata/client.conf"))
+//         {
+//             break :b .{ 0, "faked" };
+//         } else {
+//             break :b .{ std.os.linux.access(path, mode), "real" };
+//         }
+//     };
+//     log.debug("access(\"{f}\", {}) -> {} ({s})", .{
+//         std.zig.fmtString(path),
+//         mode,
+//         result,
+//         strategy,
+//     });
+//     return result;
+// }
+
 /// A dynamic library made static.
 const Lib = struct {
     /// You're allowed to pass null as the path to dlopen, in which case you're supposed to get a
@@ -354,6 +451,10 @@ const fops = struct {
     }
 };
 
+pub fn fmtFlags(val: anytype) FmtFlags(@TypeOf(val)) {
+    return .init(val);
+}
+
 /// Formats flags, skipping any values that are 0 for brevity.
 fn FmtFlags(T: type) type {
     return struct {