mach: Initial commit for gamemode

gamemode-zig/build.zig

@@ -0,0 +1,23 @@
+const std = @import("std");
+
+pub const pkg = std.build.Pkg{
+    .name = "gamemode",
+    .source = .{ .path = thisDir() ++ "/src/gamemode.zig" },
+};
+
+/// Link system library gamemode
+pub fn link(exe: *std.build.LibExeObjStep) void {
+    exe.linkSystemLibrary("gamemode");
+}
+
+/// TODO:
+/// Build and link gamemode
+pub fn buildAndLink(b: *std.build.Builder, exe: *std.build.LibExeObjStep) void {
+    const lib = b.addSharedLibrarySource("gamemode", std.build.FileSource{ .path = thisDir() ++ "/c/client_impl.c" }, .unversioned);
+    lib.linkLibC();
+    exe.linkLibrary(lib);
+}
+
+fn thisDir() []const u8 {
+    return std.fs.path.dirname(@src().file) orelse ".";
+}

gamemode-zig/c/client_impl.c

@@ -0,0 +1,395 @@
+/*
+
+Copyright (c) 2017-2019, Feral Interactive
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ * Neither the name of Feral Interactive nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+#define _GNU_SOURCE
+
+#include <common-helpers.h>
+#include <common-pidfds.h>
+
+#include <dbus/dbus.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+// For developmental purposes
+#define DO_TRACE 0
+
+// D-Bus name, path, iface
+#define DAEMON_DBUS_NAME "com.feralinteractive.GameMode"
+#define DAEMON_DBUS_PATH "/com/feralinteractive/GameMode"
+#define DAEMON_DBUS_IFACE "com.feralinteractive.GameMode"
+
+#define PORTAL_DBUS_NAME "org.freedesktop.portal.Desktop"
+#define PORTAL_DBUS_PATH "/org/freedesktop/portal/desktop"
+#define PORTAL_DBUS_IFACE "org.freedesktop.portal.GameMode"
+
+// Cleanup macros
+#define _cleanup_(x) __attribute__((cleanup(x)))
+#define _cleanup_bus_ _cleanup_(hop_off_the_bus)
+#define _cleanup_msg_ _cleanup_(cleanup_msg)
+#define _cleanup_dpc_ _cleanup_(cleanup_pending_call)
+#define _cleanup_fds_ _cleanup_(cleanup_fd_array)
+
+#ifdef NDEBUG
+#define DEBUG(...)
+#else
+#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
+#endif
+
+#if DO_TRACE
+#define TRACE(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define TRACE(...)
+#endif
+
+// Prototypes
+static int log_error(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
+
+// Storage for error strings
+static char error_string[512] = { 0 };
+
+// memory helpers
+static void cleanup_fd_array(int **fdlist)
+{
+	if (fdlist == NULL || *fdlist == NULL)
+		return;
+
+	int errsave = errno;
+	for (int *fd = *fdlist; *fd != -1; fd++) {
+		TRACE("GM Closing fd %d\n", *fd);
+		(void)close(*fd);
+	}
+
+	errno = errsave;
+	free(*fdlist);
+}
+
+// Allocate a -1 termianted array of ints
+static inline int *alloc_fd_array(int n)
+{
+	int *fds;
+
+	size_t count = (size_t)n + 1; /* -1, terminated */
+	fds = (int *)malloc(sizeof(int) * count);
+	for (size_t i = 0; i < count; i++)
+		fds[i] = -1;
+
+	return fds;
+}
+
+// Helper to check if we are running inside a flatpak
+static int in_flatpak(void)
+{
+	static int status = -1;
+
+	if (status == -1) {
+		struct stat sb;
+		int r;
+
+		r = lstat("/.flatpak-info", &sb);
+		status = r == 0 && sb.st_size > 0;
+	}
+
+	return status;
+}
+
+static int log_error(const char *fmt, ...)
+{
+	va_list args;
+	int n;
+
+	va_start(args, fmt);
+	n = vsnprintf(error_string, sizeof(error_string), fmt, args);
+	va_end(args);
+
+	if (n < 0)
+		DEBUG("Failed to format error string");
+	else if ((size_t)n >= sizeof(error_string))
+		DEBUG("Error log overflow");
+
+	fprintf(stderr, "GameMode ERROR: %s\n", error_string);
+
+	return -1;
+}
+
+static void hop_off_the_bus(DBusConnection **bus)
+{
+	if (bus == NULL)
+		return;
+
+	dbus_connection_unref(*bus);
+}
+
+static DBusConnection *hop_on_the_bus(void)
+{
+	DBusConnection *bus;
+	DBusError err;
+
+	dbus_error_init(&err);
+
+	bus = dbus_bus_get(DBUS_BUS_SESSION, &err);
+
+	if (bus == NULL) {
+		log_error("Could not connect to bus: %s", err.message);
+		dbus_error_free(&err);
+	}
+
+	return bus;
+}
+
+/* cleanup functions */
+static void cleanup_msg(DBusMessage **msg)
+{
+	if (msg == NULL || *msg == NULL)
+		return;
+
+	dbus_message_unref(*msg);
+}
+
+static void cleanup_pending_call(DBusPendingCall **call)
+{
+	if (call == NULL || *call == NULL)
+		return;
+
+	dbus_pending_call_unref(*call);
+}
+
+/* internal API */
+static int make_request(DBusConnection *bus, int native, int use_pidfds, const char *method,
+                        pid_t *pids, int npids, DBusError *error)
+{
+	_cleanup_msg_ DBusMessage *msg = NULL;
+	_cleanup_dpc_ DBusPendingCall *call = NULL;
+	_cleanup_fds_ int *fds = NULL;
+	char action[256] = {
+		0,
+	};
+	DBusError err;
+	DBusMessageIter iter;
+	int res = -1;
+
+	TRACE("GM: Incoming request: %s, npids: %d, native: %d pifds: %d\n",
+	      method,
+	      npids,
+	      native,
+	      use_pidfds);
+
+	if (use_pidfds) {
+		fds = alloc_fd_array(npids);
+
+		res = open_pidfds(pids, fds, npids);
+		if (res != npids) {
+			dbus_set_error(error, DBUS_ERROR_FAILED, "Could not open pidfd for %d", (int)pids[res]);
+			return -1;
+		}
+
+		if (strstr(method, "ByPID"))
+			snprintf(action, sizeof(action), "%sFd", method);
+		else
+			snprintf(action, sizeof(action), "%sByPIDFd", method);
+		method = action;
+	}
+
+	TRACE("GM:   Making request: %s, npids: %d, native: %d pifds: %d\n",
+	      method,
+	      npids,
+	      native,
+	      use_pidfds);
+
+	// If we are inside a flatpak we need to talk to the portal instead
+	const char *dest = native ? DAEMON_DBUS_NAME : PORTAL_DBUS_NAME;
+	const char *path = native ? DAEMON_DBUS_PATH : PORTAL_DBUS_PATH;
+	const char *iface = native ? DAEMON_DBUS_IFACE : PORTAL_DBUS_IFACE;
+
+	msg = dbus_message_new_method_call(dest, path, iface, method);
+
+	if (!msg) {
+		dbus_set_error_const(error, DBUS_ERROR_FAILED, "Could not create dbus message");
+		return -1;
+	}
+
+	dbus_message_iter_init_append(msg, &iter);
+
+	for (int i = 0; i < npids; i++) {
+		dbus_int32_t p;
+		int type;
+
+		if (use_pidfds) {
+			type = DBUS_TYPE_UNIX_FD;
+			p = (dbus_int32_t)fds[i];
+		} else {
+			type = DBUS_TYPE_INT32;
+			p = (dbus_int32_t)pids[i];
+		}
+		dbus_message_iter_append_basic(&iter, type, &p);
+	}
+
+	dbus_connection_send_with_reply(bus, msg, &call, -1);
+	dbus_connection_flush(bus);
+	dbus_message_unref(msg);
+	msg = NULL;
+
+	dbus_pending_call_block(call);
+	msg = dbus_pending_call_steal_reply(call);
+
+	if (msg == NULL) {
+		dbus_set_error_const(error, DBUS_ERROR_FAILED, "Did not receive a reply");
+		return -1;
+	}
+
+	dbus_error_init(&err);
+	res = -1;
+	if (dbus_set_error_from_message(&err, msg)) {
+		dbus_set_error(error,
+		               err.name,
+		               "Could not call method '%s' on '%s': %s",
+		               method,
+		               dest,
+		               err.message);
+	} else if (!dbus_message_iter_init(msg, &iter) ||
+	           dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32) {
+		dbus_set_error(error, DBUS_ERROR_INVALID_SIGNATURE, "Failed to parse response");
+	} else {
+		dbus_message_iter_get_basic(&iter, &res);
+	}
+
+	/* free the local error */
+	if (dbus_error_is_set(&err))
+		dbus_error_free(&err);
+
+	return res;
+}
+
+static int gamemode_request(const char *method, pid_t for_pid)
+{
+	_cleanup_bus_ DBusConnection *bus = NULL;
+	static int use_pidfs = 1;
+	DBusError err;
+	pid_t pids[2];
+	int npids;
+	int native;
+	int res = -1;
+
+	native = !in_flatpak();
+
+	/* pid[0] is the client, i.e. the game
+	 * pid[1] is the requestor, i.e. this process
+	 *
+	 * we setup the array such that pids[1] will always be a valid
+	 * pid, because if we are going to use the pidfd based API,
+	 * both pids are being sent, even if they are the same
+	 */
+	pids[1] = getpid();
+	pids[0] = for_pid != 0 ? for_pid : pids[1];
+
+	TRACE("GM: [%d] request '%s' received (by: %d) [portal: %s]\n",
+	      (int)pids[0],
+	      method,
+	      (int)pids[1],
+	      (native ? "n" : "y"));
+
+	bus = hop_on_the_bus();
+
+	if (bus == NULL)
+		return -1;
+
+	dbus_error_init(&err);
+retry:
+	if (for_pid != 0 || use_pidfs)
+		npids = 2;
+	else
+		npids = 1;
+
+	res = make_request(bus, native, use_pidfs, method, pids, npids, &err);
+
+	if (res == -1 && use_pidfs && dbus_error_is_set(&err)) {
+		TRACE("GM: Request with pidfds failed (%s). Retrying.\n", err.message);
+		use_pidfs = 0;
+		dbus_error_free(&err);
+		goto retry;
+	}
+
+	if (res == -1 && dbus_error_is_set(&err))
+		log_error("D-Bus error: %s", err.message);
+
+	TRACE("GM: [%d] request '%s' done: %d\n", (int)pids[0], method, res);
+
+	if (dbus_error_is_set(&err))
+		dbus_error_free(&err);
+
+	return res;
+}
+
+// Get the error string
+extern const char *real_gamemode_error_string(void)
+{
+	return error_string;
+}
+
+// Wrapper to call RegisterGame
+extern int real_gamemode_request_start(void)
+{
+	return gamemode_request("RegisterGame", 0);
+}
+
+// Wrapper to call UnregisterGame
+extern int real_gamemode_request_end(void)
+{
+	return gamemode_request("UnregisterGame", 0);
+}
+
+// Wrapper to call QueryStatus
+extern int real_gamemode_query_status(void)
+{
+	return gamemode_request("QueryStatus", 0);
+}
+
+// Wrapper to call RegisterGameByPID
+extern int real_gamemode_request_start_for(pid_t pid)
+{
+	return gamemode_request("RegisterGameByPID", pid);
+}
+
+// Wrapper to call UnregisterGameByPID
+extern int real_gamemode_request_end_for(pid_t pid)
+{
+	return gamemode_request("UnregisterGameByPID", pid);
+}
+
+// Wrapper to call QueryStatusByPID
+extern int real_gamemode_query_status_for(pid_t pid)
+{
+	return gamemode_request("QueryStatusByPID", pid);
+}

