2003-02-26 Alexander Larsson <alexl@redhat.com>

	* configure.in:
	Set DBUS_GLIB_THREADS_LIBS for apps using gthread-2.0

	* dbus/dbus-connection.c:
	* dbus/dbus-connection.h:
	Fix _dbus_connection_acquire_io_path and _dbus_connection_acquire_dispatch.
	Add dbus_connection_set_wakeup_main_function and use it when queueing
	incoming and outgoing messages.


	* dbus/dbus-dataslot.c:
	Threadsafe usage of DBusDataSlotAllocator

	* dbus/dbus-message.c: (dbus_message_get_args_iter):
	dbus_new can fail.

	* dbus/dbus-server-unix.c:
	Add todo comment

	* glib/dbus-gmain.c:
	Implement the new wakeup functions for glib.

	* glib/Makefile.am:
	* glib/test-thread-client.c:
	* glib/test-thread-server.c:
	* glib/test-thread.h:
	Initial cut at some thread test code. Not really done yet.

5 files changed, 362 insertions, 3 deletions

diff --git a/glib/Makefile.am b/glib/Makefile.am
index 6f3906ce..63d2edb9 100644
--- a/glib/Makefile.am
+++ b/glib/Makefile.am
@@ -16,11 +16,23 @@ libdbus_glib_1_la_LIBADD= $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la
 
 if DBUS_BUILD_TESTS
 
-noinst_PROGRAMS= test-dbus-glib
+noinst_PROGRAMS= test-dbus-glib test-thread-server test-thread-client
 
 test_dbus_glib_SOURCES=				\
-	test-dbus-glib.c				
+	test-dbus-glib.c
 
 test_dbus_glib_LDADD= $(top_builddir)/glib/libdbus-glib-1.la
 
+test_thread_server_SOURCES=				\
+	test-thread-server.c				\
+	test-thread.h
+
+test_thread_server_LDADD= $(DBUS_GLIB_THREADS_LIBS) $(top_builddir)/glib/libdbus-glib-1.la 
+
+test_thread_client_SOURCES=				\
+	test-thread-client.c				\
+	test-thread.h
+
+test_thread_client_LDADD= $(DBUS_GLIB_THREADS_LIBS) $(top_builddir)/glib/libdbus-glib-1.la 
+
 endif
diff --git a/glib/dbus-gmain.c b/glib/dbus-gmain.c
index 2638d54b..40523738 100644
--- a/glib/dbus-gmain.c
+++ b/glib/dbus-gmain.c
@@ -314,6 +314,13 @@ free_source (GSource *source)
   g_source_destroy (source);
 }
 
