+2003-04-10 Havoc Pennington <hp@pobox.com>
+
+ * bus/dispatch.c: lots of fixes
+
+ * dbus/dbus-mainloop.c (_dbus_loop_dispatch): export
+ (_dbus_loop_iterate): remove old "quit if no callbacks" code,
+ that was crack, broke the test service.
+
+ * dbus/dbus-transport.c (_dbus_transport_open): fix error
+ handling to avoid piling up errors if we get a failure on the
+ first address.
+
+ * dbus/dbus-internals.c (_dbus_real_assert_not_reached): include
+ pid in assertion failures.
+
+ * dbus/dbus-mainloop.c (_dbus_loop_iterate): use static arrays up
+ to some fixed size of file descriptor array. Don't return TRUE
+ anytime a timeout exists, that led to lots of busy loop silliness
+ in the tests.
+
2003-04-09 Havoc Pennington <hp@redhat.com>
* dbus/dbus-mainloop.c (check_timeout): fix timeouts, I thought
_dbus_string_init_const (&service_str, service_name);
if (bus_registry_lookup (bus_context_get_registry (activation->context), &service_str) != NULL)
{
+ _dbus_verbose ("Service \"%s\" is already active\n", service_name);
+
message = dbus_message_new_reply (activation_message);
if (!message)
{
DBusConnection *connection = data;
dbus_bool_t retval;
-
+
+#if 0
+ _dbus_verbose ("Calling handle_watch\n");
+#endif
retval = dbus_connection_handle_watch (connection, watch, condition);
return retval;
BusConnectionData *d;
DBusList *link;
- _dbus_verbose (" trying to add message %s to transaction%s\n",
+ _dbus_verbose (" trying to add %s %s to transaction%s\n",
+ dbus_message_get_is_error (message) ? "error" :
+ dbus_message_get_reply_serial (message) != 0 ? "reply" :
+ "message",
dbus_message_get_name (message),
dbus_connection_get_is_connected (connection) ?
"" : " (disconnected)");
static dbus_bool_t check_no_leftovers (BusContext *context);
+static void
+block_connection_until_message_from_bus (BusContext *context,
+ DBusConnection *connection)
+{
+ while (dbus_connection_get_dispatch_status (connection) ==
+ DBUS_DISPATCH_COMPLETE &&
+ dbus_connection_get_is_connected (connection))
+ {
+ bus_test_run_bus_loop (context, TRUE);
+ bus_test_run_clients_loop (FALSE);
+ }
+}
+
+/* compensate for fact that pop_message() can return #NULL due to OOM */
+static DBusMessage*
+pop_message_waiting_for_memory (DBusConnection *connection)
+{
+ while (dbus_connection_get_dispatch_status (connection) ==
+ DBUS_DISPATCH_NEED_MEMORY)
+ _dbus_wait_for_memory ();
+
+ return dbus_connection_pop_message (connection);
+}
+
typedef struct
{
const char *expected_service_name;
d->failed = TRUE;
service_name = NULL;
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive a message on %p, expecting %s\n",
CheckNoMessagesData *d = data;
DBusMessage *message;
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message != NULL)
{
_dbus_warn ("Received message %s on %p, expecting no messages\n",
d->failed = TRUE;
service_name = NULL;
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive a message on %p, expecting %s\n",
retval = FALSE;
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive a reply to %s %d on %p\n",
/* Client should also have gotten ServiceAcquired */
dbus_message_unref (message);
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Expecting %s, got nothing\n",
message = NULL;
bus_test_run_everything (context);
+ block_connection_until_message_from_bus (context, connection);
+ bus_test_run_everything (context);
if (!dbus_connection_get_is_connected (connection))
{
retval = FALSE;
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive a reply to %s %d on %p\n",
{
char *service_name;
CheckServiceCreatedData scd;
-
+
+ reget_service_name_arg:
if (!dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &service_name,
DBUS_TYPE_INVALID))
{
- _dbus_warn ("Message %s doesn't have a service name: %s\n",
- dbus_message_get_name (message),
- error.message);
- dbus_error_free (&error);
- goto out;
+ if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
+ {
+ dbus_error_free (&error);
+ _dbus_wait_for_memory ();
+ goto reget_service_name_arg;
+ }
+ else
+ {
+ _dbus_warn ("Message %s doesn't have a service name: %s\n",
+ dbus_message_get_name (message),
+ error.message);
+ dbus_error_free (&error);
+ goto out;
+ }
}
if (*service_name != ':')
if (scd.failed)
goto out;
}
+ else
+ {
+ _dbus_warn ("Expected to get base service ServiceCreated, instead got %s\n",
+ dbus_message_get_name (message));
+ goto out;
+ }
retval = TRUE;
{
char *service_name;
CheckServiceCreatedData scd;
-
+
+ reget_service_name_arg:
if (!dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &service_name,
DBUS_TYPE_INVALID))
{
- _dbus_warn ("Message %s doesn't have a service name: %s\n",
- dbus_message_get_name (message),
- error.message);
- dbus_error_free (&error);
- goto out;
+ if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
+ {
+ dbus_error_free (&error);
+ _dbus_wait_for_memory ();
+ goto reget_service_name_arg;
+ }
+ else
+ {
+ _dbus_warn ("Message %s doesn't have a service name: %s\n",
+ dbus_message_get_name (message),
+ error.message);
+ dbus_error_free (&error);
+ goto out;
+ }
}
if (strcmp (service_name, activated_name) != 0)
goto out;
dbus_message_unref (message);
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Expected a reply to %s, got nothing\n",
goto out;
}
}
-
+ else
+ {
+ _dbus_warn ("Expected to get service %s ServiceCreated, instead got %s\n",
+ activated_name, dbus_message_get_name (message));
+ goto out;
+ }
+
if (!dbus_message_name_is (message, DBUS_MESSAGE_ACTIVATE_SERVICE))
{
_dbus_warn ("Expected reply to %s, got message %s instead\n",
return retval;
}
+static dbus_bool_t
+check_send_exit_to_service (BusContext *context,
+ DBusConnection *connection,
+ const char *service_name,
+ const char *base_service)
+{
+ dbus_bool_t got_error;
+ DBusMessage *message;
+ dbus_int32_t serial;
+ dbus_bool_t retval;
+
+ _dbus_verbose ("Sending exit message to the test service\n");
+
+ retval = FALSE;
+
+ /* Kill off the test service by sending it a quit message */
+ message = dbus_message_new (service_name,
+ "org.freedesktop.DBus.TestSuiteExit");
+
+ if (message == NULL)
+ {
+ /* Do this again; we still need the service to exit... */
+ if (!check_send_exit_to_service (context, connection,
+ service_name, base_service))
+ goto out;
+
+ return TRUE;
+ }
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+
+ /* Do this again; we still need the service to exit... */
+ if (!check_send_exit_to_service (context, connection,
+ service_name, base_service))
+ goto out;
+
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ /* send message */
+ bus_test_run_clients_loop (TRUE);
+
+ /* read it in and write it out to test service */
+ bus_test_run_bus_loop (context, FALSE);
+
+ /* see if we got an error during message bus dispatching */
+ bus_test_run_clients_loop (FALSE);
+ message = dbus_connection_borrow_message (connection);
+ got_error = message != NULL && dbus_message_get_is_error (message);
+ if (message)
+ dbus_connection_return_message (connection, message);
+
+ if (!got_error)
+ {
+ /* If no error, wait for the test service to exit */
+ block_connection_until_message_from_bus (context, connection);
+
+ bus_test_run_everything (context);
+ }
+
+ if (got_error)
+ {
+ message = pop_message_waiting_for_memory (connection);
+ _dbus_assert (message != NULL);
+
+ if (!dbus_message_get_is_error (message))
+ {
+ _dbus_warn ("expecting an error reply to asking test service to exit, got %s\n",
+ dbus_message_get_name (message));
+ goto out;
+ }
+ else if (!dbus_message_name_is (message, DBUS_ERROR_NO_MEMORY))
+ {
+ _dbus_warn ("not expecting error %s when asking test service to exit\n",
+ dbus_message_get_name (message));
+ goto out;
+ }
+
+ _dbus_verbose ("Got error %s when asking test service to exit\n",
+ dbus_message_get_name (message));
+
+ /* Do this again; we still need the service to exit... */
+ if (!check_send_exit_to_service (context, connection,
+ service_name, base_service))
+ goto out;
+ }
+ else
+ {
+ if (!check_service_deactivated (context, connection,
+ service_name, base_service))
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ return retval;
+}
+
#define EXISTENT_SERVICE_NAME "org.freedesktop.DBus.TestSuiteEchoService"
/* returns TRUE if the correct thing happens,
bus_test_run_everything (context);
- if (dbus_connection_get_dispatch_status (connection) ==
- DBUS_DISPATCH_COMPLETE)
- /* now wait for the message bus to hear back from the activated service */
- bus_test_run_bus_loop (context, TRUE);
-
- /* and process everything again */
+ /* now wait for the message bus to hear back from the activated
+ * service.
+ */
+ block_connection_until_message_from_bus (context, connection);
+
bus_test_run_everything (context);
if (!dbus_connection_get_is_connected (connection))
retval = FALSE;
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive any messages after %s %d on %p\n",
goto out;
}
- _dbus_verbose ("Received %s on %p\n",
- dbus_message_get_name (message), connection);
+ _dbus_verbose ("Received %s on %p after sending %s\n",
+ dbus_message_get_name (message), connection,
+ DBUS_MESSAGE_ACTIVATE_SERVICE);
if (dbus_message_get_is_error (message))
{
message = NULL;
/* We may need to block here for the test service to exit or finish up */
- if (dbus_connection_get_dispatch_status (connection) ==
- DBUS_DISPATCH_COMPLETE)
- bus_test_run_bus_loop (context, TRUE);
+ block_connection_until_message_from_bus (context, connection);
message = dbus_connection_borrow_message (connection);
if (message == NULL)
goto out;
/* Now we should get an error about the service exiting */
- if (dbus_connection_get_dispatch_status (connection) ==
- DBUS_DISPATCH_COMPLETE)
- /* wait for the message bus to hear back from the activated service exiting */
- bus_test_run_bus_loop (context, TRUE);
+ block_connection_until_message_from_bus (context, connection);
/* and process everything again */
bus_test_run_everything (context);
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not get an error from the service %s exiting\n",
}
else
{
- dbus_bool_t got_error;
-
- message = dbus_connection_pop_message (connection);
+ message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Failed to pop message we just put back! should have been a ServiceCreated\n");
_dbus_warn ("Messages were left over after successful activation\n");
goto out;
}
-
- /* Now kill off the test service by sending it a quit message */
- message = dbus_message_new (EXISTENT_SERVICE_NAME,
- "org.freedesktop.DBus.TestSuiteExit");
-
- if (message == NULL)
- {
- dbus_free (base_service);
- return TRUE;
- }
-
- if (!dbus_connection_send (connection, message, &serial))
- {
- dbus_message_unref (message);
- dbus_free (base_service);
- return TRUE;
- }
-
- dbus_message_unref (message);
- message = NULL;
- /* send message */
- bus_test_run_clients_loop (TRUE);
-
- /* read it in and write it out to test service */
- bus_test_run_bus_loop (context, FALSE);
-
- /* see if we got an error */
- bus_test_run_clients_loop (FALSE);
- message = dbus_connection_borrow_message (connection);
- got_error = message != NULL && dbus_message_get_is_error (message);
- if (message)
- dbus_connection_return_message (connection, message);
-
- if (!got_error)
- {
- if (dbus_connection_get_dispatch_status (connection) == DBUS_DISPATCH_COMPLETE)
- /* now wait for the message bus to hear back from the activated service exiting */
- bus_test_run_bus_loop (context, TRUE);
-
- /* and process everything again */
- bus_test_run_everything (context);
- }
-
- if (got_error)
- {
- message = dbus_connection_pop_message (connection);
- _dbus_assert (message != NULL);
-
- if (!dbus_message_get_is_error (message))
- {
- _dbus_warn ("expecting an error reply to asking test service to exit, got %s\n",
- dbus_message_get_name (message));
- goto out;
- }
- else if (!dbus_message_name_is (message, DBUS_ERROR_NO_MEMORY))
- {
- _dbus_warn ("not expecting error %s when asking test service to exit\n",
- dbus_message_get_name (message));
- goto out;
- }
- }
- else
- {
- if (!check_service_deactivated (context, connection,
- EXISTENT_SERVICE_NAME, base_service))
- goto out;
- }
+ if (!check_send_exit_to_service (context, connection,
+ EXISTENT_SERVICE_NAME, base_service))
+ goto out;
}
}
/* -*- mode: C; c-file-style: "gnu" -*- */
/* driver.c Bus client (driver)
*
- * Copyright (C) 2003 CodeFactory AB
+ * Copyright (C) 2003 CodeFactory AB
+ * Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
{
if (client_loop == NULL)
return;
+
+ /* dispatch before we block so pending dispatches
+ * won't make our block return early
+ */
+ _dbus_loop_dispatch (client_loop);
/* Do one blocking wait, since we're expecting data */
_dbus_loop_iterate (client_loop, block_once);
bus_test_run_bus_loop (BusContext *context,
dbus_bool_t block_once)
{
+ /* dispatch before we block so pending dispatches
+ * won't make our block return early
+ */
+ _dbus_loop_dispatch (bus_context_get_loop (context));
+
/* Do one blocking wait, since we're expecting data */
_dbus_loop_iterate (bus_context_get_loop (context), block_once);
_dbus_assert (message == _dbus_list_get_last (&connection->outgoing_messages));
_dbus_list_pop_last (&connection->outgoing_messages);
- dbus_message_unref (message);
connection->n_outgoing -= 1;
- _dbus_verbose ("Message %p removed from outgoing queue %p, %d left to send\n",
- message, connection, connection->n_outgoing);
+ _dbus_verbose ("Message %p (%s) removed from outgoing queue %p, %d left to send\n",
+ message, dbus_message_get_name (message),
+ connection, connection->n_outgoing);
+
+ dbus_message_unref (message);
if (connection->n_outgoing == 0)
_dbus_transport_messages_pending (connection->transport,
link = _dbus_list_pop_first_link (&connection->incoming_messages);
connection->n_incoming -= 1;
- _dbus_verbose ("Message %p removed from incoming queue %p, %d incoming\n",
- link->data, connection, connection->n_incoming);
+ _dbus_verbose ("Message %p (%s) removed from incoming queue %p, %d incoming\n",
+ link->data, dbus_message_get_name (link->data),
+ connection, connection->n_incoming);
return link;
}
return NULL;
dbus_mutex_lock (connection->mutex);
-
+
message = _dbus_connection_pop_message_unlocked (connection);
+
+ _dbus_verbose ("Returning popped message %p\n", message);
dbus_mutex_unlock (connection->mutex);
*/
dbus_mutex_unlock (connection->mutex);
- _dbus_verbose (" running app handler on message %p\n", message);
+ _dbus_verbose (" running app handler on message %p (%s)\n",
+ message, dbus_message_get_name (message));
result = _dbus_message_handler_handle_message (handler, connection,
message);
{
if (!condition)
{
- _dbus_warn ("Assertion failed \"%s\" file \"%s\" line %d\n",
- condition_text, file, line);
+ _dbus_warn ("Assertion failed \"%s\" file \"%s\" line %d process %lu\n",
+ condition_text, file, line, _dbus_getpid ());
_dbus_abort ();
}
}
const char *file,
int line)
{
- _dbus_warn ("File \"%s\" line %d should not have been reached: %s\n",
- file, line, explanation);
+ _dbus_warn ("File \"%s\" line %d process %lu should not have been reached: %s\n",
+ file, line, _dbus_getpid (), explanation);
_dbus_abort ();
}
#endif /* DBUS_DISABLE_ASSERT */
_dbus_set_fail_alloc_counter (_DBUS_INT_MAX);
+ _dbus_verbose ("Running once to count mallocs\n");
+
if (!(* func) (data))
return FALSE;
approx_mallocs = _DBUS_INT_MAX - _dbus_get_fail_alloc_counter ();
- _dbus_verbose ("=================\n%s: about %d mallocs total\n=================\n",
+ _dbus_verbose ("\n=================\n%s: about %d mallocs total\n=================\n",
description, approx_mallocs);
_dbus_set_fail_alloc_failures (1);
if (!run_failing_each_malloc (approx_mallocs, description, func, data))
return FALSE;
- _dbus_verbose ("=================\n%s: all iterations passed\n=================\n",
+ _dbus_verbose ("\n=================\n%s: all iterations passed\n=================\n",
description);
return TRUE;
#include <dbus/dbus-list.h>
#include <dbus/dbus-sysdeps.h>
+#define MAINLOOP_SPEW 1
+
struct DBusLoop
{
int refcount;
*timeout = msec_remaining;
-#if 0
- printf ("Timeout expires in %d milliseconds\n", *timeout);
+#if MAINLOOP_SPEW
+ _dbus_verbose (" timeout expires in %d milliseconds\n", *timeout);
#endif
return msec_remaining == 0;
}
-static void
+dbus_bool_t
_dbus_loop_dispatch (DBusLoop *loop)
{
+
+#if MAINLOOP_SPEW
+ _dbus_verbose (" %d connections to dispatch\n", _dbus_list_get_length (&loop->need_dispatch));
+#endif
+
+ if (loop->need_dispatch == NULL)
+ return FALSE;
+
next:
while (loop->need_dispatch != NULL)
{
DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);
-
+
while (TRUE)
{
DBusDispatchStatus status;
}
}
}
+
+ return TRUE;
}
dbus_bool_t
_dbus_loop_queue_dispatch (DBusLoop *loop,
DBusConnection *connection)
{
-
if (_dbus_list_append (&loop->need_dispatch, connection))
{
dbus_connection_ref (connection);
dbus_bool_t
_dbus_loop_iterate (DBusLoop *loop,
dbus_bool_t block)
-{
+{
+#define N_STATIC_DESCRIPTORS 64
dbus_bool_t retval;
DBusPollFD *fds;
+ DBusPollFD static_fds[N_STATIC_DESCRIPTORS];
int n_fds;
WatchCallback **watches_for_fds;
+ WatchCallback *static_watches_for_fds[N_STATIC_DESCRIPTORS];
int i;
DBusList *link;
int n_ready;
oom_watch_pending = FALSE;
orig_depth = loop->depth;
-#if 0
- _dbus_verbose (" iterate %d timeouts %d watches\n",
- loop->timeout_count, loop->watch_count);
+#if MAINLOOP_SPEW
+ _dbus_verbose ("Iteration block=%d depth=%d timeout_count=%d watch_count=%d\n",
+ block, loop->depth, loop->timeout_count, loop->watch_count);
#endif
if (loop->callbacks == NULL)
- {
- _dbus_loop_quit (loop);
- goto next_iteration;
- }
+ goto next_iteration;
/* count enabled watches */
n_fds = 0;
/* fill our array of fds and watches */
if (n_fds > 0)
{
- fds = dbus_new0 (DBusPollFD, n_fds);
- while (fds == NULL)
+ if (n_fds > N_STATIC_DESCRIPTORS)
{
- _dbus_wait_for_memory ();
fds = dbus_new0 (DBusPollFD, n_fds);
- }
+
+ while (fds == NULL)
+ {
+ _dbus_wait_for_memory ();
+ fds = dbus_new0 (DBusPollFD, n_fds);
+ }
- watches_for_fds = dbus_new (WatchCallback*, n_fds);
- while (watches_for_fds == NULL)
- {
- _dbus_wait_for_memory ();
watches_for_fds = dbus_new (WatchCallback*, n_fds);
+ while (watches_for_fds == NULL)
+ {
+ _dbus_wait_for_memory ();
+ watches_for_fds = dbus_new (WatchCallback*, n_fds);
+ }
+ }
+ else
+ {
+ memset (static_fds, '\0', sizeof (static_fds[0]) * n_fds);
+ memset (static_watches_for_fds, '\0', sizeof (static_watches_for_fds[0]) * n_fds);
+
+ fds = static_fds;
+ watches_for_fds = static_watches_for_fds;
}
i = 0;
*/
wcb->last_iteration_oom = FALSE;
oom_watch_pending = TRUE;
+
+ retval = TRUE; /* return TRUE here to keep the loop going,
+ * since we don't know the watch is inactive
+ */
+
+ _dbus_verbose (" skipping watch on fd %d as it was out of memory last time\n",
+ dbus_watch_get_fd (wcb->watch));
}
else if (dbus_watch_get_enabled (wcb->watch))
{
{
unsigned long tv_sec;
unsigned long tv_usec;
-
- retval = TRUE;
_dbus_get_current_time (&tv_sec, &tv_usec);
if (!block || loop->need_dispatch != NULL)
{
timeout = 0;
-#if 0
- printf ("timeout is 0 as we aren't blocking\n");
+#if MAINLOOP_SPEW
+ _dbus_verbose (" timeout is 0 as we aren't blocking\n");
#endif
}
*/
if (oom_watch_pending)
timeout = MIN (timeout, _dbus_get_oom_wait ());
+
+#if MAINLOOP_SPEW
+ _dbus_verbose (" polling on %d descriptors timeout %ld\n", n_fds, timeout);
+#endif
n_ready = _dbus_poll (fds, n_fds, timeout);
tcb->last_tv_sec = tv_sec;
tcb->last_tv_usec = tv_usec;
-#if 0
- printf (" invoking timeout\n");
+#if MAINLOOP_SPEW
+ _dbus_verbose (" invoking timeout\n");
#endif
(* tcb->function) (tcb->timeout,
cb->data);
+
+ retval = TRUE;
}
}
((Callback*)wcb)->data))
wcb->last_iteration_oom = TRUE;
+#if MAINLOOP_SPEW
+ _dbus_verbose (" Invoked watch, oom = %d\n",
+ wcb->last_iteration_oom);
+#endif
+
retval = TRUE;
}
}
}
next_iteration:
- dbus_free (fds);
- dbus_free (watches_for_fds);
+ if (fds && fds != static_fds)
+ dbus_free (fds);
+ if (watches_for_fds && watches_for_fds != static_watches_for_fds)
+ dbus_free (watches_for_fds);
+
+ if (_dbus_loop_dispatch (loop))
+ retval = TRUE;
- if (loop->need_dispatch != NULL)
- {
- retval = TRUE;
- _dbus_loop_dispatch (loop);
- }
+#if MAINLOOP_SPEW
+ _dbus_verbose ("Returning %d\n", retval);
+#endif
return retval;
}
{
int our_exit_depth;
+ _dbus_assert (loop->depth >= 0);
+
_dbus_loop_ref (loop);
our_exit_depth = loop->depth;
loop->depth += 1;
+
+ _dbus_verbose ("Running main loop, depth %d -> %d\n",
+ loop->depth - 1, loop->depth);
while (loop->depth != our_exit_depth)
_dbus_loop_iterate (loop, TRUE);
void
_dbus_loop_quit (DBusLoop *loop)
{
- _dbus_assert (loop->depth > 0);
+ _dbus_assert (loop->depth > 0);
loop->depth -= 1;
+
+ _dbus_verbose ("Quit main loop, depth %d -> %d\n",
+ loop->depth + 1, loop->depth);
}
int
void
_dbus_wait_for_memory (void)
{
+ _dbus_verbose ("Waiting for more memory\n");
_dbus_sleep_milliseconds (_dbus_get_oom_wait ());
}
void _dbus_loop_quit (DBusLoop *loop);
dbus_bool_t _dbus_loop_iterate (DBusLoop *loop,
dbus_bool_t block);
+dbus_bool_t _dbus_loop_dispatch (DBusLoop *loop);
int _dbus_get_oom_wait (void);
void _dbus_wait_for_memory (void);
_dbus_assert (_DBUS_ALIGN_ADDRESS (field, 4) == field);
- /* I believe FROM_BE is right, but if not we'll find out
- * I guess. ;-)
- */
switch (DBUS_UINT32_FROM_BE (*(int*)field))
{
case DBUS_HEADER_FIELD_SERVICE_AS_UINT32:
message = dbus_message_new_empty_header ();
if (message == NULL)
- return FALSE;
+ {
+ _dbus_verbose ("Failed to allocate empty message\n");
+ return FALSE;
+ }
message->byte_order = byte_order;
message->header_padding = header_padding;
if (!_dbus_list_append (&loader->messages, message))
{
+ _dbus_verbose ("Failed to append new message to loader queue\n");
dbus_message_unref (message);
return FALSE;
}
if (!_dbus_string_move_len (&loader->data, 0, header_len, &message->header, 0))
{
+ _dbus_verbose ("Failed to move header into new message\n");
_dbus_list_remove_last (&loader->messages, message);
dbus_message_unref (message);
return FALSE;
{
dbus_bool_t result;
+ _dbus_verbose ("Failed to move body into new message\n");
+
/* put the header back, we'll try again later */
result = _dbus_string_copy_len (&message->header, 0, header_len,
&loader->data, 0);
/* No messages without authentication! */
if (!_dbus_transport_get_is_authenticated (transport))
- return TRUE;
+ {
+ _dbus_verbose ("Not authenticated, not writing anything\n");
+ return TRUE;
+ }
if (transport->disconnected)
- return TRUE;
+ {
+ _dbus_verbose ("Not connected, not writing anything\n");
+ return TRUE;
+ }
+#if 0
+ _dbus_verbose ("do_writing(), have_messages = %d\n",
+ _dbus_connection_have_messages_to_send (transport->connection));
+#endif
+
oom = FALSE;
total = 0;
}
}
else
- {
+ {
_dbus_verbose (" wrote %d bytes of %d\n", bytes_written,
total_bytes_to_write);
if (_dbus_transport_queue_messages (transport) == DBUS_DISPATCH_NEED_MEMORY)
{
oom = TRUE;
+ _dbus_verbose (" out of memory when queueing messages we just read in the transport\n");
goto out;
}
(flags & DBUS_WATCH_WRITABLE))
{
#if 0
- _dbus_verbose ("handling write watch\n");
+ _dbus_verbose ("handling write watch, messages_need_sending = %d\n",
+ transport->messages_need_sending);
#endif
if (!do_authentication (transport, FALSE, TRUE))
return FALSE;
if (!do_writing (transport))
return FALSE;
}
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ else
+ {
+ if (watch == unix_transport->read_watch)
+ _dbus_verbose ("asked to handle read watch with non-read condition 0x%x\n",
+ flags);
+ else if (watch == unix_transport->write_watch)
+ _dbus_verbose ("asked to handle write watch with non-write condition 0x%x\n",
+ flags);
+ else
+ _dbus_verbose ("asked to handle watch %p on fd %d that we don't recognize\n",
+ watch, dbus_watch_get_fd (watch));
+ }
+#endif /* DBUS_ENABLE_VERBOSE_MODE */
return TRUE;
}
{
DBusTransport *transport;
DBusAddressEntry **entries;
+ DBusError tmp_error;
+ DBusError first_error;
int len, i;
const char *address_problem_type;
const char *address_problem_field;
if (!dbus_parse_address (address, &entries, &len, error))
return NULL;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
transport = NULL;
address_problem_type = NULL;
address_problem_field = NULL;
address_problem_other = NULL;
-
+
+ dbus_error_init (&tmp_error);
+ dbus_error_init (&first_error);
for (i = 0; i < len; i++)
{
- const char *method = dbus_address_entry_get_method (entries[i]);
+ const char *method;
+ method = dbus_address_entry_get_method (entries[i]);
+
if (strcmp (method, "unix") == 0)
{
const char *path = dbus_address_entry_get_value (entries[i], "path");
goto bad_address;
}
- transport = _dbus_transport_new_for_domain_socket (path, error);
+ transport = _dbus_transport_new_for_domain_socket (path, &tmp_error);
}
else if (strcmp (method, "tcp") == 0)
{
goto bad_address;
}
- transport = _dbus_transport_new_for_tcp_socket (host, lport, error);
+ transport = _dbus_transport_new_for_tcp_socket (host, lport, &tmp_error);
}
#ifdef DBUS_BUILD_TESTS
else if (strcmp (method, "debug") == 0)
address_problem_field = "name";
goto bad_address;
}
-
- transport = _dbus_transport_debug_client_new (name, error);
+
+ transport = _dbus_transport_debug_client_new (name, &tmp_error);
}
else if (strcmp (method, "debug-pipe") == 0)
{
address_problem_field = "name";
goto bad_address;
}
-
- transport = _dbus_transport_debug_pipe_new (name, error);
+
+ transport = _dbus_transport_debug_pipe_new (name, &tmp_error);
}
#endif
else
}
if (transport)
- break;
+ break;
+
+ _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
+
+ if (i == 0)
+ dbus_move_error (&tmp_error, &first_error);
+ else
+ dbus_error_free (&tmp_error);
}
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
+
+ if (transport == NULL)
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (&first_error);
+ dbus_move_error (&first_error, error);
+ }
+ else
+ {
+ dbus_error_free (&first_error);
+ }
+
dbus_address_entries_free (entries);
return transport;
_dbus_transport_queue_messages (DBusTransport *transport)
{
DBusDispatchStatus status;
+
+ _dbus_verbose ("_dbus_transport_queue_messages()\n");
/* Queue any messages */
while ((status = _dbus_transport_get_dispatch_status (transport)) == DBUS_DISPATCH_DATA_REMAINS)
#include "test-utils.h"
static DBusLoop *loop;
-static dbus_bool_t already_quit;
+static dbus_bool_t already_quit = FALSE;
static void
quit (void)
dbus_error_free (&error);
exit (1);
}
-
+
+ _dbus_verbose ("*** Test service entering main loop\n");
_dbus_loop_run (loop);
test_connection_shutdown (loop, connection);
projects / platform / upstream / dbus.git / commitdiff