gamemode-zig/c/client_loader.c

@@ -0,0 +1,35 @@
+/*
+
+Copyright (c) 2017-2019, Feral Interactive
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ * Neither the name of Feral Interactive nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+// Simply include the header with GAMEMODE_AUTO set
+// This will ensure it calls the functions when it's loaded
+#define GAMEMODE_AUTO
+#include "gamemode_client.h"

gamemode-zig/c/gamemode_client.h

@@ -0,0 +1,376 @@
+/*
+
+Copyright (c) 2017-2019, Feral Interactive
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ * Neither the name of Feral Interactive nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#ifndef CLIENT_GAMEMODE_H
+#define CLIENT_GAMEMODE_H
+/*
+ * GameMode supports the following client functions
+ * Requests are refcounted in the daemon
+ *
+ * int gamemode_request_start() - Request gamemode starts
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *
+ * int gamemode_request_end() - Request gamemode ends
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *
+ * GAMEMODE_AUTO can be defined to make the above two functions apply during static init and
+ * destruction, as appropriate. In this configuration, errors will be printed to stderr
+ *
+ * int gamemode_query_status() - Query the current status of gamemode
+ *   0 if gamemode is inactive
+ *   1 if gamemode is active
+ *   2 if gamemode is active and this client is registered
+ *   -1 if the query failed
+ *
+ * int gamemode_request_start_for(pid_t pid) - Request gamemode starts for another process
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *   -2 if the request was rejected
+ *
+ * int gamemode_request_end_for(pid_t pid) - Request gamemode ends for another process
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *   -2 if the request was rejected
+ *
+ * int gamemode_query_status_for(pid_t pid) - Query status of gamemode for another process
+ *   0 if gamemode is inactive
+ *   1 if gamemode is active
+ *   2 if gamemode is active and this client is registered
+ *   -1 if the query failed
+ *
+ * const char* gamemode_error_string() - Get an error string
+ *   returns a string describing any of the above errors
+ *
+ * Note: All the above requests can be blocking - dbus requests can and will block while the daemon
+ * handles the request. It is not recommended to make these calls in performance critical code
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#include <dlfcn.h>
+#include <string.h>
+
+#include <assert.h>
+
+#include <sys/types.h>
+
+static char internal_gamemode_client_error_string[512] = { 0 };
+
+/**
+ * Load libgamemode dynamically to dislodge us from most dependencies.
+ * This allows clients to link and/or use this regardless of runtime.
+ * See SDL2 for an example of the reasoning behind this in terms of
+ * dynamic versioning as well.
+ */
+static volatile int internal_libgamemode_loaded = 1;
+
+/* Typedefs for the functions to load */
+typedef int (*api_call_return_int)(void);
+typedef const char *(*api_call_return_cstring)(void);
+typedef int (*api_call_pid_return_int)(pid_t);
+
+/* Storage for functors */
+static api_call_return_int REAL_internal_gamemode_request_start = NULL;
+static api_call_return_int REAL_internal_gamemode_request_end = NULL;
+static api_call_return_int REAL_internal_gamemode_query_status = NULL;
+static api_call_return_cstring REAL_internal_gamemode_error_string = NULL;
+static api_call_pid_return_int REAL_internal_gamemode_request_start_for = NULL;
+static api_call_pid_return_int REAL_internal_gamemode_request_end_for = NULL;
+static api_call_pid_return_int REAL_internal_gamemode_query_status_for = NULL;
+
+/**
+ * Internal helper to perform the symbol binding safely.
+ *
+ * Returns 0 on success and -1 on failure
+ */
+__attribute__((always_inline)) static inline int internal_bind_libgamemode_symbol(
+    void *handle, const char *name, void **out_func, size_t func_size, bool required)
+{
+	void *symbol_lookup = NULL;
+	char *dl_error = NULL;
+
+	/* Safely look up the symbol */
+	symbol_lookup = dlsym(handle, name);
+	dl_error = dlerror();
+	if (required && (dl_error || !symbol_lookup)) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "dlsym failed - %s",
+		         dl_error);
+		return -1;
+	}
+
+	/* Have the symbol correctly, copy it to make it usable */
+	memcpy(out_func, &symbol_lookup, func_size);
+	return 0;
+}
+
+/**
+ * Loads libgamemode and needed functions
+ *
+ * Returns 0 on success and -1 on failure
+ */
+__attribute__((always_inline)) static inline int internal_load_libgamemode(void)
+{
+	/* We start at 1, 0 is a success and -1 is a fail */
+	if (internal_libgamemode_loaded != 1) {
+		return internal_libgamemode_loaded;
+	}
+
+	/* Anonymous struct type to define our bindings */
+	struct binding {
+		const char *name;
+		void **functor;
+		size_t func_size;
+		bool required;
+	} bindings[] = {
+		{ "real_gamemode_request_start",
+		  (void **)&REAL_internal_gamemode_request_start,
+		  sizeof(REAL_internal_gamemode_request_start),
+		  true },
+		{ "real_gamemode_request_end",
+		  (void **)&REAL_internal_gamemode_request_end,
+		  sizeof(REAL_internal_gamemode_request_end),
+		  true },
+		{ "real_gamemode_query_status",
+		  (void **)&REAL_internal_gamemode_query_status,
+		  sizeof(REAL_internal_gamemode_query_status),
+		  false },
+		{ "real_gamemode_error_string",
+		  (void **)&REAL_internal_gamemode_error_string,
+		  sizeof(REAL_internal_gamemode_error_string),
+		  true },
+		{ "real_gamemode_request_start_for",
+		  (void **)&REAL_internal_gamemode_request_start_for,
+		  sizeof(REAL_internal_gamemode_request_start_for),
+		  false },
+		{ "real_gamemode_request_end_for",
+		  (void **)&REAL_internal_gamemode_request_end_for,
+		  sizeof(REAL_internal_gamemode_request_end_for),
+		  false },
+		{ "real_gamemode_query_status_for",
+		  (void **)&REAL_internal_gamemode_query_status_for,
+		  sizeof(REAL_internal_gamemode_query_status_for),
+		  false },
+	};
+
+	void *libgamemode = NULL;
+
+	/* Try and load libgamemode */
+	libgamemode = dlopen("libgamemode.so.0", RTLD_NOW);
+	if (!libgamemode) {
+		/* Attempt to load unversioned library for compatibility with older
+		 * versions (as of writing, there are no ABI changes between the two -
+		 * this may need to change if ever ABI-breaking changes are made) */
+		libgamemode = dlopen("libgamemode.so", RTLD_NOW);
+		if (!libgamemode) {
+			snprintf(internal_gamemode_client_error_string,
+			         sizeof(internal_gamemode_client_error_string),
+			         "dlopen failed - %s",
+			         dlerror());
+			internal_libgamemode_loaded = -1;
+			return -1;
+		}
+	}
+
+	/* Attempt to bind all symbols */
+	for (size_t i = 0; i < sizeof(bindings) / sizeof(bindings[0]); i++) {
+		struct binding *binder = &bindings[i];
+
+		if (internal_bind_libgamemode_symbol(libgamemode,
+		                                     binder->name,
+		                                     binder->functor,
+		                                     binder->func_size,
+		                                     binder->required)) {
+			internal_libgamemode_loaded = -1;
+			return -1;
+		};
+	}
+
+	/* Success */
+	internal_libgamemode_loaded = 0;
+	return 0;
+}
+
+/**
+ * Redirect to the real libgamemode
+ */
+__attribute__((always_inline)) static inline const char *gamemode_error_string(void)
+{
+	/* If we fail to load the system gamemode, or we have an error string already, return our error
+	 * string instead of diverting to the system version */
+	if (internal_load_libgamemode() < 0 || internal_gamemode_client_error_string[0] != '\0') {
+		return internal_gamemode_client_error_string;
+	}
+
+	/* Assert for static analyser that the function is not NULL */
+	assert(REAL_internal_gamemode_error_string != NULL);
+
+	return REAL_internal_gamemode_error_string();
+}
+
+/**
+ * Redirect to the real libgamemode
+ * Allow automatically requesting game mode
+ * Also prints errors as they happen.
+ */
+#ifdef GAMEMODE_AUTO
+__attribute__((constructor))
+#else
+__attribute__((always_inline)) static inline
+#endif
+int gamemode_request_start(void)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	/* Assert for static analyser that the function is not NULL */
+	assert(REAL_internal_gamemode_request_start != NULL);
+
+	if (REAL_internal_gamemode_request_start() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	return 0;
+}
+
+/* Redirect to the real libgamemode */
+#ifdef GAMEMODE_AUTO
+__attribute__((destructor))
+#else
+__attribute__((always_inline)) static inline
+#endif
+int gamemode_request_end(void)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	/* Assert for static analyser that the function is not NULL */
+	assert(REAL_internal_gamemode_request_end != NULL);
+
+	if (REAL_internal_gamemode_request_end() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	return 0;
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_query_status(void)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_query_status == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_query_status missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_query_status();
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_request_start_for(pid_t pid)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_request_start_for == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_request_start_for missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_request_start_for(pid);
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_request_end_for(pid_t pid)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_request_end_for == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_request_end_for missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_request_end_for(pid);
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_query_status_for(pid_t pid)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_query_status_for == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_query_status_for missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_query_status_for(pid);
+}
+
+#endif // CLIENT_GAMEMODE_H

