Commit fe401894 authored by Alexander Larsson's avatar Alexander Larsson

2003-02-15 Alexander Larsson <alexl@redhat.com>

	* dbus/dbus-threads.c:
	* dbus/dbus-threads.h:
	Add condvars. Remove static mutext from API.
	Implement static mutexes by initializing them from threads_init.

	* glib/dbus-gthread.c:
	* qt/dbus-qthread.cpp:
	Update with the thread api changes.


	* dbus/dbus-list.c:
	* dbus/dbus-list.h:
	Turn StaticMutex into normal mutex + init function.
	Export new functions _dbus_list_alloc_link, _dbus_list_free_link,
	_dbus_list_append_link, _dbus_list_prepend_link


	* dbus/dbus-sysdeps.c:
	* dbus/dbus-sysdeps.h:
	New type dbus_atomic_t, and new functions _dbus_atomic_inc,
	_dbus_atomic_dec. Only slow fallback implementation at the moment.

	* dbus/dbus-protocol.h:
	Add DBUS_MESSAGE_LOCAL_DISCONNECT define

	* dbus/dbus-message.c:
	Make ref/unref atomic.
	Fix some docs.

	* dbus/dbus-connection-internal.h:
	* dbus/dbus-connection.c:
	* dbus/dbus-connection.h:
	Make threadsafe.
	Change _peek to _borrow,_return & _steal_borrowed.
	Change disconnect callback to event.
	Make dbus_connection_dispatch_messages reentrant.

	* dbus/dbus-transport.c:
	Don't ref the connection on calls to the transport
	implementation.

	* dbus/dbus-message-handler.c:
	Make threadsafe.

	* glib/dbus-gmain.c:
	Don't use peek_message anymore

	* test/Makefile.am:
	* test/debug-thread.c:
	* test/debug-thread.h:
	Simple thread implementation that asserts() on deadlocks in
	single-threaded code.

	* test/bus-test.c:
	(main) Call debug_threads_init.

	* test/watch.c:
	Use disconnect message instead of disconnect callback.

	* bus/connection.c:
	* bus/connection.h:
	Don't call dbus_connection_set_disconnect_function. Instead export
	bus_connection_disconnect.

	* bus/dispatch.c:
	Call bus_connection_disconnect when we get a disconnected message.
