2003-01-28 Anders Carlsson <set EMAIL_ADDRESS environment variable>

	* dbus/dbus-connection-internal.h:
	* dbus/dbus-connection.c: (_dbus_connection_add_timeout),
	(_dbus_connection_remove_timeout):
	Add functions for adding and removing timeouts.

	* dbus/dbus-message.c: (dbus_message_new_from_message):
	Add new function that takes a message and creates an exact
	copy of it, but with the refcount set to 1.
	(check_message_handling):
	Fix build error.

	* dbus/dbus-server-protected.h:
	* dbus/dbus-server.c: (_dbus_server_init_base),
	(_dbus_server_finalize_base), (_dbus_server_add_timeout),
	(dbus_server_set_timeout_functions):
	(_dbus_server_remove_timeout):
	New functions so that a server can add and remove timeouts.

	(dbus_server_listen):
	Add commented out call to dbus_server_debug_new.

	* dbus/dbus-timeout.c: (_dbus_timeout_new):
	Actually set the handler, doh.

	* dbus/dbus-transport.c: (_dbus_transport_open):
	Add commented out call to dbus_transport_debug_client_new.

	* dbus/Makefile.am:
	Add dbus-transport-debug.[ch] and dbus-server-debug.[ch]

1 files changed, 312 insertions, 0 deletions

