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_