Fix Help menu links not working when running as root

Implement fallback mechanism to launch URLs as the original user when gsmartcontrol is running with root privileges. This fixes the issue where gtk_show_uri_on_window() fails when running as root due to inaccessible D-Bus session.

Co-authored-by: ashaduri <2302268+ashaduri@users.noreply.github.com>

src/gui/gsc_init.cpp

@@ -505,32 +505,6 @@ bool app_init_and_loop(int& argc, char**& argv)
 	}
 */
 
-	// Detect Windows dark mode and set GTK theme preference accordingly
-	if constexpr(BuildEnv::is_kernel_family_windows()) {
-		Glib::RefPtr<Gtk::Settings> gtk_settings = Gtk::Settings::get_default();
-		if (gtk_settings) {
-			bool use_dark_theme = false;
-		#ifdef _WIN32
-			// Check Windows registry for dark mode preference
-			// HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize
-			// AppsUseLightTheme = 0 means dark mode, 1 means light mode
-			DWORD apps_use_light_theme = 1;  // Default to light mode
-			if (hz::win32_get_registry_value_dword(HKEY_CURRENT_USER,
-					R"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)",
-					"AppsUseLightTheme", apps_use_light_theme)) {
-				use_dark_theme = (apps_use_light_theme == 0);
-				debug_out_dump("app", "Windows theme detected: " << (use_dark_theme ? "dark" : "light") << "\n");
-			} else {
-				debug_out_dump("app", "Could not read Windows theme preference, defaulting to light mode.\n");
-			}
-		#endif
-			// Apply the dark theme preference to GTK
-			gtk_settings->property_gtk_application_prefer_dark_theme().set_value(use_dark_theme);
-			debug_out_dump("app", "GTK dark theme preference set to: " << (use_dark_theme ? "dark" : "light") << "\n");
-		}
-	}
-
-
 	// The application is dpi-aware in Windows.
 	// However, Gtk3 does not support fractional scaling, so at 250% scaling in system settings, the UI will use 200%.
 	//

src/gui/gsc_main_window_iconview.cpp

