diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt index e3cefb0205..640b701a1f 100644 --- a/src/util/CMakeLists.txt +++ b/src/util/CMakeLists.txt @@ -264,7 +264,6 @@ elseif(NOT ANDROID) find_package(PkgConfig REQUIRED) pkg_check_modules(DBUS REQUIRED dbus-1) target_include_directories(util PRIVATE ${DBUS_INCLUDE_DIRS}) - target_link_libraries(util PRIVATE ${DBUS_LINK_LIBRARIES}) if(LINUX) target_link_libraries(util PRIVATE UDEV::UDEV) diff --git a/src/util/platform_misc_unix.cpp b/src/util/platform_misc_unix.cpp index e2350989bd..0e64f0d82d 100644 --- a/src/util/platform_misc_unix.cpp +++ b/src/util/platform_misc_unix.cpp @@ -4,6 +4,7 @@ #include "input_manager.h" #include "platform_misc.h" +#include "common/dynamic_library.h" #include "common/error.h" #include "common/log.h" #include "common/path.h" @@ -12,6 +13,7 @@ #include #include +#include #include #include #include @@ -32,75 +34,135 @@ bool PlatformMisc::InitializeSocketSupport(Error* error) static bool SetScreensaverInhibitDBus(const bool inhibit_requested, const char* program_name, const char* reason) { +#define DBUS_FUNCS(X) \ + X(dbus_error_is_set) \ + X(dbus_error_free) \ + X(dbus_message_unref) \ + X(dbus_error_init) \ + X(dbus_bus_get) \ + X(dbus_connection_set_exit_on_disconnect) \ + X(dbus_message_new_method_call) \ + X(dbus_message_iter_init_append) \ + X(dbus_message_iter_append_basic) \ + X(dbus_connection_send_with_reply_and_block) \ + X(dbus_message_get_args) + + static std::mutex s_screensaver_inhibit_dbus_mutex; + static DynamicLibrary s_dbus_library; + static bool s_dbus_library_loaded; static dbus_uint32_t s_cookie; + static DBusConnection* s_comparison_connection; + +#define DEFINE_FUNC(F) static decltype(&::F) x##F; + DBUS_FUNCS(DEFINE_FUNC) +#undef DEFINE_FUNC + const char* bus_method = (inhibit_requested) ? "Inhibit" : "UnInhibit"; DBusError error; DBusConnection* connection = nullptr; - static DBusConnection* s_comparison_connection; DBusMessage* message = nullptr; DBusMessage* response = nullptr; DBusMessageIter message_itr; + std::unique_lock lock(s_screensaver_inhibit_dbus_mutex); + if (!s_dbus_library_loaded) + { + Error lerror; + s_dbus_library_loaded = true; + + if (!s_dbus_library.Open(DynamicLibrary::GetVersionedFilename("dbus", 1).c_str(), &lerror)) + { + ERROR_LOG("Failed to open libdbus: {}", lerror.GetDescription()); + return false; + } + +#define LOAD_FUNC(F) \ + if (!s_dbus_library.GetSymbol(#F, &x##F)) \ + { \ + ERROR_LOG("Failed to find function {}", #F); \ + s_dbus_library.Close(); \ + return false; \ + } + DBUS_FUNCS(LOAD_FUNC) +#undef LOAD_FUNC + } + + if (!s_dbus_library.IsOpen()) + return false; + ScopedGuard cleanup = [&]() { - if (dbus_error_is_set(&error)) + if (xdbus_error_is_set(&error)) { ERROR_LOG("SetScreensaverInhibitDBus error: {}", error.message); - dbus_error_free(&error); + xdbus_error_free(&error); } if (message) - dbus_message_unref(message); + xdbus_message_unref(message); if (response) - dbus_message_unref(response); + xdbus_message_unref(response); }; - dbus_error_init(&error); + xdbus_error_init(&error); + // Calling dbus_bus_get() after the first time returns a pointer to the existing connection. - connection = dbus_bus_get(DBUS_BUS_SESSION, &error); - if (!connection || (dbus_error_is_set(&error))) + connection = xdbus_bus_get(DBUS_BUS_SESSION, &error); + if (!connection || (xdbus_error_is_set(&error))) return false; + if (s_comparison_connection != connection) { - dbus_connection_set_exit_on_disconnect(connection, false); + xdbus_connection_set_exit_on_disconnect(connection, false); s_cookie = 0; s_comparison_connection = connection; } - message = dbus_message_new_method_call("org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver", - "org.freedesktop.ScreenSaver", bus_method); + + message = xdbus_message_new_method_call("org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver", + "org.freedesktop.ScreenSaver", bus_method); if (!message) return false; + // Initialize an append iterator for the message, gets freed with the message. - dbus_message_iter_init_append(message, &message_itr); + xdbus_message_iter_init_append(message, &message_itr); if (inhibit_requested) { // Guard against repeat inhibitions which would add extra inhibitors each generating a different cookie. if (s_cookie) return false; + // Append process/window name. - if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &program_name)) + if (!xdbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &program_name)) return false; + // Append reason for inhibiting the screensaver. - if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &reason)) + if (!xdbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &reason)) return false; } else { // Only Append the cookie. - if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_UINT32, &s_cookie)) + if (!xdbus_message_iter_append_basic(&message_itr, DBUS_TYPE_UINT32, &s_cookie)) return false; } + // Send message and get response. - response = dbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT_USE_DEFAULT, &error); - if (!response || dbus_error_is_set(&error)) + response = xdbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT_USE_DEFAULT, &error); + if (!response || xdbus_error_is_set(&error)) return false; + s_cookie = 0; if (inhibit_requested) { // Get the cookie from the response message. - if (!dbus_message_get_args(response, &error, DBUS_TYPE_UINT32, &s_cookie, DBUS_TYPE_INVALID) || - dbus_error_is_set(&error)) + if (!xdbus_message_get_args(response, &error, DBUS_TYPE_UINT32, &s_cookie, DBUS_TYPE_INVALID) || + xdbus_error_is_set(&error)) + { return false; + } } + return true; + +#undef DBUS_FUNCS } static bool SetScreensaverInhibit(bool inhibit)