Fix macos fork crash in run action

lib/queue/action-queue.cpp

@@ -420,11 +420,10 @@ static bool queueWithNameExists(const std::string &name)
 	return !GetWeakActionQueueByName(name).expired();
 }
 
-static void signalImportedQueues(void *varsPtr)
+static void
+signalImportedQueues(const std::vector<std::shared_ptr<Item>> &queues)
 {
-	auto queues = std::unique_ptr<std::vector<std::shared_ptr<Item>>>(
-		static_cast<std::vector<std::shared_ptr<Item>> *>(varsPtr));
-	for (const auto &queue : *queues) {
+	for (const auto &queue : queues) {
 		ActionQueueSignalManager::Instance()->Add(
 			QString::fromStdString(queue->Name()));
 	}
@@ -436,7 +435,7 @@ void ImportQueues(obs_data_t *data)
 		obs_data_get_array(data, "actionQueues");
 	size_t count = obs_data_array_count(array);
 
-	auto importedQueues = new std::vector<std::shared_ptr<Item>>;
+	std::vector<std::shared_ptr<Item>> importedQueues;
 
 	for (size_t i = 0; i < count; i++) {
 		OBSDataAutoRelease arrayElement = obs_data_array_item(array, i);
@@ -446,10 +445,11 @@ void ImportQueues(obs_data_t *data)
 			continue;
 		}
 		queues.emplace_back(queue);
-		importedQueues->emplace_back(queue);
+		importedQueues.emplace_back(queue);
 	}
 
-	QueueUITask(signalImportedQueues, importedQueues);
+	QueueUITask(
+		[importedQueues]() { signalImportedQueues(importedQueues); });
 }
 
 std::weak_ptr<ActionQueue> GetWeakActionQueueByName(const std::string &name)

lib/utils/temp-variable.cpp

@@ -734,12 +734,10 @@ TempVarSignalManager *TempVarSignalManager::Instance()
 void NotifyUIAboutTempVarChange(MacroSegment *segment)
 {
 	IncrementTempVarInUseGeneration();
-	QueueUITask(
-		[](void *segment) {
-			TempVarSignalManager::Instance()->SegmentTempVarsChanged(
-				(MacroSegment *)segment);
-		},
-		segment);
+	QueueUITask([segment]() {
+		TempVarSignalManager::Instance()->SegmentTempVarsChanged(
+			segment);
+	});
 }
 
 TempVarOutputMappingsWidget::TempVarOutputMappingsWidget(QWidget *parent)

lib/utils/ui-helpers.cpp

@@ -184,9 +184,9 @@ std::string GetThemeTypeName()
 #endif
 }
 
-void QueueUITask(void (*task)(void *param), void *param)
+void QueueUITaskRaw(void (*task)(void *param), void *param, bool wait)
 {
-	obs_queue_task(OBS_TASK_UI, task, param, false);
+	obs_queue_task(OBS_TASK_UI, task, param, wait);
 }
 
 bool IsCursorInWidgetArea(QWidget *widget)

lib/utils/ui-helpers.hpp

@@ -6,7 +6,10 @@
 #include <QIcon>
 #include <QString>
 
+#include <memory>
 #include <string>
+#include <type_traits>
+#include <utility>
 
 class QAbstractButton;
 class QComboBox;
@@ -38,7 +41,23 @@ EXPORT void DisplayTrayMessage(const QString &title, const QString &msg,
 EXPORT std::string GetThemeTypeName();
 EXPORT QWidget *GetSettingsWindow();
 
-EXPORT void QueueUITask(void (*task)(void *param), void *param);
+EXPORT void QueueUITaskRaw(void (*task)(void *param), void *param,
+			   bool wait = false);
+
+// Runs func on the main/UI thread; blocks if wait is true.
+template<typename F> void QueueUITask(F &&func, bool wait = false)
+{
+	using FnType = std::decay_t<F>;
+	auto *heapFunc = new FnType(std::forward<F>(func));
+
+	QueueUITaskRaw(
+		[](void *param) {
+			std::unique_ptr<FnType> fn(
+				static_cast<FnType *>(param));
+			(*fn)();
+		},
+		heapFunc, wait);
+}
 
 bool IsCursorInWidgetArea(QWidget *widget);
 

lib/variables/variable.cpp

@@ -504,11 +504,10 @@ void LoadVariables(obs_data_t *obj)
 	}
 }
 
