Commit 17fbe2b7 authored by Havoc Pennington's avatar Havoc Pennington

2002-12-24 Havoc Pennington <hp@pobox.com>

	* glib/dbus-gthread.c: fix include

	* glib/dbus-glib.h: rename DBusMessageHandler for now.
	I think glib API needs to change, though, as you don't
	want to use DBusMessageFunction, you want to use the
	DBusMessageHandler object. Probably
	dbus_connection_open_with_g_main_loop()
	and dbus_connection_setup_g_main_loop() or something like that
	(but think of better names...) that just create a connection
	that has watch/timeout functions etc. already set up.

	* dbus/dbus-connection.c
	(dbus_connection_send_message_with_reply): new function just to
	show how the message handler helps us deal with replies.

	* dbus/dbus-list.c (_dbus_list_remove_last): new function

	* dbus/dbus-string.c (_dbus_string_test): free a string that
	wasn't

	* dbus/dbus-hash.c: use memory pools for the hash entries
	(rebuild_table): be more paranoid about overflow, and
	shrink table when we can
	(_dbus_hash_test): reduce number of sprintfs and write
	valid C89. Add tests for case where we grow and then
	shrink the hash table.

	* dbus/dbus-mempool.h, dbus/dbus-mempool.c: memory pools

	* dbus/dbus-connection.c (dbus_connection_register_handler)
	(dbus_connection_unregister_handler): new functions

	* dbus/dbus-message.c (dbus_message_get_name): new

	* dbus/dbus-list.c: fix docs typo

	* dbus/dbus-message-handler.h, dbus/dbus-message-handler.c:
	an object representing a handler for messages.
