diff --git a/libs/dbus/0001-Add-support-for-auto-shutdown-dbus-daemon-after-last.patch b/libs/dbus/0001-Add-support-for-auto-shutdown-dbus-daemon-after-last.patch new file mode 100644 --- /dev/null +++ b/libs/dbus/0001-Add-support-for-auto-shutdown-dbus-daemon-after-last.patch @@ -0,0 +1,316 @@ +From 78ee2681919740331ce773b6b4a613ba77e8353c Mon Sep 17 00:00:00 2001 +From: Ralf Habacker +Date: Tue, 11 Apr 2017 11:17:40 +0200 +Subject: [PATCH] Add support for auto shutdown dbus-daemon after last client + disconnects on Windows. + +By default dbus-daemon on Windows is auto started on request by any dbus +client application and now also shutdown itself after the last +client has been disconnected to free unused system resources and +simplifies portable installations. + +The auto shutting down behavior could be disabled by specifing +--disable-auto-shutdown on dbus-daemon command line. + +https://bugs.freedesktop.org/show_bug.cgi?id=99751 +--- + bus/bus.c | 33 +++++++++++++++++++++++++++++++++ + bus/bus.h | 14 ++++++++++++++ + bus/connection.c | 22 ++++++++++++++++++++++ + bus/main.c | 19 +++++++++++++++++++ + dbus/dbus-sysdeps-unix.c | 6 ++++++ + dbus/dbus-sysdeps-win.c | 28 +++++++++++++++++++++++++--- + dbus/dbus-sysdeps.h | 2 ++ + doc/dbus-daemon.1.xml.in | 10 ++++++++++ + 8 files changed, 131 insertions(+), 3 deletions(-) + +diff --git a/bus/bus.c b/bus/bus.c +index 2ad8e789..0a9e9fe8 100644 +--- a/bus/bus.c ++++ b/bus/bus.c +@@ -75,6 +75,7 @@ struct BusContext + unsigned int allow_anonymous : 1; + unsigned int systemd_activation : 1; + dbus_bool_t watches_enabled; ++ dbus_bool_t auto_shutdown_enabled; + }; + + static dbus_int32_t server_data_slot = -1; +@@ -1831,3 +1832,35 @@ bus_context_check_all_watches (BusContext *context) + _dbus_server_toggle_all_watches (server, enabled); + } + } ++ ++#ifdef DBUS_ENABLE_EMBEDDED_TESTS ++void ++bus_context_quiet_log_begin (BusContext *context) ++{ ++ context->quiet_log = TRUE; ++} ++ ++void ++bus_context_quiet_log_end (BusContext *context) ++{ ++ context->quiet_log = FALSE; ++} ++ ++dbus_bool_t ++bus_context_get_quiet_log (BusContext *context) ++{ ++ return context->quiet_log; ++} ++#endif ++ ++dbus_bool_t ++bus_context_get_auto_shutdown_enabled (BusContext *context) ++{ ++ return context->auto_shutdown_enabled; ++} ++ ++void ++bus_context_set_auto_shutdown_enabled (BusContext *context, dbus_bool_t state) ++{ ++ context->auto_shutdown_enabled = state; ++} +diff --git a/bus/bus.h b/bus/bus.h +index 2e0de825..530f2d63 100644 +--- a/bus/bus.h ++++ b/bus/bus.h +@@ -146,4 +146,18 @@ dbus_bool_t bus_context_check_security_policy (BusContext + DBusError *error); + void bus_context_check_all_watches (BusContext *context); + ++dbus_bool_t bus_context_setup_server (BusContext *context, ++ DBusServer *server, ++ DBusError *error); ++dbus_bool_t bus_context_add_incoming_connection (BusContext *context, ++ DBusConnection *new_connection); ++dbus_bool_t bus_context_get_auto_shutdown_enabled (BusContext *context); ++void bus_context_set_auto_shutdown_enabled (BusContext *context, ++ dbus_bool_t state); ++#ifdef DBUS_ENABLE_EMBEDDED_TESTS ++void bus_context_quiet_log_begin (BusContext *context); ++void bus_context_quiet_log_end (BusContext *context); ++dbus_bool_t bus_context_get_quiet_log (BusContext *context); ++#endif ++ + #endif /* BUS_BUS_H */ +diff --git a/bus/connection.c b/bus/connection.c +index 53605fa3..eba9ca7e 100644 +--- a/bus/connection.c ++++ b/bus/connection.c +@@ -340,6 +340,27 @@ bus_connection_disconnected (DBusConnection *connection) + + bus_connection_drop_pending_replies (d->connections, connection); + ++ if (bus_connections_get_n_active (d->connections) ++ + bus_connections_get_n_incomplete (d->connections) == 0) ++ { ++ if (bus_context_get_auto_shutdown_enabled (d->connections->context)) ++ { ++ if (_dbus_daemon_lock_autolaunch_address ()) ++ { ++ DBusLoop *loop = bus_context_get_loop (d->connections->context); ++ _dbus_loop_quit (loop); ++ _dbus_verbose ("Got auto shutdown request - quit event loop\n"); ++ } ++ else ++ { ++ // We are not able to lock autolaunch address mutex because a ++ // dbus client tries to fetch autolaunch address as part of the ++ // autolaunch connection attempt ++ _dbus_verbose ("Could not lock autolaunch address - skipping shutdown"); ++ } ++ } ++ } ++ + /* frees "d" as side effect */ + dbus_connection_set_data (connection, + connection_data_slot, +@@ -1576,6 +1597,7 @@ bus_connection_complete (DBusConnection *connection, + return FALSE; + } + ++ + if (dbus_connection_get_unix_user (connection, &uid)) + { + if (!adjust_connections_for_uid (d->connections, +diff --git a/bus/main.c b/bus/main.c +index 4ee3f75d..d2eacc99 100644 +--- a/bus/main.c ++++ b/bus/main.c +@@ -163,6 +163,9 @@ usage (void) + " [--syslog]" + " [--syslog-only]" + " [--nofork]" ++#ifdef DBUS_WIN ++ " [--disable-auto-shutdown]" ++#endif + #ifdef DBUS_UNIX + " [--fork]" + " [--systemd-activation]" +@@ -401,6 +404,9 @@ main (int argc, char **argv) + int i; + dbus_bool_t print_address; + dbus_bool_t print_pid; ++#ifdef DBUS_WIN ++ dbus_bool_t auto_shutdown; ++#endif + BusContextFlags flags; + #ifdef DBUS_UNIX + const char *error_str; +@@ -438,6 +444,9 @@ main (int argc, char **argv) + + print_address = FALSE; + print_pid = FALSE; ++#ifdef DBUS_WIN ++ auto_shutdown = TRUE; ++#endif + + flags = BUS_CONTEXT_FLAG_WRITE_PID_FILE; + +@@ -614,6 +623,12 @@ main (int argc, char **argv) + { + print_pid = TRUE; /* and we'll get the next arg if appropriate */ + } ++#ifdef DBUS_WIN ++ else if (strcmp (arg, "--disable-auto-shutdown") == 0) ++ { ++ auto_shutdown = FALSE; ++ } ++#endif + else + { + usage (); +@@ -701,6 +716,10 @@ main (int argc, char **argv) + exit (1); + } + ++#ifdef DBUS_WIN ++ if (auto_shutdown) ++ bus_context_set_auto_shutdown_enabled (context, TRUE); ++#endif + /* bus_context_new() closes the print_addr_pipe and + * print_pid_pipe + */ +diff --git a/dbus/dbus-sysdeps-unix.c b/dbus/dbus-sysdeps-unix.c +index e8cd5b33..39d9363d 100644 +--- a/dbus/dbus-sysdeps-unix.c ++++ b/dbus/dbus-sysdeps-unix.c +@@ -4348,6 +4348,12 @@ _dbus_daemon_publish_session_bus_address (const char* addr, + return TRUE; + } + ++dbus_bool_t ++_dbus_daemon_lock_autolaunch_address () ++{ ++ return FALSE; ++} ++ + //PENDING(kdab) docs + void + _dbus_daemon_unpublish_session_bus_address (void) +diff --git a/dbus/dbus-sysdeps-win.c b/dbus/dbus-sysdeps-win.c +index 0deedeaf..84f35769 100644 +--- a/dbus/dbus-sysdeps-win.c ++++ b/dbus/dbus-sysdeps-win.c +@@ -2859,6 +2859,25 @@ _dbus_daemon_is_session_bus_address_published (const char *scope) + return FALSE; + } + ++/** ++ * Lock access to autolaunched address ++ * ++ * This function is called to prevent client from accessing ++ * autolaunch address in shared memory segment as preparation ++ * to shutdown server ++ * @return TRUE lock has been gotten ++ * @return FALSE lock has not been gotten ++ */ ++dbus_bool_t ++_dbus_daemon_lock_autolaunch_address () ++{ ++ HANDLE lock; ++ ++ // sync _dbus_daemon_publish_session_bus_address, _dbus_daemon_unpublish_session_bus_address, ++ // _dbus_daemon_already_runs and _dbus_daemon_lock_autolaunch_address ++ return _dbus_global_lock (cUniqueDBusInitMutex) != FALSE; ++} ++ + dbus_bool_t + _dbus_daemon_publish_session_bus_address (const char* address, const char *scope) + { +@@ -2876,7 +2895,8 @@ _dbus_daemon_publish_session_bus_address (const char* address, const char *scope + return FALSE; + } + +- // sync _dbus_daemon_publish_session_bus_address, _dbus_daemon_unpublish_session_bus_address and _dbus_daemon_already_runs ++ // sync _dbus_daemon_publish_session_bus_address, _dbus_daemon_unpublish_session_bus_address, ++ // _dbus_daemon_already_runs and _dbus_daemon_lock_autolaunch_address + lock = _dbus_global_lock( cUniqueDBusInitMutex ); + + if (!hDBusDaemonMutex) +@@ -2929,7 +2949,8 @@ _dbus_daemon_unpublish_session_bus_address (void) + { + HANDLE lock; + +- // sync _dbus_daemon_publish_session_bus_address, _dbus_daemon_unpublish_session_bus_address and _dbus_daemon_already_runs ++ // sync _dbus_daemon_publish_session_bus_address, _dbus_daemon_unpublish_session_bus_address, ++ // _dbus_daemon_already_runs and _dbus_daemon_lock_autolaunch_address + lock = _dbus_global_lock( cUniqueDBusInitMutex ); + + CloseHandle( hDBusSharedMem ); +@@ -2996,7 +3017,8 @@ _dbus_daemon_already_runs (DBusString *address, DBusString *shm_name, const char + return FALSE; + } + +- // sync _dbus_daemon_publish_session_bus_address, _dbus_daemon_unpublish_session_bus_address and _dbus_daemon_already_runs ++ // sync _dbus_daemon_publish_session_bus_address, _dbus_daemon_unpublish_session_bus_address, ++ // _dbus_daemon_already_runs and _dbus_daemon_lock_autolaunch_address + lock = _dbus_global_lock( cUniqueDBusInitMutex ); + + // do checks +diff --git a/dbus/dbus-sysdeps.h b/dbus/dbus-sysdeps.h +index 24fbec6a..df7fd3c9 100644 +--- a/dbus/dbus-sysdeps.h ++++ b/dbus/dbus-sysdeps.h +@@ -630,6 +630,8 @@ void _dbus_logv (DBusSystemLogSeverity severity, + _DBUS_BYTE_OF_PRIMITIVE (a, 6) == _DBUS_BYTE_OF_PRIMITIVE (b, 6) && \ + _DBUS_BYTE_OF_PRIMITIVE (a, 7) == _DBUS_BYTE_OF_PRIMITIVE (b, 7)) + ++DBUS_PRIVATE_EXPORT ++dbus_bool_t _dbus_daemon_lock_autolaunch_address(); + dbus_bool_t _dbus_get_autolaunch_address (const char *scope, + DBusString *address, + DBusError *error); +diff --git a/doc/dbus-daemon.1.xml.in b/doc/dbus-daemon.1.xml.in +index 960da080..6e65a5af 100644 +--- a/doc/dbus-daemon.1.xml.in ++++ b/doc/dbus-daemon.1.xml.in +@@ -32,6 +32,7 @@ + --nosyslog + --syslog + --syslog-only ++ --disable-auto-shutdown + + + +@@ -199,6 +200,15 @@ files. + + + ++ ++ ++ ++ On Windows dbus daemon is autolaunched by dbus client library if an ++ autolaunch bus address is specified. After last client disconnects it ++ shuts down by default if not disabled with this switch. ++ ++ ++ + + + +-- +2.16.4 + diff --git a/libs/dbus/dbus.py b/libs/dbus/dbus.py --- a/libs/dbus/dbus.py +++ b/libs/dbus/dbus.py @@ -43,7 +43,8 @@ ("dbus-fix_data_dir.diff", 1)] self.patchToApply["1.12.12"] = [("dbus-1.11.4-20160903.diff", 1), ("dbus-fix_data_dir.diff", 1), - ("dbus-1.12.12-launchd.diff", 1)] + ("dbus-1.12.12-launchd.diff", 1), + ("0001-Add-support-for-auto-shutdown-dbus-daemon-after-last.patch", 1)] self.patchLevel["1.11.14"] = 2 self.patchLevel["1.12.12"] = 2