parent ece62d7c
2003-02-15 Alexander Larsson <alexl@redhat.com>
* dbus/dbus-threads.c:
* dbus/dbus-threads.h:
Add condvars. Remove static mutext from API.
Implement static mutexes by initializing them from threads_init.
* glib/dbus-gthread.c:
* qt/dbus-qthread.cpp:
Update with the thread api changes.
* dbus/dbus-list.c:
* dbus/dbus-list.h:
Turn StaticMutex into normal mutex + init function.
Export new functions _dbus_list_alloc_link, _dbus_list_free_link,
_dbus_list_append_link, _dbus_list_prepend_link
* dbus/dbus-sysdeps.c:
* dbus/dbus-sysdeps.h:
New type dbus_atomic_t, and new functions _dbus_atomic_inc,
_dbus_atomic_dec. Only slow fallback implementation at the moment.
* dbus/dbus-protocol.h:
Add DBUS_MESSAGE_LOCAL_DISCONNECT define
* dbus/dbus-message.c:
Make ref/unref atomic.
Fix some docs.
* dbus/dbus-connection-internal.h:
* dbus/dbus-connection.c:
* dbus/dbus-connection.h:
Make threadsafe.
Change _peek to _borrow,_return & _steal_borrowed.
Change disconnect callback to event.
Make dbus_connection_dispatch_messages reentrant.
* dbus/dbus-transport.c:
Don't ref the connection on calls to the transport
implementation.
* dbus/dbus-message-handler.c:
Make threadsafe.
* glib/dbus-gmain.c:
Don't use peek_message anymore
* test/Makefile.am:
* test/debug-thread.c:
* test/debug-thread.h:
Simple thread implementation that asserts() on deadlocks in
single-threaded code.
* test/bus-test.c:
(main) Call debug_threads_init.
* test/watch.c:
Use disconnect message instead of disconnect callback.
* bus/connection.c:
* bus/connection.h:
Don't call dbus_connection_set_disconnect_function. Instead export
bus_connection_disconnect.
* bus/dispatch.c:
Call bus_connection_disconnect when we get a disconnected message.
2003-02-15 Havoc Pennington <hp@pobox.com>
* dbus/dbus-message.c (dbus_message_new): fool around with the
......
......@@ -38,9 +38,8 @@ typedef struct
#define BUS_CONNECTION_DATA(connection) (dbus_connection_get_data ((connection), connection_data_slot))
static void
connection_disconnect_handler (DBusConnection *connection,
void *data)
void
bus_connection_disconnect (DBusConnection *connection)
{
BusConnectionData *d;
BusService *service;
......@@ -157,10 +156,6 @@ bus_connection_setup (DBusConnection *connection)
connection,
NULL);
dbus_connection_set_disconnect_function (connection,
connection_disconnect_handler,
NULL, NULL);
/* Setup the connection with the dispatcher */
if (!bus_dispatch_add_connection (connection))
return FALSE;
......
......@@ -47,5 +47,8 @@ const char *bus_connection_get_name (DBusConnection *connection);
void bus_connection_foreach (BusConnectionForeachFunction function,
void *data);
/* called by dispatch.c */
void bus_connection_disconnect (DBusConnection *connection);
#endif /* BUS_CONNECTION_H */
......@@ -51,16 +51,23 @@ bus_dispatch_message_handler (DBusMessageHandler *handler,
DBusMessage *message,
void *user_data)
{
const char *sender, *service_name;
const char *sender, *service_name, *message_name;
/* Assign a sender to the message */
sender = bus_connection_get_name (connection);
BUS_HANDLE_OOM (dbus_message_set_sender (message, sender));
service_name = dbus_message_get_service (message);
message_name = dbus_message_get_name (message);
/* TODO: Crashes if service_name == NULL */
/* See if the message is to the driver */
if (strcmp (service_name, DBUS_SERVICE_DBUS) == 0)
if (message_name && strcmp (message_name, DBUS_MESSAGE_LOCAL_DISCONNECT) == 0)
{
bus_connection_disconnect (connection);
}
else if (strcmp (service_name, DBUS_SERVICE_DBUS) == 0)
{
bus_driver_handle_message (connection, message);
}
......
......@@ -38,6 +38,8 @@ typedef enum
DBUS_ITERATION_BLOCK = 1 << 2 /**< Block if nothing to do. */
} DBusIterationFlags;
void _dbus_connection_ref_unlocked (DBusConnection *connection);
dbus_bool_t _dbus_connection_queue_received_message (DBusConnection *connection,
DBusMessage *message);
dbus_bool_t _dbus_connection_have_messages_to_send (DBusConnection *connection);
......@@ -60,14 +62,14 @@ void _dbus_connection_do_iteration (DBusConnection *connect
unsigned int flags,
int timeout_milliseconds);
void _dbus_connection_notify_disconnected (DBusConnection *connection);
void _dbus_connection_notify_disconnected (DBusConnection *connection);
void _dbus_connection_handler_destroyed (DBusConnection *connection,
DBusMessageHandler *handler);
void _dbus_connection_handler_destroyed_locked (DBusConnection *connection,
DBusMessageHandler *handler);
void _dbus_connection_set_connection_counter (DBusConnection *connection,
DBusCounter *counter);
void _dbus_connection_set_connection_counter (DBusConnection *connection,
DBusCounter *counter);
dbus_bool_t _dbus_message_handler_add_connection (DBusMessageHandler *handler,
DBusConnection *connection);
......
This diff is collapsed.
......@@ -66,21 +66,23 @@ typedef void (* DBusAddTimeoutFunction) (DBusTimeout *timeout,
typedef void (* DBusRemoveTimeoutFunction) (DBusTimeout *timeout,
void *data);
typedef void (* DBusDisconnectFunction) (DBusConnection *connection,
void *data);
DBusConnection* dbus_connection_open (const char *address,
DBusResultCode *result);
void dbus_connection_ref (DBusConnection *connection);
void dbus_connection_unref (DBusConnection *connection);
void dbus_connection_disconnect (DBusConnection *connection);
dbus_bool_t dbus_connection_get_is_connected (DBusConnection *connection);
dbus_bool_t dbus_connection_get_is_authenticated (DBusConnection *connection);
void dbus_connection_flush (DBusConnection *connection);
int dbus_connection_get_n_messages (DBusConnection *connection);
DBusMessage* dbus_connection_borrow_message (DBusConnection *connection);
void dbus_connection_return_message (DBusConnection *connection,
DBusMessage *message);
void dbus_connection_steal_borrowed_message (DBusConnection *connection,
DBusMessage *message);
DBusMessage* dbus_connection_pop_message (DBusConnection *connection);
dbus_bool_t dbus_connection_dispatch_message (DBusConnection *connection);
DBusConnection* dbus_connection_open (const char *address,
DBusResultCode *result);
void dbus_connection_ref (DBusConnection *connection);
void dbus_connection_unref (DBusConnection *connection);
void dbus_connection_disconnect (DBusConnection *connection);
dbus_bool_t dbus_connection_get_is_connected (DBusConnection *connection);
dbus_bool_t dbus_connection_get_is_authenticated (DBusConnection *connection);
void dbus_connection_flush (DBusConnection *connection);
int dbus_connection_get_n_messages (DBusConnection *connection);
DBusMessage* dbus_connection_peek_message (DBusConnection *connection);
DBusMessage* dbus_connection_pop_message (DBusConnection *connection);
dbus_bool_t dbus_connection_dispatch_message (DBusConnection *connection);
dbus_bool_t dbus_connection_send_message (DBusConnection *connection,
DBusMessage *message,
......@@ -97,10 +99,6 @@ DBusMessage *dbus_connection_send_message_with_reply_and_block (DBusConnection
DBusResultCode *result);
void dbus_connection_set_disconnect_function (DBusConnection *connection,
DBusDisconnectFunction function,
void *data,
DBusFreeFunction free_data_function);
void dbus_connection_set_watch_functions (DBusConnection *connection,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
......
......@@ -35,7 +35,15 @@
*/
static DBusMemPool *list_pool;
static DBusStaticMutex list_pool_lock = DBUS_STATIC_MUTEX_INIT;
static DBusMutex *list_pool_lock = NULL;
DBusMutex *_dbus_list_init_lock (void);
DBusMutex *
_dbus_list_init_lock (void)
{
list_pool_lock = dbus_mutex_new ();
return list_pool_lock;
}
/**
* @defgroup DBusListInternals Linked list implementation details
......@@ -55,7 +63,7 @@ alloc_link (void *data)
{
DBusList *link;
if (!dbus_static_mutex_lock (&list_pool_lock))
if (!dbus_mutex_lock (list_pool_lock))
return NULL;
if (!list_pool)
......@@ -64,7 +72,7 @@ alloc_link (void *data)
if (list_pool == NULL)
{
dbus_static_mutex_unlock (&list_pool_lock);
dbus_mutex_unlock (list_pool_lock);
return NULL;
}
}
......@@ -72,7 +80,7 @@ alloc_link (void *data)
link = _dbus_mem_pool_alloc (list_pool);
link->data = data;
dbus_static_mutex_unlock (&list_pool_lock);
dbus_mutex_unlock (list_pool_lock);
return link;
}
......@@ -80,9 +88,9 @@ alloc_link (void *data)
static void
free_link (DBusList *link)
{
dbus_static_mutex_lock (&list_pool_lock);
dbus_mutex_lock (list_pool_lock);
_dbus_mem_pool_dealloc (list_pool, link);
dbus_static_mutex_unlock (&list_pool_lock);
dbus_mutex_unlock (list_pool_lock);
}
static void
......@@ -189,6 +197,33 @@ link_after (DBusList **list,
*
*/
/**
* Allocates a linked list node. Useful for preallocating
* nodes and using _dbus_list_append_link() to avoid
* allocations.
*
* @param data the value to store in the link.
* @returns a newly allocated link.
*/
DBusList*
_dbus_list_alloc_link (void *data)
{
return alloc_link (data);
}
/**
* Frees a linked list node allocated with _dbus_list_alloc_link.
* Does not free the data in the node.
*
* @param link the list node
*/
void
_dbus_list_free_link (DBusList *link)
{
free_link (link);
}
/**
* Appends a value to the list. May return #FALSE
* if insufficient memory exists to add a list link.
......@@ -235,6 +270,43 @@ _dbus_list_prepend (DBusList **list,
return TRUE;
}
/**
* Appends a link to the list.
* Cannot fail due to out of memory.
* This is a constant-time operation.
*
* @param list address of the list head.
* @param link the link to append.
*/
void
_dbus_list_append_link (DBusList **list,
DBusList *link)
{
_dbus_list_prepend_link (list, link);
/* Now cycle the list forward one so the prepended node is the tail */
*list = (*list)->next;
return TRUE;
}
/**
* Prepends a link to the list.
* Cannot fail due to out of memory.
* This is a constant-time operation.
*
* @param list address of the list head.
* @param link the link to prepend.
*/
void
_dbus_list_prepend_link (DBusList **list,
DBusList *link)
{
link_before (list, *list, link);
return TRUE;
}
/**
* Inserts data into the list before the given existing link.
*
......
......@@ -66,6 +66,13 @@ dbus_bool_t _dbus_list_copy (DBusList **list,
DBusList **dest);
int _dbus_list_get_length (DBusList **list);
DBusList* _dbus_list_alloc_link (void *data);
void _dbus_list_free_link (DBusList *link);
void _dbus_list_append_link (DBusList **list,
DBusList *link);
void _dbus_list_prepend_link (DBusList **list,
DBusList *link);
void _dbus_list_foreach (DBusList **list,
DBusForeachFunction function,
void *data);
......
......@@ -24,6 +24,7 @@
#include "dbus-internals.h"
#include "dbus-message-handler.h"
#include "dbus-list.h"
#include "dbus-threads.h"
#include "dbus-connection-internal.h"
/**
......@@ -36,6 +37,14 @@
* @{
*/
static DBusMutex *message_handler_lock = NULL;
DBusMutex *_dbus_message_handler_init_lock (void);
DBusMutex *
_dbus_message_handler_init_lock (void)
{
message_handler_lock = dbus_mutex_new ();
return message_handler_lock;
}
/**
* @brief Internals of DBusMessageHandler
......@@ -66,13 +75,20 @@ dbus_bool_t
_dbus_message_handler_add_connection (DBusMessageHandler *handler,
DBusConnection *connection)
{
dbus_bool_t res;
dbus_mutex_lock (message_handler_lock);
/* This is a bit wasteful - we just put the connection in the list
* once per time it's added. :-/
*/
if (!_dbus_list_prepend (&handler->connections, connection))
return FALSE;
res = FALSE;
else
res = TRUE;
return TRUE;
dbus_mutex_unlock (message_handler_lock);
return res;
}
/**
......@@ -84,8 +100,10 @@ void
_dbus_message_handler_remove_connection (DBusMessageHandler *handler,
DBusConnection *connection)
{
dbus_mutex_lock (message_handler_lock);
if (!_dbus_list_remove (&handler->connections, connection))
_dbus_warn ("Function _dbus_message_handler_remove_connection() called when the connection hadn't been added\n");
dbus_mutex_unlock (message_handler_lock);
}
......@@ -104,11 +122,19 @@ _dbus_message_handler_handle_message (DBusMessageHandler *handler,
DBusConnection *connection,
DBusMessage *message)
{
DBusHandleMessageFunction function;
void *user_data;
dbus_mutex_lock (message_handler_lock);
function = handler->function;
user_data = handler->user_data;
dbus_mutex_unlock (message_handler_lock);
/* This function doesn't ref handler/connection/message
* since that's done in dbus_connection_dispatch_message().
*/
if (handler->function != NULL)
return (* handler->function) (handler, connection, message, handler->user_data);
if (function != NULL)
return (* function) (handler, connection, message, user_data);
else
return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
......@@ -173,9 +199,11 @@ dbus_message_handler_new (DBusHandleMessageFunction function,
void
dbus_message_handler_ref (DBusMessageHandler *handler)
{
dbus_mutex_lock (message_handler_lock);
_dbus_assert (handler != NULL);
handler->refcount += 1;
dbus_mutex_unlock (message_handler_lock);
}
/**
......@@ -187,11 +215,19 @@ dbus_message_handler_ref (DBusMessageHandler *handler)
void
dbus_message_handler_unref (DBusMessageHandler *handler)
{
int refcount;
dbus_mutex_lock (message_handler_lock);
_dbus_assert (handler != NULL);
_dbus_assert (handler->refcount > 0);
handler->refcount -= 1;
if (handler->refcount == 0)
refcount = handler->refcount;
dbus_mutex_unlock (message_handler_lock);
if (refcount == 0)
{
DBusList *link;
......@@ -203,7 +239,7 @@ dbus_message_handler_unref (DBusMessageHandler *handler)
{
DBusConnection *connection = link->data;
_dbus_connection_handler_destroyed (connection, handler);
_dbus_connection_handler_destroyed_locked (connection, handler);
link = _dbus_list_get_next_link (&handler->connections, link);
}
......@@ -224,7 +260,11 @@ dbus_message_handler_unref (DBusMessageHandler *handler)
void*
dbus_message_handler_get_data (DBusMessageHandler *handler)
{
return handler->user_data;
void* user_data;
dbus_mutex_lock (message_handler_lock);
user_data = handler->user_data;
dbus_mutex_unlock (message_handler_lock);
return user_data;
}
/**
......@@ -241,11 +281,20 @@ dbus_message_handler_set_data (DBusMessageHandler *handler,
void *user_data,
DBusFreeFunction free_user_data)
{
if (handler->free_user_data)
(* handler->free_user_data) (handler->user_data);
DBusFreeFunction old_free_func;
void *old_user_data;
dbus_mutex_lock (message_handler_lock);
old_free_func = handler->free_user_data;
old_user_data = handler->user_data;
handler->user_data = user_data;
handler->free_user_data = free_user_data;
dbus_mutex_unlock (message_handler_lock);
if (old_free_func)
(* old_free_func) (old_user_data);
}
/**
......@@ -259,7 +308,9 @@ void
dbus_message_handler_set_function (DBusMessageHandler *handler,
DBusHandleMessageFunction function)
{
dbus_mutex_lock (message_handler_lock);
handler->function = function;
dbus_mutex_unlock (message_handler_lock);
}
/** @} */
......@@ -81,7 +81,7 @@ typedef struct
*/
struct DBusMessage
{
int refcount; /**< Reference count */
dbus_atomic_t refcount; /**< Reference count */
DBusString header; /**< Header network data, stored
* separately from body so we can
......@@ -887,9 +887,10 @@ dbus_message_new_from_message (const DBusMessage *message)
void
dbus_message_ref (DBusMessage *message)
{
_dbus_assert (message->refcount > 0);
message->refcount += 1;
dbus_atomic_t refcount;
refcount = _dbus_atomic_inc (&message->refcount);
_dbus_assert (refcount > 1);
}
/**
......@@ -901,10 +902,13 @@ dbus_message_ref (DBusMessage *message)
void
dbus_message_unref (DBusMessage *message)
{
_dbus_assert (message->refcount > 0);
dbus_atomic_t refcount;
message->refcount -= 1;
if (message->refcount == 0)
refcount = _dbus_atomic_dec (&message->refcount);
_dbus_assert (refcount >= 0);
if (refcount == 0)
{
if (message->size_counter != NULL)
{
......@@ -1519,7 +1523,7 @@ dbus_message_iter_get_string (DBusMessageIter *iter)
/**
* Returns the 32 bit signed integer value that an iterator may point to.
* Note that you need to check that the iterator points to
* a string value before using this function.
* an integer value before using this function.
*
* @see dbus_message_iter_get_field_type
* @param iter the message iter
......@@ -1535,7 +1539,7 @@ dbus_message_iter_get_int32 (DBusMessageIter *iter)
/**
* Returns the 32 bit unsigned integer value that an iterator may point to.
* Note that you need to check that the iterator points to
* a string value before using this function.
* an unsigned integer value before using this function.
*
* @see dbus_message_iter_get_field_type
* @param iter the message iter
......
......@@ -85,6 +85,7 @@ extern "C" {
#define DBUS_MESSAGE_SERVICE_DELETED "org.freedesktop.DBus.ServiceDeleted"
#define DBUS_MESSAGE_SERVICE_LOST "org.freedesktop.DBus.ServiceLost"
#define DBUS_MESSAGE_LOCAL_DISCONNECT "org.freedesktop.Local.Disconnect"
#ifdef __cplusplus
}
......
......@@ -23,6 +23,7 @@
#include "dbus-internals.h"
#include "dbus-sysdeps.h"
#include "dbus-threads.h"
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
......@@ -941,6 +942,55 @@ _dbus_string_append_our_uid (DBusString *str)
}
static DBusMutex *atomic_lock = NULL;
DBusMutex *_dbus_atomic_init_lock (void);
DBusMutex *
_dbus_atomic_init_lock (void)
{
atomic_lock = dbus_mutex_new ();
return atomic_lock;
}
/**
* Atomically increments an integer
*
* @param atomic pointer to the integer to increment
* @returns the value after incrementing
*
* @todo implement arch-specific faster atomic ops
*/
dbus_atomic_t
_dbus_atomic_inc (dbus_atomic_t *atomic)
{
dbus_atomic_t res;
dbus_mutex_lock (atomic_lock);
*atomic += 1;
res = *atomic;
dbus_mutex_unlock (atomic_lock);
return res;
}
/**
* Atomically decrement an integer
*
* @param atomic pointer to the integer to decrement
* @returns the value after decrementing
*
* @todo implement arch-specific faster atomic ops
*/
dbus_atomic_t
_dbus_atomic_dec (dbus_atomic_t *atomic)
{
dbus_atomic_t res;
dbus_mutex_lock (atomic_lock);
*atomic -= 1;
res = *atomic;
dbus_mutex_unlock (atomic_lock);
return res;
}
/**
* Wrapper for poll().
*
......
......@@ -98,6 +98,10 @@ dbus_bool_t _dbus_credentials_match (const DBusCredentials *expec
dbus_bool_t _dbus_string_append_our_uid (DBusString *str);
typedef int dbus_atomic_t;
dbus_atomic_t _dbus_atomic_inc (dbus_atomic_t *atomic);
dbus_atomic_t _dbus_atomic_dec (dbus_atomic_t *atomic);
#define _DBUS_POLLIN 0x0001 /* There is data to read */
#define _DBUS_POLLPRI 0x0002 /* There is urgent data to read */
......
......@@ -27,16 +27,18 @@ static DBusThreadFunctions thread_functions =
{
0,
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL
};
static DBusMutex *static_mutex_init_lock = NULL;
/** This is used for the no-op default mutex pointer, just to be distinct from #NULL */
#define _DBUS_DUMMY_MUTEX ((void*)0xABCDEF)
/** This is used for the no-op default mutex pointer, just to be distinct from #NULL */
#define _DBUS_DUMMY_CONDVAR ((void*)0xABCDEF2)
/**
* @defgroup DBusThreads Thread functions
* @ingroup DBus
......@@ -104,6 +106,130 @@ dbus_mutex_unlock (DBusMutex *mutex)
return TRUE;
}
/**
* Creates a new condition variable using the function supplied
* to dbus_threads_init(), or creates a no-op condition variable
* if threads are not initialized. May return #NULL even if
* threads are initialized, indicating out-of-memory.
*
* @returns new mutex or #NULL
*/
DBusCondVar *
dbus_condvar_new (void)
{
if (thread_functions.condvar_new)
return (* thread_functions.condvar_new) ();
else
return _DBUS_DUMMY_MUTEX;
}
/**
* Frees a conditional variable created with dbus_condvar_new(); does
* nothing if passed a #NULL pointer.
*/
void
dbus_condvar_free (DBusCondVar *cond)
{
if (cond && thread_functions.condvar_free)
(* thread_functions.condvar_free) (cond);
}
/**
* Atomically unlocks the mutex and waits for the conditions
* variable to be signalled. Locks the mutex again before
* returning.
* Does nothing if passed a #NULL pointer.
*/
void
dbus_condvar_wait (DBusCondVar *cond,
DBusMutex *mutex)
{
if (cond && mutex && thread_functions.condvar_wait)
(* thread_functions.condvar_wait) (cond, mutex);
}
/**
* Atomically unlocks the mutex and waits for the conditions
* variable to be signalled, or for a timeout. Locks the
* mutex again before returning.
* Does nothing if passed a #NULL pointer.
*
* @param timeout_milliseconds the maximum time to wait
* @returns TRUE if the condition was reached, or FALSE if the
* timeout was reached.
*/
dbus_bool_t
dbus_condvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_milliseconds)
{
if (cond && mutex && thread_functions.condvar_wait)
return (* thread_functions.condvar_wait_timeout) (cond, mutex, timeout_milliseconds);
else
return FALSE;
}
/**
* If there are threads waiting on the condition variable, wake
* up exactly one.
* Does nothing if passed a #NULL pointer.
*/
void
dbus_condvar_wake_one (DBusCondVar *cond)
{
if (cond && thread_functions.condvar_wake_one)