#include "dbus-protocol.h"
#include "dbus-dataslot.h"
#include "dbus-string.h"
+#include "dbus-signature.h"
#include "dbus-pending-call.h"
#include "dbus-object-tree.h"
#include "dbus-threads-internal.h"
TOOK_LOCK_CHECK (connection); \
} while (0)
-#define CONNECTION_UNLOCK(connection) do { \
- if (TRACE_LOCKS) { _dbus_verbose ("UNLOCK\n"); } \
- RELEASING_LOCK_CHECK (connection); \
- _dbus_mutex_unlock ((connection)->mutex); \
- } while (0)
+#define CONNECTION_UNLOCK(connection) _dbus_connection_unlock (connection)
#define SLOTS_LOCK(connection) do { \
_dbus_mutex_lock ((connection)->slot_mutex); \
DBusList *counter_link; /**< Preallocated link in the resource counter */
};
-#ifdef HAVE_DECL_MSG_NOSIGNAL
+#if HAVE_DECL_MSG_NOSIGNAL
static dbus_bool_t _dbus_modify_sigpipe = FALSE;
#else
static dbus_bool_t _dbus_modify_sigpipe = TRUE;
DBusList *outgoing_messages; /**< Queue of messages we need to send, send the end of the list first. */
DBusList *incoming_messages; /**< Queue of messages we have received, end of the list received most recently. */
+ DBusList *expired_messages; /**< Messages that will be released when we next unlock. */
DBusMessage *message_borrowed; /**< Filled in if the first incoming message has been borrowed;
* dispatch_acquired will be set by the borrower
DBusDispatchStatus last_dispatch_status; /**< The last dispatch status we reported to the application. */
- DBusList *link_cache; /**< A cache of linked list links to prevent contention
- * for the global linked list mempool lock
- */
DBusObjectTree *objects; /**< Object path handlers registered with this connection */
char *server_guid; /**< GUID of server if we are in shared_connections, #NULL if server GUID is unknown or connection is private */
static DBusMessageFilter *
_dbus_message_filter_ref (DBusMessageFilter *filter)
{
- _dbus_assert (filter->refcount.value > 0);
+#ifdef DBUS_DISABLE_ASSERT
_dbus_atomic_inc (&filter->refcount);
+#else
+ dbus_int32_t old_value;
+
+ old_value = _dbus_atomic_inc (&filter->refcount);
+ _dbus_assert (old_value > 0);
+#endif
return filter;
}
static void
_dbus_message_filter_unref (DBusMessageFilter *filter)
{
- _dbus_assert (filter->refcount.value > 0);
+ dbus_int32_t old_value;
- if (_dbus_atomic_dec (&filter->refcount) == 1)
+ old_value = _dbus_atomic_dec (&filter->refcount);
+ _dbus_assert (old_value > 0);
+
+ if (old_value == 1)
{
if (filter->free_user_data_function)
(* filter->free_user_data_function) (filter->user_data);
void
_dbus_connection_unlock (DBusConnection *connection)
{
- CONNECTION_UNLOCK (connection);
+ DBusList *expired_messages;
+ DBusList *iter;
+
+ if (TRACE_LOCKS)
+ {
+ _dbus_verbose ("UNLOCK\n");
+ }
+
+ /* If we had messages that expired (fell off the incoming or outgoing
+ * queues) while we were locked, actually release them now */
+ expired_messages = connection->expired_messages;
+ connection->expired_messages = NULL;
+
+ RELEASING_LOCK_CHECK (connection);
+ _dbus_mutex_unlock (connection->mutex);
+
+ for (iter = _dbus_list_pop_first_link (&expired_messages);
+ iter != NULL;
+ iter = _dbus_list_pop_first_link (&expired_messages))
+ {
+ DBusMessage *message = iter->data;
+
+ dbus_message_unref (message);
+ _dbus_list_free_link (iter);
+ }
}
/**
* @param message the message that was sent.
*/
void
-_dbus_connection_message_sent (DBusConnection *connection,
- DBusMessage *message)
+_dbus_connection_message_sent_unlocked (DBusConnection *connection,
+ DBusMessage *message)
{
DBusList *link;
_dbus_assert (link != NULL);
_dbus_assert (link->data == message);
- /* Save this link in the link cache */
_dbus_list_unlink (&connection->outgoing_messages,
link);
- _dbus_list_prepend_link (&connection->link_cache, link);
-
+ _dbus_list_prepend_link (&connection->expired_messages, link);
+
connection->n_outgoing -= 1;
_dbus_verbose ("Message %p (%s %s %s %s '%s') removed from outgoing queue %p, %d left to send\n",
dbus_message_get_signature (message),
connection, connection->n_outgoing);
- /* Save this link in the link cache also */
- _dbus_message_remove_counter (message, connection->outgoing_counter,
- &link);
- _dbus_list_prepend_link (&connection->link_cache, link);
-
- dbus_message_unref (message);
+ /* It's OK that in principle we call the notify function, because for the
+ * outgoing limit, there isn't one */
+ _dbus_message_remove_counter (message, connection->outgoing_counter);
+
+ /* The message will actually be unreffed when we unlock */
}
/** Function to be called in protected_change_watch() with refcount held */
if (_dbus_modify_sigpipe)
_dbus_disable_sigpipe ();
-
- connection->refcount.value = 1;
+
+ /* initialized to 0: use atomic op to avoid mixing atomic and non-atomic */
+ _dbus_atomic_inc (&connection->refcount);
connection->transport = transport;
connection->watches = watch_list;
connection->timeouts = timeout_list;
_dbus_assert (connection->generation == _dbus_current_generation);
HAVE_LOCK_CHECK (connection);
-
-#ifdef DBUS_HAVE_ATOMIC_INT
+
_dbus_atomic_inc (&connection->refcount);
-#else
- _dbus_assert (connection->refcount.value > 0);
- connection->refcount.value += 1;
-#endif
return connection;
}
_dbus_assert (connection != NULL);
- /* The connection lock is better than the global
- * lock in the atomic increment fallback
- */
-
-#ifdef DBUS_HAVE_ATOMIC_INT
last_unref = (_dbus_atomic_dec (&connection->refcount) == 1);
-#else
- _dbus_assert (connection->refcount.value > 0);
- connection->refcount.value -= 1;
- last_unref = (connection->refcount.value == 0);
-#if 0
- printf ("unref_unlocked() connection %p count = %d\n", connection, connection->refcount.value);
-#endif
-#endif
-
if (last_unref)
_dbus_connection_last_unref (connection);
}
if (preallocated == NULL)
return NULL;
- if (connection->link_cache != NULL)
- {
- preallocated->queue_link =
- _dbus_list_pop_first_link (&connection->link_cache);
- preallocated->queue_link->data = NULL;
- }
- else
- {
- preallocated->queue_link = _dbus_list_alloc_link (NULL);
- if (preallocated->queue_link == NULL)
- goto failed_0;
- }
-
- if (connection->link_cache != NULL)
- {
- preallocated->counter_link =
- _dbus_list_pop_first_link (&connection->link_cache);
- preallocated->counter_link->data = connection->outgoing_counter;
- }
- else
- {
- preallocated->counter_link = _dbus_list_alloc_link (connection->outgoing_counter);
- if (preallocated->counter_link == NULL)
- goto failed_1;
- }
+ preallocated->queue_link = _dbus_list_alloc_link (NULL);
+ if (preallocated->queue_link == NULL)
+ goto failed_0;
+
+ preallocated->counter_link = _dbus_list_alloc_link (connection->outgoing_counter);
+ if (preallocated->counter_link == NULL)
+ goto failed_1;
_dbus_counter_ref (preallocated->counter_link->data);
_dbus_list_prepend_link (&connection->outgoing_messages,
preallocated->queue_link);
+ /* It's OK that we'll never call the notify function, because for the
+ * outgoing limit, there isn't one */
_dbus_message_add_counter_link (message,
preallocated->counter_link);
void
_dbus_connection_close_if_only_one_ref (DBusConnection *connection)
{
+ dbus_int32_t refcount;
+
CONNECTION_LOCK (connection);
-
- _dbus_assert (connection->refcount.value > 0);
- if (connection->refcount.value == 1)
+ refcount = _dbus_atomic_get (&connection->refcount);
+ /* The caller should have at least one ref */
+ _dbus_assert (refcount >= 1);
+
+ if (refcount == 1)
_dbus_connection_close_possibly_shared_and_unlock (connection);
else
CONNECTION_UNLOCK (connection);
{
_dbus_return_val_if_fail (connection != NULL, NULL);
_dbus_return_val_if_fail (connection->generation == _dbus_current_generation, NULL);
-
- /* The connection lock is better than the global
- * lock in the atomic increment fallback
- *
- * (FIXME but for now we always use the atomic version,
- * to avoid taking the connection lock, due to
- * the mess with set_timeout_functions()/set_watch_functions()
- * calling out to the app without dropping locks)
- */
-
-#if 1
- _dbus_atomic_inc (&connection->refcount);
-#else
- CONNECTION_LOCK (connection);
- _dbus_assert (connection->refcount.value > 0);
- connection->refcount.value += 1;
- CONNECTION_UNLOCK (connection);
-#endif
+ _dbus_atomic_inc (&connection->refcount);
return connection;
}
DBusMessage *message = element;
DBusConnection *connection = data;
- _dbus_message_remove_counter (message,
- connection->outgoing_counter,
- NULL);
+ _dbus_message_remove_counter (message, connection->outgoing_counter);
dbus_message_unref (message);
}
DBusList *link;
_dbus_verbose ("Finalizing connection %p\n", connection);
-
- _dbus_assert (connection->refcount.value == 0);
-
+
+ _dbus_assert (_dbus_atomic_get (&connection->refcount) == 0);
+
/* You have to disconnect the connection before unref:ing it. Otherwise
* you won't get the disconnected message.
*/
_dbus_list_free_link (connection->disconnect_message_link);
}
- _dbus_list_clear (&connection->link_cache);
-
_dbus_condvar_free_at_location (&connection->dispatch_cond);
_dbus_condvar_free_at_location (&connection->io_path_cond);
_dbus_return_if_fail (connection != NULL);
_dbus_return_if_fail (connection->generation == _dbus_current_generation);
-
- /* The connection lock is better than the global
- * lock in the atomic increment fallback
- *
- * (FIXME but for now we always use the atomic version,
- * to avoid taking the connection lock, due to
- * the mess with set_timeout_functions()/set_watch_functions()
- * calling out to the app without dropping locks)
- */
-
-#if 1
- last_unref = (_dbus_atomic_dec (&connection->refcount) == 1);
-#else
- CONNECTION_LOCK (connection);
-
- _dbus_assert (connection->refcount.value > 0);
- connection->refcount.value -= 1;
- last_unref = (connection->refcount.value == 0);
+ last_unref = (_dbus_atomic_dec (&connection->refcount) == 1);
-#if 0
- printf ("unref() connection %p count = %d\n", connection, connection->refcount.value);
-#endif
-
- CONNECTION_UNLOCK (connection);
-#endif
-
if (last_unref)
{
#ifndef DBUS_DISABLE_CHECKS
* This function can be used to do runtime checking for types that
* might be unknown to the specific D-Bus client implementation
* version, i.e. it will return FALSE for all types this
- * implementation does not know.
+ * implementation does not know, including invalid or reserved types.
*
* @param connection the connection
* @param type the type to check
{
_dbus_return_val_if_fail (connection != NULL, FALSE);
- if (!_dbus_type_is_valid(type))
+ if (!dbus_type_is_valid (type))
return FALSE;
if (type != DBUS_TYPE_UNIX_FD)
DBusPendingCall *pending = data;
connection = _dbus_pending_call_get_connection_and_lock (pending);
+ _dbus_connection_ref_unlocked (connection);
_dbus_pending_call_queue_timeout_error_unlocked (pending,
connection);
/* Unlocks, and calls out to user code */
_dbus_connection_update_dispatch_status_and_unlock (connection, status);
+ dbus_connection_unref (connection);
return TRUE;
}
*
* If -1 is passed for the timeout, a sane default timeout is used. -1
* is typically the best value for the timeout for this reason, unless
- * you want a very short or very long timeout. If INT_MAX is passed for
- * the timeout, no timeout will be set and the call will block forever.
+ * you want a very short or very long timeout. If #DBUS_TIMEOUT_INFINITE is
+ * passed for the timeout, no timeout will be set and the call will block
+ * forever.
*
* @warning if the connection is disconnected or you try to send Unix
* file descriptors on a connection that does not support them, the
* object, or #NULL if connection is disconnected or when you try to
* send Unix file descriptors on a connection that does not support
* them.
- * @param timeout_milliseconds timeout in milliseconds, -1 for default or INT_MAX for no timeout
+ * @param timeout_milliseconds timeout in milliseconds, -1 (or
+ * #DBUS_TIMEOUT_USE_DEFAULT) for default or #DBUS_TIMEOUT_INFINITE for no
+ * timeout
* @returns #FALSE if no memory, #TRUE otherwise.
*
*/
*
* @param connection the connection
* @param message the message to send
- * @param timeout_milliseconds timeout in milliseconds, -1 for default or INT_MAX for no timeout.
+ * @param timeout_milliseconds timeout in milliseconds, -1 (or
+ * #DBUS_TIMEOUT_USE_DEFAULT) for default or #DBUS_TIMEOUT_INFINITE for no
+ * timeout
* @param error return location for error message
* @returns the message that is the reply or #NULL with an error code if the
* function fails.
while ((link = _dbus_list_get_last_link (&connection->outgoing_messages)))
{
- _dbus_connection_message_sent (connection, link->data);
+ _dbus_connection_message_sent_unlocked (connection, link->data);
}
}
}
_dbus_connection_peer_filter_unlocked_no_update (DBusConnection *connection,
DBusMessage *message)
{
+ dbus_bool_t sent = FALSE;
+ DBusMessage *ret = NULL;
+ DBusList *expire_link;
+
if (connection->route_peer_messages && dbus_message_get_destination (message) != NULL)
{
/* This means we're letting the bus route this message */
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
- else if (dbus_message_is_method_call (message,
- DBUS_INTERFACE_PEER,
- "Ping"))
+
+ if (!dbus_message_has_interface (message, DBUS_INTERFACE_PEER))
+ {
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ /* Preallocate a linked-list link, so that if we need to dispose of a
+ * message, we can attach it to the expired list */
+ expire_link = _dbus_list_alloc_link (NULL);
+
+ if (!expire_link)
+ return DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+ if (dbus_message_is_method_call (message,
+ DBUS_INTERFACE_PEER,
+ "Ping"))
{
- DBusMessage *ret;
- dbus_bool_t sent;
-
ret = dbus_message_new_method_return (message);
if (ret == NULL)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
-
- sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
-
- dbus_message_unref (ret);
+ goto out;
- if (!sent)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
-
- return DBUS_HANDLER_RESULT_HANDLED;
+ sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
}
else if (dbus_message_is_method_call (message,
DBUS_INTERFACE_PEER,
"GetMachineId"))
{
- DBusMessage *ret;
- dbus_bool_t sent;
DBusString uuid;
ret = dbus_message_new_method_return (message);
if (ret == NULL)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ goto out;
- sent = FALSE;
_dbus_string_init (&uuid);
if (_dbus_get_local_machine_uuid_encoded (&uuid))
{
}
}
_dbus_string_free (&uuid);
-
- dbus_message_unref (ret);
-
- if (!sent)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
-
- return DBUS_HANDLER_RESULT_HANDLED;
}
- else if (dbus_message_has_interface (message, DBUS_INTERFACE_PEER))
+ else
{
/* We need to bounce anything else with this interface, otherwise apps
* could start extending the interface and when we added extensions
* here to DBusConnection we'd break those apps.
*/
-
- DBusMessage *ret;
- dbus_bool_t sent;
-
ret = dbus_message_new_error (message,
DBUS_ERROR_UNKNOWN_METHOD,
"Unknown method invoked on org.freedesktop.DBus.Peer interface");
if (ret == NULL)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
-
+ goto out;
+
sent = _dbus_connection_send_unlocked_no_update (connection, ret, NULL);
-
- dbus_message_unref (ret);
-
- if (!sent)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
-
- return DBUS_HANDLER_RESULT_HANDLED;
+ }
+
+out:
+ if (ret == NULL)
+ {
+ _dbus_list_free_link (expire_link);
}
else
{
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ /* It'll be safe to unref the reply when we unlock */
+ expire_link->data = ret;
+ _dbus_list_prepend_link (&connection->expired_messages, expire_link);
}
+
+ if (!sent)
+ return DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+ return DBUS_HANDLER_RESULT_HANDLED;
}
/**
DBusPendingCall *pending;
dbus_int32_t reply_serial;
DBusDispatchStatus status;
+ dbus_bool_t found_object;
_dbus_return_val_if_fail (connection != NULL, DBUS_DISPATCH_COMPLETE);
/* unlocks and calls user code */
_dbus_connection_update_dispatch_status_and_unlock (connection,
DBUS_DISPATCH_NEED_MEMORY);
-
- if (pending)
- dbus_pending_call_unref (pending);
dbus_connection_unref (connection);
return DBUS_DISPATCH_NEED_MEMORY;
HAVE_LOCK_CHECK (connection);
result = _dbus_object_tree_dispatch_and_unlock (connection->objects,
- message);
+ message,
+ &found_object);
CONNECTION_LOCK (connection);
DBusMessage *reply;
DBusString str;
DBusPreallocatedSend *preallocated;
+ DBusList *expire_link;
_dbus_verbose (" sending error %s\n",
DBUS_ERROR_UNKNOWN_METHOD);
-
+
if (!_dbus_string_init (&str))
{
result = DBUS_HANDLER_RESULT_NEED_MEMORY;
}
reply = dbus_message_new_error (message,
- DBUS_ERROR_UNKNOWN_METHOD,
+ found_object ? DBUS_ERROR_UNKNOWN_METHOD : DBUS_ERROR_UNKNOWN_OBJECT,
_dbus_string_get_const_data (&str));
_dbus_string_free (&str);
_dbus_verbose ("no memory for error reply in dispatch\n");
goto out;
}
-
+
+ expire_link = _dbus_list_alloc_link (reply);
+
+ if (expire_link == NULL)
+ {
+ dbus_message_unref (reply);
+ result = DBUS_HANDLER_RESULT_NEED_MEMORY;
+ _dbus_verbose ("no memory for error send in dispatch\n");
+ goto out;
+ }
+
preallocated = _dbus_connection_preallocate_send_unlocked (connection);
if (preallocated == NULL)
{
+ _dbus_list_free_link (expire_link);
+ /* It's OK that this is finalized, because it hasn't been seen by
+ * anything that could attach user callbacks */
dbus_message_unref (reply);
result = DBUS_HANDLER_RESULT_NEED_MEMORY;
_dbus_verbose ("no memory for error send in dispatch\n");
_dbus_connection_send_preallocated_unlocked_no_update (connection, preallocated,
reply, NULL);
+ /* reply will be freed when we release the lock */
+ _dbus_list_prepend_link (&connection->expired_messages, expire_link);
- dbus_message_unref (reply);
-
result = DBUS_HANDLER_RESULT_HANDLED;
}
*/
_dbus_connection_putback_message_link_unlocked (connection,
message_link);
+ /* now we don't want to free them */
+ message_link = NULL;
+ message = NULL;
}
else
{
_dbus_verbose (" ... done dispatching\n");
-
- _dbus_list_free_link (message_link);
- dbus_message_unref (message); /* don't want the message to count in max message limits
- * in computing dispatch status below
- */
}
-
+
_dbus_connection_release_dispatch (connection);
HAVE_LOCK_CHECK (connection);
+ if (message != NULL)
+ {
+ /* We don't want this message to count in maximum message limits when
+ * computing the dispatch status, below. We have to drop the lock
+ * temporarily, because finalizing a message can trigger callbacks.
+ *
+ * We have a reference to the connection, and we don't use any cached
+ * pointers to the connection's internals below this point, so it should
+ * be safe to drop the lock and take it back. */
+ CONNECTION_UNLOCK (connection);
+ dbus_message_unref (message);
+ CONNECTION_LOCK (connection);
+ }
+
+ if (message_link != NULL)
+ _dbus_list_free_link (message_link);
+
_dbus_verbose ("before final status update\n");
status = _dbus_connection_get_dispatch_status_unlocked (connection);
if (filter == NULL)
return FALSE;
- filter->refcount.value = 1;
-
+ _dbus_atomic_inc (&filter->refcount);
+
CONNECTION_LOCK (connection);
if (!_dbus_list_append (&connection->filter_list,
}
/**
- * Registers a handler for a given path in the object hierarchy.
- * The given vtable handles messages sent to exactly the given path.
+ * Registers a handler for a given path or subsection in the object
+ * hierarchy. The given vtable handles messages sent to exactly the
+ * given path or also for paths bellow that, depending on fallback
+ * parameter.
*
* @param connection the connection
+ * @param fallback whether to handle messages also for "subdirectory"
* @param path a '/' delimited string of path elements
* @param vtable the virtual table
* @param user_data data to pass to functions in the vtable
* @param error address where an error can be returned
* @returns #FALSE if an error (#DBUS_ERROR_NO_MEMORY or
- * #DBUS_ERROR_ADDRESS_IN_USE) is reported
+ * #DBUS_ERROR_OBJECT_PATH_IN_USE) is reported
*/
-dbus_bool_t
-dbus_connection_try_register_object_path (DBusConnection *connection,
- const char *path,
- const DBusObjectPathVTable *vtable,
- void *user_data,
- DBusError *error)
+static dbus_bool_t
+_dbus_connection_register_object_path (DBusConnection *connection,
+ dbus_bool_t fallback,
+ const char *path,
+ const DBusObjectPathVTable *vtable,
+ void *user_data,
+ DBusError *error)
{
char **decomposed_path;
dbus_bool_t retval;
-
- _dbus_return_val_if_fail (connection != NULL, FALSE);
- _dbus_return_val_if_fail (path != NULL, FALSE);
- _dbus_return_val_if_fail (path[0] == '/', FALSE);
- _dbus_return_val_if_fail (vtable != NULL, FALSE);
if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
return FALSE;
CONNECTION_LOCK (connection);
retval = _dbus_object_tree_register (connection->objects,
- FALSE,
+ fallback,
(const char **) decomposed_path, vtable,
user_data, error);
* Registers a handler for a given path in the object hierarchy.
* The given vtable handles messages sent to exactly the given path.
*
+ * @param connection the connection
+ * @param path a '/' delimited string of path elements
+ * @param vtable the virtual table
+ * @param user_data data to pass to functions in the vtable
+ * @param error address where an error can be returned
+ * @returns #FALSE if an error (#DBUS_ERROR_NO_MEMORY or
+ * #DBUS_ERROR_OBJECT_PATH_IN_USE) is reported
+ */
+dbus_bool_t
+dbus_connection_try_register_object_path (DBusConnection *connection,
+ const char *path,
+ const DBusObjectPathVTable *vtable,
+ void *user_data,
+ DBusError *error)
+{
+ _dbus_return_val_if_fail (connection != NULL, FALSE);
+ _dbus_return_val_if_fail (path != NULL, FALSE);
+ _dbus_return_val_if_fail (path[0] == '/', FALSE);
+ _dbus_return_val_if_fail (vtable != NULL, FALSE);
+
+ return _dbus_connection_register_object_path (connection, FALSE, path, vtable, user_data, error);
+}
+
+/**
+ * Registers a handler for a given path in the object hierarchy.
+ * The given vtable handles messages sent to exactly the given path.
+ *
* It is a bug to call this function for object paths which already
* have a handler. Use dbus_connection_try_register_object_path() if this
* might be the case.
* @param path a '/' delimited string of path elements
* @param vtable the virtual table
* @param user_data data to pass to functions in the vtable
- * @returns #FALSE if not enough memory
+ * @returns #FALSE if an error (#DBUS_ERROR_NO_MEMORY or
+ * #DBUS_ERROR_OBJECT_PATH_IN_USE) ocurred
*/
dbus_bool_t
dbus_connection_register_object_path (DBusConnection *connection,
const DBusObjectPathVTable *vtable,
void *user_data)
{
- char **decomposed_path;
dbus_bool_t retval;
DBusError error = DBUS_ERROR_INIT;
_dbus_return_val_if_fail (path[0] == '/', FALSE);
_dbus_return_val_if_fail (vtable != NULL, FALSE);
- if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
- return FALSE;
-
- CONNECTION_LOCK (connection);
-
- retval = _dbus_object_tree_register (connection->objects,
- FALSE,
- (const char **) decomposed_path, vtable,
- user_data, &error);
-
- CONNECTION_UNLOCK (connection);
-
- dbus_free_string_array (decomposed_path);
+ retval = _dbus_connection_register_object_path (connection, FALSE, path, vtable, user_data, &error);
- if (dbus_error_has_name (&error, DBUS_ERROR_ADDRESS_IN_USE))
+ if (dbus_error_has_name (&error, DBUS_ERROR_OBJECT_PATH_IN_USE))
{
_dbus_warn ("%s\n", error.message);
dbus_error_free (&error);
* @param user_data data to pass to functions in the vtable
* @param error address where an error can be returned
* @returns #FALSE if an error (#DBUS_ERROR_NO_MEMORY or
- * #DBUS_ERROR_ADDRESS_IN_USE) is reported
+ * #DBUS_ERROR_OBJECT_PATH_IN_USE) is reported
*/
dbus_bool_t
dbus_connection_try_register_fallback (DBusConnection *connection,
void *user_data,
DBusError *error)
{
- char **decomposed_path;
- dbus_bool_t retval;
-
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (path != NULL, FALSE);
_dbus_return_val_if_fail (path[0] == '/', FALSE);
_dbus_return_val_if_fail (vtable != NULL, FALSE);
- if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
- return FALSE;
-
- CONNECTION_LOCK (connection);
-
- retval = _dbus_object_tree_register (connection->objects,
- TRUE,
- (const char **) decomposed_path, vtable,
- user_data, error);
-
- CONNECTION_UNLOCK (connection);
-
- dbus_free_string_array (decomposed_path);
-
- return retval;
+ return _dbus_connection_register_object_path (connection, TRUE, path, vtable, user_data, error);
}
/**
* @param path a '/' delimited string of path elements
* @param vtable the virtual table
* @param user_data data to pass to functions in the vtable
- * @returns #FALSE if not enough memory
+ * @returns #FALSE if an error (#DBUS_ERROR_NO_MEMORY or
+ * #DBUS_ERROR_OBJECT_PATH_IN_USE) occured
*/
dbus_bool_t
dbus_connection_register_fallback (DBusConnection *connection,
const DBusObjectPathVTable *vtable,
void *user_data)
{
- char **decomposed_path;
dbus_bool_t retval;
DBusError error = DBUS_ERROR_INIT;
_dbus_return_val_if_fail (path[0] == '/', FALSE);
_dbus_return_val_if_fail (vtable != NULL, FALSE);
- if (!_dbus_decompose_path (path, strlen (path), &decomposed_path, NULL))
- return FALSE;
-
- CONNECTION_LOCK (connection);
-
- retval = _dbus_object_tree_register (connection->objects,
- TRUE,
- (const char **) decomposed_path, vtable,
- user_data, &error);
-
- CONNECTION_UNLOCK (connection);
-
- dbus_free_string_array (decomposed_path);
+ retval = _dbus_connection_register_object_path (connection, TRUE, path, vtable, user_data, &error);
- if (dbus_error_has_name (&error, DBUS_ERROR_ADDRESS_IN_USE))
+ if (dbus_error_has_name (&error, DBUS_ERROR_OBJECT_PATH_IN_USE))
{
_dbus_warn ("%s\n", error.message);
dbus_error_free (&error);
return res;
}
+#ifdef DBUS_ENABLE_STATS
+void
+_dbus_connection_get_stats (DBusConnection *connection,
+ dbus_uint32_t *in_messages,
+ dbus_uint32_t *in_bytes,
+ dbus_uint32_t *in_fds,
+ dbus_uint32_t *in_peak_bytes,
+ dbus_uint32_t *in_peak_fds,
+ dbus_uint32_t *out_messages,
+ dbus_uint32_t *out_bytes,
+ dbus_uint32_t *out_fds,
+ dbus_uint32_t *out_peak_bytes,
+ dbus_uint32_t *out_peak_fds)
+{
+ CONNECTION_LOCK (connection);
+
+ if (in_messages != NULL)
+ *in_messages = connection->n_incoming;
+
+ _dbus_transport_get_stats (connection->transport,
+ in_bytes, in_fds, in_peak_bytes, in_peak_fds);
+
+ if (out_messages != NULL)
+ *out_messages = connection->n_outgoing;
+
+ if (out_bytes != NULL)
+ *out_bytes = _dbus_counter_get_size_value (connection->outgoing_counter);
+
+ if (out_fds != NULL)
+ *out_fds = _dbus_counter_get_unix_fd_value (connection->outgoing_counter);
+
+ if (out_peak_bytes != NULL)
+ *out_peak_bytes = _dbus_counter_get_peak_size_value (connection->outgoing_counter);
+
+ if (out_peak_fds != NULL)
+ *out_peak_fds = _dbus_counter_get_peak_unix_fd_value (connection->outgoing_counter);
+
+ CONNECTION_UNLOCK (connection);
+}
+#endif /* DBUS_ENABLE_STATS */
+
/**
* Gets the approximate number of uni fds of all messages in the
* outgoing message queue.
projects / platform / upstream / dbus.git / blobdiff