diff --git a/dbus/dbus-transport-debug.c b/dbus/dbus-transport-debug.c
new file mode 100644
index 00000000..3277094f
--- /dev/null
+++ b/dbus/dbus-transport-debug.c
@@ -0,0 +1,312 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-transport-debug.c In-proc debug subclass of DBusTransport
+ *
+ * Copyright (C) 2003  CodeFactory AB
+ *
+ * Licensed under the Academic Free License version 1.2
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "dbus-internals.h"
+#include "dbus-connection-internal.h"
+#include "dbus-transport-protected.h"
+#include "dbus-transport-debug.h"
+#include "dbus-server-debug.h"
+#include "dbus-list.h"
+
+#ifdef DBUS_BUILD_TESTS
+
+
+#define DEFAULT_INTERVAL 10
+
+typedef struct DBusTransportDebug DBusTransportDebug;
+
+struct DBusTransportDebug
+{
+  DBusTransport base;                   /**< Parent instance */
+
+  DBusTimeout *write_timeout;
+  DBusTimeout *read_timeout;
+  
+  DBusTransport *other_end;
+};
+
+static void
+debug_finalize (DBusTransport *transport)
+{
+  _dbus_transport_finalize_base (transport);  
+
+  dbus_free (transport);
+}
+
+static void
+do_reading (DBusTransport *transport)
+{
+  printf ("in do reading!\n");
+  
+  if (transport->disconnected)
+    return;
+
+  /* Now dispatch the messages */
+  while (dbus_connection_dispatch_message (transport->connection));
+}
+
+static void
+check_read_timeout (DBusTransport *transport)
+{
+  DBusTransportDebug *debug_transport = (DBusTransportDebug*) transport;
+  dbus_bool_t need_read_timeout;
+
+  if (transport->connection == NULL)
+    return;
+
+  _dbus_transport_ref (transport);
+  
+  need_read_timeout = dbus_connection_get_n_messages (transport->connection) > 0;
+  
+  if (transport->disconnected)
+    need_read_timeout = FALSE;
+  
+  if (need_read_timeout &&
+      debug_transport->read_timeout == NULL)
+    {
+      debug_transport->read_timeout =
+	_dbus_timeout_new (DEFAULT_INTERVAL, (DBusTimeoutHandler)do_reading,
+			   transport, NULL);
+
+      if (debug_transport->read_timeout == NULL)
+	goto out;
+
+      if (!_dbus_connection_add_timeout (transport->connection,
+					 debug_transport->read_timeout))
+	{
+	  _dbus_timeout_unref (debug_transport->read_timeout);
+	  debug_transport->read_timeout = NULL;
+
+	  goto out;
+	}
+    }
+  else if (!need_read_timeout &&
+	   debug_transport->read_timeout != NULL)
+    {
+      _dbus_connection_remove_timeout (transport->connection,
+				       debug_transport->read_timeout);
+      _dbus_timeout_unref (debug_transport->read_timeout);
+      debug_transport->read_timeout = NULL;
+    }
+
+ out:
+  _dbus_transport_unref (transport);      
+}
+
+static void
+do_writing (DBusTransport *transport)
+{
+  if (transport->disconnected)
+    return;
+
+  while (!transport->disconnected &&
+	 _dbus_connection_have_messages_to_send (transport->connection))
+    {
+      DBusMessage *message, *copy;
+      
+      message = _dbus_connection_get_message_to_send (transport->connection);
+      _dbus_message_lock (message);
+      
+      copy = dbus_message_new_from_message (message);
+      
+      _dbus_connection_message_sent (transport->connection,
+				     message);
+      
+      _dbus_connection_queue_received_message (((DBusTransportDebug *)transport)->other_end->connection,
+                                               copy);
+
+    }
+
+  check_read_timeout (((DBusTransportDebug *)transport)->other_end);
+}
+
+static void
+check_write_timeout (DBusTransport *transport)
+{
+  DBusTransportDebug *debug_transport = (DBusTransportDebug *)transport;
+  dbus_bool_t need_write_timeout;
+  
+  if (transport->connection == NULL)
+    return;
+
+  _dbus_transport_ref (transport);
+
+  need_write_timeout = transport->messages_need_sending;
+  
+  if (transport->disconnected)
+    need_write_timeout = FALSE;
+
+  if (need_write_timeout &&
+      debug_transport->write_timeout == NULL)
+    {
+      debug_transport->write_timeout =
+	_dbus_timeout_new (DEFAULT_INTERVAL, (DBusTimeoutHandler)do_writing,
+			   transport, NULL);
+
+      if (debug_transport->write_timeout == NULL)
+	goto out;
+
+      if (!_dbus_connection_add_timeout (transport->connection,
+					 debug_transport->write_timeout))
+	{
+	  _dbus_timeout_unref (debug_transport->write_timeout);
+	  debug_transport->write_timeout = NULL;
+	}
+    }
+  else if (!need_write_timeout &&
+	   debug_transport->write_timeout != NULL)
+    {
+      _dbus_connection_remove_timeout (transport->connection,
+				       debug_transport->write_timeout);
+      _dbus_timeout_unref (debug_transport->write_timeout);
+      debug_transport->write_timeout = NULL;
+    }
+
+ out:
+  _dbus_transport_unref (transport);
+}
+
+static void
+debug_handle_watch (DBusTransport *transport,
+		    DBusWatch     *watch,
+		    unsigned int   flags)
+{
+}
+
+static void
+debug_disconnect (DBusTransport *transport)
+{
+}
+
+static void
+debug_connection_set (DBusTransport *transport)
+{
+}
+
+static void
+debug_messages_pending (DBusTransport *transport,
+			int            messages_pending)
+{
+  check_write_timeout (transport);
+  printf ("messages pending!: %d\n", messages_pending);
+}
+
+static void
+debug_do_iteration (DBusTransport *transport,
+		    unsigned int   flags,
+		    int            timeout_milliseconds)
+{
+  printf ("do iteration: %d %d!!\n", transport->is_server,
+	  flags);
+}
+
+static void
+debug_live_messages_changed (DBusTransport *transport)
+{
+}
+
+static DBusTransportVTable debug_vtable = {
+  debug_finalize,
+  debug_handle_watch,
+  debug_disconnect,
+  debug_connection_set,
+  debug_messages_pending,
+  debug_do_iteration,
+  debug_live_messages_changed
+};
+
+DBusTransport*
+_dbus_transport_debug_server_new (DBusTransport *client)
+{
+  DBusTransportDebug *debug_transport;
+
+  debug_transport = dbus_new0 (DBusTransportDebug, 1);
+  
+  if (debug_transport == NULL)
+    return NULL;
+
+  if (!_dbus_transport_init_base (&debug_transport->base,
+				  &debug_vtable,
+				  TRUE))
+    {
+      dbus_free (debug_transport);
+      return NULL;
+    }
+
+  debug_transport->base.authenticated = TRUE;
+
+  /* Connect the two transports */
+  debug_transport->other_end = client;
+  ((DBusTransportDebug *)client)->other_end = (DBusTransport *)debug_transport;
+  
+  return (DBusTransport *)debug_transport;
+}
+
+DBusTransport*
+_dbus_transport_debug_client_new (const char     *server_name,
+				  DBusResultCode *result)
+{
+  DBusServer *debug_server;
+  DBusTransportDebug *debug_transport;
+  
+  debug_server = _dbus_server_debug_lookup (server_name);
+
+  if (!debug_server)
+    {
+      dbus_set_result (result, DBUS_RESULT_NO_SERVER);
+      return NULL;
+    }
+
+  debug_transport = dbus_new0 (DBusTransportDebug, 1);
+  if (debug_transport == NULL)
+    {
+      dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+      return NULL;
+    }
+
+  if (!_dbus_transport_init_base (&debug_transport->base,
+				  &debug_vtable,
+				  FALSE))
+    {
+      dbus_free (debug_transport);
+      dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+      return NULL;
+    }
+
+  if (!_dbus_server_debug_accept_transport (debug_server, (DBusTransport *)debug_transport))
+    {
+      _dbus_transport_finalize_base (&debug_transport->base);
+
+      dbus_free (debug_transport);      
+      dbus_set_result (result, DBUS_RESULT_IO_ERROR);
+      return NULL;
+      
+    }
+
+  /* FIXME: Prolly wrong to do this. */
+  debug_transport->base.authenticated = TRUE;
+  
+  return (DBusTransport *)debug_transport;
+}
+
+#endif /* DBUS_BUILD_TESTS */