#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) _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) \
{
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 *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. */
#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
};
connection->expired_messages = NULL;
RELEASING_LOCK_CHECK (connection);
- _dbus_mutex_unlock (connection->mutex);
+ _dbus_rmutex_unlock (connection->mutex);
for (iter = _dbus_list_pop_first_link (&expired_messages);
iter != NULL;
(*connection->wakeup_main_function) (connection->wakeup_main_data);
}
-#ifdef DBUS_BUILD_TESTS
+#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;
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);
}
/**
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->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
{
_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 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",
* 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)
* 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;
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_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);
}
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;
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,
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
_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,
_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,
return res;
}
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
+/**
+ * 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);
+}
+#endif
+
/** @} */
projects / platform / upstream / dbus.git / blobdiff