/* dbus-connection.c DBusConnection object
*
* Copyright (C) 2002-2006 Red Hat Inc.
+ * Copyright (C) 2013 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
#include "dbus-threads-internal.h"
#include "dbus-bus.h"
#include "dbus-marshal-basic.h"
+#ifdef ENABLE_KDBUS_TRANSPORT
+#include "dbus-transport-kdbus.h"
+#include <stdlib.h>
+#endif
#ifdef DBUS_DISABLE_CHECKS
#define TOOK_LOCK_CHECK(connection)
#define CONNECTION_LOCK(connection) do { \
if (TRACE_LOCKS) { _dbus_verbose ("LOCK\n"); } \
- _dbus_mutex_lock ((connection)->mutex); \
+ _dbus_rmutex_lock ((connection)->mutex); \
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); \
+ _dbus_rmutex_lock ((connection)->slot_mutex); \
} while (0)
#define SLOTS_UNLOCK(connection) do { \
- _dbus_mutex_unlock ((connection)->slot_mutex); \
+ _dbus_rmutex_unlock ((connection)->slot_mutex); \
} while (0)
#define DISPATCH_STATUS_NAME(s) \
* @{
*/
+static void
+_dbus_connection_trace_ref (DBusConnection *connection,
+ int old_refcount,
+ int new_refcount,
+ const char *why)
+{
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ static int enabled = -1;
+
+ _dbus_trace_ref ("DBusConnection", connection, old_refcount, new_refcount,
+ why, "DBUS_CONNECTION_TRACE", &enabled);
+#endif
+}
+
/**
* Internal struct representing a message filter function
*/
{
DBusAtomic refcount; /**< Reference count. */
- DBusMutex *mutex; /**< Lock on the entire DBusConnection */
+ DBusRMutex *mutex; /**< Lock on the entire DBusConnection */
- DBusMutex *dispatch_mutex; /**< Protects dispatch_acquired */
+ DBusCMutex *dispatch_mutex; /**< Protects dispatch_acquired */
DBusCondVar *dispatch_cond; /**< Notify when dispatch_acquired is available */
- DBusMutex *io_path_mutex; /**< Protects io_path_acquired */
+ DBusCMutex *io_path_mutex; /**< Protects io_path_acquired */
DBusCondVar *io_path_cond; /**< Notify when io_path_acquired is available */
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
DBusList *filter_list; /**< List of filters. */
- DBusMutex *slot_mutex; /**< Lock on slot_list so overall connection lock need not be taken */
+ DBusRMutex *slot_mutex; /**< Lock on slot_list so overall connection lock need not be taken */
DBusDataSlotList slot_list; /**< Data stored by allocated integer ID */
DBusHashTable *pending_replies; /**< Hash of message serials to #DBusPendingCall. */
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 */
#ifndef DBUS_DISABLE_CHECKS
unsigned int have_connection_lock : 1; /**< Used to check locking */
#endif
-
-#ifndef DBUS_DISABLE_CHECKS
+
+#if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)
int generation; /**< _dbus_current_generation that should correspond to this connection */
#endif
};
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_rmutex_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);
+ }
}
/**
(*connection->wakeup_main_function) (connection->wakeup_main_data);
}
-#ifdef DBUS_BUILD_TESTS
-/* For now this function isn't used */
-/**
- * Adds a message to the incoming message queue, returning #FALSE
- * if there's insufficient memory to queue the message.
- * Does not take over refcount of the message.
- *
- * @param connection the connection.
- * @param message the message to queue.
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_connection_queue_received_message (DBusConnection *connection,
- DBusMessage *message)
-{
- DBusList *link;
-
- link = _dbus_list_alloc_link (message);
- if (link == NULL)
- return FALSE;
-
- dbus_message_ref (message);
- _dbus_connection_queue_received_message_link (connection, link);
-
- return TRUE;
-}
-
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
/**
* Gets the locks so we can examine them
*
DBusCondVar **dispatch_cond_loc,
DBusCondVar **io_path_cond_loc)
{
- *mutex_loc = connection->mutex;
- *dispatch_mutex_loc = connection->dispatch_mutex;
- *io_path_mutex_loc = connection->io_path_mutex;
+ *mutex_loc = (DBusMutex *) connection->mutex;
+ *dispatch_mutex_loc = (DBusMutex *) connection->dispatch_mutex;
+ *io_path_mutex_loc = (DBusMutex *) connection->io_path_mutex;
*dispatch_cond_loc = connection->dispatch_cond;
*io_path_cond_loc = connection->io_path_cond;
}
DBusPendingCall *pending;
dbus_uint32_t reply_serial;
DBusMessage *message;
-
- _dbus_assert (_dbus_transport_get_is_authenticated (connection->transport));
-
+
+ _dbus_assert (_dbus_transport_peek_is_authenticated (connection->transport));
+
_dbus_list_append_link (&connection->incoming_messages,
link);
message = link->data;
dbus_message_get_signature (message),
dbus_message_get_reply_serial (message),
connection,
- connection->n_incoming);}
+ connection->n_incoming);
+
+ _dbus_message_trace_ref (message, -1, -1,
+ "_dbus_conection_queue_received_message_link");
+}
/**
* Adds a link + message to the incoming message queue.
connection->n_incoming += 1;
_dbus_connection_wakeup_mainloop (connection);
-
+
+ _dbus_message_trace_ref (link->data, -1, -1,
+ "_dbus_connection_queue_synthesized_message_link");
+
_dbus_verbose ("Synthesized message %p added to incoming queue %p, %d incoming\n",
link->data, connection, connection->n_incoming);
}
* @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 */
CONNECTION_UNLOCK (connection);
_dbus_verbose ("locking io_path_mutex\n");
- _dbus_mutex_lock (connection->io_path_mutex);
+ _dbus_cmutex_lock (connection->io_path_mutex);
_dbus_verbose ("start connection->io_path_acquired = %d timeout = %d\n",
connection->io_path_acquired, timeout_milliseconds);
connection->io_path_acquired, we_acquired);
_dbus_verbose ("unlocking io_path_mutex\n");
- _dbus_mutex_unlock (connection->io_path_mutex);
+ _dbus_cmutex_unlock (connection->io_path_mutex);
CONNECTION_LOCK (connection);
HAVE_LOCK_CHECK (connection);
_dbus_verbose ("locking io_path_mutex\n");
- _dbus_mutex_lock (connection->io_path_mutex);
+ _dbus_cmutex_lock (connection->io_path_mutex);
_dbus_assert (connection->io_path_acquired);
_dbus_condvar_wake_one (connection->io_path_cond);
_dbus_verbose ("unlocking io_path_mutex\n");
- _dbus_mutex_unlock (connection->io_path_mutex);
+ _dbus_cmutex_unlock (connection->io_path_mutex);
}
/**
*
* @param transport the transport.
* @returns the new connection, or #NULL on failure.
- */
+*/
+#ifdef ENABLE_KDBUS_TRANSPORT
+static DBusConnection*
+_dbus_connection_new_for_transport_internal (DBusTransport *transport, dbus_bool_t exists)
+#else
DBusConnection*
_dbus_connection_new_for_transport (DBusTransport *transport)
+#endif
{
DBusConnection *connection;
DBusWatchList *watch_list;
pending_replies =
_dbus_hash_table_new (DBUS_HASH_INT,
- NULL,
+ NULL,
(DBusFreeFunction)free_pending_call_on_hash_removal);
if (pending_replies == NULL)
goto error;
if (connection == NULL)
goto error;
- _dbus_mutex_new_at_location (&connection->mutex);
+ _dbus_rmutex_new_at_location (&connection->mutex);
if (connection->mutex == NULL)
goto error;
- _dbus_mutex_new_at_location (&connection->io_path_mutex);
+ _dbus_cmutex_new_at_location (&connection->io_path_mutex);
if (connection->io_path_mutex == NULL)
goto error;
- _dbus_mutex_new_at_location (&connection->dispatch_mutex);
+ _dbus_cmutex_new_at_location (&connection->dispatch_mutex);
if (connection->dispatch_mutex == NULL)
goto error;
if (connection->io_path_cond == NULL)
goto error;
- _dbus_mutex_new_at_location (&connection->slot_mutex);
+ _dbus_rmutex_new_at_location (&connection->slot_mutex);
if (connection->slot_mutex == NULL)
goto error;
connection->route_peer_messages = FALSE;
connection->disconnected_message_arrived = FALSE;
connection->disconnected_message_processed = FALSE;
-
-#ifndef DBUS_DISABLE_CHECKS
+
+#if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)
connection->generation = _dbus_current_generation;
#endif
connection->disconnect_message_link = disconnect_link;
- CONNECTION_LOCK (connection);
-
- if (!_dbus_transport_set_connection (transport, connection))
- {
- CONNECTION_UNLOCK (connection);
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(!exists)
+#endif
+ {
+ CONNECTION_LOCK (connection);
- goto error;
- }
+ if (!_dbus_transport_set_connection (transport, connection))
+ {
+ CONNECTION_UNLOCK (connection);
- _dbus_transport_ref (transport);
+ goto error;
+ }
- CONNECTION_UNLOCK (connection);
-
+ _dbus_transport_ref (transport);
+
+ CONNECTION_UNLOCK (connection);
+ }
+
+ _dbus_connection_trace_ref (connection, 0, 1, "new_for_transport");
return connection;
error:
{
_dbus_condvar_free_at_location (&connection->io_path_cond);
_dbus_condvar_free_at_location (&connection->dispatch_cond);
- _dbus_mutex_free_at_location (&connection->mutex);
- _dbus_mutex_free_at_location (&connection->io_path_mutex);
- _dbus_mutex_free_at_location (&connection->dispatch_mutex);
- _dbus_mutex_free_at_location (&connection->slot_mutex);
+ _dbus_rmutex_free_at_location (&connection->mutex);
+ _dbus_cmutex_free_at_location (&connection->io_path_mutex);
+ _dbus_cmutex_free_at_location (&connection->dispatch_mutex);
+ _dbus_rmutex_free_at_location (&connection->slot_mutex);
dbus_free (connection);
}
if (pending_replies)
return NULL;
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+/**
+ * Creates a new connection for the given transport. A transport
+ * represents a message stream that uses some concrete mechanism, such
+ * as UNIX domain sockets. May return #NULL if insufficient
+ * memory exists to create the connection.
+ *
+ * @param transport the transport.
+ * @returns the new connection, or #NULL on failure.
+ */
+DBusConnection*
+_dbus_connection_new_for_transport (DBusTransport *transport)
+{
+ return _dbus_connection_new_for_transport_internal(transport, FALSE);
+}
+
+DBusConnection*
+_dbus_connection_new_for_used_transport (DBusTransport *transport)
+{
+ return _dbus_connection_new_for_transport_internal(transport, TRUE);
+}
+#endif
+
/**
* Increments the reference count of a DBusConnection.
* Requires that the caller already holds the connection lock.
*/
DBusConnection *
_dbus_connection_ref_unlocked (DBusConnection *connection)
-{
+{
+ dbus_int32_t old_refcount;
+
_dbus_assert (connection != NULL);
_dbus_assert (connection->generation == _dbus_current_generation);
HAVE_LOCK_CHECK (connection);
- _dbus_atomic_inc (&connection->refcount);
+ old_refcount = _dbus_atomic_inc (&connection->refcount);
+ _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
+ "ref_unlocked");
return connection;
}
void
_dbus_connection_unref_unlocked (DBusConnection *connection)
{
- dbus_bool_t last_unref;
+ dbus_int32_t old_refcount;
HAVE_LOCK_CHECK (connection);
-
+
_dbus_assert (connection != NULL);
- last_unref = (_dbus_atomic_dec (&connection->refcount) == 1);
+ old_refcount = _dbus_atomic_dec (&connection->refcount);
- if (last_unref)
+ _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
+ "unref_unlocked");
+
+ if (old_refcount == 1)
_dbus_connection_last_unref (connection);
}
return retval;
}
-_DBUS_DEFINE_GLOBAL_LOCK (shared_connections);
+/* Protected by _DBUS_LOCK (shared_connections) */
static DBusHashTable *shared_connections = NULL;
static DBusList *shared_connections_no_guid = NULL;
shared_connections_shutdown (void *data)
{
int n_entries;
-
- _DBUS_LOCK (shared_connections);
-
+
+ if (!_DBUS_LOCK (shared_connections))
+ {
+ /* We'd have initialized locks before adding anything, so there
+ * can't be anything there. */
+ return;
+ }
+
/* This is a little bit unpleasant... better ideas? */
while ((n_entries = _dbus_hash_table_get_n_entries (shared_connections)) > 0)
{
_DBUS_UNLOCK (shared_connections);
close_connection_on_shutdown (connection);
- _DBUS_LOCK (shared_connections);
+ if (!_DBUS_LOCK (shared_connections))
+ _dbus_assert_not_reached ("global locks were already initialized");
/* The connection should now be dead and not in our hash ... */
_dbus_assert (_dbus_hash_table_get_n_entries (shared_connections) < n_entries);
{
_DBUS_UNLOCK (shared_connections);
close_connection_on_shutdown (connection);
- _DBUS_LOCK (shared_connections);
+ if (!_DBUS_LOCK (shared_connections))
+ _dbus_assert_not_reached ("global locks were already initialized");
connection = _dbus_list_pop_first (&shared_connections_no_guid);
}
}
_dbus_verbose ("checking for existing connection\n");
*result = NULL;
-
- _DBUS_LOCK (shared_connections);
+
+ if (!_DBUS_LOCK (shared_connections))
+ {
+ /* If it was shared, we'd have initialized global locks when we put
+ * it in shared_connections. */
+ return FALSE;
+ }
if (shared_connections == NULL)
{
if (guid == NULL)
{
- _DBUS_LOCK (shared_connections);
+ if (!_DBUS_LOCK (shared_connections))
+ return FALSE;
if (!_dbus_list_prepend (&shared_connections_no_guid, connection))
{
dbus_free (guid_key);
return FALSE;
}
-
- _DBUS_LOCK (shared_connections);
+
+ if (!_DBUS_LOCK (shared_connections))
+ {
+ dbus_free (guid_in_connection);
+ dbus_free (guid_key);
+ return FALSE;
+ }
+
_dbus_assert (shared_connections != NULL);
if (!_dbus_hash_table_insert_string (shared_connections,
if (!connection->shareable)
return;
-
- _DBUS_LOCK (shared_connections);
-
+
+ if (!_DBUS_LOCK (shared_connections))
+ {
+ /* If it was shared, we'd have initialized global locks when we put
+ * it in the table; so it can't be there. */
+ return;
+ }
+
if (connection->server_guid != NULL)
{
_dbus_verbose ("dropping connection to %s out of the shared table\n",
#ifndef DBUS_DISABLE_CHECKS
_dbus_assert (!connection->have_connection_lock);
#endif
+
return 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);
* relatively long time for memory, if they were only willing to block
* briefly then we retry for memory at a rapid rate.
*
- * @timeout_milliseconds the timeout requested for blocking
+ * @param timeout_milliseconds the timeout requested for blocking
*/
static void
_dbus_memory_pause_based_on_timeout (int timeout_milliseconds)
_dbus_sleep_milliseconds (1000);
}
-static DBusMessage *
+DBusMessage *
generate_local_error_message (dbus_uint32_t serial,
char *error_name,
char *error_msg)
* below
*/
timeout = _dbus_pending_call_get_timeout_unlocked (pending);
- _dbus_get_current_time (&start_tv_sec, &start_tv_usec);
+ _dbus_get_monotonic_time (&start_tv_sec, &start_tv_usec);
if (timeout)
{
timeout_milliseconds = dbus_timeout_get_interval (timeout);
return;
}
- _dbus_get_current_time (&tv_sec, &tv_usec);
+ _dbus_get_monotonic_time (&tv_sec, &tv_usec);
elapsed_milliseconds = (tv_sec - start_tv_sec) * 1000 +
(tv_usec - start_tv_usec) / 1000;
DBusConnection *
dbus_connection_ref (DBusConnection *connection)
{
+ dbus_int32_t old_refcount;
+
_dbus_return_val_if_fail (connection != NULL, NULL);
_dbus_return_val_if_fail (connection->generation == _dbus_current_generation, NULL);
-
- _dbus_atomic_inc (&connection->refcount);
+ old_refcount = _dbus_atomic_inc (&connection->refcount);
+ _dbus_connection_trace_ref (connection, old_refcount, old_refcount + 1,
+ "ref");
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);
}
-/* This is run without the mutex held, but after the last reference
- * to the connection has been dropped we should have no thread-related
- * problems
- */
+#ifdef ENABLE_KDBUS_TRANSPORT
+static void
+_dbus_connection_last_unref_internal (DBusConnection *connection, dbus_bool_t unref_transport)
+#else
static void
_dbus_connection_last_unref (DBusConnection *connection)
+#endif
{
DBusList *link;
/* You have to disconnect the connection before unref:ing it. Otherwise
* you won't get the disconnected message.
*/
- _dbus_assert (!_dbus_transport_get_is_connected (connection->transport));
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(unref_transport)
+#endif
+ _dbus_assert (!_dbus_transport_get_is_connected (connection->transport));
_dbus_assert (connection->server_guid == NULL);
/* ---- We're going to call various application callbacks here, hope it doesn't break anything... */
dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
dbus_connection_set_wakeup_main_function (connection, NULL, NULL, NULL);
dbus_connection_set_unix_user_function (connection, NULL, NULL, NULL);
+ dbus_connection_set_windows_user_function (connection, NULL, NULL, NULL);
_dbus_watch_list_free (connection->watches);
connection->watches = NULL;
_dbus_list_foreach (&connection->outgoing_messages,
free_outgoing_message,
- connection);
+ connection);
_dbus_list_clear (&connection->outgoing_messages);
_dbus_list_foreach (&connection->incoming_messages,
- (DBusForeachFunction) dbus_message_unref,
- NULL);
+ (DBusForeachFunction) dbus_message_unref,
+ NULL);
_dbus_list_clear (&connection->incoming_messages);
_dbus_counter_unref (connection->outgoing_counter);
- _dbus_transport_unref (connection->transport);
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(unref_transport)
+#endif
+ _dbus_transport_unref (connection->transport);
if (connection->disconnect_message_link)
{
_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_mutex_free_at_location (&connection->io_path_mutex);
- _dbus_mutex_free_at_location (&connection->dispatch_mutex);
+ _dbus_cmutex_free_at_location (&connection->io_path_mutex);
+ _dbus_cmutex_free_at_location (&connection->dispatch_mutex);
- _dbus_mutex_free_at_location (&connection->slot_mutex);
+ _dbus_rmutex_free_at_location (&connection->slot_mutex);
- _dbus_mutex_free_at_location (&connection->mutex);
+ _dbus_rmutex_free_at_location (&connection->mutex);
dbus_free (connection);
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+/* This is run without the mutex held, but after the last reference
+ * to the connection has been dropped we should have no thread-related
+ * problems
+ */
+static void
+_dbus_connection_last_unref (DBusConnection *connection)
+{
+ _dbus_connection_last_unref_internal(connection, TRUE);
+}
+#endif
+
/**
* Decrements the reference count of a DBusConnection, and finalizes
* it if the count reaches zero.
void
dbus_connection_unref (DBusConnection *connection)
{
- dbus_bool_t last_unref;
+ dbus_int32_t old_refcount;
_dbus_return_if_fail (connection != NULL);
_dbus_return_if_fail (connection->generation == _dbus_current_generation);
- last_unref = (_dbus_atomic_dec (&connection->refcount) == 1);
+ old_refcount = _dbus_atomic_dec (&connection->refcount);
- if (last_unref)
+ _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1,
+ "unref");
+
+ if (old_refcount == 1)
{
#ifndef DBUS_DISABLE_CHECKS
if (_dbus_transport_get_is_connected (connection->transport))
}
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+void
+dbus_connection_unref_phantom (DBusConnection *connection)
+{
+ dbus_int32_t old_refcount;
+
+ _dbus_return_if_fail (connection != NULL);
+ _dbus_return_if_fail (connection->generation == _dbus_current_generation);
+
+ old_refcount = _dbus_atomic_dec (&connection->refcount);
+
+ _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1, "unref");
+
+ if (old_refcount == 1)
+ _dbus_connection_last_unref_internal(connection, FALSE);
+}
+#endif
+
/*
* Note that the transport can disconnect itself (other end drops us)
* and in that case this function never runs. So this function must
dbus_bool_t res;
_dbus_return_val_if_fail (connection != NULL, FALSE);
-
+
CONNECTION_LOCK (connection);
- res = _dbus_transport_get_is_authenticated (connection->transport);
+ res = _dbus_transport_try_to_authenticate (connection->transport);
CONNECTION_UNLOCK (connection);
return res;
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+/**
+ * Sets authenticated status for connection. Needed for kdbus, where authentication is
+ * made in different manner.
+ * LOCK commented out because called with lock already set
+ * @param connection the connection
+ */
+dbus_bool_t
+dbus_connection_set_is_authenticated (DBusConnection *connection)
+{
+ _dbus_return_val_if_fail (connection != NULL, FALSE);
+
+// CONNECTION_LOCK (connection);
+ connection->transport->authenticated = TRUE;
+// CONNECTION_UNLOCK (connection);
+
+ return TRUE;
+}
+#endif
+
/**
* Gets whether the connection is not authenticated as a specific
* user. If the connection is not authenticated, this function
CONNECTION_UNLOCK (connection);
+ _dbus_message_trace_ref (message, -1, -1, "dbus_connection_borrow_message");
+
/* We don't update dispatch status until it's returned or stolen */
return message;
status = _dbus_connection_get_dispatch_status_unlocked (connection);
_dbus_connection_update_dispatch_status_and_unlock (connection, status);
+
+ _dbus_message_trace_ref (message, -1, -1, "dbus_connection_return_message");
}
/**
pop_message = _dbus_list_pop_first (&connection->incoming_messages);
_dbus_assert (message == pop_message);
-
+ (void) pop_message; /* unused unless asserting */
+
connection->n_incoming -= 1;
_dbus_verbose ("Incoming message %p stolen from queue, %d incoming\n",
status = _dbus_connection_get_dispatch_status_unlocked (connection);
_dbus_connection_update_dispatch_status_and_unlock (connection, status);
+ _dbus_message_trace_ref (message, -1, -1,
+ "dbus_connection_steal_borrowed_message");
}
/* See dbus_connection_pop_message, but requires the caller to own
link = _dbus_list_pop_first_link (&connection->incoming_messages);
connection->n_incoming -= 1;
- _dbus_verbose ("Message %p (%s %s %s %s '%s') removed from incoming queue %p, %d incoming\n",
+ _dbus_verbose ("Message %p (%s %s %s %s sig:'%s' serial:%u) removed from incoming queue %p, %d incoming\n",
link->data,
dbus_message_type_to_string (dbus_message_get_type (link->data)),
dbus_message_get_path (link->data) ?
dbus_message_get_member (link->data) :
"no member",
dbus_message_get_signature (link->data),
+ dbus_message_get_serial (link->data),
connection, connection->n_incoming);
+ _dbus_message_trace_ref (link->data, -1, -1,
+ "_dbus_connection_pop_message_link_unlocked");
+
check_disconnected_message_arrived_unlocked (connection, link->data);
return link;
"no member",
dbus_message_get_signature (message_link->data),
connection, connection->n_incoming);
+
+ _dbus_message_trace_ref (message_link->data, -1, -1,
+ "_dbus_connection_putback_message_link_unlocked");
}
/**
CONNECTION_UNLOCK (connection);
_dbus_verbose ("locking dispatch_mutex\n");
- _dbus_mutex_lock (connection->dispatch_mutex);
+ _dbus_cmutex_lock (connection->dispatch_mutex);
while (connection->dispatch_acquired)
{
connection->dispatch_acquired = TRUE;
_dbus_verbose ("unlocking dispatch_mutex\n");
- _dbus_mutex_unlock (connection->dispatch_mutex);
+ _dbus_cmutex_unlock (connection->dispatch_mutex);
CONNECTION_LOCK (connection);
_dbus_connection_unref_unlocked (connection);
HAVE_LOCK_CHECK (connection);
_dbus_verbose ("locking dispatch_mutex\n");
- _dbus_mutex_lock (connection->dispatch_mutex);
+ _dbus_cmutex_lock (connection->dispatch_mutex);
_dbus_assert (connection->dispatch_acquired);
_dbus_condvar_wake_one (connection->dispatch_cond);
_dbus_verbose ("unlocking dispatch_mutex\n");
- _dbus_mutex_unlock (connection->dispatch_mutex);
+ _dbus_cmutex_unlock (connection->dispatch_mutex);
}
static void
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_get_dispatch_status_unlocked (DBusConnection *connection)
{
HAVE_LOCK_CHECK (connection);
-
+
if (connection->n_incoming > 0)
return DBUS_DISPATCH_DATA_REMAINS;
else if (!_dbus_transport_queue_messages (connection->transport))
{
DBusDispatchStatus status;
dbus_bool_t is_connected;
-
+
status = _dbus_transport_get_dispatch_status (connection->transport);
is_connected = _dbus_transport_get_is_connected (connection->transport);
_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);
+ goto out;
- dbus_message_unref (ret);
-
- 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;
}
/**
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;
_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);
return retval;
}
-
/**
* Gets the UNIX user ID of the connection if known. Returns #TRUE if
* the uid is filled in. Always returns #FALSE on non-UNIX platforms
* @param uid return location for the user ID
* @returns #TRUE if uid is filled in with a valid user ID
*/
+#ifdef ENABLE_KDBUS_TRANSPORT
+dbus_bool_t
+dbus_connection_get_unix_user_dbus (DBusConnection *connection,
+ unsigned long *uid)
+#else
dbus_bool_t
dbus_connection_get_unix_user (DBusConnection *connection,
unsigned long *uid)
+#endif
{
dbus_bool_t result;
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (uid != NULL, FALSE);
-
+
CONNECTION_LOCK (connection);
- if (!_dbus_transport_get_is_authenticated (connection->transport))
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
result = FALSE;
else
result = _dbus_transport_get_unix_user (connection->transport,
* @param pid return location for the process ID
* @returns #TRUE if uid is filled in with a valid process ID
*/
+#ifdef ENABLE_KDBUS_TRANSPORT
+dbus_bool_t
+dbus_connection_get_unix_process_id_dbus (DBusConnection *connection,
+ unsigned long *pid)
+#else
dbus_bool_t
dbus_connection_get_unix_process_id (DBusConnection *connection,
unsigned long *pid)
+#endif
{
dbus_bool_t result;
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (pid != NULL, FALSE);
-
+
CONNECTION_LOCK (connection);
- if (!_dbus_transport_get_is_authenticated (connection->transport))
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
result = FALSE;
else
result = _dbus_transport_get_unix_process_id (connection->transport,
* connection.
*
* @param connection the connection
- * @param data return location for audit data
+ * @param data return location for audit data
+ * @param data_size return location for length of audit data
* @returns #TRUE if audit data is filled in with a valid ucred pointer
*/
dbus_bool_t
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (data != NULL, FALSE);
_dbus_return_val_if_fail (data_size != NULL, FALSE);
-
+
CONNECTION_LOCK (connection);
- if (!_dbus_transport_get_is_authenticated (connection->transport))
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
result = FALSE;
else
result = _dbus_transport_get_adt_audit_session_data (connection->transport,
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (windows_sid_p != NULL, FALSE);
-
+
CONNECTION_LOCK (connection);
- if (!_dbus_transport_get_is_authenticated (connection->transport))
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
result = FALSE;
else
result = _dbus_transport_get_windows_user (connection->transport,
return retval;
}
-static DBusDataSlotAllocator slot_allocator;
-_DBUS_DEFINE_GLOBAL_LOCK (connection_slots);
+static DBusDataSlotAllocator slot_allocator =
+ _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (connection_slots));
/**
* Allocates an integer ID to be used for storing application-specific
dbus_connection_allocate_data_slot (dbus_int32_t *slot_p)
{
return _dbus_data_slot_allocator_alloc (&slot_allocator,
- &_DBUS_LOCK_NAME (connection_slots),
slot_p);
}
void *res;
_dbus_return_val_if_fail (connection != NULL, NULL);
-
+ _dbus_return_val_if_fail (slot >= 0, NULL);
+
SLOTS_LOCK (connection);
res = _dbus_data_slot_list_get (&slot_allocator,
* result in disconnecting the connection.
*
* @param connection a #DBusConnection
- * @param size maximum message unix fds the connection can receive
+ * @param n maximum message unix fds the connection can receive
*/
void
dbus_connection_set_max_message_unix_fds (DBusConnection *connection,
* The semantics are analogous to those of dbus_connection_set_max_received_size().
*
* @param connection the connection
- * @param size the maximum size in bytes of all outstanding messages
+ * @param n the maximum size in bytes of all outstanding messages
*/
void
dbus_connection_set_max_received_unix_fds (DBusConnection *connection,
dbus_uint32_t *out_bytes,
dbus_uint32_t *out_fds,
dbus_uint32_t *out_peak_bytes,
- dbus_uint32_t *out_peak_fds,
- dbus_uint32_t *link_cache_size)
+ dbus_uint32_t *out_peak_fds)
{
CONNECTION_LOCK (connection);
if (out_peak_fds != NULL)
*out_peak_fds = _dbus_counter_get_peak_unix_fd_value (connection->outgoing_counter);
- if (link_cache_size != NULL)
- {
- *link_cache_size = _dbus_list_get_length (&connection->link_cache) * sizeof (DBusList);
- }
-
CONNECTION_UNLOCK (connection);
}
#endif /* DBUS_ENABLE_STATS */
return res;
}
+/**
+ * Returns the address of the transport object of this connection
+ *
+ * @param connection the connection
+ * @returns the address string
+ */
+const char*
+_dbus_connection_get_address (DBusConnection *connection)
+{
+ return _dbus_transport_get_address (connection->transport);
+}
+
+#ifdef ENABLE_KDBUS_TRANSPORT
+DBusTransport*
+dbus_connection_get_transport(DBusConnection *connection)
+{
+ _dbus_return_val_if_fail (connection != NULL, NULL);
+
+ return connection->transport;
+}
+#endif
+
/** @} */