From ce173b29fc1e9432cb5956952afdbe775da12415 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sun, 16 Mar 2003 08:08:21 +0000 Subject: 2003-03-16 Havoc Pennington Oops - test code was only testing failure of around 30 of the mallocs in the test path, but it turns out there are 500+ mallocs. I believe this was due to misguided linking setup such that there was one copy of dbus_malloc etc. in the daemon and one in the shared lib, and only daemon mallocs were tested. In any case, the test case now tests all 500+ mallocs, and doesn't pass yet, though there are lots of fixes in this patch. * dbus/dbus-connection.c (dbus_connection_dispatch_message): fix this so that it doesn't need to allocate memory, since it has no way of indicating failure due to OOM (and would be annoying if it did). * dbus/dbus-list.c (_dbus_list_pop_first_link): new function * bus/Makefile.am: rearrange to create two self-contained libraries, to avoid having libraries with overlapping symbols. that was resulting in weirdness, e.g. I'm pretty sure there were two copies of global static variables. * dbus/dbus-internals.c: move the malloc debug stuff to dbus-memory.c * dbus/dbus-list.c (free_link): free list mempool if it becomes empty. * dbus/dbus-memory.c (_dbus_disable_mem_pools): new function * dbus/dbus-address.c (dbus_parse_address): free list nodes on failure. * bus/dispatch.c (bus_dispatch_add_connection): free message_handler_slot when no longer using it, so memory leak checkers are happy for the test suite. * dbus/dbus-server-debug-pipe.c (debug_finalize): free server name * bus/bus.c (new_connection_callback): disconnect in here if bus_connections_setup_connection fails. * bus/connection.c (bus_connections_unref): fix to free the connections (bus_connections_setup_connection): if this fails, don't disconnect the connection, just be sure there are no side effects. * dbus/dbus-string.c (undo_alignment): unbreak this * dbus/dbus-auth.c (_dbus_auth_unref): free some stuff we were leaking (_dbus_auth_new): fix the order in which we free strings on OOM failure * bus/connection.c (bus_connection_disconnected): fix to not send ServiceDeleted multiple times in case of memory allocation failure * dbus/dbus-bus.c (dbus_bus_get_base_service): new function to get the base service name (dbus_bus_register_client): don't return base service name, instead store it on the DBusConnection and have an accessor function for it. (dbus_bus_register_client): rename dbus_bus_register() * bus/dispatch.c (check_hello_message): verify that other connections on the bus also got the correct results, not just the one sending hello --- bus/test.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 67 insertions(+), 6 deletions(-) (limited to 'bus/test.c') diff --git a/bus/test.c b/bus/test.c index fe4cdc42..09e40f34 100644 --- a/bus/test.c +++ b/bus/test.c @@ -27,11 +27,13 @@ #include "test.h" #include "loop.h" #include +#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 * are different from the real handlers in connection.c */ +static DBusList *clients = NULL; static void client_watch_callback (DBusWatch *watch, @@ -95,17 +97,29 @@ client_disconnect_handler (DBusMessageHandler *handler, DBusMessage *message, void *user_data) { + _dbus_verbose ("Removing client %p in disconnect handler\n", + connection); + + _dbus_list_remove (&clients, connection); + dbus_connection_unref (connection); return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS; } +static int handler_slot = -1; + 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 (handler_slot < 0) + handler_slot = dbus_connection_allocate_data_slot (); + if (handler_slot < 0) + return FALSE; disconnect_handler = dbus_message_handler_new (client_disconnect_handler, NULL, NULL); @@ -139,24 +153,71 @@ bus_setup_debug_client (DBusConnection *connection) connection, NULL)) goto out; + if (!_dbus_list_append (&clients, connection)) + goto out; + + /* Set up handler to be destroyed */ + if (!dbus_connection_set_data (connection, handler_slot, + disconnect_handler, + (DBusFreeFunction) + dbus_message_handler_unref)) + goto out; + retval = TRUE; out: if (!retval) { - dbus_connection_unregister_handler (connection, - disconnect_handler, - to_handle, - _DBUS_N_ELEMENTS (to_handle)); + dbus_message_handler_unref (disconnect_handler); /* unregisters it */ dbus_connection_set_watch_functions (connection, NULL, NULL, NULL, NULL, NULL); dbus_connection_set_timeout_functions (connection, NULL, NULL, NULL, NULL, NULL); + + _dbus_list_remove_last (&clients, connection); } + + return retval; +} + +void +bus_test_clients_foreach (BusConnectionForeachFunction function, + void *data) +{ + DBusList *link; - dbus_message_handler_unref (disconnect_handler); + link = _dbus_list_get_first_link (&clients); + while (link != NULL) + { + DBusConnection *connection = link->data; + DBusList *next = _dbus_list_get_next_link (&clients, link); + + if (!(* function) (connection, data)) + break; + + link = next; + } +} + +dbus_bool_t +bus_test_client_listed (DBusConnection *connection) +{ + DBusList *link; - return retval; + link = _dbus_list_get_first_link (&clients); + while (link != NULL) + { + DBusConnection *c = link->data; + DBusList *next = _dbus_list_get_next_link (&clients, link); + + if (c == connection) + return TRUE; + + link = next; + } + + return FALSE; } + #endif -- cgit