From f05f87a825ab8ed5273674a7f65521ffc526f0d2 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sat, 15 Mar 2003 06:00:01 +0000 Subject: 2003-03-15 Havoc Pennington * bus/dispatch.c (bus_dispatch_test): OK, now finally actually write useful test code, after all that futzing around ;-) Test does not yet pass because we can't handle OOM in _dbus_transport_messages_pending (basically, dbus_connection_preallocate_send() does not prealloc the write watch). To fix this, I think we need to add new stuff to set_watch_functions, namely a SetEnabled function so we can alloc the watch earlier, then enable it later. * dbus/Makefile.am (libdbus_convenience_la_SOURCES): move dbus-memory.c to the convenience lib * bus/test.c: rename some static functions to keep them clearly distinct from stuff in connection.c. Handle client disconnection. --- bus/test.c | 87 ++++++++++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 65 insertions(+), 22 deletions(-) (limited to 'bus/test.c') diff --git a/bus/test.c b/bus/test.c index 3b933388..8d8aa492 100644 --- a/bus/test.c +++ b/bus/test.c @@ -26,6 +26,7 @@ #ifdef DBUS_BUILD_TESTS #include "test.h" #include "loop.h" +#include /* The "debug client" watch/timeout handlers don't dispatch messages, * as we manually pull them in order to verify them. This is why they @@ -33,7 +34,7 @@ */ static void -connection_watch_callback (DBusWatch *watch, +client_watch_callback (DBusWatch *watch, unsigned int condition, void *data) { @@ -47,22 +48,22 @@ connection_watch_callback (DBusWatch *watch, } static dbus_bool_t -add_connection_watch (DBusWatch *watch, +add_client_watch (DBusWatch *watch, DBusConnection *connection) { - return bus_loop_add_watch (watch, connection_watch_callback, connection, + return bus_loop_add_watch (watch, client_watch_callback, connection, NULL); } static void -remove_connection_watch (DBusWatch *watch, +remove_client_watch (DBusWatch *watch, DBusConnection *connection) { - bus_loop_remove_watch (watch, connection_watch_callback, connection); + bus_loop_remove_watch (watch, client_watch_callback, connection); } static void -connection_timeout_callback (DBusTimeout *timeout, +client_timeout_callback (DBusTimeout *timeout, void *data) { DBusConnection *connection = data; @@ -75,43 +76,85 @@ connection_timeout_callback (DBusTimeout *timeout, } static dbus_bool_t -add_connection_timeout (DBusTimeout *timeout, +add_client_timeout (DBusTimeout *timeout, DBusConnection *connection) { - return bus_loop_add_timeout (timeout, connection_timeout_callback, connection, NULL); + return bus_loop_add_timeout (timeout, client_timeout_callback, connection, NULL); } static void -remove_connection_timeout (DBusTimeout *timeout, +remove_client_timeout (DBusTimeout *timeout, DBusConnection *connection) { - bus_loop_remove_timeout (timeout, connection_timeout_callback, connection); + bus_loop_remove_timeout (timeout, client_timeout_callback, connection); } +static DBusHandlerResult +client_disconnect_handler (DBusMessageHandler *handler, + DBusConnection *connection, + DBusMessage *message, + void *user_data) +{ + dbus_connection_unref (connection); + + return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS; +} dbus_bool_t bus_setup_debug_client (DBusConnection *connection) { + DBusMessageHandler *disconnect_handler; + const char *to_handle[] = { DBUS_MESSAGE_LOCAL_DISCONNECT }; + dbus_bool_t retval; - if (!dbus_connection_set_watch_functions (connection, - (DBusAddWatchFunction) add_connection_watch, - (DBusRemoveWatchFunction) remove_connection_watch, - connection, - NULL)) + disconnect_handler = dbus_message_handler_new (client_disconnect_handler, + NULL, NULL); + + if (disconnect_handler == NULL) + return FALSE; + + if (!dbus_connection_register_handler (connection, + disconnect_handler, + to_handle, + _DBUS_N_ELEMENTS (to_handle))) { - dbus_connection_disconnect (connection); + dbus_message_handler_unref (disconnect_handler); return FALSE; } + + retval = FALSE; + if (!dbus_connection_set_watch_functions (connection, + (DBusAddWatchFunction) add_client_watch, + (DBusRemoveWatchFunction) remove_client_watch, + connection, + NULL)) + goto out; + if (!dbus_connection_set_timeout_functions (connection, - (DBusAddTimeoutFunction) add_connection_timeout, - (DBusRemoveTimeoutFunction) remove_connection_timeout, + (DBusAddTimeoutFunction) add_client_timeout, + (DBusRemoveTimeoutFunction) remove_client_timeout, connection, NULL)) + goto out; + + retval = TRUE; + + out: + if (!retval) { - dbus_connection_disconnect (connection); - return FALSE; + dbus_connection_unregister_handler (connection, + disconnect_handler, + to_handle, + _DBUS_N_ELEMENTS (to_handle)); + + dbus_connection_set_watch_functions (connection, + NULL, NULL, NULL, NULL); + dbus_connection_set_timeout_functions (connection, + NULL, NULL, NULL, NULL); } - - return TRUE; + + dbus_message_handler_unref (disconnect_handler); + + return retval; } #endif -- cgit