summaryrefslogtreecommitdiffstats
path: root/dbus
diff options
context:
space:
mode:
Diffstat (limited to 'dbus')
-rw-r--r--dbus/dbus-connection.c87
-rw-r--r--dbus/dbus-connection.h31
-rw-r--r--dbus/dbus-dataslot.c20
-rw-r--r--dbus/dbus-message.c13
-rw-r--r--dbus/dbus-server-unix.c5
5 files changed, 128 insertions, 28 deletions
diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c
index 6fb4e84c..4990cff3 100644
--- a/dbus/dbus-connection.c
+++ b/dbus/dbus-connection.c
@@ -105,6 +105,10 @@ struct DBusConnection
int client_serial; /**< Client serial. Increments each time a message is sent */
DBusList *disconnect_message_link; /**< Preallocated list node for queueing the disconnection message */
+
+ DBusWakeupMainFunction wakeup_main_function; /**< Function to wake up the mainloop */
+ void *wakeup_main_data; /**< Application data for wakeup_main_function */
+ DBusFreeFunction free_wakeup_main_data; /**< free wakeup_main_data */
};
typedef struct
@@ -147,6 +151,19 @@ _dbus_connection_unlock (DBusConnection *connection)
dbus_mutex_unlock (connection->mutex);
}
+/**
+ * Wakes up the main loop if it is sleeping
+ * Needed if we're e.g. queueing outgoing messages
+ * on a thread while the mainloop sleeps.
+ *
+ * @param connection the connection.
+ */
+static void
+_dbus_connection_wakeup_mainloop (DBusConnection *connection)
+{
+ if (connection->wakeup_main_function)
+ (*connection->wakeup_main_function) (connection->wakeup_main_data);
+}
/**
* Adds a message to the incoming message queue, returning #FALSE
@@ -187,6 +204,8 @@ _dbus_connection_queue_received_message (DBusConnection *connection,
dbus_message_ref (message);
connection->n_incoming += 1;
+ _dbus_connection_wakeup_mainloop (connection);
+
_dbus_verbose ("Incoming message %p added to queue, %d incoming\n",
message, connection->n_incoming);
@@ -211,6 +230,8 @@ _dbus_connection_queue_synthesized_message_link (DBusConnection *connection,
connection->n_incoming += 1;
+ _dbus_connection_wakeup_mainloop (connection);
+
_dbus_verbose ("Incoming synthesized message %p added to queue, %d incoming\n",
link->data, connection->n_incoming);
}
@@ -388,13 +409,17 @@ _dbus_connection_acquire_io_path (DBusConnection *connection,
int timeout_milliseconds)
{
dbus_bool_t res = TRUE;
- if (timeout_milliseconds != -1)
- res = dbus_condvar_wait_timeout (connection->io_path_cond,
- connection->mutex,
- timeout_milliseconds);
- else
- dbus_condvar_wait (connection->io_path_cond, connection->mutex);
+ if (connection->io_path_acquired)
+ {
+ if (timeout_milliseconds != -1)
+ res = dbus_condvar_wait_timeout (connection->io_path_cond,
+ connection->mutex,
+ timeout_milliseconds);
+ else
+ dbus_condvar_wait (connection->io_path_cond, connection->mutex);
+ }
+
if (res)
{
_dbus_assert (!connection->io_path_acquired);
@@ -774,6 +799,9 @@ _dbus_connection_last_unref (DBusConnection *connection)
DBusHashIter iter;
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));
if (connection->connection_counter != NULL)
@@ -953,7 +981,7 @@ dbus_connection_get_is_authenticated (DBusConnection *connection)
dbus_bool_t
dbus_connection_send_message (DBusConnection *connection,
DBusMessage *message,
- dbus_int32_t *client_serial,
+ dbus_int32_t *client_serial,
DBusResultCode *result)
{
@@ -988,7 +1016,9 @@ dbus_connection_send_message (DBusConnection *connection,
if (connection->n_outgoing == 1)
_dbus_transport_messages_pending (connection->transport,
- connection->n_outgoing);
+ connection->n_outgoing);
+
+ _dbus_connection_wakeup_mainloop (connection);
dbus_mutex_unlock (connection->mutex);
@@ -1512,7 +1542,8 @@ dbus_connection_pop_message (DBusConnection *connection)
static void
_dbus_connection_acquire_dispatch (DBusConnection *connection)
{
- dbus_condvar_wait (connection->dispatch_cond, connection->mutex);
+ if (connection->dispatch_acquired)
+ dbus_condvar_wait (connection->dispatch_cond, connection->mutex);
_dbus_assert (!connection->dispatch_acquired);
connection->dispatch_acquired = TRUE;
@@ -1789,6 +1820,44 @@ dbus_connection_set_timeout_functions (DBusConnection *connection,
}
/**
+ * Sets the mainloop wakeup function for the connection. Thi function is
+ * responsible for waking up the main loop (if its sleeping) when some some
+ * change has happened to the connection that the mainloop needs to reconsiders
+ * (e.g. a message has been queued for writing).
+ * When using Qt, this typically results in a call to QEventLoop::wakeUp().
+ * When using GLib, it would call g_main_context_wakeup().
+ *
+ *
+ * @param connection the connection.
+ * @param wakeup_main_function function to wake up the mainloop
+ * @param data data to pass wakeup_main_function
+ * @param free_data_function function to be called to free the data.
+ */
+void
+dbus_connection_set_wakeup_main_function (DBusConnection *connection,
+ DBusWakeupMainFunction wakeup_main_function,
+ void *data,
+ DBusFreeFunction free_data_function)
+{
+ void *old_data;
+ DBusFreeFunction old_free_data;
+
+ dbus_mutex_lock (connection->mutex);
+ old_data = connection->wakeup_main_data;
+ old_free_data = connection->free_wakeup_main_data;
+
+ connection->wakeup_main_function = wakeup_main_function;
+ connection->wakeup_main_data = data;
+ connection->free_wakeup_main_data = free_data_function;
+
+ dbus_mutex_unlock (connection->mutex);
+
+ /* Callback outside the lock */
+ if (old_free_data)
+ (*old_free_data) (old_data);
+}
+
+/**
* Called to notify the connection when a previously-added watch
* is ready for reading or writing, or has an exception such
* as a hangup.
diff --git a/dbus/dbus-connection.h b/dbus/dbus-connection.h
index 5a91ce82..fd631c6d 100644
--- a/dbus/dbus-connection.h
+++ b/dbus/dbus-connection.h
@@ -61,6 +61,7 @@ typedef void (* DBusAddWatchFunction) (DBusWatch *watch,
typedef void (* DBusRemoveWatchFunction) (DBusWatch *watch,
void *data);
+typedef void (* DBusWakeupMainFunction) (void *data);
typedef void (* DBusAddTimeoutFunction) (DBusTimeout *timeout,
void *data);
typedef void (* DBusRemoveTimeoutFunction) (DBusTimeout *timeout,
@@ -99,19 +100,23 @@ DBusMessage *dbus_connection_send_message_with_reply_and_block (DBusConnection
DBusResultCode *result);
-void dbus_connection_set_watch_functions (DBusConnection *connection,
- DBusAddWatchFunction add_function,
- DBusRemoveWatchFunction remove_function,
- void *data,
- DBusFreeFunction free_data_function);
-void dbus_connection_set_timeout_functions (DBusConnection *connection,
- DBusAddTimeoutFunction add_function,
- DBusRemoveTimeoutFunction remove_function,
- void *data,
- DBusFreeFunction free_data_function);
-void dbus_connection_handle_watch (DBusConnection *connection,
- DBusWatch *watch,
- unsigned int condition);
+void dbus_connection_set_watch_functions (DBusConnection *connection,
+ DBusAddWatchFunction add_function,
+ DBusRemoveWatchFunction remove_function,
+ void *data,
+ DBusFreeFunction free_data_function);
+void dbus_connection_set_timeout_functions (DBusConnection *connection,
+ DBusAddTimeoutFunction add_function,
+ DBusRemoveTimeoutFunction remove_function,
+ void *data,
+ DBusFreeFunction free_data_function);
+void dbus_connection_set_wakeup_main_function (DBusConnection *connection,
+ DBusWakeupMainFunction wakeup_main_function,
+ void *data,
+ DBusFreeFunction free_data_function);
+void dbus_connection_handle_watch (DBusConnection *connection,
+ DBusWatch *watch,
+ unsigned int condition);
diff --git a/dbus/dbus-dataslot.c b/dbus/dbus-dataslot.c
index a5909ffc..53fb9e4c 100644
--- a/dbus/dbus-dataslot.c
+++ b/dbus/dbus-dataslot.c
@@ -177,9 +177,18 @@ _dbus_data_slot_list_set (DBusDataSlotAllocator *allocator,
DBusFreeFunction free_data_func,
DBusFreeFunction *old_free_func,
void **old_data)
-{
+{
+#ifndef DBUS_DISABLE_ASSERT
+ /* We need to take the allocator lock here, because the allocator could
+ * be e.g. realloc()ing allocated_slots. We avoid doing this if asserts
+ * are disabled, since then the asserts are empty.
+ */
+ if (!dbus_mutex_lock (allocator->lock))
+ return FALSE;
_dbus_assert (slot < allocator->n_allocated_slots);
_dbus_assert (allocator->allocated_slots[slot] == slot);
+ dbus_mutex_unlock (allocator->lock);
+#endif
if (slot >= list->n_slots)
{
@@ -227,8 +236,17 @@ _dbus_data_slot_list_get (DBusDataSlotAllocator *allocator,
DBusDataSlotList *list,
int slot)
{
+#ifndef DBUS_DISABLE_ASSERT
+ /* We need to take the allocator lock here, because the allocator could
+ * be e.g. realloc()ing allocated_slots. We avoid doing this if asserts
+ * are disabled, since then the asserts are empty.
+ */
+ if (!dbus_mutex_lock (allocator->lock))
+ return FALSE;
_dbus_assert (slot < allocator->n_allocated_slots);
_dbus_assert (allocator->allocated_slots[slot] == slot);
+ dbus_mutex_unlock (allocator->lock);
+#endif
if (slot >= list->n_slots)
return NULL;
diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c
index 355d6310..1a112a79 100644
--- a/dbus/dbus-message.c
+++ b/dbus/dbus-message.c
@@ -1725,12 +1725,15 @@ dbus_message_get_args_iter (DBusMessage *message)
iter = dbus_new (DBusMessageIter, 1);
- dbus_message_ref (message);
+ if (iter != NULL)
+ {
+ dbus_message_ref (message);
+
+ iter->refcount = 1;
+ iter->message = message;
+ iter->pos = 0;
+ }
- iter->refcount = 1;
- iter->message = message;
- iter->pos = 0;
-
return iter;
}
diff --git a/dbus/dbus-server-unix.c b/dbus/dbus-server-unix.c
index a6635ddc..0a98c53c 100644
--- a/dbus/dbus-server-unix.c
+++ b/dbus/dbus-server-unix.c
@@ -65,6 +65,11 @@ unix_finalize (DBusServer *server)
dbus_free (server);
}
+/**
+ * @todo unreffing the connection at the end may cause
+ * us to drop the last ref to the connection before
+ * disconnecting it. That is invalid.
+ */
static void
handle_new_client_fd (DBusServer *server,
int client_fd)