-static void signalImportedVariables(void *varsPtr)
+static void
+signalImportedVariables(const std::vector<std::shared_ptr<Item>> &vars)
 {
-	auto vars = std::unique_ptr<std::vector<std::shared_ptr<Item>>>(
-		static_cast<std::vector<std::shared_ptr<Item>> *>(varsPtr));
-	for (const auto &var : *vars) {
+	for (const auto &var : vars) {
 		VariableSignalManager::Instance()->Add(
 			QString::fromStdString(var->Name()));
 	}
@@ -519,7 +518,7 @@ void ImportVariables(obs_data_t *data)
 	OBSDataArrayAutoRelease array = obs_data_get_array(data, "variables");
 	size_t count = obs_data_array_count(array);
 
-	auto importedVars = new std::vector<std::shared_ptr<Item>>;
+	std::vector<std::shared_ptr<Item>> importedVars;
 
 	for (size_t i = 0; i < count; i++) {
 		OBSDataAutoRelease arrayElement = obs_data_array_item(array, i);
@@ -531,10 +530,11 @@ void ImportVariables(obs_data_t *data)
 		}
 
 		GetVariables().emplace_back(var);
-		importedVars->emplace_back(var);
+		importedVars.emplace_back(var);
 	}
 
-	QueueUITask(signalImportedVariables, importedVars);
+	QueueUITask(
+		[importedVars]() { signalImportedVariables(importedVars); });
 }
 
 std::chrono::high_resolution_clock::time_point GetLastVariableChangeTime()

plugins/base/macro-action-scene-collection.cpp

@@ -17,20 +17,6 @@ bool MacroActionSceneCollection::_registered = MacroActionFactory::Register(
 	 MacroActionSceneCollectionEdit::Create,
 	 "AdvSceneSwitcher.action.sceneCollection"});
 
-template<typename F> void QueueUITaskLambda(F &&func)
-{
-	using FnType = std::decay_t<F>;
-	auto *heapFunc = new FnType(std::forward<F>(func));
-
-	QueueUITask(
-		[](void *param) {
-			std::unique_ptr<FnType> fn(
-				static_cast<FnType *>(param));
-			(*fn)();
-		},
-		heapFunc);
-}
-
 bool MacroActionSceneCollection::PerformAction()
 {
 	// Changing the scene collection will also reload the settings of the
@@ -41,7 +27,7 @@ bool MacroActionSceneCollection::PerformAction()
 	}
 
 	const auto collectionName = _sceneCollection;
