2003-03-16 Havoc Pennington <hp@pobox.com>

	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

1 files changed, 67 insertions, 6 deletions

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 <dbus/dbus-internals.h>
+#include <dbus/dbus-list.h>
 
 /* 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