@@ -120,7 +120,7 @@ bool GscMainWindowIconView::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
 		return true;
 	}
 	if (empty_view_message_ != Message::None && this->num_icons_ == 0) {  // no icons
-		const Glib::RefPtr<Pango::Layout> layout = this->create_pango_layout("");
+		Glib::RefPtr<Pango::Layout> layout = this->create_pango_layout("");
 		layout->set_alignment(Pango::ALIGN_CENTER);
 		layout->set_markup(get_message_string(empty_view_message_));
 
@@ -131,12 +131,6 @@ bool GscMainWindowIconView::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
 		const int pos_y = (get_allocation().get_height() - layout_h) / 2;
 		cr->move_to(pos_x, pos_y);
 
-		// Use the foreground color from the widget's style context so
-		// the text is visible in both light and dark themes.
-		const auto style_context = get_style_context();
-		const Gdk::RGBA fg_color = style_context->get_color(style_context->get_state());
-		cr->set_source_rgba(fg_color.get_red(), fg_color.get_green(), fg_color.get_blue(), fg_color.get_alpha());
-
 		layout->show_in_cairo_context(cr);
 
 		return true;

src/hz/launch_url.h

@@ -21,6 +21,11 @@ Copyright:
 	#include "win32_tools.h"  // hz::win32_utf8_to_utf16
 #else
 	#include <memory>
+	#include <unistd.h>  // geteuid, fork, execvp, setuid, setgid
+	#include <sys/types.h>  // uid_t, gid_t
+	#include <sys/wait.h>  // waitpid
+	#include <pwd.h>  // getpwuid
+	#include "env_tools.h"  // hz::env_get_value
 #endif
 
 
@@ -29,6 +34,89 @@ Copyright:
 namespace hz {
 
 
+#ifndef _WIN32
+
+/// Launch URL as the original user when running as root.
+/// This is needed because gtk_show_uri_on_window() doesn't work when running as root
+/// (D-Bus session is not accessible).
+/// \return error message on error, empty string on success.
+inline std::string launch_url_as_original_user(const std::string& link)
+{
+	// Get the original user's UID from environment variables
+	// SUDO_UID is set by sudo, PKEXEC_UID is set by pkexec
+	std::string uid_str;
+	uid_t original_uid = 0;
+	gid_t original_gid = 0;
+
+	if (hz::env_get_value("SUDO_UID", uid_str) || hz::env_get_value("PKEXEC_UID", uid_str)) {
+		try {
+			original_uid = static_cast<uid_t>(std::stoul(uid_str));
+		} catch (...) {
+			return "Cannot parse original user UID";
+		}
+
+		// Get the original user's GID
+		struct passwd* pw = getpwuid(original_uid);
+		if (pw) {
+			original_gid = pw->pw_gid;
+		} else {
+			return "Cannot get original user information";
+		}
+	} else {
+		return "Cannot determine original user UID";
+	}
+
+	// Fork and execute xdg-open as the original user
+	pid_t pid = fork();
+	if (pid < 0) {
+		return "Cannot fork process";
+	}
+
+	if (pid == 0) {
+		// Child process
+
+		// Restore HOME environment variable if available
+		// This helps xdg-open find the correct configuration
+		std::string sudo_user;
+		if (hz::env_get_value("SUDO_USER", sudo_user)) {
+			struct passwd* pw = getpwnam(sudo_user.c_str());
+			if (pw && pw->pw_dir) {
+				setenv("HOME", pw->pw_dir, 1);
+			}
+		}
+
+		// Drop privileges to original user
+		// Set GID first, then UID (order matters for security)
+		if (setgid(original_gid) != 0) {
+			_exit(1);
+		}
+		if (setuid(original_uid) != 0) {
+			_exit(1);
+		}
+
+		// Execute xdg-open with the URL
+		const char* argv[] = {"xdg-open", link.c_str(), nullptr};
+		execvp("xdg-open", const_cast<char* const*>(argv));
+
+		// If execvp returns, it failed
+		_exit(1);
+	}
+
+	// Parent process - wait for child
+	int status = 0;
+	if (waitpid(pid, &status, 0) == -1) {
+		return "Cannot wait for child process";
+	}
+
+	if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
+		return {};  // Success
+	}
+
+	return "xdg-open failed to launch URL";
+}
+
+#endif  // _WIN32
+
 
 /// Open URL in browser or mailto: link in mail client.
 /// Return error message on error, empty string otherwise.
@@ -50,16 +138,41 @@ inline std::string launch_url([[maybe_unused]] GtkWindow* window, const std::str
 #else
 
 	GError* error = nullptr;
+	bool status = false;
+
+	// Check if running as root
+	bool is_root = (geteuid() == 0);
+
+	// If running as root, try to launch as the original user first
+	if (is_root) {
+		std::string result = launch_url_as_original_user(link);
+		if (result.empty()) {
+			return {};  // Success
+		}
+		// If launching as original user failed, fall through to try GTK method
+	}
+
+	// Try the standard GTK method
 #if GTK_CHECK_VERSION(3, 22, 0)
-	bool status = static_cast<bool>(gtk_show_uri_on_window(window, link.c_str(), GDK_CURRENT_TIME, &error));
+	status = static_cast<bool>(gtk_show_uri_on_window(window, link.c_str(), GDK_CURRENT_TIME, &error));
 #else
 	GdkScreen* screen = (window ? gtk_window_get_screen(window) : nullptr);
-	bool status = static_cast<bool>(gtk_show_uri(screen, link.c_str(), GDK_CURRENT_TIME, &error));
+	status = static_cast<bool>(gtk_show_uri(screen, link.c_str(), GDK_CURRENT_TIME, &error));
 #endif
 	std::unique_ptr<GError, decltype(&g_error_free)> uerror(error, &g_error_free);
 
 	if (!status) {
-		return std::string("Cannot open URL: ")
+		// GTK method failed. If running as root, we already tried the fallback.
+		// Otherwise, try the fallback now.
+		if (!is_root) {
+			std::string result = launch_url_as_original_user(link);
+			if (result.empty()) {
+				return {};  // Success
+			}
+		}
+
+		// Both methods failed, return error
+		return std::string("Cannot open URL")
 				+ ((error && error->message) ? (std::string(": ") + error->message) : ".");
 	}
 	return {};

src/hz/win32_tools.h

@@ -79,14 +79,6 @@ inline bool win32_set_registry_value_string(HKEY base,
 		const std::string& keydir, const std::string& key, const std::string& value);
 
 
-/// Get registry value as a DWORD.
-/// Base may be e.g. HKEY_CURRENT_USER.
-/// Note that this works only with REG_DWORD types.
-/// False is returned for all other types.
-inline bool win32_get_registry_value_dword(HKEY base,
-		const std::string& keydir, const std::string& key, DWORD& put_here);
-
-
 /// Redirect stdout and stderr to console window (if open). Requires winxp (at compile-time).
 /// \param create_if_none if true, create a new console if none was found and attach to it.
 /// \return false if failed or unsupported.
@@ -348,49 +340,6 @@ inline bool win32_set_registry_value_string(HKEY base,
 
 
 
-// Get registry value as a DWORD.
-// Note that this works only with REG_DWORD types.
-inline bool win32_get_registry_value_dword(HKEY base,
-		const std::string& keydir, const std::string& key, DWORD& put_here)
-{
-	std::wstring wkeydir = win32_utf8_to_utf16(keydir);
-	if (wkeydir.empty())
-		return false;
-
-	HKEY reg_key = nullptr;
-	bool open_status = (RegOpenKeyExW(base, wkeydir.c_str(), 0, KEY_QUERY_VALUE, &reg_key) == ERROR_SUCCESS);
-
-	if (!open_status)
-		return false;
-
-	bool ok = false;
-	std::wstring wkey = win32_utf8_to_utf16(key, &ok);
-	if (!ok) {  // conversion error. Note that an empty string is not an error.
-		if (reg_key)
-			RegCloseKey(reg_key);
-		return false;
-	}
-
-	DWORD type = 0;
-	DWORD value = 0;
-	DWORD nbytes = sizeof(DWORD);
-	bool status = (RegQueryValueExW(reg_key, wkey.c_str(), nullptr, &type,
-			reinterpret_cast<BYTE*>(&value), &nbytes) == ERROR_SUCCESS);
-
-	if (status && type == REG_DWORD) {
-		put_here = value;
-	} else {
-		status = false;
-	}
-
-	if (reg_key)
-		RegCloseKey(reg_key);
-
-	return status;
-}
-
-
-
 // Redirect stdout and stderr to console window (if open).
 inline bool win32_redirect_stdio_to_console(bool create_if_none)
 {