WIP: Move Mumble Socket and Overlay to $XDG_RUNTIME_DIR/mumble/

.gitmodules

@@ -25,3 +25,6 @@
 [submodule "3rdparty/SPSCQueue"]
 	path = 3rdparty/SPSCQueue
 	url = https://github.com/rigtorp/SPSCQueue.git
+[submodule "3rdparty/cwalk"]
+	path = 3rdparty/cwalk
+	url = https://github.com/likle/cwalk.git

CMakeLists.txt

@@ -98,6 +98,8 @@ endif()
 
 option(lto "Enables link-time optimizations for release builds" ${LTO_DEFAULT})
 
+# option(bundled-cwalk "Build the included version of CWalk instead of looking for one on the system." ON)
+
 include(compiler)
 include(os)
 
@@ -165,6 +167,29 @@ if(client OR server)
 	add_subdirectory(src)
 endif()
 
+# if(client OR overlay)
+# 	if(bundled-cwalk)
+# 		add_subdirectory("${3RDPARTY_DIR}/cwalk" "${CMAKE_CURRENT_BINARY_DIR}/cwalk" EXCLUDE_FROM_ALL)
+# 		if(overlay-xcompile)
+# 			# Just check for this header file while using a 32bit target as a really small and incomplete check whether g++-multilib seems to be
+# 			# installed. If we don't find it, we can assume it's not there but if we do find it, we still don't know. Thus we still print the
+# 			# message about the 32bit target potentially failing due to missing g++-multilib.
+# 			CHECK_INCLUDE_FILE("sys/cdefs.h" FOUND_CDEFS "-m32")
+# 			if(NOT FOUND_CDEFS)
+# 				message(FATAL_ERROR "Can't find the 32bit version of sys/cdefs.h - did you install g++-multilib?")
+# 			else()
+# 				message(STATUS "\nIf the 32 bit overlay library fails to compile, make sure the requirements are installed (\"g++-multilib\" package on Debian-based distributions).\n")
+# 			endif()
+
+
+# 			add_subdirectory("${3RDPARTY_DIR}/cwalk" "${CMAKE_CURRENT_BINARY_DIR}/cwalk_x86" EXCLUDE_FROM_ALL)
+# 			set_target_properties(cwalk PROPERTIES COMPILE_OPTIONS "-m32" LINK_OPTIONS "-m32")
+# 		endif()
+# 	else()
+# 		find_pkg(Cwalk REQUIRED)
+# 	endif()
+# endif()
+
 if(g15 AND WIN32)
 	add_subdirectory("helpers/g15helper")
 endif()

overlay/CMakeLists.txt

