+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:
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);
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;
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;
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)
{
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;
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;
_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);
_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);
_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);
_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);
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])
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
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}
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
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);
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;
return TRUE;
}
- message = dbus_message_new (DBUS_SERVICE_DBUS,
- DBUS_MESSAGE_HELLO);
+ message = dbus_message_new (DBUS_MESSAGE_HELLO,
+ DBUS_SERVICE_DBUS);
+
if (!message)
{
{
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;
{
BusData *bd;
+ _dbus_return_val_if_fail (connection != NULL, NULL);
+
bd = ensure_bus_data (connection);
if (bd == NULL)
return NULL;
{
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)
{
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);
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;
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)
{
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;
+}
+
/** @} */
/**
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)
void
dbus_connection_ref (DBusConnection *connection)
{
+ _dbus_return_if_fail (connection != NULL);
+
dbus_mutex_lock (connection->mutex);
_dbus_assert (connection->refcount > 0);
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)
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;
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);
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);
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);
{
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;
failed_0:
dbus_free (preallocated);
+ dbus_mutex_unlock (connection->mutex);
+
return NULL;
}
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);
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);
{
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)
{
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;
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;
* dispatch status.
*/
DBusDispatchStatus status;
+
+ _dbus_return_if_fail (connection != NULL);
dbus_mutex_lock (connection->mutex);
while (connection->n_outgoing > 0 &&
{
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
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);
DBusMessage *message)
{
DBusMessage *pop_message;
+
+ _dbus_return_if_fail (connection != NULL);
+ _dbus_return_if_fail (message != NULL);
dbus_mutex_lock (connection->mutex);
dbus_connection_get_dispatch_status (DBusConnection *connection)
{
DBusDispatchStatus status;
+
+ _dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE);
dbus_mutex_lock (connection->mutex);
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)
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 */
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 */
{
void *old_data;
DBusFreeFunction old_free_data;
+
+ _dbus_return_if_fail (connection != NULL);
dbus_mutex_lock (connection->mutex);
old_data = connection->wakeup_main_data;
{
void *old_data;
DBusFreeFunction old_free_data;
+
+ _dbus_return_if_fail (connection != NULL);
dbus_mutex_lock (connection->mutex);
old_data = connection->dispatch_status_data;
(*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.
{
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))
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,
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))
{
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))
{
{
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)
{
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)
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);
int slot)
{
void *res;
+
+ _dbus_return_val_if_fail (connection != NULL, NULL);
dbus_mutex_lock (connection->mutex);
*/
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;
}
/**
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);
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);
*/
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);
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);
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);
{
DBusRealError *real;
- _dbus_assert (error != NULL);
+ _dbus_return_if_fail (error != NULL);
_dbus_assert (sizeof (DBusError) == sizeof (DBusRealError));
{
DBusRealError *real;
+ _dbus_return_if_fail (error != NULL);
+
real = (DBusRealError *)error;
if (!real->const_message)
{
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);
dbus_move_error (DBusError *src,
DBusError *dest)
{
- _dbus_assert (!dbus_error_is_set (dest));
+ _dbus_return_if_error_is_set (dest);
if (dest)
{
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));
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;
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);
}
}
+#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
...) _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
_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))
#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.
void
dbus_message_handler_ref (DBusMessageHandler *handler)
{
+ _dbus_return_if_fail (handler != NULL);
+
_DBUS_LOCK (message_handler);
_dbus_assert (handler != NULL);
dbus_message_handler_unref (DBusMessageHandler *handler)
{
int refcount;
+
+ _dbus_return_if_fail (handler != NULL);
_DBUS_LOCK (message_handler);
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);
{
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;
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);
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;
* @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;
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,
/* 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;
*
* @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*
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;
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);
{
DBusMessage *retval;
int i;
+
+ _dbus_return_val_if_fail (message != NULL, NULL);
retval = dbus_new0 (DBusMessage, 1);
if (retval == NULL)
{
dbus_atomic_t refcount;
+ _dbus_return_if_fail (message != NULL);
+
refcount = _dbus_atomic_inc (&message->refcount);
_dbus_assert (refcount > 1);
}
{
DBusCounter *counter = element;
DBusMessage *message = data;
-
+
_dbus_counter_adjust (counter, - message->size_counter_delta);
_dbus_counter_unref (counter);
{
dbus_atomic_t refcount;
+ _dbus_return_if_fail (message != NULL);
+
refcount = _dbus_atomic_dec (&message->refcount);
_dbus_assert (refcount >= 0);
const char*
dbus_message_get_name (DBusMessage *message)
{
+ _dbus_return_val_if_fail (message != NULL, NULL);
+
return get_string_field (message, FIELD_NAME, NULL);
}
const char*
dbus_message_get_service (DBusMessage *message)
{
+ _dbus_return_val_if_fail (message != NULL, NULL);
+
return get_string_field (message, FIELD_SERVICE, NULL);
}
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,
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;
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);
{
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);
}
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);
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;
* @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;
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)
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;
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);
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;
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;
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
{
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);
* @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;
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)
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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)
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;
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
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)
{
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);
{
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;
const char*
dbus_message_get_sender (DBusMessage *message)
{
+ _dbus_return_val_if_fail (message != NULL, NULL);
+
return get_string_field (message, FIELD_SENDER, NULL);
}
{
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);
{
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);
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;
_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,
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);
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;
void
dbus_server_ref (DBusServer *server)
{
+ _dbus_return_if_fail (server != NULL);
+
server->refcount += 1;
}
void
dbus_server_unref (DBusServer *server)
{
- _dbus_assert (server != NULL);
+ _dbus_return_if_fail (server != NULL);
+
_dbus_assert (server->refcount > 0);
server->refcount -= 1;
void
dbus_server_disconnect (DBusServer *server)
{
+ _dbus_return_if_fail (server != NULL);
+
_dbus_assert (server->vtable->disconnect != NULL);
if (server->disconnected)
dbus_bool_t
dbus_server_get_is_connected (DBusServer *server)
{
+ _dbus_return_val_if_fail (server != NULL, FALSE);
+
return !server->disconnected;
}
char*
dbus_server_get_address (DBusServer *server)
{
+ _dbus_return_val_if_fail (server != NULL, NULL);
+
return _dbus_strdup (server->address);
}
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);
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,
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,
{
char **copy;
+ _dbus_return_val_if_fail (server != NULL, FALSE);
+
if (mechanisms != NULL)
{
copy = _dbus_dup_string_array (mechanisms);
void
dbus_server_free_data_slot (int slot)
{
+ _dbus_return_if_fail (slot >= 0);
+
_dbus_data_slot_allocator_free (&slot_allocator, 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)
void *old_data;
dbus_bool_t retval;
+ _dbus_return_val_if_fail (server != NULL, FALSE);
+
#if 0
dbus_mutex_lock (server->mutex);
#endif
*/
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);
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
#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)
{
- 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.
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);
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);
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");
projects / thirdparty / dbus.git / commitdiff
