fdo-mirrors/dbus
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/dbus/dbus.git synced 2026-04-22 08:10:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
* 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.
This commit is contained in:
Alexander Larsson 2003-02-15 16:25:08 +00:00
parent ece62d7c14
commit fe40189411
25 changed files with 1523 additions and 400 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

69
ChangeLog
View file

@ -1,3 +1,72 @@
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

9
bus/connection.c
View file

@ -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;

3
bus/connection.h
View file

@ -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 */

11
bus/dispatch.c
View file

@ -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);
}

12
dbus/dbus-connection-internal.h
View file

@ -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);

784
dbus/dbus-connection.c
View file

File diff suppressed because it is too large Load diff

34
dbus/dbus-connection.h
View file

@ -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,

84
dbus/dbus-list.c
View file

@ -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.
*

7
dbus/dbus-list.h
View file

@ -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);

69
dbus/dbus-message-handler.c
View file

@ -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);
}
/** @} */

22
dbus/dbus-message.c
View file

@ -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

1
dbus/dbus-protocol.h
View file

@ -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
}

50
dbus/dbus-sysdeps.c
View file

@ -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().
*

4
dbus/dbus-sysdeps.h
View file

@ -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 */

218
dbus/dbus-threads.c
View file

@ -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)
(* thread_functions.condvar_wake_one) (cond);
}
/**
* If there are threads waiting on the condition variable, wake
* up all of them.
* Does nothing if passed a #NULL pointer.
*/
void
dbus_condvar_wake_all (DBusCondVar *cond)
{
if (cond && thread_functions.condvar_wake_all)
(* thread_functions.condvar_wake_all) (cond);
}
DBusMutex * _dbus_list_init_lock (void);
DBusMutex * _dbus_allocated_slots_init_lock (void);
DBusMutex *_dbus_atomic_init_lock (void);
DBusMutex *_dbus_message_handler_init_lock (void);
static dbus_bool_t
init_static_locks(void)
{
int i;
struct {
DBusMutex *(*init_func)(void);
DBusMutex *mutex;
} static_locks[] = {
{&_dbus_list_init_lock},
{&_dbus_allocated_slots_init_lock},
{&_dbus_atomic_init_lock},
{&_dbus_message_handler_init_lock},
};
for (i = 0; i < _DBUS_N_ELEMENTS (static_locks); i++)
{
static_locks[i].mutex = (*static_locks[i].init_func)();
if (static_locks[i].mutex == NULL)
{
for (i = i - 1; i >= 0; i--)
dbus_mutex_free (static_locks[i].mutex);
return FALSE;
}
}
return TRUE;
}
/**
* Initializes threads. If this function is not called,
* the D-BUS library will not lock any data structures.
@ -125,14 +251,26 @@ dbus_threads_init (const DBusThreadFunctions *functions)
/* these base functions are required. Future additions to
* DBusThreadFunctions may be optional.
*/
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_NEW_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_FREE_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_LOCK_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_UNLOCK_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK);
_dbus_assert (functions->mask & DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK);
_dbus_assert (functions->mutex_new != NULL);
_dbus_assert (functions->mutex_free != NULL);
_dbus_assert (functions->mutex_lock != NULL);
_dbus_assert (functions->mutex_unlock != NULL);
_dbus_assert (functions->condvar_new != NULL);
_dbus_assert (functions->condvar_free != NULL);
_dbus_assert (functions->condvar_wait != NULL);
_dbus_assert (functions->condvar_wait_timeout != NULL);
_dbus_assert (functions->condvar_wake_one != NULL);
_dbus_assert (functions->condvar_wake_all != NULL);
/* Check that all bits in the mask actually are valid mask bits.
* ensures people won't write code that breaks when we add
@ -151,67 +289,19 @@ dbus_threads_init (const DBusThreadFunctions *functions)
thread_functions.mutex_lock = functions->mutex_lock;
thread_functions.mutex_unlock = functions->mutex_unlock;
thread_functions.condvar_new = functions->condvar_new;
thread_functions.condvar_free = functions->condvar_free;
thread_functions.condvar_wait = functions->condvar_wait;
thread_functions.condvar_wait_timeout = functions->condvar_wait_timeout;
thread_functions.condvar_wake_one = functions->condvar_wake_one;
thread_functions.condvar_wake_all = functions->condvar_wake_all;
thread_functions.mask = functions->mask;
static_mutex_init_lock = dbus_mutex_new ();
if (static_mutex_init_lock == NULL)
{
thread_functions.mask = 0;
return FALSE;
}
if (!init_static_locks ())
return FALSE;
return TRUE;
}
/** Accesses the field of DBusStaticMutex that
* stores the DBusMutex used to implement.
*/
#define _DBUS_STATIC_MUTEX_IMPL(mutex) ((mutex)->pad1)
/**
* Lock a static mutex
*
* @todo currently broken on some platforms due to
* non-workingness of "double checked locking"
* see http://bugzilla.gnome.org/show_bug.cgi?id=69668
* and http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
* for example.
*
* @param mutex the mutex to lock
* @returns #TRUE on success
*/
dbus_bool_t
dbus_static_mutex_lock (DBusStaticMutex *mutex)
{
if (_DBUS_STATIC_MUTEX_IMPL (mutex))
return dbus_mutex_lock (_DBUS_STATIC_MUTEX_IMPL (mutex));
if (!dbus_mutex_lock (static_mutex_init_lock))
return FALSE;
if (_DBUS_STATIC_MUTEX_IMPL (mutex) == NULL)
_DBUS_STATIC_MUTEX_IMPL (mutex) = dbus_mutex_new ();
dbus_mutex_unlock (static_mutex_init_lock);
if (_DBUS_STATIC_MUTEX_IMPL (mutex))
return dbus_mutex_lock (_DBUS_STATIC_MUTEX_IMPL (mutex));
else
return FALSE;
}
/**
* Unlock a static mutex
* @param mutex the mutex to lock
* @returns #TRUE on success
*/
dbus_bool_t
dbus_static_mutex_unlock (DBusStaticMutex *mutex)
{
_dbus_assert (_DBUS_STATIC_MUTEX_IMPL (mutex) != NULL);
return dbus_mutex_unlock (_DBUS_STATIC_MUTEX_IMPL (mutex));
}
/** @} */