@@ -94,6 +94,8 @@ target_sources(overlay
 		"dxgi.cpp"
 		"excludecheck.cpp"
 		"excludecheck.h"
+		"ipc_utils.h"
+		"ipc_utils.c"
 		"lib.cpp"
 		"lib.h"
 		"ods.cpp"

overlay/ipc_utils.c

@@ -0,0 +1,97 @@
+// Copyright 2022 The Mumble Developers. All rights reserved.
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file at the root of the
+// Mumble source tree or at <https://www.mumble.info/LICENSE>.
+
+#include "ipc_utils.h"
+// #include <cwalk.h>
+#include <string.h>
+
+#ifdef _WIN32
+#	include <direct.h>
+#	include <stdlib.h>
+#	include <malloc.h>
+#else
+#	include <pwd.h>
+#	include <stdio.h>
+#	include <stdlib.h>
+#	include <sys/stat.h>
+#	include <sys/types.h>
+#	include <unistd.h>
+#endif
+
+// can't trust POSIX's nor Window's PATH_MAX constants
+// see: https://eklitzke.org/path-max-is-tricky
+//      https://stackoverflow.com/a/56385296
+#define MUMBLE_MAX_PATH 1024
+
+char *getRuntimePath__() {
+	char buffer[MUMBLE_MAX_PATH];
+	char *path = NULL;
+
+#ifdef _WIN32
+	path = strdup("\0");
+#elif __linux__
+	char *xdgRuntimeDir = getenv("XDG_RUNTIME_DIR");
+	if (xdgRuntimeDir == NULL || !xdgRuntimeDir) {
+		// char uid[10];
+		// sprintf(uid, "%d", getuid());
+		xdgRuntimeDir = "/run/user/";
+		// cwk_path_join(xdgRuntimeDir, uid, buffer, sizeof(buffer));
+		snprintf(buffer, sizeof(buffer), "%s/%d", xdgRuntimeDir, getuid());
+	}
+	// size_t path_len = cwk_path_join(xdgRuntimeDir, "mumble", buffer, sizeof(buffer));
+	int path_len        = snprintf(buffer, sizeof(buffer), "%s/mumble/", xdgRuntimeDir);
+#else
+	char *home = getenv("HOME");
+	if (home == NULL) {
+		struct passwd *pwent = getpwuid(getuid());
+		if (pwent && pwent->pw_dir && pwent->pw_dir[0])
+			home = pwent->pw_dir;
+		else
+			return NULL;
+	}
+	if ((path = malloc(strlen(home) + 1)) == NULL)
+		return NULL;
+	int path_len = snprintf(buffer, sizeof(buffer), "%s/", home);
+#endif
+#if !defined _WIN32
+	// if (path_len != strlen(buffer))
+	// 		buffer is too small. Result is truncated
+	if ((path = malloc(path_len + 1)) == NULL)
+		return NULL;
+	strcpy(path, buffer);
+#endif
+	return path;
+}
+
+char *getAndCreateOverlayPipePath__() {
+	char buffer[MUMBLE_MAX_PATH];
+	char *overlapyPipeFile = "MumbleOverlayPipe";
+	char *path             = NULL;
+	char *runtimePath      = getRuntimePath__();
+	if (runtimePath == NULL)
+		return NULL;
+#if !defined __linux__ && !defined _WIN32
+	char *path_template = "%s.%s";
+#else
+	char *path_template = "%s%s";
+#endif
+#if _WIN32
+/*
+ * on Windows we don't create the directory as getRuntimePath__() returns an empty string.
+ * _mkdir(runtimePath);
+ */
+#else
+	mkdir(runtimePath, 0755);
+#endif
+	// size_t path_len = cwk_path_join(runtimePath, overlapyPipeFile, buffer, sizeof(buffer));
+	int path_len = snprintf(buffer, sizeof(buffer), path_template, runtimePath, overlapyPipeFile);
+	// if (path_len != strlen(path))
+	// 		path is too small. Result is truncated
+	if ((path = malloc(path_len + 1)) == NULL)
+		return NULL;
+	strcpy(path, buffer);
+	free(runtimePath);
+	return path;
+}

overlay/ipc_utils.h

@@ -0,0 +1,13 @@
+// Copyright 2022 The Mumble Developers. All rights reserved.
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file at the root of the
+// Mumble source tree or at <https://www.mumble.info/LICENSE>.
+
+#ifndef MUMBLE_OVERLAY_IPC_UTILS_H__
+#define MUMBLE_OVERLAY_IPC_UTILS_H__
+
+char *getRuntimePath__();
+
+char *getAndCreateOverlayPipePath__();
+
+#endif // MUMBLE_OVERLAY_IPC_UTILS_H__

overlay_gl/CMakeLists.txt

@@ -13,7 +13,13 @@ if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64" OR ${CMAKE_SYSTEM_PROCESSOR} STRE
 	endif()
 endif()
 
-add_library(overlay_gl SHARED "overlay.c")
+set(OVERLAY_SOURCES
+	"${CMAKE_SOURCE_DIR}/overlay/ipc_utils.c"
+	"overlay.c"
+)
+add_library(overlay_gl SHARED ${OVERLAY_SOURCES})
+
+# target_link_libraries(overlay_gl PRIVATE cwalk)
 
 set_target_properties(overlay_gl
 	PROPERTIES
@@ -31,10 +37,9 @@ if(NOT APPLE)
 			"-Wl,-z,lazy"
 	)
 
-	set_target_properties(overlay_gl
-		PROPERTIES
-			COMPILE_DEFINITIONS
-				"TARGET_UNIX"
+	target_compile_definitions(overlay_gl
+		PRIVATE
+			"TARGET_UNIX"
 	)
 
 	if(overlay-xcompile)
@@ -47,13 +52,13 @@ if(NOT APPLE)
 		else()
 			message(STATUS "\nIf the 32 bit overlay library fails to compile, make sure the requirements are installed (\"g++-multilib\" package on Debian-based distributions).\n")
 		endif()
-
 		set_target_properties(overlay_gl
 			PROPERTIES
 				OUTPUT_NAME "mumbleoverlay.x86_64"
 		)
 
-		add_library(overlay_gl_x86 SHARED "overlay.c")
+		add_library(overlay_gl_x86 SHARED ${OVERLAY_SOURCES})
+		# target_link_libraries(overlay_gl_x86 PRIVATE cwalk)
 
 		target_compile_definitions(overlay_gl_x86
 			PRIVATE

overlay_gl/overlay.c

@@ -11,7 +11,6 @@
 #include <fcntl.h>
 #include <limits.h>
 #include <math.h>
-#include <pwd.h>
 #include <semaphore.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -53,6 +52,7 @@ typedef unsigned char bool;
 #	include "avail_mac.h"
 #endif
 
+#include "../overlay/ipc_utils.h"
 #include "../overlay/overlay.h"
 
 static bool bDebug       = false;
@@ -147,25 +147,10 @@ static void newContext(Context *ctx) {
 	ctx->timeT             = clock();
 	ctx->frameCount        = 0;
 
-	char *home = getenv("HOME");
-	if (home == NULL) {
-		struct passwd *pwent = getpwuid(getuid());
-		if (pwent && pwent->pw_dir && pwent->pw_dir[0]) {
-			home = pwent->pw_dir;
-		}
-	}
-
-	char *xdgRuntimeDir = getenv("XDG_RUNTIME_DIR");
-
-	if (xdgRuntimeDir != NULL) {
-		ctx->saName.sun_family = PF_UNIX;
-		strcpy(ctx->saName.sun_path, xdgRuntimeDir);
-		strcat(ctx->saName.sun_path, "/MumbleOverlayPipe");
-	} else if (home) {
-		ctx->saName.sun_family = PF_UNIX;
-		strcpy(ctx->saName.sun_path, home);
-		strcat(ctx->saName.sun_path, "/.MumbleOverlayPipe");
-	}
+	char *path = getAndCreateOverlayPipePath__();
+	strcpy(ctx->saName.sun_path, path);
+	free(path);
+	ctx->saName.sun_family = PF_UNIX;
 
 	ods("OpenGL Version %s, Vendor %s, Renderer %s, Shader %s", glGetString(GL_VERSION), glGetString(GL_VENDOR),
 		glGetString(GL_RENDERER), glGetString(GL_SHADING_LANGUAGE_VERSION));

src/mumble/CMakeLists.txt

@@ -156,6 +156,10 @@ set(MUMBLE_SOURCES
 	"GlobalShortcutButtons.ui"
 	"GlobalShortcutTarget.ui"
 	"GlobalShortcutTypes.h"
+	"IPCUtils.cpp"
+	"IPCUtils.h"
+	"${CMAKE_SOURCE_DIR}/overlay/ipc_utils.c"
+	"${CMAKE_SOURCE_DIR}/overlay/ipc_utils.h"
 	"JSONSerialization.cpp"
 	"JSONSerialization.h"
 	"LCD.cpp"
@@ -508,6 +512,7 @@ else()
 	find_pkg("nlohmann_json" REQUIRED)
 endif()
 
+# target_link_libraries(mumble_client_object_lib PUBLIC cwalk)
 target_link_libraries(mumble_client_object_lib PUBLIC nlohmann_json::nlohmann_json)
 
 find_pkg("SndFile;LibSndFile;sndfile" REQUIRED)

src/mumble/IPCUtils.cpp

@@ -0,0 +1,51 @@
+// Copyright 2021-2022 The Mumble Developers. All rights reserved.
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file at the root of the
+// Mumble source tree or at <https://www.mumble.info/LICENSE>.
+
+#include "IPCUtils.h"
+extern "C" {
+#include "../../overlay/ipc_utils.h"
+}
+
+#include <QDir>
+#include <QProcessEnvironment>
+#include <QString>
+
+namespace Mumble {
+const std::string getRuntimePath(void) {
+	char *c_mumbleRuntimePath = getRuntimePath__();
+	if (c_mumbleRuntimePath == NULL)
+		return "";
+	std::string mumbleRuntimePath = c_mumbleRuntimePath;
+	std::free(c_mumbleRuntimePath);
+	return mumbleRuntimePath;
+}
+
+const std::string getAndCreateOverlayPipePath(void) {
+	char *c_pipepath = getAndCreateOverlayPipePath__();
+	if (c_pipepath == NULL)
+		return "";
+	std::string pipepath = c_pipepath;
+	std::free(c_pipepath);
+	return pipepath;
+}
+
+const std::string getAndCreateSocketPath(const std::string &basename) {
+	const std::string mumbleRuntimePath = getRuntimePath();
+#ifdef Q_OS_WIN
+	return basename;
+#endif
+	if (mumbleRuntimePath.empty())
+		return "";
+	QString qMumbleRuntimePath = QString::fromUtf8(mumbleRuntimePath.data(), int(mumbleRuntimePath.size()));
+	QDir(qMumbleRuntimePath).mkpath(".");
+#ifdef Q_OS_LINUX
+	std::string pipepath = mumbleRuntimePath + basename + "Socket";
+#else // MAC or BSD
+	const std::string pipepath = mumbleRuntimePath + "." + basename + "Socket";
+#endif
+	return pipepath;
+}
+
+}; // namespace Mumble

src/mumble/IPCUtils.h

@@ -0,0 +1,30 @@
+// Copyright 2021-2022 The Mumble Developers. All rights reserved.
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file at the root of the
+// Mumble source tree or at <https://www.mumble.info/LICENSE>.
+
+#ifndef MUMBLE_MUMBLE_IPCUTILS_H_
+#define MUMBLE_MUMBLE_IPCUTILS_H_
+
+#include <string>
+
+namespace Mumble {
+
+/**
+ * @returns The path to MumbleOverlayPipe
+ */
+const std::string getAndCreateOverlayPipePath();
+
+/**
+ * @returns The path to MumbleSocket
+ */
+const std::string getAndCreateSocketPath(const std::string &);
+
+/**
+ * @returns The path where Mumble sets up MumbleOverlayPipe and MumbleSocket
+ */
+const std::string getRuntimePath();
+
+}; // namespace Mumble
+
+#endif // MUMBLE_MUMBLE_IPCUTILS_H_