-	QueueUITaskLambda([collectionName]() {
+	QueueUITask([collectionName]() {
 		obs_frontend_set_current_scene_collection(
 			collectionName.c_str());
 	});

plugins/base/macro-action-source.cpp

@@ -185,20 +185,6 @@ static void closeSourceDialog(obs_source_t *source, bool accept,
 	}
 }
 
-template<typename F> void QueueUITaskLambda(F &&func)
-{
-	using FnType = std::decay_t<F>;
-	auto *heapFunc = new FnType(std::forward<F>(func));
-
-	QueueUITask(
-		[](void *param) {
-			std::unique_ptr<FnType> fn(
-				static_cast<FnType *>(param));
-			(*fn)();
-		},
-		heapFunc);
-}
-
 bool MacroActionSource::PerformAction()
 {
 	OBSSource s = obs_weak_source_get_source(_source.GetSource());
@@ -271,17 +257,17 @@ bool MacroActionSource::PerformAction()
 			break;
 		}
 
-		QueueUITaskLambda([&]() {
+		QueueUITask([&]() {
 			closeSourceDialog(s, true, "OBSBasicInteraction");
 		});
 		break;
 	case Action::CLOSE_FILTER_DIALOG:
-		QueueUITaskLambda([&]() {
+		QueueUITask([&]() {
 			closeSourceDialog(s, _acceptDialog, "OBSBasicFilters");
 		});
 		break;
 	case Action::CLOSE_PROPERTIES_DIALOG:
-		QueueUITaskLambda([&]() {
+		QueueUITask([&]() {
 			closeSourceDialog(s, _acceptDialog,
 					  "OBSBasicProperties");
 		});

plugins/base/utils/process-config.cpp

@@ -5,8 +5,74 @@
 
 #include <QFileDialog>
 
+#ifdef __APPLE__
+#include <spawn.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <csignal>
+#include <cerrno>
+#include <chrono>
+#include <thread>
+#include <vector>
+
+extern char **environ;
+#endif
+
 namespace advss {
 
+#ifdef __APPLE__
+// QProcess uses fork(), which is unsafe to call in OBS's multi-threaded,
+// CEF/XPC-using process (see fork(2)). posix_spawn() avoids fork() entirely.
+
+namespace {
+
+std::vector<char *> BuildArgv(const std::string &path, const QStringList &args,
+			      std::vector<std::string> &storage)
+{
+	storage.push_back(path);
+	for (auto &arg : args) {
+		storage.push_back(arg.toStdString());
+	}
+
+	std::vector<char *> argv;
+	argv.reserve(storage.size() + 1);
+	for (auto &arg : storage) {
+		argv.push_back(const_cast<char *>(arg.c_str()));
+	}
+	argv.push_back(nullptr);
+	return argv;
+}
+
+bool DrainPipe(int fd, std::string &buffer)
+{
+	char chunk[4096];
+	while (true) {
+		ssize_t n = read(fd, chunk, sizeof(chunk));
+		if (n > 0) {
+			buffer.append(chunk, static_cast<size_t>(n));
+			continue;
+		}
+		if (n == 0) {
+			return false; // EOF
+		}
+		if (errno == EINTR) {
+			continue;
+		}
+		return true; // EAGAIN/EWOULDBLOCK
+	}
+}
+
+std::string TrimTrailingNewline(const std::string &s)
+{
+	static const QRegularExpression regex("(\\r\\n|\\r|\\n)$");
+	return QString::fromStdString(s).remove(regex).toStdString();
+}
+
+} // namespace
+#endif
+
 bool ProcessConfig::Save(obs_data_t *obj) const
 {
 	auto data = obs_data_create();
@@ -50,11 +116,44 @@ QStringList ProcessConfig::Args() const
 	return result;
 }
 
+#ifdef __APPLE__
+bool ProcessConfig::StartProcessDetached() const
+{
+	auto path = Path();
+	auto workDir = WorkingDir();
+	std::vector<std::string> argStorage;
+	auto argv = BuildArgv(path, Args(), argStorage);
+
+	posix_spawn_file_actions_t actions;
+	posix_spawn_file_actions_init(&actions);
+	if (!workDir.empty()) {
+		posix_spawn_file_actions_addchdir_np(&actions, workDir.c_str());
+	}
+
+	pid_t pid = 0;
+	int rc = posix_spawn(&pid, path.c_str(), &actions, nullptr, argv.data(),
+			     environ);
+	posix_spawn_file_actions_destroy(&actions);
+
+	if (rc != 0) {
+		return false;
+	}
+
+	std::thread([pid]() {
+		int status = 0;
+		while (waitpid(pid, &status, 0) == -1 && errno == EINTR) {
+		}
+	}).detach();
+
+	return true;
+}
+#else
 bool ProcessConfig::StartProcessDetached() const
 {
 	return QProcess::startDetached(QString::fromStdString(Path()), Args(),
 				       QString::fromStdString(WorkingDir()));
 }
+#endif
 
 void ProcessConfig::ResolveVariables()
 {
@@ -63,6 +162,139 @@ void ProcessConfig::ResolveVariables()
 	_args.ResolveVariables();
 }
 
+#ifdef __APPLE__
+std::variant<int, ProcessConfig::ProcStartError>
+ProcessConfig::StartProcessAndWait(int timeout)
+{
+	ResetFinishedProcessData();
+
+	vblog(LOG_INFO, "run \"%s\" with a timeout of %d ms", Path().c_str(),
+	      timeout);
+
+	int outPipe[2];
+	int errPipe[2];
+	if (pipe(outPipe) != 0 || pipe(errPipe) != 0) {
+		vblog(LOG_INFO, "failed to start \"%s\"!", Path().c_str());
+		return ProcStartError::FAILED_TO_START;
+	}
+
+	auto path = Path();
+	auto workDir = WorkingDir();
+	std::vector<std::string> argStorage;
+	auto argv = BuildArgv(path, Args(), argStorage);
+
+	posix_spawn_file_actions_t actions;
+	posix_spawn_file_actions_init(&actions);
+	posix_spawn_file_actions_addclose(&actions, outPipe[0]);
+	posix_spawn_file_actions_addclose(&actions, errPipe[0]);
+	posix_spawn_file_actions_adddup2(&actions, outPipe[1], STDOUT_FILENO);
+	posix_spawn_file_actions_adddup2(&actions, errPipe[1], STDERR_FILENO);
+	posix_spawn_file_actions_addclose(&actions, outPipe[1]);
+	posix_spawn_file_actions_addclose(&actions, errPipe[1]);
+	if (!workDir.empty()) {
+		posix_spawn_file_actions_addchdir_np(&actions, workDir.c_str());
+	}
+
+	pid_t pid = 0;
+	int rc = posix_spawn(&pid, path.c_str(), &actions, nullptr, argv.data(),
+			     environ);
+	posix_spawn_file_actions_destroy(&actions);
+	close(outPipe[1]);
+	close(errPipe[1]);
+
+	if (rc != 0) {
+		close(outPipe[0]);
+		close(errPipe[0]);
+		vblog(LOG_INFO, "failed to start \"%s\"!", Path().c_str());
+		return ProcStartError::FAILED_TO_START;
+	}
+
+	SetProcessId(std::to_string(pid));
+	fcntl(outPipe[0], F_SETFL, O_NONBLOCK);
+	fcntl(errPipe[0], F_SETFL, O_NONBLOCK);
+
+	std::string outBuf;
+	std::string errBuf;
+	bool outDone = false;
+	bool errDone = false;
+	auto deadline = std::chrono::steady_clock::now() +
+			std::chrono::milliseconds(timeout);
+
+	while (!outDone || !errDone) {
+		auto remaining =
+			std::chrono::duration_cast<std::chrono::milliseconds>(
+				deadline - std::chrono::steady_clock::now())
+				.count();
+		if (remaining <= 0) {
+			break;
+		}
+
+		struct pollfd fds[2];
+		int n = 0;
+		int outIdx = -1;
+		int errIdx = -1;
+		if (!outDone) {
+			fds[n] = {outPipe[0], POLLIN, 0};
+			outIdx = n++;
+		}
+		if (!errDone) {
+			fds[n] = {errPipe[0], POLLIN, 0};
+			errIdx = n++;
+		}
+
+		int pr = poll(fds, n, static_cast<int>(remaining));
+		if (pr < 0) {
+			if (errno == EINTR) {
+				continue;
+			}
+			break;
+		}
+
+		if (outIdx >= 0 && fds[outIdx].revents != 0) {
+			if (!DrainPipe(outPipe[0], outBuf)) {
+				outDone = true;
+			}
+		}
+		if (errIdx >= 0 && fds[errIdx].revents != 0) {
+			if (!DrainPipe(errPipe[0], errBuf)) {
+				errDone = true;
+			}
+		}
+	}
+
+	close(outPipe[0]);
+	close(errPipe[0]);
+
+	if (!outDone || !errDone) {
+		vblog(LOG_INFO,
+		      "timeout while running \"%s\"\nAttempting to kill process!",
+		      Path().c_str());
+		kill(pid, SIGKILL);
+		int status = 0;
+		while (waitpid(pid, &status, 0) == -1 && errno == EINTR) {
+		}
+		_processOutputStream = TrimTrailingNewline(outBuf);
+		_processErrorStream = TrimTrailingNewline(errBuf);
+		return ProcStartError::TIMEOUT;
+	}
+
+	int status = 0;
+	while (waitpid(pid, &status, 0) == -1 && errno == EINTR) {
+	}
+
+	_processOutputStream = TrimTrailingNewline(outBuf);
+	_processErrorStream = TrimTrailingNewline(errBuf);
+
+	if (WIFEXITED(status)) {
+		int exitCode = WEXITSTATUS(status);
+		_processExitCode = std::to_string(exitCode);
+		return exitCode;
+	}
+
+	vblog(LOG_INFO, "process \"%s\" crashed!", Path().c_str());
+	return ProcStartError::CRASH;
+}
+#else
 std::variant<int, ProcessConfig::ProcStartError>
 ProcessConfig::StartProcessAndWait(int timeout)
 {
@@ -101,6 +333,7 @@ ProcessConfig::StartProcessAndWait(int timeout)
 	vblog(LOG_INFO, "process \"%s\" crashed!", Path().c_str());
 	return ProcStartError::CRASH;
 }
+#endif
 
 void ProcessConfig::SetFinishedProcessData(QProcess &process)
 {

plugins/twitch/twitch-tab.cpp

@@ -31,14 +31,9 @@ static bool setup()
 	static const auto showInvalidWarnings = [](void *) {
 		const auto invalidTokens = getInvalidTokens();
 		for (const auto &token : invalidTokens) {
-			QueueUITask(
-				[](void *tokenPtr) {
-					auto tokenName = static_cast<QString *>(
-						tokenPtr);
-					InvalidTokenDialog::ShowWarning(
-						*tokenName);
-				},
-				(void *)&token);
+			QueueUITask([token]() {
+				InvalidTokenDialog::ShowWarning(token);
+			});
 		}
 	};
 

tests/stubs/ui-helpers.cpp

@@ -40,7 +40,7 @@ std::string GetThemeTypeName()
 	return "Dark";
 }
 
-void QueueUITask(void (*task)(void *param), void *) {}
+void QueueUITaskRaw(void (*task)(void *param), void *, bool) {}
 
 QWidget *GetSettingsWindow()
 {