2003-04-24 Havoc Pennington <hp@redhat.com>

	* 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

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  <hp@redhat.com>
+
+	* 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  <jwillcox@gnome.org>
 
 	* 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;
@@ -2427,45 +2520,6 @@ dbus_connection_set_dispatch_status_function (DBusConnection             *connec
 }
 
 /**
- * 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.
  * Always returns #FALSE on non-UNIX platforms.
@@ -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");