65
dbus/dbus-threads.h
View file

@ -33,20 +33,37 @@
DBUS_BEGIN_DECLS;
typedef struct DBusMutex DBusMutex;
typedef struct DBusCondVar DBusCondVar;
typedef DBusMutex* (* DBusMutexNewFunction) (void);
typedef void (* DBusMutexFreeFunction) (DBusMutex *mutex);
typedef dbus_bool_t (* DBusMutexLockFunction) (DBusMutex *mutex);
typedef dbus_bool_t (* DBusMutexUnlockFunction) (DBusMutex *mutex);
typedef DBusCondVar* (* DBusCondVarNewFunction) (void);
typedef void (* DBusCondVarFreeFunction) (DBusCondVar *cond);
typedef void (* DBusCondVarWaitFunction) (DBusCondVar *cond,
DBusMutex *mutex);
typedef dbus_bool_t (* DBusCondVarWaitTimeoutFunction) (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_milliseconds);
typedef void (* DBusCondVarWakeOneFunction) (DBusCondVar *cond);
typedef void (* DBusCondVarWakeAllFunction) (DBusCondVar *cond);
typedef enum
{
DBUS_THREAD_FUNCTIONS_NEW_MASK = 1 << 0,
DBUS_THREAD_FUNCTIONS_FREE_MASK = 1 << 1,
DBUS_THREAD_FUNCTIONS_LOCK_MASK = 1 << 2,
DBUS_THREAD_FUNCTIONS_UNLOCK_MASK = 1 << 3,
DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK = 1 << 0,
DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK = 1 << 1,
DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK = 1 << 2,
DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK = 1 << 3,
DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK = 1 << 4,
DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK = 1 << 5,
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK = 1 << 6,
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK = 1 << 7,
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK = 1 << 8,
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK = 1 << 9,
DBUS_THREAD_FUNCTIONS_ALL_MASK = 0xf
DBUS_THREAD_FUNCTIONS_ALL_MASK = (1 << 10) - 1
} DBusThreadFunctionsMask;
typedef struct
@ -58,6 +75,13 @@ typedef struct
DBusMutexLockFunction mutex_lock;
DBusMutexUnlockFunction mutex_unlock;
DBusCondVarNewFunction condvar_new;
DBusCondVarFreeFunction condvar_free;
DBusCondVarWaitFunction condvar_wait;
DBusCondVarWaitTimeoutFunction condvar_wait_timeout;
DBusCondVarWakeOneFunction condvar_wake_one;
DBusCondVarWakeAllFunction condvar_wake_all;
void (* padding1) (void);
void (* padding2) (void);
void (* padding3) (void);
@ -70,27 +94,24 @@ typedef struct
} DBusThreadFunctions;
DBusMutex* dbus_mutex_new (void);
void dbus_mutex_free (DBusMutex *mutex);
dbus_bool_t dbus_mutex_lock (DBusMutex *mutex);
dbus_bool_t dbus_mutex_unlock (DBusMutex *mutex);
DBusMutex* dbus_mutex_new (void);
void dbus_mutex_free (DBusMutex *mutex);
dbus_bool_t dbus_mutex_lock (DBusMutex *mutex);
dbus_bool_t dbus_mutex_unlock (DBusMutex *mutex);
dbus_bool_t dbus_threads_init (const DBusThreadFunctions *functions);
DBusCondVar* dbus_condvar_new (void);
void dbus_condvar_free (DBusCondVar *cond);
void dbus_condvar_wait (DBusCondVar *cond,
DBusMutex *mutex);
dbus_bool_t dbus_condvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_milliseconds);
void dbus_condvar_wake_one (DBusCondVar *cond);
void dbus_condvar_wake_all (DBusCondVar *cond);
typedef struct DBusStaticMutex DBusStaticMutex;
dbus_bool_t dbus_threads_init (const DBusThreadFunctions *functions);
struct DBusStaticMutex
{
void *pad1;
void *pad2;
void *pad3;
void *pad4;
};
#define DBUS_STATIC_MUTEX_INIT { NULL, NULL, NULL, NULL }
dbus_bool_t dbus_static_mutex_lock (DBusStaticMutex *mutex);
dbus_bool_t dbus_static_mutex_unlock (DBusStaticMutex *mutex);
DBUS_END_DECLS;