parent 7af22a5e
2002-12-24 Havoc Pennington <hp@pobox.com>
* glib/dbus-gthread.c: fix include
* glib/dbus-glib.h: rename DBusMessageHandler for now.
I think glib API needs to change, though, as you don't
want to use DBusMessageFunction, you want to use the
DBusMessageHandler object. Probably
dbus_connection_open_with_g_main_loop()
and dbus_connection_setup_g_main_loop() or something like that
(but think of better names...) that just create a connection
that has watch/timeout functions etc. already set up.
* dbus/dbus-connection.c
(dbus_connection_send_message_with_reply): new function just to
show how the message handler helps us deal with replies.
* dbus/dbus-list.c (_dbus_list_remove_last): new function
* dbus/dbus-string.c (_dbus_string_test): free a string that
wasn't
* dbus/dbus-hash.c: use memory pools for the hash entries
(rebuild_table): be more paranoid about overflow, and
shrink table when we can
(_dbus_hash_test): reduce number of sprintfs and write
valid C89. Add tests for case where we grow and then
shrink the hash table.
* dbus/dbus-mempool.h, dbus/dbus-mempool.c: memory pools
* dbus/dbus-connection.c (dbus_connection_register_handler)
(dbus_connection_unregister_handler): new functions
* dbus/dbus-message.c (dbus_message_get_name): new
* dbus/dbus-list.c: fix docs typo
* dbus/dbus-message-handler.h, dbus/dbus-message-handler.c:
an object representing a handler for messages.
2002-12-16 Anders Carlsson <andersca@codefactory.se>
* glib/dbus-glib.h:
......
......@@ -11,6 +11,7 @@ dbusinclude_HEADERS= \
dbus-macros.h \
dbus-memory.h \
dbus-message.h \
dbus-message-handler.h \
dbus-server.h \
dbus-threads.h \
dbus-types.h
......@@ -21,6 +22,7 @@ libdbus_1_la_SOURCES= \
dbus-errors.c \
dbus-memory.c \
dbus-message.c \
dbus-message-handler.c \
dbus-message-internal.h \
dbus-server.c \
dbus-server-protected.h \
......@@ -51,6 +53,8 @@ libdbus_convenience_la_SOURCES= \
dbus-internals.h \
dbus-list.c \
dbus-list.h \
dbus-mempool.c \
dbus-mempool.h \
dbus-string.c \
dbus-string.h \
dbus-sysdeps.c \
......
......@@ -59,6 +59,20 @@ void _dbus_connection_do_iteration (DBusConnection *connect
void _dbus_connection_transport_error (DBusConnection *connection,
DBusResultCode result_code);
void _dbus_connection_handler_destroyed (DBusConnection *connection,
DBusMessageHandler *handler);
dbus_bool_t _dbus_message_handler_add_connection (DBusMessageHandler *handler,
DBusConnection *connection);
void _dbus_message_handler_remove_connection (DBusMessageHandler *handler,
DBusConnection *connection);
DBusHandlerResult _dbus_message_handler_handle_message (DBusMessageHandler *handler,
DBusConnection *connection,
DBusMessage *message);
DBUS_END_DECLS;
#endif /* DBUS_CONNECTION_INTERNAL_H */
......@@ -27,6 +27,7 @@
#include "dbus-watch.h"
#include "dbus-connection-internal.h"
#include "dbus-list.h"
#include "dbus-hash.h"
#include "dbus-message-internal.h"
/**
......@@ -75,6 +76,10 @@ struct DBusConnection
DBusConnectionErrorFunction error_function; /**< Callback for errors. */
void *error_data; /**< Data for error callback. */
DBusFreeFunction error_free_data_function; /**< Free function for error callback data. */
DBusHashTable *handler_table; /**< Table of registered DBusMessageHandler */
DBusList *filter_list; /**< List of filters. */
int filters_serial; /**< Increments when the list of filters is changed. */
int handlers_serial; /**< Increments when the handler table is changed. */
};
/**
......@@ -270,13 +275,21 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
{
DBusConnection *connection;
DBusWatchList *watch_list;
DBusHashTable *handler_table;
watch_list = NULL;
connection = NULL;
handler_table = NULL;
watch_list = _dbus_watch_list_new ();
if (watch_list == NULL)
goto error;
handler_table =
_dbus_hash_table_new (DBUS_HASH_STRING,
dbus_free, NULL);
if (handler_table == NULL)
goto error;
connection = dbus_new0 (DBusConnection, 1);
if (connection == NULL)
......@@ -285,7 +298,9 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
connection->refcount = 1;
connection->transport = transport;
connection->watches = watch_list;
connection->handler_table = handler_table;
connection->filter_list = NULL;
_dbus_transport_ref (transport);
_dbus_transport_set_connection (transport, connection);
......@@ -293,14 +308,56 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
error:
_dbus_assert (connection == NULL);
if (connection != NULL)
dbus_free (connection);
if (handler_table)
_dbus_hash_table_unref (handler_table);
if (watch_list)
_dbus_watch_list_free (watch_list);
return NULL;
}
/**
* Used to notify a connection when a DBusMessageHandler is
* destroyed, so the connection can drop any reference
* to the handler.
*
* @param connection the connection
* @param handler the handler
*/
void
_dbus_connection_handler_destroyed (DBusConnection *connection,
DBusMessageHandler *handler)
{
DBusHashIter iter;
DBusList *link;
_dbus_hash_iter_init (connection->handler_table, &iter);
while (_dbus_hash_iter_next (&iter))
{
DBusMessageHandler *h = _dbus_hash_iter_get_value (&iter);
if (h == handler)
_dbus_hash_iter_remove_entry (&iter);
}
link = _dbus_list_get_first_link (&connection->filter_list);
while (link != NULL)
{
DBusMessageHandler *h = link->data;
DBusList *next = _dbus_list_get_next_link (&connection->filter_list, link);
if (h == handler)
_dbus_list_remove_link (&connection->filter_list,
link);
link = next;
}
}
/** @} */
/**
......@@ -377,11 +434,38 @@ dbus_connection_unref (DBusConnection *connection)
connection->refcount -= 1;
if (connection->refcount == 0)
{
DBusHashIter iter;
DBusList *link;
/* free error data as a side effect */
dbus_connection_set_error_function (connection,
NULL, NULL, NULL);
_dbus_watch_list_free (connection->watches);
_dbus_hash_iter_init (connection->handler_table, &iter);
while (_dbus_hash_iter_next (&iter))
{
DBusMessageHandler *h = _dbus_hash_iter_get_value (&iter);
_dbus_message_handler_remove_connection (h, connection);
}
link = _dbus_list_get_first_link (&connection->filter_list);
while (link != NULL)
{
DBusMessageHandler *h = link->data;
DBusList *next = _dbus_list_get_next_link (&connection->filter_list, link);
_dbus_message_handler_remove_connection (h, connection);
link = next;
}
_dbus_hash_table_unref (connection->handler_table);
connection->handler_table = NULL;
_dbus_list_clear (&connection->filter_list);
_dbus_list_foreach (&connection->outgoing_messages,
(DBusForeachFunction) dbus_message_unref,
......@@ -470,6 +554,66 @@ dbus_connection_send_message (DBusConnection *connection,
return TRUE;
}
/**
* Queues a message to send, as with dbus_connection_send_message(),
* but also sets up a DBusMessageHandler to receive a reply to the
* message. If no reply is received in the given timeout_milliseconds,
* expires the pending reply and sends the DBusMessageHandler a
* synthetic error reply (generated in-process, not by the remote
* application) indicating that a timeout occurred.
*
* Reply handlers see their replies after message filters see them,
* but before message handlers added with
* dbus_connection_register_handler() see them, regardless of the
* reply message's name. Reply handlers are only handed a single
* message as a reply, after a reply has been seen the handler is
* removed. If a filter filters out the reply before the handler sees
* it, the handler is not removed but the timeout will immediately
* fire again. If a filter was dumb and kept removing the timeout
* reply then we'd get in an infinite loop.
*
* If #NULL is passed for the reply_handler, the timeout reply will
* still be generated and placed into the message queue, but no
* specific message handler will receive the reply.
*
* If -1 is passed for the timeout, a sane default timeout is used. -1
* is typically the best value for the timeout for this reason, unless
* you want a very short or very long timeout. There is no way to
* avoid a timeout entirely, other than passing INT_MAX for the
* timeout to postpone it indefinitely.
*
* @param connection the connection
* @param message the message to send
* @param reply_handler message handler expecting the reply, or #NULL
* @param timeout_milliseconds timeout in milliseconds or -1 for default
* @param result return location for result code
* @returns #TRUE if the message is successfully queued, #FALSE if no memory.
*
* @todo this function isn't implemented because we need message serials
* and other slightly more rich DBusMessage implementation in order to
* implement it. The basic idea will be to keep a hash of serials we're
* expecting a reply to, and also to add a way to tell GLib or Qt to
* install a timeout. Then install a timeout which is the shortest
* timeout of any pending reply.
*
* @todo implement non-reentrant "block for reply" variant. i.e. send
* a message, block until we get a reply, then pull reply out of
* message queue and return it, *without dispatching any handlers for
* any other messages* - used for non-reentrant "method calls" We can
* block properly for this using _dbus_connection_do_iteration().
*
*/
dbus_bool_t
dbus_connection_send_message_with_reply (DBusConnection *connection,
DBusMessage *message,
DBusMessageHandler *reply_handler,
int timeout_milliseconds,
DBusResultCode *result)
{
/* FIXME */
return dbus_connection_send_message (connection, message, result);
}
/**
* Blocks until the outgoing message queue is empty.
*
......@@ -531,6 +675,90 @@ dbus_connection_pop_message (DBusConnection *connection)
return NULL;
}
/**
* Pops the first-received message from the current incoming message
* queue, runs any handlers for it, then unrefs the message.
*
* @param connection the connection
* @returns #TRUE if the queue is not empty after dispatch
*
* @todo this function is not properly robust against reentrancy,
* that is, if handlers are added/removed while dispatching
* a message, things will get messed up.
*/
dbus_bool_t
dbus_connection_dispatch_message (DBusConnection *connection)
{
DBusMessage *message;
int filter_serial;
int handler_serial;
DBusList *link;
DBusHandlerResult result;
const char *name;
dbus_connection_ref (connection);
message = dbus_connection_pop_message (connection);
if (message == NULL)
return FALSE;
filter_serial = connection->filters_serial;
handler_serial = connection->handlers_serial;
result = DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
link = _dbus_list_get_first_link (&connection->filter_list);
while (link != NULL)
{
DBusMessageHandler *handler = link->data;
DBusList *next = _dbus_list_get_next_link (&connection->filter_list, link);
result = _dbus_message_handler_handle_message (handler, connection,
message);
if (result == DBUS_HANDLER_RESULT_REMOVE_MESSAGE)
goto out;
if (filter_serial != connection->filters_serial)
{
_dbus_warn ("Message filters added or removed while dispatching filters - not currently supported!\n");
goto out;
}
link = next;
}
name = dbus_message_get_name (message);
if (name != NULL)
{
DBusMessageHandler *handler;
handler = _dbus_hash_table_lookup_string (connection->handler_table,
name);
if (handler != NULL)
{
result = _dbus_message_handler_handle_message (handler, connection,
message);
if (result == DBUS_HANDLER_RESULT_REMOVE_MESSAGE)
goto out;
if (handler_serial != connection->handlers_serial)
{
_dbus_warn ("Message handlers added or removed while dispatching handlers - not currently supported!\n");
goto out;
}
}
}
out:
dbus_connection_unref (connection);
dbus_message_unref (message);
return connection->n_incoming > 0;
}
/**
* Sets the error handler function for the connection.
*
......@@ -623,4 +851,185 @@ dbus_connection_handle_watch (DBusConnection *connection,
watch, condition);
}
/**
* Adds a message filter. Filters are handlers that are run on
* all incoming messages, prior to the normal handlers
* registered with dbus_connection_register_handler().
* Filters are run in the order that they were added.
* The same handler can be added as a filter more than once, in
* which case it will be run more than once.
*
* @param connection the connection
* @param handler the handler
* @returns #TRUE on success, #FALSE if not enough memory.
*/
dbus_bool_t
dbus_connection_add_filter (DBusConnection *connection,
DBusMessageHandler *handler)
{
if (!_dbus_message_handler_add_connection (handler, connection))
return FALSE;
if (!_dbus_list_append (&connection->filter_list,
handler))
{
_dbus_message_handler_remove_connection (handler, connection);
return FALSE;
}
connection->filters_serial += 1;
return TRUE;
}
/**
* Removes a previously-added message filter. It is a programming
* error to call this function for a handler that has not
* been added as a filter. If the given handler was added
* more than once, only one instance of it will be removed
* (the most recently-added instance).
*
* @param connection the connection
* @param handler the handler to remove
*
*/
void
dbus_connection_remove_filter (DBusConnection *connection,
DBusMessageHandler *handler)
{
if (!_dbus_list_remove_last (&connection->filter_list, handler))
{
_dbus_warn ("Tried to remove a DBusConnection filter that had not been added\n");
return;
}
_dbus_message_handler_remove_connection (handler, connection);
connection->filters_serial += 1;
}
/**
* Registers a handler for a list of message names. A single handler
* can be registered for any number of message names, but each message
* name can only have one handler at a time. It's not allowed to call
* this function with the name of a message that already has a
* handler. If the function returns #FALSE, the handlers were not
* registered due to lack of memory.
*
* @param connection the connection
* @param handler the handler
* @param messages_to_handle the messages to handle
* @param n_messages the number of message names in messages_to_handle
* @returns #TRUE on success, #FALSE if no memory or another handler already exists
*
**/
dbus_bool_t
dbus_connection_register_handler (DBusConnection *connection,
DBusMessageHandler *handler,
const char **messages_to_handle,
int n_messages)
{
int i;
i = 0;
while (i < n_messages)
{
DBusHashIter iter;
char *key;
key = _dbus_strdup (messages_to_handle[i]);
if (key == NULL)
goto failed;
if (!_dbus_hash_iter_lookup (connection->handler_table,
key, TRUE,
&iter))
{
dbus_free (key);
goto failed;
}
if (_dbus_hash_iter_get_value (&iter) != NULL)
{
_dbus_warn ("Bug in application: attempted to register a second handler for %s\n",
messages_to_handle[i]);
dbus_free (key); /* won't have replaced the old key with the new one */
goto failed;
}
if (!_dbus_message_handler_add_connection (handler, connection))
{
_dbus_hash_iter_remove_entry (&iter);
/* key has freed on nuking the entry */
goto failed;
}
_dbus_hash_iter_set_value (&iter, handler);
connection->handlers_serial += 1;
++i;
}
return TRUE;
failed:
/* unregister everything registered so far,
* so we don't fail partially
*/
dbus_connection_unregister_handler (connection,
handler,
messages_to_handle,
i);
return FALSE;
}
/**
* Unregisters a handler for a list of message names. The handlers
* must have been previously registered.
*
* @param connection the connection
* @param handler the handler
* @param messages_to_handle the messages to handle
* @param n_messages the number of message names in messages_to_handle
*
**/
void
dbus_connection_unregister_handler (DBusConnection *connection,
DBusMessageHandler *handler,
const char **messages_to_handle,
int n_messages)
{
int i;
i = 0;
while (i < n_messages)
{
DBusHashIter iter;
if (!_dbus_hash_iter_lookup (connection->handler_table,
(char*) messages_to_handle[i], FALSE,
&iter))
{
_dbus_warn ("Bug in application: attempted to unregister handler for %s which was not registered\n",
messages_to_handle[i]);
}
else if (_dbus_hash_iter_get_value (&iter) != handler)
{
_dbus_warn ("Bug in application: attempted to unregister handler for %s which was registered by a different handler\n",
messages_to_handle[i]);
}
else
{
_dbus_hash_iter_remove_entry (&iter);
_dbus_message_handler_remove_connection (handler, connection);
}
++i;
}
connection->handlers_serial += 1;
}
/** @} */
......@@ -35,6 +35,13 @@ DBUS_BEGIN_DECLS;
typedef struct DBusConnection DBusConnection;
typedef struct DBusWatch DBusWatch;
typedef struct DBusMessageHandler DBusMessageHandler;
typedef enum
{
DBUS_HANDLER_RESULT_REMOVE_MESSAGE, /**< Remove this message, no further processing. */
DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS /**< Run any additional handlers that are interested on this message. */
} DBusHandlerResult;
typedef enum
{
......@@ -63,15 +70,21 @@ 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_send_message (DBusConnection *connection,
DBusMessage *message,
DBusResultCode *result);
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,
DBusResultCode *result);
dbus_bool_t dbus_connection_send_message_with_reply (DBusConnection *connection,
DBusMessage *message,
DBusMessageHandler *reply_handler,
int timeout_milliseconds,
DBusResultCode *result);
void dbus_connection_set_error_function (DBusConnection *connection,
DBusConnectionErrorFunction error_function,
......@@ -86,7 +99,6 @@ void dbus_connection_handle_watch (DBusConnection *connectio
DBusWatch *watch,
unsigned int condition);
int dbus_watch_get_fd (DBusWatch *watch);
unsigned int dbus_watch_get_flags (DBusWatch *watch);
void* dbus_watch_get_data (DBusWatch *watch);
......@@ -95,6 +107,21 @@ void dbus_watch_set_data (DBusWatch *watch,
DBusFreeFunction free_data_function);
/* Handlers */
dbus_bool_t dbus_connection_add_filter (DBusConnection *connection,
DBusMessageHandler *handler);
void dbus_connection_remove_filter (DBusConnection *connection,
DBusMessageHandler *handler);
dbus_bool_t dbus_connection_register_handler (DBusConnection *connection,
DBusMessageHandler *handler,
const char **messages_to_handle,
int n_messages);
void dbus_connection_unregister_handler (DBusConnection *connection,
DBusMessageHandler *handler,
const char **messages_to_handle,
int n_messages);
DBUS_END_DECLS;
#endif /* DBUS_CONNECTION_H */
......@@ -76,6 +76,7 @@
#include "dbus-hash.h"
#include "dbus-internals.h"
#include "dbus-mempool.h"
/**