REFAC(ipc): extract IPCUtils for Socket and OverlayPipe

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,107 @@
+// Copyright 2007-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 <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
+
+char *getRuntimePath__() {
+ size_t n = 0;
+ char *path = NULL;
+
+#ifdef __linux__
+ char *xdgRuntimeDir = getenv("XDG_RUNTIME_DIR");
+
+ if (xdgRuntimeDir != NULL) {
+ if (xdgRuntimeDir)
+ n += strlen(xdgRuntimeDir);
+ if (xdgRuntimeDir[(strlen(xdgRuntimeDir) - 1)] != '/')
+ n++;
+ n += strlen("mumble/");
+
+ if ((path = malloc(n + 1)) == NULL)
+ return path;
+ *path = '\0';
+
+ strcpy(path, xdgRuntimeDir);
+ if (xdgRuntimeDir[(strlen(xdgRuntimeDir) - 1)] != '/')
+ strcat(path, "/");
+ strcat(path, "mumble/");
+ } else {
+ char uid[10];
+ n += strlen("/run/user//mumble/");
+ sprintf(uid, "%d", getuid());
+ n += strlen(uid);
+
+ if ((path = malloc(n + 1)) == NULL)
+ return path;
+ *path = '\0';
+
+ strcpy(path, "/run/user/");
+ strcat(path, uid);
+ strcat(path, "/mumble/");
+ }
+#elif defined(_WIN32)
+ path = strdup("");
+#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;
+ }
+ if (home == NULL)
+ return NULL;
+ n += strlen(home);
+ if (home[(strlen(home) - 1)] != '/')
+ n++;
+ if ((path = malloc(n + 1)) == NULL)
+ return path;
+ strcpy(path, home);
+ if (home[(strlen(home) - 1)] != '/')
+ strcat(path, "/");
+#endif
+ return path;
+}
+
+char *getAndCreateOverlayPipePath__() {
+ char *runtimePath = getRuntimePath__();
+ char *path = NULL;
+ if (runtimePath == NULL)
+ return runtimePath;
+#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 n = 1;
+ n += strlen(runtimePath);
+ n += strlen("MumbleOverlayPipe");
+ path = (char *) malloc(n + 1);
+ if (path == NULL)
+ return path;
+#if !defined __linux__ && !defined _WIN32
+ strcat(path, ".");
+#endif
+ strcpy(path, runtimePath);
+ strcat(path, "MumbleOverlayPipe");
+ free(runtimePath);
+ return path;
+}

overlay/ipc_utils.h

@@ -0,0 +1,13 @@
+// Copyright 2015-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/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,37 +147,10 @@ static void newContext(Context *ctx) {
  ctx->timeT = clock();
  ctx->frameCount = 0;
 
-#ifdef __linux__
- char *xdgRuntimeDir = getenv("XDG_RUNTIME_DIR");
-
- if (xdgRuntimeDir != NULL) {
- ctx->saName.sun_family = PF_UNIX;
- strcpy(ctx->saName.sun_path, xdgRuntimeDir);
- if(xdgRuntimeDir[(strlen(xdgRuntimeDir)-1)] != '/')
- strcat(ctx->saName.sun_path, "/");
- strcat(ctx->saName.sun_path, "mumble/MumbleOverlayPipe");
- } else {
- char uid[10];
- sprintf(uid, "%d", getuid());
- ctx->saName.sun_family = PF_UNIX;
- strcpy(ctx->saName.sun_path, "/run/user/");
- strcat(ctx->saName.sun_path, uid);
- strcat(ctx->saName.sun_path, "/mumble/MumbleOverlayPipe");
- }
-#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;
- }
- }
- if (home) {
- ctx->saName.sun_family = PF_UNIX;
- strcpy(ctx->saName.sun_path, home);
- strcat(ctx->saName.sun_path, "/MumbleOverlayPipe");
- }
-#endif
+ 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"

src/mumble/IPCUtils.cpp

@@ -0,0 +1,49 @@
+// 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;
+ return mumbleRuntimePath;
+}
+
+const std::string getAndCreateOverlayPipePath(void) {
+ char *c_pipepath = getAndCreateOverlayPipePath__();
+ if (c_pipepath == NULL)
+ return "";
+ std::string pipepath = 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_

src/mumble/Overlay.cpp

@@ -8,6 +8,7 @@
 #include "Channel.h"
 #include "ClientUser.h"
 #include "Database.h"
+#include "IPCUtils.h"
 #include "MainWindow.h"
 #include "OverlayClient.h"
 #include "OverlayText.h"
@@ -238,36 +239,21 @@ void Overlay::createPipe() {
  // Allow anyone to access the pipe in order to communicate with the overlay
  qlsServer->setSocketOptions(QLocalServer::WorldAccessOption);
 
- QString pipepath;
-#ifdef Q_OS_WIN
- pipepath = QLatin1String("MumbleOverlayPipe");
-#else
- {
- QString xdgRuntimePath = QProcessEnvironment::systemEnvironment().value(QLatin1String("XDG_RUNTIME_DIR"));
- QString mumbleRuntimePath;
- if (!xdgRuntimePath.isNull()) {
- mumbleRuntimePath = QDir(xdgRuntimePath).absolutePath() + QLatin1String("/mumble/");
- } else {
- mumbleRuntimePath = QLatin1String("/run/user/") + QString::number(getuid()) + QLatin1String("/mumble/");
- }
- QDir mumbleRuntimeDir = QDir(mumbleRuntimePath);
- mumbleRuntimeDir.mkpath(".");
- pipepath = mumbleRuntimeDir.absoluteFilePath(QLatin1String("MumbleOverlayPipe"));
- }
+ const std::string pipepath = Mumble::getAndCreateOverlayPipePath();
+ QString qPipepath = QString::fromUtf8(pipepath.data(), int(pipepath.size()));
 
  {
- QFile f(pipepath);
+ QFile f(qPipepath);
  if (f.exists()) {
- qWarning() << "Overlay: Removing old socket on" << pipepath;
+ qWarning() << "Overlay: Removing old socket on" << qPipepath;
  f.remove();
  }
  }
-#endif
 
- if (!qlsServer->listen(pipepath)) {
+ if (!qlsServer->listen(qPipepath)) {
  QMessageBox::warning(nullptr, QLatin1String("Mumble"),
  tr("Failed to create communication with overlay at %2: %1. No overlay will be available.")
- .arg(qlsServer->errorString().toHtmlEscaped(), pipepath.toHtmlEscaped()),
+ .arg(qlsServer->errorString().toHtmlEscaped(), qPipepath.toHtmlEscaped()),
  QMessageBox::Ok, QMessageBox::NoButton);
  } else {
  qWarning() << "Overlay: Listening on" << qlsServer->fullServerName();