gamemode-zig/fetch_upstream.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+rm ./c/*
+cd ./c
+wget "https://github.com/FeralInteractive/gamemode/raw/master/lib/gamemode_client.h"
+wget "https://github.com/FeralInteractive/gamemode/raw/master/lib/client_impl.c"
+wget "https://github.com/FeralInteractive/gamemode/raw/master/lib/client_loader.c"
+cd ..
+
+# The output from translate-c isn't perfect, so we need this fix
+zig translate-c ./c/gamemode_client.h -lc | sed "s#functor\(.*\)@alignCast\(.*\),\(.*\))#functor\1\3#" > ./src/gamemode_client.zig
+
+rm -r ./zig-cache

gamemode-zig/src/gamemode.zig

@@ -0,0 +1,76 @@
+//! Note: All the above requests can be blocking - dbus requests can and will block while the daemon
+//! handles the request. It is not recommended to make these calls in performance critical code
+
+pub const c = @import("gamemode_client.zig");
+
+pub const GamemodeError = error{
+    RequestFailed,
+    RequestRejected,
+    QueryFailed,
+};
+
+pub const GamemodeStatus = enum(c_int) {
+    Inactive = 0,
+    Active = 1,
+    /// Gamemode is active and the client is registered
+    ActiveAndRegistered = 2,
+};
+
+/// Request gamemode starts
+pub fn requestStart() GamemodeError!void {
+    if (c.gamemode_request_start() == -1)
+        return GamemodeError.RequestFailed;
+}
+
+/// Request gamemode ends
+pub fn requestEnd() GamemodeError!void {
+    if (c.gamemode_request_end() == -1)
+        return GamemodeError.RequestFailed;
+}
+
+/// Query the current status of gamemode
+pub fn queryStatus() GamemodeError!GamemodeStatus {
+    const status = c.gamemode_query_status();
+    if (status == -1)
+        return GamemodeError.QueryFailed;
+
+    return @intToEnum(GamemodeStatus, status);
+}
+
+/// Request gamemode starts for another process
+pub fn requestStartFor(pid: c.pid_t) GamemodeError!void {
+    const res = c.gamemode_request_start_for(pid);
+    if (res == 0) {
+        return;
+    } else if (res == -1) {
+        return GamemodeError.RequestFailed;
+    } else if (res == -2) {
+        return GamemodeError.RequestRejected;
+    }
+}
+
+/// Request gamemode ends for another process
+pub fn requestEndFor(pid: c.pid_t) GamemodeError!void {
+    const res = c.gamemode_request_end_for(pid);
+    if (res == 0) {
+        return;
+    } else if (res == -1) {
+        return GamemodeError.RequestFailed;
+    } else if (res == -2) {
+        return GamemodeError.RequestRejected;
+    }
+}
+
+/// Query the current status of gamemode for another process
+pub fn queryStatusFor(pid: c.pid_t) GamemodeError!GamemodeStatus {
+    const status = c.gamemode_query_status_for(pid);
+    if (status == -1)
+        return GamemodeError.QueryFailed;
+
+    return @intToEnum(GamemodeStatus, status);
+}
+
+/// Get an error string
+pub fn errorString() []const u8 {
+    return @import("std").mem.sliceTo(c.gamemode_error_string(), 0);
+}