42
dbus/dbus-transport.c
View file

@ -52,31 +52,13 @@
* or encryption schemes.
*/
/**
* Refs a transport and associated connection for reentrancy.
*
* @todo this macro reflects a design mistake, which is that the
* transport has a pointer to its connection. Ownership should move in
* only one direction; the connection should push/pull from the
* transport, rather than vice versa. Then the connection would take
* care of referencing itself when needed.
*/
#define DBUS_TRANSPORT_HOLD_REF(t) \
_dbus_transport_ref (t); if ((t)->connection) dbus_connection_ref ((t)->connection)
/**
* Inverse of DBUS_TRANSPORT_HOLD_REF().
*/
#define DBUS_TRANSPORT_RELEASE_REF(t) \
if ((t)->connection) dbus_connection_unref ((t)->connection); _dbus_transport_unref (t)
static void
live_messages_size_notify (DBusCounter *counter,
void *user_data)
{
DBusTransport *transport = user_data;
DBUS_TRANSPORT_HOLD_REF (transport);
_dbus_transport_ref (transport);
#if 0
_dbus_verbose ("Counter value is now %d\n",
@ -89,7 +71,7 @@ live_messages_size_notify (DBusCounter *counter,
if (* transport->vtable->live_messages_changed)
(* transport->vtable->live_messages_changed) (transport);
DBUS_TRANSPORT_RELEASE_REF (transport);
_dbus_transport_unref (transport);
}
/**
@ -294,14 +276,14 @@ _dbus_transport_disconnect (DBusTransport *transport)
if (transport->disconnected)
return;
DBUS_TRANSPORT_HOLD_REF (transport);
_dbus_transport_ref (transport);
(* transport->vtable->disconnect) (transport);
transport->disconnected = TRUE;
_dbus_connection_notify_disconnected (transport->connection);
DBUS_TRANSPORT_RELEASE_REF (transport);
_dbus_transport_unref (transport);
}
/**
@ -401,11 +383,11 @@ _dbus_transport_handle_watch (DBusTransport *transport,
_dbus_watch_sanitize_condition (watch, &condition);
DBUS_TRANSPORT_HOLD_REF (transport);
_dbus_transport_ref (transport);
_dbus_watch_ref (watch);
(* transport->vtable->handle_watch) (transport, watch, condition);
_dbus_watch_unref (watch);
DBUS_TRANSPORT_RELEASE_REF (transport);
_dbus_transport_unref (transport);
}
/**
@ -425,9 +407,9 @@ _dbus_transport_set_connection (DBusTransport *transport,
transport->connection = connection;
DBUS_TRANSPORT_HOLD_REF (transport);
_dbus_transport_ref (transport);
(* transport->vtable->connection_set) (transport);
DBUS_TRANSPORT_RELEASE_REF (transport);
_dbus_transport_unref (transport);
}
/**
@ -450,10 +432,10 @@ _dbus_transport_messages_pending (DBusTransport *transport,
transport->messages_need_sending = queue_length > 0;
DBUS_TRANSPORT_HOLD_REF (transport);
_dbus_transport_ref (transport);
(* transport->vtable->messages_pending) (transport,
queue_length);
DBUS_TRANSPORT_RELEASE_REF (transport);
_dbus_transport_unref (transport);
}
/**
@ -481,10 +463,10 @@ _dbus_transport_do_iteration (DBusTransport *transport,
if (transport->disconnected)
return;
DBUS_TRANSPORT_HOLD_REF (transport);
_dbus_transport_ref (transport);
(* transport->vtable->do_iteration) (transport, flags,
timeout_milliseconds);
DBUS_TRANSPORT_RELEASE_REF (transport);
_dbus_transport_unref (transport);
}
/**

2
glib/dbus-gmain.c
View file

@ -59,7 +59,7 @@ dbus_connection_prepare (GSource *source,
*timeout = -1;
return (dbus_connection_peek_message (connection) != NULL);
return (dbus_connection_get_n_messages (connection) > 0);
}
static gboolean

94
glib/dbus-gthread.c
View file

@ -25,21 +25,45 @@
#include <dbus/dbus.h>
#include "dbus-glib.h"
static DBusMutex * dbus_gmutex_new (void);
static void dbus_gmutex_free (DBusMutex *mutex);
static dbus_bool_t dbus_gmutex_lock (DBusMutex *mutex);
static dbus_bool_t dbus_gmutex_unlock (DBusMutex *mutex);
static DBusMutex * dbus_gmutex_new (void);
static void dbus_gmutex_free (DBusMutex *mutex);
static dbus_bool_t dbus_gmutex_lock (DBusMutex *mutex);
static dbus_bool_t dbus_gmutex_unlock (DBusMutex *mutex);
static DBusCondVar* dbus_gcondvar_new (void);
static void dbus_gcondvar_free (DBusCondVar *cond);
static void dbus_gcondvar_wait (DBusCondVar *cond,
DBusMutex *mutex);
static dbus_bool_t dbus_gcondvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_msec);
static void dbus_gcondvar_wake_one (DBusCondVar *cond);
static void dbus_gcondvar_wake_all (DBusCondVar *cond);
static const DBusThreadFunctions functions =
{
DBUS_THREAD_FUNCTIONS_NEW_MASK |
DBUS_THREAD_FUNCTIONS_FREE_MASK |
DBUS_THREAD_FUNCTIONS_LOCK_MASK |
DBUS_THREAD_FUNCTIONS_UNLOCK_MASK,
DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK |
DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK |
DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK |
DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK|
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK,
dbus_gmutex_new,
dbus_gmutex_free,
dbus_gmutex_lock,
dbus_gmutex_unlock
dbus_gmutex_unlock,
dbus_gcondvar_new,
dbus_gcondvar_free,
dbus_gcondvar_wait,
dbus_gcondvar_wait_timeout,
dbus_gcondvar_wake_one,
dbus_gcondvar_wake_all
};
static DBusMutex *
@ -74,6 +98,58 @@ dbus_gmutex_unlock (DBusMutex *mutex)
return TRUE;
}
static DBusCondVar*
dbus_gcondvar_new (void)
{
return (DBusCondVar*)g_cond_new ();
}
static void
dbus_gcondvar_free (DBusCondVar *cond)
{
g_cond_free ((GCond *)cond);
}
static void
dbus_gcondvar_wait (DBusCondVar *cond,
DBusMutex *mutex)
{
g_cond_wait ((GCond *)cond, (GMutex *)mutex);
}
static dbus_bool_t
dbus_gcondvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_msec)
{
GTimeVal now;
g_get_current_time (&now);
now.tv_sec += timeout_msec / 1000;
now.tv_usec += (timeout_msec % 1000) * 1000;
if (now.tv_usec > G_USEC_PER_SEC)
{
now.tv_sec += 1;
now.tv_usec -= G_USEC_PER_SEC;
}
return g_cond_timed_wait ((GCond *)cond, (GMutex *)mutex, &now);
}
static void
dbus_gcondvar_wake_one (DBusCondVar *cond)
{
g_cond_signal ((GCond *)cond);
}
static void
dbus_gcondvar_wake_all (DBusCondVar *cond)
{
g_cond_broadcast ((GCond *)cond);
}
void
dbus_gthread_init (void)
{

76
qt/dbus-qthread.cpp
View file

@ -31,17 +31,39 @@ static void dbus_qmutex_free (DBusMutex *mutex);
static dbus_bool_t dbus_qmutex_lock (DBusMutex *mutex);
static dbus_bool_t dbus_qmutex_unlock (DBusMutex *mutex);
static DBusCondVar*dbus_qcondvar_new (void);
static void dbus_qcondvar_free (DBusCondVar *cond);
static void dbus_qcondvar_wait (DBusCondVar *cond,
DBusMutex *mutex);
static dbus_bool_t dbus_qcondvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex.
int timeout_msec);
static void dbus_qcondvar_wake_one (DBusCondVar *cond);
static void dbus_qcondvar_wake_all (DBusCondVar *cond);
static const DBusThreadFunctions functions =
{
DBUS_THREAD_FUNCTIONS_NEW_MASK |
DBUS_THREAD_FUNCTIONS_FREE_MASK |
DBUS_THREAD_FUNCTIONS_LOCK_MASK |
DBUS_THREAD_FUNCTIONS_UNLOCK_MASK,
DBUS_THREAD_FUNCTIONS_UNLOCK_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK|
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK,
dbus_qmutex_new,
dbus_qmutex_free,
dbus_qmutex_lock,
dbus_qmutex_unlock
dbus_qcondvar_new,
dbus_qcondvar_free,
dbus_qcondvar_wait,
dbus_qcondvar_wait_timeout,
dbus_qcondvar_wake_one,
dbus_qcondvar_wake_all
};
static DBusMutex *
@ -75,6 +97,58 @@ dbus_qmutex_unlock (DBusMutex *mutex)
return TRUE;
}
static DBusCondVar*
dbus_qcondvar_new (void)
{
QWaitCondition *cond;
cond = new QWaitCondition;
return static_cast<DBusCondVar*>( cond );
}
static void
dbus_qcondvar_free (DBusCondVar *cond)
{
QWaitCondition *cqond = static_cast<QMutex*>(mutex);
delete qcond;
}
static void
dbus_qcondvar_wait (DBusCondVar *cond,
DBusMutex *mutex)
{
QWaitCondition *qcond = static_cast<QWaitCondition*>(cond);
QMutex *qmutex = static_cast<QMutex*>(mutex);
qcond->wait (qmutex);
}
static dbus_bool_t
dbus_gcondvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_msec)
{
QWaitCondition *qcond = static_cast<QWaitCondition*>(cond);
QMutex *qmutex = static_cast<QMutex*>(mutex);
return qcond->wait (qmutex, timout_msec);
}
static void
dbus_qcondvar_wake_one (DBusCondVar *cond)
{
QWaitCondition *qcond = static_cast<QWaitCondition*>(cond);
qcond->wakeOne (qmutex);
}
static void
dbus_qcondvar_wake_all (DBusCondVar *cond)
{
QWaitCondition *qcond = static_cast<QWaitCondition*>(cond);
qcond->wakeAll (qmutex);
}
extern "C" {
void

2
test/Makefile.am
View file

@ -24,6 +24,8 @@ unbase64_SOURCES= \
bus_test_SOURCES = \
debug-thread.c \
debug-thread.h \
bus-test.c
break_loader_SOURCES= \

4
test/bus-test.c
View file

@ -8,6 +8,8 @@
#undef DBUS_COMPILATION
#include "debug-thread.h"
typedef struct
{
long time;
@ -140,6 +142,8 @@ main (int argc,
DBusMessage *message;
DBusMessageHandler *handler;
debug_threads_init ();
server = dbus_server_listen ("debug:name=test-server", &result);
dbus_server_set_new_connection_function (server,
new_connection_callback,

161
test/debug-thread.c Normal file
View file

@ -0,0 +1,161 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-test.c Program to run all tests
*
* Copyright (C) 2002 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <stdlib.h>
#include <dbus/dbus.h>
#include "debug-thread.h"
#define DBUS_COMPILATION
#include <dbus/dbus-internals.h>
#undef DBUS_COMPILATION
static DBusMutex * tmutex_new (void);
static void tmutex_free (DBusMutex *mutex);
static dbus_bool_t tmutex_lock (DBusMutex *mutex);
static dbus_bool_t tmutex_unlock (DBusMutex *mutex);
static DBusCondVar*tcondvar_new (void);
static void tcondvar_free (DBusCondVar *cond);
static void tcondvar_wait (DBusCondVar *cond,
DBusMutex *mutex);
static dbus_bool_t tcondvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_msec);
static void tcondvar_wake_one (DBusCondVar *cond);
static void tcondvar_wake_all (DBusCondVar *cond);
static const DBusThreadFunctions functions =
{
DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK |
DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK |
DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK |
DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK |
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK|
DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK,
tmutex_new,
tmutex_free,
tmutex_lock,
tmutex_unlock,
tcondvar_new,
tcondvar_free,
tcondvar_wait,
tcondvar_wait_timeout,
tcondvar_wake_one,
tcondvar_wake_all
};
static DBusMutex *
tmutex_new (void)
{
int *tmutex;
tmutex = malloc (sizeof (int*));
*tmutex = 0;
return (DBusMutex *)tmutex;
}
static void
tmutex_free (DBusMutex *mutex)
{
free (mutex);
}
static dbus_bool_t
tmutex_lock (DBusMutex *mutex)
{
int *tmutex = (int *)mutex;
_dbus_assert (*tmutex == 0);
*tmutex = 1;
return TRUE;
}
static dbus_bool_t
tmutex_unlock (DBusMutex *mutex)
{
int *tmutex = (int *)mutex;
_dbus_assert (*tmutex == 1);
*tmutex = 0;
return TRUE;
}
static DBusCondVar*
tcondvar_new (void)
{
return (DBusCondVar*)0xcafebabe;
}
static void
tcondvar_free (DBusCondVar *cond)
{
}
static void
tcondvar_wait (DBusCondVar *cond,
DBusMutex *mutex)
{
int *tmutex = (int *)mutex;
_dbus_assert (*tmutex == 1);
}
static dbus_bool_t
tcondvar_wait_timeout (DBusCondVar *cond,
DBusMutex *mutex,
int timeout_msec)
{
int *tmutex = (int *)mutex;
_dbus_assert (*tmutex == 1);
return TRUE;
}
static void
tcondvar_wake_one (DBusCondVar *cond)
{
}
static void
tcondvar_wake_all (DBusCondVar *cond)
{
}
void
debug_threads_init (void)
{
dbus_threads_init (&functions);
}

29
test/debug-thread.h Normal file
View file

@ -0,0 +1,29 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-test.c Program to run all tests
*
* Copyright (C) 2002 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef DEBUG_THREAD_H
#define DEBUG_THREAD_H
void debug_threads_init (void);
#endif

71
test/watch.c
View file

@ -130,6 +130,17 @@ remove_server_watch (DBusWatch *watch,
static int count = 0;
static void
disconnect (DBusConnection *connection)
{
fprintf (stderr, "Disconnected\n");
_dbus_list_remove (&connections, connection);
dbus_connection_unref (connection);
quit_mainloop ();
}
static void
check_messages (void)
{
@ -141,28 +152,37 @@ check_messages (void)
DBusList *next = _dbus_list_get_next_link (&connections, link);
DBusConnection *connection = link->data;
DBusMessage *message;
const char *name;
while ((message = dbus_connection_pop_message (connection)))
{
DBusMessage *reply;
fprintf (stderr, "Received message %d, sending reply\n", count);
reply = dbus_message_new ("org.freedesktop.DBus.Test", "org.freedesktop.DBus.Test");
dbus_connection_send_message (connection,
reply,
NULL,
NULL);
dbus_message_unref (reply);
dbus_message_unref (message);
count += 1;
if (count > 100)
{
printf ("Saw %d messages, exiting\n", count);
quit_mainloop ();
}
name = dbus_message_get_name (message);
if (name && strcmp (name, DBUS_MESSAGE_LOCAL_DISCONNECT) == 0)
{
disconnect (connection);
}
else
{
fprintf (stderr, "Received message %d, sending reply\n", count);
reply = dbus_message_new ("org.freedesktop.DBus.Test", "org.freedesktop.DBus.Test");
dbus_connection_send_message (connection,
reply,
NULL,
NULL);
dbus_message_unref (reply);
dbus_message_unref (message);
count += 1;
if (count > 100)
{
printf ("Saw %d messages, exiting\n", count);
quit_mainloop ();
}
}
}
link = next;
@ -185,6 +205,9 @@ do_mainloop (void)
int initial_watch_serial;
check_messages ();
if (exited)
break;
FD_ZERO (&read_set);
FD_ZERO (&write_set);
@ -297,16 +320,6 @@ quit_mainloop (void)
exited = TRUE;
}
static void
disconnect_handler (DBusConnection *connection,
void *data)
{
fprintf (stderr, "Disconnected\n");
_dbus_list_remove (&connections, connection);
dbus_connection_unref (connection);
quit_mainloop ();
}
void
setup_connection (DBusConnection *connection)
@ -317,10 +330,6 @@ setup_connection (DBusConnection *connection)
connection,
NULL);
dbus_connection_set_disconnect_function (connection,
disconnect_handler,
NULL, NULL);
dbus_connection_ref (connection);
_dbus_list_append (&connections, connection);
}