From c9cd648f115759176d35508e9007dc5520a0dd3f Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Thu, 24 Apr 2003 19:18:23 +0000 Subject: 2003-04-24 Havoc Pennington * configure.in: add --enable-checks * dbus/dbus-message.c (dbus_message_new): reverse name/service arguments * dbus/dbus-connection.c (dbus_connection_preallocate_send): fix to use thread locks. (_dbus_connection_handler_destroyed_locked): move some private functions into proper docs group * dbus/dbus-internals.h: add _dbus_return_if_fail, _dbus_return_val_if_fail Throughout: use dbus_return_if_fail --- ChangeLog | 16 +++ bus/connection.c | 6 +- bus/dispatch.c | 20 ++-- bus/driver.c | 17 +-- configure.in | 16 ++- dbus/dbus-bus.c | 43 ++++---- dbus/dbus-connection.c | 219 +++++++++++++++++++++++++++----------- dbus/dbus-errors.c | 22 ++-- dbus/dbus-internals.c | 6 ++ dbus/dbus-internals.h | 33 ++++++ dbus/dbus-message-handler.c | 11 ++ dbus/dbus-message.c | 249 ++++++++++++++++++++++++++++++-------------- dbus/dbus-server.c | 32 +++++- dbus/dbus-spawn.c | 14 +-- doc/TODO | 6 -- glib/test-dbus-glib.c | 3 +- glib/test-thread-client.c | 2 +- tools/dbus-send.c | 2 +- 18 files changed, 502 insertions(+), 215 deletions(-) diff --git a/ChangeLog b/ChangeLog index e13e05d5..270d0d1f 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,19 @@ +2003-04-24 Havoc Pennington + + * configure.in: add --enable-checks + + * dbus/dbus-message.c (dbus_message_new): reverse name/service arguments + + * dbus/dbus-connection.c (dbus_connection_preallocate_send): fix + to use thread locks. + (_dbus_connection_handler_destroyed_locked): move some private + functions into proper docs group + + * dbus/dbus-internals.h: add _dbus_return_if_fail, + _dbus_return_val_if_fail + + Throughout: use dbus_return_if_fail + 2003-04-23 James Willcox * glib/dbus-glib.h: diff --git a/bus/connection.c b/bus/connection.c index 14081e2e..146e3769 100644 --- a/bus/connection.c +++ b/bus/connection.c @@ -880,9 +880,9 @@ bus_connection_preallocate_oom_error (DBusConnection *connection) if (preallocated == NULL) return FALSE; - /* d->name may be NULL, but that should be OK */ - message = dbus_message_new (d->name, - DBUS_ERROR_NO_MEMORY); + /* d->name may be NULL, but that is OK */ + message = dbus_message_new (DBUS_ERROR_NO_MEMORY, + d->name); if (message == NULL) { dbus_connection_free_preallocated_send (connection, preallocated); diff --git a/bus/dispatch.c b/bus/dispatch.c index c1e67d6a..e38b3402 100644 --- a/bus/dispatch.c +++ b/bus/dispatch.c @@ -704,8 +704,8 @@ check_hello_message (BusContext *context, acquired = NULL; message = NULL; - message = dbus_message_new (DBUS_SERVICE_DBUS, - DBUS_MESSAGE_HELLO); + message = dbus_message_new (DBUS_MESSAGE_HELLO, + DBUS_SERVICE_DBUS); if (message == NULL) return TRUE; @@ -936,8 +936,8 @@ check_nonexistent_service_activation (BusContext *context, dbus_error_init (&error); - message = dbus_message_new (DBUS_SERVICE_DBUS, - DBUS_MESSAGE_ACTIVATE_SERVICE); + message = dbus_message_new (DBUS_MESSAGE_ACTIVATE_SERVICE, + DBUS_SERVICE_DBUS); if (message == NULL) return TRUE; @@ -1317,8 +1317,8 @@ check_send_exit_to_service (BusContext *context, retval = FALSE; /* Kill off the test service by sending it a quit message */ - message = dbus_message_new (service_name, - "org.freedesktop.DBus.TestSuiteExit"); + message = dbus_message_new ("org.freedesktop.DBus.TestSuiteExit", + service_name); if (message == NULL) { @@ -1490,8 +1490,8 @@ check_existent_service_activation (BusContext *context, dbus_error_init (&error); - message = dbus_message_new (DBUS_SERVICE_DBUS, - DBUS_MESSAGE_ACTIVATE_SERVICE); + message = dbus_message_new (DBUS_MESSAGE_ACTIVATE_SERVICE, + DBUS_SERVICE_DBUS); if (message == NULL) return TRUE; @@ -1698,8 +1698,8 @@ check_segfault_service_activation (BusContext *context, dbus_error_init (&error); - message = dbus_message_new (DBUS_SERVICE_DBUS, - DBUS_MESSAGE_ACTIVATE_SERVICE); + message = dbus_message_new (DBUS_MESSAGE_ACTIVATE_SERVICE, + DBUS_SERVICE_DBUS); if (message == NULL) return TRUE; diff --git a/bus/driver.c b/bus/driver.c index bc58f556..299968f4 100644 --- a/bus/driver.c +++ b/bus/driver.c @@ -49,8 +49,8 @@ bus_driver_send_service_deleted (const char *service_name, _dbus_verbose ("sending service deleted: %s\n", service_name); - message = dbus_message_new (DBUS_SERVICE_BROADCAST, - DBUS_MESSAGE_SERVICE_DELETED); + message = dbus_message_new (DBUS_MESSAGE_SERVICE_DELETED, + DBUS_SERVICE_BROADCAST); if (message == NULL) { BUS_SET_OOM (error); @@ -83,8 +83,8 @@ bus_driver_send_service_created (const char *service_name, _DBUS_ASSERT_ERROR_IS_CLEAR (error); - message = dbus_message_new (DBUS_SERVICE_BROADCAST, - DBUS_MESSAGE_SERVICE_CREATED); + message = dbus_message_new (DBUS_MESSAGE_SERVICE_CREATED, + DBUS_SERVICE_BROADCAST); if (message == NULL) { BUS_SET_OOM (error); @@ -123,8 +123,8 @@ bus_driver_send_service_lost (DBusConnection *connection, _DBUS_ASSERT_ERROR_IS_CLEAR (error); - message = dbus_message_new (bus_connection_get_name (connection), - DBUS_MESSAGE_SERVICE_LOST); + message = dbus_message_new (DBUS_MESSAGE_SERVICE_LOST, + bus_connection_get_name (connection)); if (message == NULL) { BUS_SET_OOM (error); @@ -163,8 +163,9 @@ bus_driver_send_service_acquired (DBusConnection *connection, _DBUS_ASSERT_ERROR_IS_CLEAR (error); - message = dbus_message_new (bus_connection_get_name (connection), - DBUS_MESSAGE_SERVICE_ACQUIRED); + message = dbus_message_new (DBUS_MESSAGE_SERVICE_ACQUIRED, + bus_connection_get_name (connection)); + if (message == NULL) { BUS_SET_OOM (error); diff --git a/configure.in b/configure.in index faac0553..37a1bef8 100644 --- a/configure.in +++ b/configure.in @@ -27,8 +27,9 @@ AC_ARG_ENABLE(qt, [ --enable-qt enable Qt-friendly client library],en AC_ARG_ENABLE(glib, [ --enable-glib enable GLib-friendly client library],enable_glib=$enableval,enable_glib=auto) AC_ARG_ENABLE(tests, [ --enable-tests enable unit test code],enable_tests=$enableval,enable_tests=$USE_MAINTAINER_MODE) AC_ARG_ENABLE(ansi, [ --enable-ansi enable -ansi -pedantic gcc flags],enable_ansi=$enableval,enable_ansi=no) -AC_ARG_ENABLE(verbose-mode, [ --enable-verbose-mode support verbose debug mode],enable_verbose_mode=$enableval,enable_verbose_mode=yes) -AC_ARG_ENABLE(asserts, [ --enable-asserts include assertion checks],enable_asserts=$enableval,enable_asserts=yes) +AC_ARG_ENABLE(verbose-mode, [ --enable-verbose-mode support verbose debug mode],enable_verbose_mode=$enableval,enable_verbose_mode=$USE_MAINTAINER_MODE) +AC_ARG_ENABLE(asserts, [ --enable-asserts include assertion checks],enable_asserts=$enableval,enable_asserts=$USE_MAINTAINER_MODE) +AC_ARG_ENABLE(checks, [ --enable-checks include sanity checks on public API],enable_checks=$enableval,enable_checks=yes) AC_ARG_ENABLE(gcov, [ --enable-gcov compile with coverage profiling instrumentation (gcc only)],enable_gcov=$enableval,enable_gcov=no) AC_ARG_WITH(xml, [ --with-xml=[libxml/expat] XML library to use]) @@ -51,6 +52,9 @@ fi if test x$enable_asserts = xno; then AC_DEFINE(DBUS_DISABLE_ASSERT,1,[Disable assertion checking]) fi +if test x$enable_checks = xno; then + AC_DEFINE(DBUS_DISABLE_CHECKS,1,[Disable public API sanity checking]) +fi #### gcc warning flags @@ -578,6 +582,7 @@ echo " Building unit tests: ${enable_tests} Building verbose mode: ${enable_verbose_mode} Building assertions: ${enable_asserts} + Building checks: ${enable_checks} Building Qt bindings: ${have_qt} Building GLib bindings: ${have_glib} Using XML parser: ${with_xml} @@ -595,8 +600,11 @@ if test x$enable_gcov = xyes; then echo "NOTE: building with coverage profiling is definitely for developers only." fi if test x$enable_verbose_mode = xyes; then - echo "NOTE: building with verbose mode increases library size, may slightly increase security risk, and may cause a slight performance decrease, but aids debugging." + echo "NOTE: building with verbose mode increases library size, may slightly increase security risk, and decreases performance." fi if test x$enable_asserts = xyes; then - echo "NOTE: building with assertions increases library size, but will help a lot when tracking down bugs in software using D-BUS." + echo "NOTE: building with assertions increases library size and decreases performance." fi +if test x$enable_checks = xno; then + echo "NOTE: building without checks for arguments passed to public API makes it harder to debug apps using D-BUS, but will slightly decrease D-BUS library size and _very_ slightly improve performance." +fi \ No newline at end of file diff --git a/dbus/dbus-bus.c b/dbus/dbus-bus.c index e7b4c06e..9627341e 100644 --- a/dbus/dbus-bus.c +++ b/dbus/dbus-bus.c @@ -329,14 +329,8 @@ dbus_bus_get (DBusBusType type, BusData *bd; DBusBusType address_type; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); - - if (type < 0 || type >= N_BUS_TYPES) - { - _dbus_assert_not_reached ("Invalid bus type specified."); - - return NULL; - } + _dbus_return_val_if_fail (type >= 0 && type < N_BUS_TYPES, NULL); + _dbus_return_val_if_error_is_set (error, NULL); _DBUS_LOCK (bus); @@ -429,8 +423,9 @@ dbus_bus_register (DBusConnection *connection, char *name; BusData *bd; dbus_bool_t retval; - - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_error_is_set (error, FALSE); retval = FALSE; @@ -450,8 +445,9 @@ dbus_bus_register (DBusConnection *connection, return TRUE; } - message = dbus_message_new (DBUS_SERVICE_DBUS, - DBUS_MESSAGE_HELLO); + message = dbus_message_new (DBUS_MESSAGE_HELLO, + DBUS_SERVICE_DBUS); + if (!message) { @@ -504,12 +500,14 @@ dbus_bus_set_base_service (DBusConnection *connection, { BusData *bd; + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (base_service != NULL, FALSE); + bd = ensure_bus_data (connection); if (bd == NULL) return FALSE; _dbus_assert (bd->base_service == NULL); - _dbus_assert (base_service != NULL); bd->base_service = _dbus_strdup (base_service); return bd->base_service != NULL; @@ -528,6 +526,8 @@ dbus_bus_get_base_service (DBusConnection *connection) { BusData *bd; + _dbus_return_val_if_fail (connection != NULL, NULL); + bd = ensure_bus_data (connection); if (bd == NULL) return NULL; @@ -558,9 +558,14 @@ dbus_bus_acquire_service (DBusConnection *connection, { DBusMessage *message, *reply; dbus_uint32_t service_result; + + _dbus_return_val_if_fail (connection != NULL, 0); + _dbus_return_val_if_fail (service_name != NULL, 0); + _dbus_return_val_if_error_is_set (error, 0); - message = dbus_message_new (DBUS_SERVICE_DBUS, - DBUS_MESSAGE_ACQUIRE_SERVICE); + message = dbus_message_new (DBUS_MESSAGE_ACQUIRE_SERVICE, + DBUS_SERVICE_DBUS); + if (message == NULL) { @@ -628,10 +633,12 @@ dbus_bus_service_exists (DBusConnection *connection, DBusMessage *message, *reply; unsigned int exists; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (service_name != NULL, FALSE); + _dbus_return_val_if_error_is_set (error, FALSE); - message = dbus_message_new (DBUS_SERVICE_DBUS, - DBUS_MESSAGE_SERVICE_EXISTS); + message = dbus_message_new (DBUS_MESSAGE_SERVICE_EXISTS, + DBUS_SERVICE_DBUS); if (message == NULL) { _DBUS_SET_OOM (error); diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c index eb331662..4bb0514f 100644 --- a/dbus/dbus-connection.c +++ b/dbus/dbus-connection.c @@ -691,7 +691,7 @@ _dbus_connection_new_for_transport (DBusTransport *transport) if (io_path_cond == NULL) goto error; - disconnect_message = dbus_message_new (NULL, DBUS_MESSAGE_LOCAL_DISCONNECT); + disconnect_message = dbus_message_new (DBUS_MESSAGE_LOCAL_DISCONNECT, NULL); if (disconnect_message == NULL) goto error; @@ -773,6 +773,19 @@ _dbus_connection_new_for_transport (DBusTransport *transport) return NULL; } +/** + * Increments the reference count of a DBusConnection. + * Requires that the caller already holds the connection lock. + * + * @param connection the connection. + */ +void +_dbus_connection_ref_unlocked (DBusConnection *connection) +{ + _dbus_assert (connection->refcount > 0); + connection->refcount += 1; +} + static dbus_uint32_t _dbus_connection_get_next_client_serial (DBusConnection *connection) { @@ -830,6 +843,45 @@ _dbus_connection_handler_destroyed_locked (DBusConnection *connection, dbus_mutex_unlock (connection->mutex); } +/** + * A callback for use with dbus_watch_new() to create a DBusWatch. + * + * @todo This is basically a hack - we could delete _dbus_transport_handle_watch() + * and the virtual handle_watch in DBusTransport if we got rid of it. + * The reason this is some work is threading, see the _dbus_connection_handle_watch() + * implementation. + * + * @param watch the watch. + * @param condition the current condition of the file descriptors being watched. + * @param data must be a pointer to a #DBusConnection + * @returns #FALSE if the IO condition may not have been fully handled due to lack of memory + */ +dbus_bool_t +_dbus_connection_handle_watch (DBusWatch *watch, + unsigned int condition, + void *data) +{ + DBusConnection *connection; + dbus_bool_t retval; + DBusDispatchStatus status; + + connection = data; + + dbus_mutex_lock (connection->mutex); + _dbus_connection_acquire_io_path (connection, -1); + retval = _dbus_transport_handle_watch (connection->transport, + watch, condition); + _dbus_connection_release_io_path (connection); + + status = _dbus_connection_get_dispatch_status_unlocked (connection); + + dbus_mutex_unlock (connection->mutex); + + _dbus_connection_update_dispatch_status_locked (connection, status); + + return retval; +} + /** @} */ /** @@ -861,7 +913,8 @@ dbus_connection_open (const char *address, DBusConnection *connection; DBusTransport *transport; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + _dbus_return_val_if_fail (address != NULL, NULL); + _dbus_return_val_if_error_is_set (error, NULL); transport = _dbus_transport_open (address, error); if (transport == NULL) @@ -891,6 +944,8 @@ dbus_connection_open (const char *address, void dbus_connection_ref (DBusConnection *connection) { + _dbus_return_if_fail (connection != NULL); + dbus_mutex_lock (connection->mutex); _dbus_assert (connection->refcount > 0); @@ -898,19 +953,6 @@ dbus_connection_ref (DBusConnection *connection) dbus_mutex_unlock (connection->mutex); } -/** - * Increments the reference count of a DBusConnection. - * Requires that the caller already holds the connection lock. - * - * @param connection the connection. - */ -void -_dbus_connection_ref_unlocked (DBusConnection *connection) -{ - _dbus_assert (connection->refcount > 0); - connection->refcount += 1; -} - static void free_outgoing_message (void *element, void *data) @@ -1028,10 +1070,11 @@ void dbus_connection_unref (DBusConnection *connection) { dbus_bool_t last_unref; + + _dbus_return_if_fail (connection != NULL); dbus_mutex_lock (connection->mutex); - _dbus_assert (connection != NULL); _dbus_assert (connection->refcount > 0); connection->refcount -= 1; @@ -1060,6 +1103,8 @@ dbus_connection_unref (DBusConnection *connection) void dbus_connection_disconnect (DBusConnection *connection) { + _dbus_return_if_fail (connection != NULL); + dbus_mutex_lock (connection->mutex); _dbus_transport_disconnect (connection->transport); dbus_mutex_unlock (connection->mutex); @@ -1079,6 +1124,8 @@ dbus_bool_t dbus_connection_get_is_connected (DBusConnection *connection) { dbus_bool_t res; + + _dbus_return_val_if_fail (connection != NULL, FALSE); dbus_mutex_lock (connection->mutex); res = _dbus_transport_get_is_connected (connection->transport); @@ -1099,6 +1146,8 @@ dbus_bool_t dbus_connection_get_is_authenticated (DBusConnection *connection) { dbus_bool_t res; + + _dbus_return_val_if_fail (connection != NULL, FALSE); dbus_mutex_lock (connection->mutex); res = _dbus_transport_get_is_authenticated (connection->transport); @@ -1129,10 +1178,14 @@ dbus_connection_preallocate_send (DBusConnection *connection) { DBusPreallocatedSend *preallocated; + _dbus_return_val_if_fail (connection != NULL, NULL); + preallocated = dbus_new (DBusPreallocatedSend, 1); if (preallocated == NULL) return NULL; + dbus_mutex_lock (connection->mutex); + preallocated->queue_link = _dbus_list_alloc_link (NULL); if (preallocated->queue_link == NULL) goto failed_0; @@ -1152,6 +1205,8 @@ dbus_connection_preallocate_send (DBusConnection *connection) failed_0: dbus_free (preallocated); + dbus_mutex_unlock (connection->mutex); + return NULL; } @@ -1168,7 +1223,9 @@ void dbus_connection_free_preallocated_send (DBusConnection *connection, DBusPreallocatedSend *preallocated) { - _dbus_assert (connection == preallocated->connection); + _dbus_return_if_fail (connection != NULL); + _dbus_return_if_fail (preallocated != NULL); + _dbus_return_if_fail (connection == preallocated->connection); _dbus_list_free_link (preallocated->queue_link); _dbus_counter_unref (preallocated->counter_link->data); @@ -1195,9 +1252,12 @@ dbus_connection_send_preallocated (DBusConnection *connection, dbus_uint32_t *client_serial) { dbus_uint32_t serial; - - _dbus_assert (preallocated->connection == connection); - _dbus_assert (dbus_message_get_name (message) != NULL); + + _dbus_return_if_fail (connection != NULL); + _dbus_return_if_fail (preallocated != NULL); + _dbus_return_if_fail (message != NULL); + _dbus_return_if_fail (preallocated->connection == connection); + _dbus_return_if_fail (dbus_message_get_name (message) != NULL); dbus_mutex_lock (connection->mutex); @@ -1270,6 +1330,9 @@ dbus_connection_send (DBusConnection *connection, { DBusPreallocatedSend *preallocated; + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (message != NULL, FALSE); + preallocated = dbus_connection_preallocate_send (connection); if (preallocated == NULL) { @@ -1383,6 +1446,11 @@ dbus_connection_send_with_reply (DBusConnection *connection, DBusMessage *reply; DBusList *reply_link; dbus_int32_t serial = -1; + + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (reply_handler != NULL, FALSE); + _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE); if (timeout_milliseconds == -1) timeout_milliseconds = DEFAULT_TIMEOUT_VALUE; @@ -1538,7 +1606,10 @@ dbus_connection_send_with_reply_and_block (DBusConnection *connection, long tv_sec, tv_usec; DBusDispatchStatus status; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + _dbus_return_val_if_fail (connection != NULL, NULL); + _dbus_return_val_if_fail (message != NULL, NULL); + _dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, FALSE); + _dbus_return_val_if_error_is_set (error, NULL); if (timeout_milliseconds == -1) timeout_milliseconds = DEFAULT_TIMEOUT_VALUE; @@ -1680,6 +1751,8 @@ dbus_connection_flush (DBusConnection *connection) * dispatch status. */ DBusDispatchStatus status; + + _dbus_return_if_fail (connection != NULL); dbus_mutex_lock (connection->mutex); while (connection->n_outgoing > 0 && @@ -1728,6 +1801,8 @@ dbus_connection_borrow_message (DBusConnection *connection) { DBusMessage *message; DBusDispatchStatus status; + + _dbus_return_val_if_fail (connection != NULL, NULL); /* this is called for the side effect that it queues * up any messages from the transport @@ -1761,6 +1836,9 @@ void dbus_connection_return_message (DBusConnection *connection, DBusMessage *message) { + _dbus_return_if_fail (connection != NULL); + _dbus_return_if_fail (message != NULL); + dbus_mutex_lock (connection->mutex); _dbus_assert (message == connection->message_borrowed); @@ -1785,6 +1863,9 @@ dbus_connection_steal_borrowed_message (DBusConnection *connection, DBusMessage *message) { DBusMessage *pop_message; + + _dbus_return_if_fail (connection != NULL); + _dbus_return_if_fail (message != NULL); dbus_mutex_lock (connection->mutex); @@ -2004,6 +2085,8 @@ DBusDispatchStatus dbus_connection_get_dispatch_status (DBusConnection *connection) { DBusDispatchStatus status; + + _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE); dbus_mutex_lock (connection->mutex); @@ -2035,6 +2118,8 @@ dbus_connection_dispatch (DBusConnection *connection) const char *name; dbus_int32_t reply_serial; DBusDispatchStatus status; + + _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE); status = dbus_connection_get_dispatch_status (connection); if (status != DBUS_DISPATCH_DATA_REMAINS) @@ -2271,6 +2356,8 @@ dbus_connection_set_watch_functions (DBusConnection *connection, DBusFreeFunction free_data_function) { dbus_bool_t retval; + + _dbus_return_val_if_fail (connection != NULL, FALSE); dbus_mutex_lock (connection->mutex); /* ref connection for slightly better reentrancy */ @@ -2331,6 +2418,8 @@ dbus_connection_set_timeout_functions (DBusConnection *connection, DBusFreeFunction free_data_function) { dbus_bool_t retval; + + _dbus_return_val_if_fail (connection != NULL, FALSE); dbus_mutex_lock (connection->mutex); /* ref connection for slightly better reentrancy */ @@ -2370,6 +2459,8 @@ dbus_connection_set_wakeup_main_function (DBusConnection *connection, { void *old_data; DBusFreeFunction old_free_data; + + _dbus_return_if_fail (connection != NULL); dbus_mutex_lock (connection->mutex); old_data = connection->wakeup_main_data; @@ -2410,6 +2501,8 @@ dbus_connection_set_dispatch_status_function (DBusConnection *connec { void *old_data; DBusFreeFunction old_free_data; + + _dbus_return_if_fail (connection != NULL); dbus_mutex_lock (connection->mutex); old_data = connection->dispatch_status_data; @@ -2426,45 +2519,6 @@ dbus_connection_set_dispatch_status_function (DBusConnection *connec (*old_free_data) (old_data); } -/** - * A callback for use with dbus_watch_new() to create a DBusWatch. - * - * @todo This is basically a hack - we could delete _dbus_transport_handle_watch() - * and the virtual handle_watch in DBusTransport if we got rid of it. - * The reason this is some work is threading, see the _dbus_connection_handle_watch() - * implementation. - * - * @param watch the watch. - * @param condition the current condition of the file descriptors being watched. - * @param data must be a pointer to a #DBusConnection - * @returns #FALSE if the IO condition may not have been fully handled due to lack of memory - */ -dbus_bool_t -_dbus_connection_handle_watch (DBusWatch *watch, - unsigned int condition, - void *data) -{ - DBusConnection *connection; - dbus_bool_t retval; - DBusDispatchStatus status; - - connection = data; - - dbus_mutex_lock (connection->mutex); - _dbus_connection_acquire_io_path (connection, -1); - retval = _dbus_transport_handle_watch (connection->transport, - watch, condition); - _dbus_connection_release_io_path (connection); - - status = _dbus_connection_get_dispatch_status_unlocked (connection); - - dbus_mutex_unlock (connection->mutex); - - _dbus_connection_update_dispatch_status_locked (connection, status); - - return retval; -} - /** * Gets the UNIX user ID of the connection if any. * Returns #TRUE if the uid is filled in. @@ -2482,6 +2536,9 @@ dbus_connection_get_unix_user (DBusConnection *connection, { dbus_bool_t result; + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (uid != NULL, FALSE); + dbus_mutex_lock (connection->mutex); if (!_dbus_transport_get_is_authenticated (connection->transport)) @@ -2519,6 +2576,8 @@ dbus_connection_set_unix_user_function (DBusConnection *connection, void *old_data = NULL; DBusFreeFunction old_free_function = NULL; + _dbus_return_if_fail (connection != NULL); + dbus_mutex_lock (connection->mutex); _dbus_transport_set_unix_user_function (connection->transport, function, data, free_data_function, @@ -2552,6 +2611,9 @@ dbus_bool_t dbus_connection_add_filter (DBusConnection *connection, DBusMessageHandler *handler) { + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (handler != NULL, FALSE); + dbus_mutex_lock (connection->mutex); if (!_dbus_message_handler_add_connection (handler, connection)) { @@ -2586,6 +2648,9 @@ void dbus_connection_remove_filter (DBusConnection *connection, DBusMessageHandler *handler) { + _dbus_return_if_fail (connection != NULL); + _dbus_return_if_fail (handler != NULL); + dbus_mutex_lock (connection->mutex); if (!_dbus_list_remove_last (&connection->filter_list, handler)) { @@ -2633,6 +2698,11 @@ dbus_connection_register_handler (DBusConnection *connection, { int i; + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (handler != NULL, FALSE); + _dbus_return_val_if_fail (n_messages >= 0, FALSE); + _dbus_return_val_if_fail (n_messages == 0 || messages_to_handle != NULL, FALSE); + dbus_mutex_lock (connection->mutex); i = 0; while (i < n_messages) @@ -2706,6 +2776,11 @@ dbus_connection_unregister_handler (DBusConnection *connection, { int i; + _dbus_return_if_fail (connection != NULL); + _dbus_return_if_fail (handler != NULL); + _dbus_return_if_fail (n_messages >= 0); + _dbus_return_if_fail (n_messages == 0 || messages_to_handle != NULL); + dbus_mutex_lock (connection->mutex); i = 0; while (i < n_messages) @@ -2795,6 +2870,9 @@ dbus_connection_set_data (DBusConnection *connection, DBusFreeFunction old_free_func; void *old_data; dbus_bool_t retval; + + _dbus_return_val_if_fail (connection != NULL, FALSE); + _dbus_return_val_if_fail (slot >= 0, FALSE); dbus_mutex_lock (connection->mutex); @@ -2828,6 +2906,8 @@ dbus_connection_get_data (DBusConnection *connection, int slot) { void *res; + + _dbus_return_val_if_fail (connection != NULL, NULL); dbus_mutex_lock (connection->mutex); @@ -2848,8 +2928,8 @@ dbus_connection_get_data (DBusConnection *connection, */ void dbus_connection_set_change_sigpipe (dbus_bool_t will_modify_sigpipe) -{ - _dbus_modify_sigpipe = will_modify_sigpipe; +{ + _dbus_modify_sigpipe = will_modify_sigpipe != FALSE; } /** @@ -2864,6 +2944,8 @@ void dbus_connection_set_max_message_size (DBusConnection *connection, long size) { + _dbus_return_if_fail (connection != NULL); + dbus_mutex_lock (connection->mutex); _dbus_transport_set_max_message_size (connection->transport, size); @@ -2880,6 +2962,9 @@ long dbus_connection_get_max_message_size (DBusConnection *connection) { long res; + + _dbus_return_val_if_fail (connection != NULL, 0); + dbus_mutex_lock (connection->mutex); res = _dbus_transport_get_max_message_size (connection->transport); dbus_mutex_unlock (connection->mutex); @@ -2913,8 +2998,10 @@ dbus_connection_get_max_message_size (DBusConnection *connection) */ void dbus_connection_set_max_received_size (DBusConnection *connection, - long size) + long size) { + _dbus_return_if_fail (connection != NULL); + dbus_mutex_lock (connection->mutex); _dbus_transport_set_max_received_size (connection->transport, size); @@ -2931,6 +3018,9 @@ long dbus_connection_get_max_received_size (DBusConnection *connection) { long res; + + _dbus_return_val_if_fail (connection != NULL, 0); + dbus_mutex_lock (connection->mutex); res = _dbus_transport_get_max_received_size (connection->transport); dbus_mutex_unlock (connection->mutex); @@ -2951,6 +3041,9 @@ long dbus_connection_get_outgoing_size (DBusConnection *connection) { long res; + + _dbus_return_val_if_fail (connection != NULL, 0); + dbus_mutex_lock (connection->mutex); res = _dbus_counter_get_value (connection->outgoing_counter); dbus_mutex_unlock (connection->mutex); diff --git a/dbus/dbus-errors.c b/dbus/dbus-errors.c index 30b2e0a6..f7636287 100644 --- a/dbus/dbus-errors.c +++ b/dbus/dbus-errors.c @@ -139,7 +139,7 @@ dbus_error_init (DBusError *error) { DBusRealError *real; - _dbus_assert (error != NULL); + _dbus_return_if_fail (error != NULL); _dbus_assert (sizeof (DBusError) == sizeof (DBusRealError)); @@ -162,6 +162,8 @@ dbus_error_free (DBusError *error) { DBusRealError *real; + _dbus_return_if_fail (error != NULL); + real = (DBusRealError *)error; if (!real->const_message) @@ -187,13 +189,14 @@ dbus_set_error_const (DBusError *error, { DBusRealError *real; + _dbus_return_if_error_is_set (error); + _dbus_return_if_fail (name != NULL); + if (error == NULL) return; - /* it's a bug to pile up errors */ _dbus_assert (error->name == NULL); _dbus_assert (error->message == NULL); - _dbus_assert (name != NULL); if (message == NULL) message = message_from_error (name); @@ -219,7 +222,7 @@ void dbus_move_error (DBusError *src, DBusError *dest) { - _dbus_assert (!dbus_error_is_set (dest)); + _dbus_return_if_error_is_set (dest); if (dest) { @@ -242,8 +245,9 @@ dbus_bool_t dbus_error_has_name (const DBusError *error, const char *name) { - _dbus_assert (error != NULL); - _dbus_assert (name != NULL); + _dbus_return_val_if_fail (error != NULL, FALSE); + _dbus_return_val_if_fail (name != NULL, FALSE); + _dbus_assert ((error->name != NULL && error->message != NULL) || (error->name == NULL && error->message == NULL)); @@ -267,7 +271,7 @@ dbus_error_has_name (const DBusError *error, dbus_bool_t dbus_error_is_set (const DBusError *error) { - _dbus_assert (error != NULL); + _dbus_return_val_if_fail (error != NULL, FALSE); _dbus_assert ((error->name != NULL && error->message != NULL) || (error->name == NULL && error->message == NULL)); return error->name != NULL; @@ -307,9 +311,11 @@ dbus_set_error (DBusError *error, return; /* it's a bug to pile up errors */ + _dbus_return_if_error_is_set (error); + _dbus_return_if_fail (name != NULL); + _dbus_assert (error->name == NULL); _dbus_assert (error->message == NULL); - _dbus_assert (name != NULL); if (format == NULL) format = message_from_error (name); diff --git a/dbus/dbus-internals.c b/dbus/dbus-internals.c index 30f47f00..25bd52ba 100644 --- a/dbus/dbus-internals.c +++ b/dbus/dbus-internals.c @@ -356,6 +356,12 @@ _dbus_type_to_string (int type) } } +#ifndef DBUS_DISABLE_CHECKS +const char _dbus_return_if_fail_warning_format[] = +"Arguments to %s were incorrect, assertion \"%s\" failed in file %s line %d.\n" +"This is normally a bug in some application using the D-BUS library.\n"; +#endif + #ifndef DBUS_DISABLE_ASSERT /** * Internals of _dbus_assert(); it's a function diff --git a/dbus/dbus-internals.h b/dbus/dbus-internals.h index c99caa74..6a0ae746 100644 --- a/dbus/dbus-internals.h +++ b/dbus/dbus-internals.h @@ -43,6 +43,14 @@ void _dbus_verbose_real (const char *format, ...) _DBUS_GNUC_PRINTF (1, 2); void _dbus_verbose_reset_real (void); +#if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#define _DBUS_FUNCTION_NAME __func__ +#elif defined(__GNUC__) +#define _DBUS_FUNCTION_NAME __FUNCTION__ +#else +#define _DBUS_FUNCTION_NAME "unknown function" +#endif + #ifdef DBUS_ENABLE_VERBOSE_MODE # define _dbus_verbose _dbus_verbose_real # define _dbus_verbose_reset _dbus_verbose_reset_real @@ -80,6 +88,28 @@ void _dbus_real_assert_not_reached (const char *explanation, _dbus_real_assert_not_reached (explanation, __FILE__, __LINE__) #endif /* !DBUS_DISABLE_ASSERT */ +#ifdef DBUS_DISABLE_CHECKS +#define _dbus_return_if_fail(condition) +#define _dbus_return_val_if_fail(condition, val) +#else +extern const char _dbus_return_if_fail_warning_format[]; + +#define _dbus_return_if_fail(condition) do { \ + if (!(condition)) { \ + _dbus_warn (_dbus_return_if_fail_warning_format, \ + _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \ + return; \ + } } while (0) + +#define _dbus_return_val_if_fail(condition, val) do { \ + if (!(condition)) { \ + _dbus_warn (_dbus_return_if_fail_warning_format, \ + _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \ + return (val); \ + } } while (0) + +#endif /* !DBUS_DISABLE_ASSERT */ + #define _DBUS_N_ELEMENTS(array) ((int) (sizeof ((array)) / sizeof ((array)[0]))) #define _DBUS_POINTER_TO_INT(pointer) ((long)(pointer)) @@ -93,6 +123,9 @@ void _dbus_real_assert_not_reached (const char *explanation, #define _DBUS_ASSERT_ERROR_IS_SET(error) _dbus_assert ((error) == NULL || dbus_error_is_set ((error))) #define _DBUS_ASSERT_ERROR_IS_CLEAR(error) _dbus_assert ((error) == NULL || !dbus_error_is_set ((error))) +#define _dbus_return_if_error_is_set(error) _dbus_return_if_fail ((error) == NULL || !dbus_error_is_set ((error))) +#define _dbus_return_val_if_error_is_set(error, val) _dbus_return_val_if_fail ((error) == NULL || !dbus_error_is_set ((error)), (val)) + /* This alignment thing is from ORBit2 */ /* Align a value upward to a boundary, expressed as a number of bytes. * E.g. align to an 8-byte boundary with argument of 8. diff --git a/dbus/dbus-message-handler.c b/dbus/dbus-message-handler.c index fb9eff07..964f7d72 100644 --- a/dbus/dbus-message-handler.c +++ b/dbus/dbus-message-handler.c @@ -192,6 +192,8 @@ dbus_message_handler_new (DBusHandleMessageFunction function, void dbus_message_handler_ref (DBusMessageHandler *handler) { + _dbus_return_if_fail (handler != NULL); + _DBUS_LOCK (message_handler); _dbus_assert (handler != NULL); @@ -209,6 +211,8 @@ void dbus_message_handler_unref (DBusMessageHandler *handler) { int refcount; + + _dbus_return_if_fail (handler != NULL); _DBUS_LOCK (message_handler); @@ -254,6 +258,9 @@ void* dbus_message_handler_get_data (DBusMessageHandler *handler) { void* user_data; + + _dbus_return_val_if_fail (handler != NULL, NULL); + _DBUS_LOCK (message_handler); user_data = handler->user_data; _DBUS_UNLOCK (message_handler); @@ -276,6 +283,8 @@ dbus_message_handler_set_data (DBusMessageHandler *handler, { DBusFreeFunction old_free_func; void *old_user_data; + + _dbus_return_if_fail (handler != NULL); _DBUS_LOCK (message_handler); old_free_func = handler->free_user_data; @@ -301,6 +310,8 @@ void dbus_message_handler_set_function (DBusMessageHandler *handler, DBusHandleMessageFunction function) { + _dbus_return_if_fail (handler != NULL); + _DBUS_LOCK (message_handler); handler->function = function; _DBUS_UNLOCK (message_handler); diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index fe07c865..c9053eb9 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -789,8 +789,8 @@ _dbus_message_remove_size_counter (DBusMessage *message, static dbus_bool_t dbus_message_create_header (DBusMessage *message, - const char *service, - const char *name) + const char *name, + const char *service) { unsigned int flags; @@ -936,22 +936,24 @@ dbus_message_new_empty_header (void) * @todo reverse the arguments, first 'name' then 'service' * as 'name' is more fundamental * - * @param service service that the message should be sent to or #NULL * @param name name of the message + * @param destination_service service that the message should be sent to or #NULL * @returns a new DBusMessage, free with dbus_message_unref() * @see dbus_message_unref() */ DBusMessage* -dbus_message_new (const char *service, - const char *name) +dbus_message_new (const char *name, + const char *destination_service) { DBusMessage *message; + _dbus_return_val_if_fail (name != NULL, NULL); + message = dbus_message_new_empty_header (); if (message == NULL) return NULL; - if (!dbus_message_create_header (message, service, name)) + if (!dbus_message_create_header (message, name, destination_service)) { dbus_message_unref (message); return NULL; @@ -976,6 +978,8 @@ dbus_message_new_reply (DBusMessage *original_message) DBusMessage *message; const char *sender, *name; + _dbus_return_val_if_fail (original_message != NULL, NULL); + sender = get_string_field (original_message, FIELD_SENDER, NULL); name = get_string_field (original_message, @@ -983,7 +987,7 @@ dbus_message_new_reply (DBusMessage *original_message) /* sender is allowed to be null here in peer-to-peer case */ - message = dbus_message_new (sender, name); + message = dbus_message_new (name, sender); if (message == NULL) return NULL; @@ -1003,7 +1007,7 @@ dbus_message_new_reply (DBusMessage *original_message) * * @param original_message the original message * @param error_name the error name - * @param error_message the error message string + * @param error_message the error message string or #NULL for none * @returns a new error message */ DBusMessage* @@ -1015,12 +1019,15 @@ dbus_message_new_error_reply (DBusMessage *original_message, const char *sender; DBusMessageIter iter; + _dbus_return_val_if_fail (original_message != NULL, NULL); + _dbus_return_val_if_fail (error_name != NULL, NULL); + sender = get_string_field (original_message, FIELD_SENDER, NULL); _dbus_assert (sender != NULL); - message = dbus_message_new (sender, error_name); + message = dbus_message_new (error_name, sender); if (message == NULL) return NULL; @@ -1032,11 +1039,14 @@ dbus_message_new_error_reply (DBusMessage *original_message, return NULL; } - dbus_message_append_iter_init (message, &iter); - if (!dbus_message_iter_append_string (&iter, error_message)) + if (error_message != NULL) { - dbus_message_unref (message); - return NULL; + dbus_message_append_iter_init (message, &iter); + if (!dbus_message_iter_append_string (&iter, error_message)) + { + dbus_message_unref (message); + return NULL; + } } dbus_message_set_is_error (message, TRUE); @@ -1056,6 +1066,8 @@ dbus_message_copy (const DBusMessage *message) { DBusMessage *retval; int i; + + _dbus_return_val_if_fail (message != NULL, NULL); retval = dbus_new0 (DBusMessage, 1); if (retval == NULL) @@ -1121,6 +1133,8 @@ dbus_message_ref (DBusMessage *message) { dbus_atomic_t refcount; + _dbus_return_if_fail (message != NULL); + refcount = _dbus_atomic_inc (&message->refcount); _dbus_assert (refcount > 1); } @@ -1131,7 +1145,7 @@ free_size_counter (void *element, { DBusCounter *counter = element; DBusMessage *message = data; - + _dbus_counter_adjust (counter, - message->size_counter_delta); _dbus_counter_unref (counter); @@ -1148,6 +1162,8 @@ dbus_message_unref (DBusMessage *message) { dbus_atomic_t refcount; + _dbus_return_if_fail (message != NULL); + refcount = _dbus_atomic_dec (&message->refcount); _dbus_assert (refcount >= 0); @@ -1174,6 +1190,8 @@ dbus_message_unref (DBusMessage *message) const char* dbus_message_get_name (DBusMessage *message) { + _dbus_return_val_if_fail (message != NULL, NULL); + return get_string_field (message, FIELD_NAME, NULL); } @@ -1191,6 +1209,8 @@ dbus_message_get_name (DBusMessage *message) const char* dbus_message_get_service (DBusMessage *message) { + _dbus_return_val_if_fail (message != NULL, NULL); + return get_string_field (message, FIELD_SERVICE, NULL); } @@ -1220,6 +1240,8 @@ dbus_message_append_args (DBusMessage *message, dbus_bool_t retval; va_list var_args; + _dbus_return_val_if_fail (message != NULL, FALSE); + va_start (var_args, first_arg_type); retval = dbus_message_append_args_valist (message, first_arg_type, @@ -1250,6 +1272,8 @@ dbus_message_append_args_valist (DBusMessage *message, int type, old_len; DBusMessageIter iter; + _dbus_return_val_if_fail (message != NULL, FALSE); + old_len = _dbus_string_get_length (&message->body); type = first_arg_type; @@ -1405,7 +1429,8 @@ dbus_message_get_args (DBusMessage *message, dbus_bool_t retval; va_list var_args; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_error_is_set (error, FALSE); va_start (var_args, first_arg_type); retval = dbus_message_get_args_valist (message, error, first_arg_type, var_args); @@ -1434,6 +1459,9 @@ dbus_message_get_args_valist (DBusMessage *message, { DBusMessageIter iter; + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_error_is_set (error, FALSE); + dbus_message_iter_init (message, &iter); return dbus_message_iter_get_args_valist (&iter, error, first_arg_type, var_args); } @@ -1459,7 +1487,8 @@ dbus_message_iter_get_args (DBusMessageIter *iter, dbus_bool_t retval; va_list var_args; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + _dbus_return_val_if_fail (iter != NULL, FALSE); + _dbus_return_val_if_error_is_set (error, FALSE); va_start (var_args, first_arg_type); retval = dbus_message_iter_get_args_valist (iter, error, first_arg_type, var_args); @@ -1499,7 +1528,8 @@ dbus_message_iter_get_args_valist (DBusMessageIter *iter, int spec_type, msg_type, i; dbus_bool_t retval; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + _dbus_return_val_if_fail (iter != NULL, FALSE); + _dbus_return_val_if_error_is_set (error, FALSE); retval = FALSE; @@ -1756,11 +1786,14 @@ dbus_message_iter_get_args_valist (DBusMessageIter *iter, * @param iter pointer to an iterator to initialize */ void -dbus_message_iter_init (DBusMessage *message, +dbus_message_iter_init (DBusMessage *message, DBusMessageIter *iter) { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; + _dbus_return_if_fail (message != NULL); + _dbus_return_if_fail (iter != NULL); + _dbus_assert (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter)); real->message = message; @@ -1777,14 +1810,31 @@ dbus_message_iter_init (DBusMessage *message, real->array_type_pos = 0; } -static void +#ifndef DBUS_DISABLE_CHECKS +static dbus_bool_t dbus_message_iter_check (DBusMessageRealIter *iter) { - if (iter->changed_stamp != iter->message->changed_stamp) - _dbus_warn ("dbus iterator check failed: invalid iterator\n"); + if (iter == NULL) + { + _dbus_warn ("dbus iterator check failed: iterator is NULL\n"); + return FALSE; + } + + if (iter->changed_stamp != iter->message->changed_stamp) + { + _dbus_warn ("dbus iterator check failed: invalid iterator, must re-initialize it after modifying the message\n"); + return FALSE; + } + if (iter->pos < 0 || iter->pos > iter->end) - _dbus_warn ("dbus iterator check failed: invalid position\n"); + { + _dbus_warn ("dbus iterator check failed: invalid position\n"); + return FALSE; + } + + return TRUE; } +#endif /* DBUS_DISABLE_CHECKS */ static int skip_array_type (DBusMessageRealIter *iter, int pos) @@ -1868,7 +1918,7 @@ dbus_message_iter_has_next (DBusMessageIter *iter) int end_pos; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); if (real->pos >= real->end) return FALSE; @@ -1899,7 +1949,7 @@ dbus_message_iter_next (DBusMessageIter *iter) int end_pos; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -1929,7 +1979,7 @@ dbus_message_iter_get_arg_type (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), DBUS_TYPE_INVALID); if (real->pos >= real->end) return DBUS_TYPE_INVALID; @@ -1996,7 +2046,7 @@ dbus_message_iter_get_array_type (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), DBUS_TYPE_INVALID); if (real->pos >= real->end) return DBUS_TYPE_INVALID; @@ -2024,7 +2074,7 @@ dbus_message_iter_get_string (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), NULL); pos = dbus_message_iter_get_data_start (real, &type); @@ -2058,7 +2108,7 @@ dbus_message_iter_get_named (DBusMessageIter *iter, int type, pos; char *_name; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2098,7 +2148,7 @@ dbus_message_iter_get_byte (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), 0); pos = dbus_message_iter_get_data_start (real, &type); @@ -2126,7 +2176,7 @@ dbus_message_iter_get_boolean (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2152,7 +2202,7 @@ dbus_message_iter_get_int32 (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), 0); pos = dbus_message_iter_get_data_start (real, &type); @@ -2177,7 +2227,7 @@ dbus_message_iter_get_uint32 (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), 0); pos = dbus_message_iter_get_data_start (real, &type); @@ -2206,7 +2256,7 @@ dbus_message_iter_get_int64 (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), 0); pos = dbus_message_iter_get_data_start (real, &type); @@ -2233,7 +2283,7 @@ dbus_message_iter_get_uint64 (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), 0); pos = dbus_message_iter_get_data_start (real, &type); @@ -2260,7 +2310,7 @@ dbus_message_iter_get_double (DBusMessageIter *iter) DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), 0.0); pos = dbus_message_iter_get_data_start (real, &type); @@ -2293,7 +2343,7 @@ dbus_message_iter_init_array_iterator (DBusMessageIter *iter, int type, pos, len_pos, len, array_type_pos; int _array_type; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2343,7 +2393,7 @@ dbus_message_iter_init_dict_iterator (DBusMessageIter *iter, DBusMessageRealIter *dict_real = (DBusMessageRealIter *)dict_iter; int type, pos, len_pos, len; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2386,7 +2436,7 @@ dbus_message_iter_get_byte_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2421,7 +2471,7 @@ dbus_message_iter_get_boolean_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2456,7 +2506,7 @@ dbus_message_iter_get_int32_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2491,7 +2541,7 @@ dbus_message_iter_get_uint32_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2529,7 +2579,7 @@ dbus_message_iter_get_int64_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2566,7 +2616,7 @@ dbus_message_iter_get_uint64_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2602,7 +2652,7 @@ dbus_message_iter_get_double_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2641,7 +2691,7 @@ dbus_message_iter_get_string_array (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; int type, pos; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); pos = dbus_message_iter_get_data_start (real, &type); @@ -2671,7 +2721,7 @@ dbus_message_iter_get_dict_key (DBusMessageIter *iter) { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_check (real); + _dbus_return_val_if_fail (dbus_message_iter_check (real), NULL); _dbus_assert (real->type == DBUS_MESSAGE_ITER_TYPE_DICT); @@ -2688,10 +2738,13 @@ dbus_message_iter_get_dict_key (DBusMessageIter *iter) * @param iter pointer to an iterator to initialize */ void -dbus_message_append_iter_init (DBusMessage *message, +dbus_message_append_iter_init (DBusMessage *message, DBusMessageIter *iter) { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; + + _dbus_return_if_fail (message != NULL); + _dbus_return_if_fail (iter != NULL); real->message = message; real->parent_iter = NULL; @@ -2705,24 +2758,47 @@ dbus_message_append_iter_init (DBusMessage *message, real->wrote_dict_key = 0; } -static void +#ifndef DBUS_DISABLE_CHECKS +static dbus_bool_t dbus_message_iter_append_check (DBusMessageRealIter *iter) { - _dbus_assert (!iter->message->locked); + if (iter == NULL) + { + _dbus_warn ("dbus iterator check failed: NULL iterator\n"); + return FALSE; + } + if (iter->message->locked) + { + _dbus_warn ("dbus iterator check failed: message is locked (has already been sent)\n"); + return FALSE; + } + if (iter->changed_stamp != iter->message->changed_stamp) - _dbus_warn ("dbus iterator check failed: invalid iterator"); + { + _dbus_warn ("dbus iterator check failed: invalid iterator, must re-initialize it after modifying the message"); + return FALSE; + } if (iter->pos != iter->end) - _dbus_warn ("dbus iterator check failed: can only append at end of message"); + { + _dbus_warn ("dbus iterator check failed: can only append at end of message"); + return FALSE; + } if (iter->pos != _dbus_string_get_length (&iter->message->body)) - _dbus_warn ("dbus iterator check failed: append pos not at end of message string"); + { + _dbus_warn ("dbus iterator check failed: append pos not at end of message string"); + return FALSE; + } + + return TRUE; } +#endif /* DBUS_DISABLE_CHECKS */ static dbus_bool_t dbus_message_iter_append_type (DBusMessageRealIter *iter, - int type) + int type) { const char *data; switch (iter->type) @@ -2802,7 +2878,7 @@ dbus_message_iter_append_nil (DBusMessageIter *iter) { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_NIL)) return FALSE; @@ -2825,7 +2901,7 @@ dbus_message_iter_append_boolean (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_BOOLEAN)) return FALSE; @@ -2854,7 +2930,7 @@ dbus_message_iter_append_byte (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_BYTE)) return FALSE; @@ -2884,7 +2960,7 @@ dbus_message_iter_append_int32 (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_INT32)) return FALSE; @@ -2913,7 +2989,7 @@ dbus_message_iter_append_uint32 (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_UINT32)) return FALSE; @@ -2946,7 +3022,7 @@ dbus_message_iter_append_int64 (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_INT64)) return FALSE; @@ -2977,7 +3053,7 @@ dbus_message_iter_append_uint64 (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_UINT64)) return FALSE; @@ -3008,7 +3084,7 @@ dbus_message_iter_append_double (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_DOUBLE)) return FALSE; @@ -3037,7 +3113,7 @@ dbus_message_iter_append_string (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_STRING)) return FALSE; @@ -3073,7 +3149,7 @@ dbus_message_iter_append_named (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_NAMED)) return FALSE; @@ -3110,7 +3186,7 @@ dbus_message_iter_append_dict_key (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); _dbus_assert (real->type == DBUS_MESSAGE_ITER_TYPE_DICT); if (real->wrote_dict_key) @@ -3232,7 +3308,7 @@ dbus_message_iter_append_array (DBusMessageIter *iter, return FALSE; } - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, element_type, &array_type_done, &array_type_pos)) return FALSE; @@ -3284,7 +3360,7 @@ dbus_message_iter_append_dict (DBusMessageIter *iter, DBusMessageRealIter *dict_real = (DBusMessageRealIter *)dict_iter; int len_pos; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!dbus_message_iter_append_type (real, DBUS_TYPE_DICT)) return FALSE; @@ -3331,7 +3407,7 @@ dbus_message_iter_append_boolean_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_BOOLEAN, NULL, NULL)) return FALSE; @@ -3362,7 +3438,7 @@ dbus_message_iter_append_int32_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_INT32, NULL, NULL)) return FALSE; @@ -3393,7 +3469,7 @@ dbus_message_iter_append_uint32_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_UINT32, NULL, NULL)) return FALSE; @@ -3428,7 +3504,7 @@ dbus_message_iter_append_int64_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_INT64, NULL, NULL)) return FALSE; @@ -3461,7 +3537,7 @@ dbus_message_iter_append_uint64_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_UINT64, NULL, NULL)) return FALSE; @@ -3493,7 +3569,7 @@ dbus_message_iter_append_double_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_DOUBLE, NULL, NULL)) return FALSE; @@ -3524,7 +3600,7 @@ dbus_message_iter_append_byte_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_BYTE, NULL, NULL)) return FALSE; @@ -3555,7 +3631,7 @@ dbus_message_iter_append_string_array (DBusMessageIter *iter, { DBusMessageRealIter *real = (DBusMessageRealIter *)iter; - dbus_message_iter_append_check (real); + _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); if (!append_array_type (real, DBUS_TYPE_STRING, NULL, NULL)) return FALSE; @@ -3582,7 +3658,8 @@ dbus_bool_t dbus_message_set_sender (DBusMessage *message, const char *sender) { - _dbus_assert (!message->locked); + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (!message->locked, FALSE); if (sender == NULL) { @@ -3609,8 +3686,9 @@ dbus_message_set_is_error (DBusMessage *message, dbus_bool_t is_error_reply) { char *header; - - _dbus_assert (!message->locked); + + _dbus_return_if_fail (message != NULL); + _dbus_return_if_fail (!message->locked); header = _dbus_string_get_data_len (&message->header, 1, 1); @@ -3632,6 +3710,8 @@ dbus_message_get_is_error (DBusMessage *message) { const char *header; + _dbus_return_val_if_fail (message != NULL, FALSE); + header = _dbus_string_get_const_data_len (&message->header, 1, 1); return (*header & DBUS_HEADER_FLAG_ERROR) != 0; @@ -3647,6 +3727,8 @@ dbus_message_get_is_error (DBusMessage *message) const char* dbus_message_get_sender (DBusMessage *message) { + _dbus_return_val_if_fail (message != NULL, NULL); + return get_string_field (message, FIELD_SENDER, NULL); } @@ -3666,7 +3748,8 @@ dbus_message_name_is (DBusMessage *message, { const char *n; - _dbus_assert (name != NULL); + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (name != NULL, FALSE); n = dbus_message_get_name (message); @@ -3692,7 +3775,8 @@ dbus_message_service_is (DBusMessage *message, { const char *s; - _dbus_assert (service != NULL); + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (service != NULL, FALSE); s = dbus_message_get_service (message); @@ -3754,6 +3838,9 @@ dbus_set_error_from_message (DBusError *error, DBusMessage *message) { char *str; + + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_error_is_set (error, FALSE); if (!dbus_message_get_is_error (message)) return FALSE; @@ -5485,7 +5572,7 @@ _dbus_message_test (const char *test_data_dir) _dbus_assert (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter)); /* Test the vararg functions */ - message = dbus_message_new ("org.freedesktop.DBus.Test", "test.Message"); + message = dbus_message_new ("test.Message", "org.freedesktop.DBus.Test"); _dbus_message_set_serial (message, 1); dbus_message_append_args (message, DBUS_TYPE_INT32, -0x12345678, @@ -5533,7 +5620,7 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); dbus_message_unref (copy); - message = dbus_message_new ("org.freedesktop.DBus.Test", "test.Message"); + message = dbus_message_new ("test.Message", "org.freedesktop.DBus.Test"); _dbus_message_set_serial (message, 1); dbus_message_set_reply_serial (message, 0x12345678); diff --git a/dbus/dbus-server.c b/dbus/dbus-server.c index dd33804c..72a60d04 100644 --- a/dbus/dbus-server.c +++ b/dbus/dbus-server.c @@ -277,7 +277,8 @@ dbus_server_listen (const char *address, const char *address_problem_field; const char *address_problem_other; - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + _dbus_return_val_if_fail (address != NULL, NULL); + _dbus_return_val_if_error_is_set (error, NULL); if (!dbus_parse_address (address, &entries, &len, error)) return NULL; @@ -452,6 +453,8 @@ dbus_server_listen (const char *address, void dbus_server_ref (DBusServer *server) { + _dbus_return_if_fail (server != NULL); + server->refcount += 1; } @@ -466,7 +469,8 @@ dbus_server_ref (DBusServer *server) void dbus_server_unref (DBusServer *server) { - _dbus_assert (server != NULL); + _dbus_return_if_fail (server != NULL); + _dbus_assert (server->refcount > 0); server->refcount -= 1; @@ -489,6 +493,8 @@ dbus_server_unref (DBusServer *server) void dbus_server_disconnect (DBusServer *server) { + _dbus_return_if_fail (server != NULL); + _dbus_assert (server->vtable->disconnect != NULL); if (server->disconnected) @@ -506,6 +512,8 @@ dbus_server_disconnect (DBusServer *server) dbus_bool_t dbus_server_get_is_connected (DBusServer *server) { + _dbus_return_val_if_fail (server != NULL, FALSE); + return !server->disconnected; } @@ -519,6 +527,8 @@ dbus_server_get_is_connected (DBusServer *server) char* dbus_server_get_address (DBusServer *server) { + _dbus_return_val_if_fail (server != NULL, NULL); + return _dbus_strdup (server->address); } @@ -540,6 +550,8 @@ dbus_server_set_new_connection_function (DBusServer *server, void *data, DBusFreeFunction free_data_function) { + _dbus_return_if_fail (server != NULL); + if (server->new_connection_free_data_function != NULL) (* server->new_connection_free_data_function) (server->new_connection_data); @@ -572,6 +584,8 @@ dbus_server_set_watch_functions (DBusServer *server, void *data, DBusFreeFunction free_data_function) { + _dbus_return_val_if_fail (server != NULL, FALSE); + return _dbus_watch_list_set_functions (server->watches, add_function, remove_function, @@ -603,6 +617,8 @@ dbus_server_set_timeout_functions (DBusServer *server, void *data, DBusFreeFunction free_data_function) { + _dbus_return_val_if_fail (server != NULL, FALSE); + return _dbus_timeout_list_set_functions (server->timeouts, add_function, remove_function, toggled_function, @@ -625,6 +641,8 @@ dbus_server_set_auth_mechanisms (DBusServer *server, { char **copy; + _dbus_return_val_if_fail (server != NULL, FALSE); + if (mechanisms != NULL) { copy = _dbus_dup_string_array (mechanisms); @@ -675,6 +693,8 @@ dbus_server_allocate_data_slot (void) void dbus_server_free_data_slot (int slot) { + _dbus_return_if_fail (slot >= 0); + _dbus_data_slot_allocator_free (&slot_allocator, slot); } @@ -692,7 +712,7 @@ dbus_server_free_data_slot (int slot) * @returns #TRUE if there was enough memory to store the data */ dbus_bool_t -dbus_server_set_data (DBusServer *server, +dbus_server_set_data (DBusServer *server, int slot, void *data, DBusFreeFunction free_data_func) @@ -701,6 +721,8 @@ dbus_server_set_data (DBusServer *server, void *old_data; dbus_bool_t retval; + _dbus_return_val_if_fail (server != NULL, FALSE); + #if 0 dbus_mutex_lock (server->mutex); #endif @@ -734,9 +756,11 @@ dbus_server_set_data (DBusServer *server, */ void* dbus_server_get_data (DBusServer *server, - int slot) + int slot) { void *res; + + _dbus_return_val_if_fail (server != NULL, NULL); #if 0 dbus_mutex_lock (server->mutex); diff --git a/dbus/dbus-spawn.c b/dbus/dbus-spawn.c index 7161e6ed..5a367036 100644 --- a/dbus/dbus-spawn.c +++ b/dbus/dbus-spawn.c @@ -588,13 +588,6 @@ _dbus_babysitter_get_child_exited (DBusBabysitter *sitter) return sitter->socket_to_babysitter < 0; } -static void -_dbus_babysitter_block_for_child_exit (DBusBabysitter *sitter) -{ - while (LIVE_CHILDREN (sitter)) - babysitter_iteration (sitter, TRUE); -} - /** * Sets the #DBusError with an explanation of why the spawned * child process exited (on a signal, or whatever). If @@ -1162,6 +1155,13 @@ _dbus_spawn_async_with_babysitter (DBusBabysitter **sitter_p, #ifdef DBUS_BUILD_TESTS +static void +_dbus_babysitter_block_for_child_exit (DBusBabysitter *sitter) +{ + while (LIVE_CHILDREN (sitter)) + babysitter_iteration (sitter, TRUE); +} + static dbus_bool_t check_spawn_nonexistent (void *data) { diff --git a/doc/TODO b/doc/TODO index 9e7b7505..147f8340 100644 --- a/doc/TODO +++ b/doc/TODO @@ -43,18 +43,12 @@ - there are various bits of code to manage ref/unref of data slots, that should be merged into a generic facility - - add _dbus_return_if_fail, _dbus_return_val_if_fail() and use on public entry - points in place of _dbus_assert(). Add --disable-checks to control whether these - do anything. - - assorted _-prefixed symbols in libdbus aren't actually used by libdbus, only by the message bus. These bloat up the library size. Not sure how to fix, really. - dbus_error_has_name(), dbus_message_name_is() - - add DBUS_TYPE_INT64 ? - - if you send a message to a service then block for reply, and the service exits/crashes after the message bus has processed your message but before the service has replied, it would be nice if the message bus sent you an error reply. diff --git a/glib/test-dbus-glib.c b/glib/test-dbus-glib.c index 9fcbe4c0..d963ee3d 100644 --- a/glib/test-dbus-glib.c +++ b/glib/test-dbus-glib.c @@ -30,7 +30,8 @@ main (int argc, char **argv) dbus_connection_setup_with_g_main (connection, NULL); - message = dbus_message_new ("org.freedesktop.DBus", "org.freedesktop.DBus.Hello"); + message = dbus_message_new (DBUS_MESSAGE_HELLO, + DBUS_SERVICE_DBUS); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error); diff --git a/glib/test-thread-client.c b/glib/test-thread-client.c index 3ae0a517..02ebdf67 100644 --- a/glib/test-thread-client.c +++ b/glib/test-thread-client.c @@ -19,7 +19,7 @@ thread_func (gpointer data) while (1) { - message = dbus_message_new (NULL, "org.freedesktop.ThreadTest"); + message = dbus_message_new ("org.freedesktop.ThreadTest", NULL); dbus_message_append_iter_init (message, &iter); diff --git a/tools/dbus-send.c b/tools/dbus-send.c index f9f9881e..a105f8b4 100644 --- a/tools/dbus-send.c +++ b/tools/dbus-send.c @@ -75,7 +75,7 @@ main (int argc, char *argv[]) exit (1); } - message = dbus_message_new (dest, name); + message = dbus_message_new (name, dest); if (message == NULL) { fprintf (stderr, "Couldn't allocate D-BUS message\n"); -- cgit