+static void
+wakeup_main (void *data)
+{
+  g_main_context_wakeup (NULL);
+}
+
+
 /** @} */ /* End of GLib bindings internals */
 
 /** @addtogroup DBusGLib
@@ -359,6 +366,10 @@ dbus_connection_setup_with_g_main (DBusConnection *connection)
                                          remove_timeout,
                                          NULL, NULL);
       
+  dbus_connection_set_wakeup_main_function (connection,
+					    wakeup_main,
+					    NULL, NULL);
+      
   g_source_attach (source, NULL);
 
   g_static_mutex_lock (&connection_slot_lock);
@@ -401,7 +412,7 @@ dbus_server_setup_with_g_main (DBusServer *server)
                                      add_timeout,
                                      remove_timeout,
                                      NULL, NULL);
-      
+  
   g_source_attach (source, NULL);
 
   g_static_mutex_lock (&server_slot_lock);
diff --git a/glib/test-thread-client.c b/glib/test-thread-client.c
new file mode 100644
index 00000000..ca78dbb8
--- /dev/null
+++ b/glib/test-thread-client.c
@@ -0,0 +1,89 @@
+#include <glib.h>
+#include "dbus-glib.h"
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "test-thread.h"
+
+DBusConnection *connection;
+
+static  gpointer
+thread_func (gpointer data)
+{
+  gint32 threadnr = GPOINTER_TO_INT (data);
+  guint32 counter = 0;
+  DBusMessage *message;
+  char *str;
+
+  while (1)
+    {
+      message = dbus_message_new (NULL, "org.freedesktop.ThreadTest");
+
+      if (!dbus_message_append_int32 (message, threadnr))
+	{
+	  g_print ("thread %d: append threadnr failed\n", threadnr);
+	}
+      
+      if (!dbus_message_append_uint32 (message, counter))
+	{
+	  g_print ("thread %d: append counter (%d) failed\n", threadnr, counter);
+	}
+      
+      str = g_strdup_printf ("Thread %d-%d\n", threadnr, counter);
+      if (!dbus_message_append_string (message, str))
+	{
+	  g_print ("thread %d: append string (%s) failed\n", threadnr, str);
+	}
+      g_free (str);
+
+      if (!dbus_connection_send_message (connection,
+					 message,
+					 NULL, NULL))
+	{
+	  g_print ("thread %d: send message failerd\n", threadnr);
+	}
+      dbus_message_unref (message);
+      
+      counter ++;
+    }
+
+  return NULL;
+}
+
+int
+main (int argc, char *argv[])
+{
+  GMainLoop *loop;
+  DBusResultCode result;
+  int i;
+
+  g_thread_init (NULL);
+  dbus_gthread_init ();
+
+  if(argc < 2)
+    {
+      g_error("Need an address as argv[1]\n");
+      return 1;
+    }
+
+  connection = dbus_connection_open (argv[1], &result);
+  if (connection == NULL)
+    {
+      g_printerr ("could not open connection\n");
+      return 1;
+    }
+
+  dbus_connection_setup_with_g_main (connection);
+
+  for (i = 0; i < N_TEST_THREADS; i++)
+    {
+      g_thread_create (thread_func, GINT_TO_POINTER (i), FALSE, NULL);
+    }
+
+  loop = g_main_loop_new (NULL, FALSE);
+  g_main_run (loop);  
+  
+  return 0;
+}
+  
diff --git a/glib/test-thread-server.c b/glib/test-thread-server.c
new file mode 100644
index 00000000..066c393b
--- /dev/null
+++ b/glib/test-thread-server.c
@@ -0,0 +1,246 @@
+#include <glib.h>
+#include "dbus-glib.h"
+#include <stdio.h>
+#include <string.h>
+
+#include "test-thread.h"
+
+typedef struct {
+  guint32 counters[N_TEST_THREADS];
+} ThreadTestData;
+
+static ThreadTestData *
+thread_test_data_new (void)
+{
+  ThreadTestData *data;
+
+  data = g_new0 (ThreadTestData, 1);
+  
+  return data;
+}
+
+static void
+thread_test_data_free (ThreadTestData *data)
+{
+  g_free (data);
+}
+
+static DBusMessageHandler *disconnect_handler;
+static DBusMessageHandler *filter_handler;
+static int handler_slot;
+
+static DBusHandlerResult
+handle_test_message (DBusMessageHandler *handler,
+		     DBusConnection     *connection,
+		     DBusMessage        *message,
+		     void               *user_data)
+{
+  ThreadTestData *data = user_data;
+  DBusMessageIter *iter;
+  gint32 threadnr;
+  guint32 counter;
+  char *str, *expected_str;
+  GString *counter_str;
+  int i;
+  
+  iter = dbus_message_get_args_iter (message);
+  g_assert (iter != NULL);
+  
+  if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_INT32)
+    {
+      g_print ("First arg not right type\n");
+      goto out;
+    }
+  threadnr = dbus_message_iter_get_int32 (iter);
+  if (threadnr < 0 || threadnr >= N_TEST_THREADS)
+    {
+      g_print ("Invalid thread nr\n");
+      goto out;
+    }
+
+  if (! dbus_message_iter_next (iter))
+    {
+      g_print ("Couldn't get second arg\n");
+      goto out;
+    }
+
+  if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_UINT32)
+    {
+      g_print ("Second arg not right type\n");
+      goto out;
+    }
+  
+  counter = dbus_message_iter_get_uint32 (iter);
+
+  if (counter != data->counters[threadnr])
+    {
+      g_print ("Thread %d, counter %d, expected %d\n", threadnr, counter, data->counters[threadnr]);
+      goto out;
+    }
+  data->counters[threadnr]++;
+  
+  if (! dbus_message_iter_next (iter))
+    {
+      g_print ("Couldn't get third arg\n");
+      goto out;
+    }
+
+  if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_STRING)
+    {
+      g_print ("Third arg not right type\n");
+      goto out;
+    }
+
+  str = dbus_message_iter_get_string (iter);
+
+  if (str == NULL)
+    {
+      g_print ("No third arg\n");
+      goto out;
+    }
+
+  expected_str = g_strdup_printf ("Thread %d-%d\n", threadnr, counter);
+  if (strcmp (expected_str, str) != 0)
+    {
+      g_print ("Wrong string '%s', expected '%s'\n", str, expected_str);
+      goto out;
+    }
+  g_free (str);
+  g_free (expected_str);
+
+  if (dbus_message_iter_next (iter))
+    {
+      g_print ("Extra args on end of message\n");
+      goto out;
+    }
+  
+  dbus_connection_flush (connection);
+
+  counter_str = g_string_new ("");
+  for (i = 0; i < N_TEST_THREADS; i++)
+    {
+      g_string_append_printf (counter_str, "%d ", data->counters[i]);
+    }
+  g_print ("%s\r", counter_str->str);
+  g_string_free (counter_str, TRUE);
+  
+ out:
+  return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+}
+
+static DBusHandlerResult
+handle_filter (DBusMessageHandler *handler,
+	       DBusConnection     *connection,
+	       DBusMessage        *message,
+	       void               *user_data)
+{
+  return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+}
+
+static DBusHandlerResult
+handle_disconnect (DBusMessageHandler *handler,
+                   DBusConnection     *connection,
+                   DBusMessage        *message,
+                   void               *user_data)
+{
+  g_print ("connection disconnected\n");
+  dbus_connection_unref (connection);
+
+  return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+}
+
+
+static void
+new_connection_callback (DBusServer     *server,
+                         DBusConnection *new_connection,
+                         void           *user_data)
+{
+  const char *test_messages[] = { "org.freedesktop.ThreadTest" };
+  const char *disconnect_messages[] = { "org.freedesktop.Local.Disconnect" };
+  DBusMessageHandler *test_message_handler;
+  ThreadTestData * data;
+
+  g_print ("new_connection_callback\n");
+  
+  dbus_connection_ref (new_connection);
+  dbus_connection_setup_with_g_main (new_connection);
+
+  data = thread_test_data_new ();
+  
+  test_message_handler =
+    dbus_message_handler_new (handle_test_message,
+			      data, (DBusFreeFunction)thread_test_data_free);
+  
+  if (!dbus_connection_register_handler (new_connection,
+                                         test_message_handler,
+                                         test_messages, 1))
+    goto nomem;
+
+  if (!dbus_connection_set_data (new_connection,
+				 handler_slot,
+				 test_message_handler,
+				 (DBusFreeFunction)dbus_message_handler_unref))
+    goto nomem;
+  
+  if (!dbus_connection_register_handler (new_connection,
+                                         disconnect_handler,
+                                         disconnect_messages, 1))
+    goto nomem;
+  
+  if (!dbus_connection_add_filter (new_connection,
+				   filter_handler))
+    goto nomem;
+
+  return;
+  
+ nomem:
+  g_error ("no memory to setup new connection");
+}
+
+int
+main (int argc, char *argv[])
+{
+  GMainLoop *loop;
+  DBusServer *server;
+  DBusResultCode result;
+
+  g_thread_init (NULL);
+  dbus_gthread_init ();
+  
+  if (argc < 2)
+    {
+      fprintf (stderr, "Give the server address as an argument\n");
+      return 1;
+    }
+
+  server = dbus_server_listen (argv[1], &result);
+  if (server == NULL)
+    {
+      fprintf (stderr, "Failed to start server on %s: %s\n",
+               argv[1], dbus_result_to_string (result));
+      return 1;
+    }
+
+  handler_slot = dbus_connection_allocate_data_slot ();
+  
+  filter_handler =
+    dbus_message_handler_new (handle_filter, NULL, NULL);
+  if (filter_handler == NULL)
+    g_error ("no memory for handler");
+  
+  disconnect_handler =
+    dbus_message_handler_new (handle_disconnect, NULL, NULL);
+  if (disconnect_handler == NULL)
+    g_error ("no memory for handler");
+  
+  dbus_server_set_new_connection_function (server,
+                                           new_connection_callback,
+                                           NULL, NULL);
+
+  dbus_server_setup_with_g_main (server);
+  
+  loop = g_main_loop_new (NULL, FALSE);
+  g_main_run (loop);  
+
+  return 0;
+}
diff --git a/glib/test-thread.h b/glib/test-thread.h
new file mode 100644
index 00000000..8c78fba2
--- /dev/null
+++ b/glib/test-thread.h
@@ -0,0 +1 @@
+#define N_TEST_THREADS 5