+2003-02-26 Havoc Pennington <hp@pobox.com>
+
+ * dbus/dbus-connection.c
+ (dbus_connection_send_message_with_reply_and_block): fix crash
+ where we ref'd the outgoing message instead of the returned reply
+
+ * dbus/dbus-transport-unix.c (do_authentication): check read watch
+ at the end of this function, so if we didn't need to read for
+ authentication, we reinstall it for receiving messages
+
+ * dbus/dbus-message.c (dbus_message_new_reply): allow replies to
+ a NULL sender for peer-to-peer case
+
+ * dbus/dbus-transport-unix.c (check_read_watch): handle
+ !authenticated case correctly
+
+ * glib/dbus-gmain.c: add support for DBusServer
+
+ * dbus/dbus-server.c: add data slot support
+
+ * glib/dbus-gmain.c (dbus_connection_setup_with_g_main): check
+ return values and handle errors
+
+ * dbus/dbus-dataslot.c: factor out the data slot stuff from
+ DBusConnection
+
+ * Doxyfile.in (INPUT): add glib subdir
+
+ * glib/dbus-gmain.c (dbus_connection_setup_with_g_main): rename
+ setup_with_g_main instead of hookup_with_g_main; write docs
+
2003-02-24 Anders Carlsson <andersca@codefactory.se>
* dbus/dbus-marshal.c: (_dbus_marshal_validate_arg):
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
-INPUT = dbus bus
+INPUT = dbus bus glib
FILE_PATTERNS = *.c *.h
RECURSIVE = YES
#EXCLUDE = test
noinst_LTLIBRARIES=libdbus-convenience.la
libdbus_convenience_la_SOURCES= \
+ dbus-dataslot.c \
+ dbus-dataslot.h \
dbus-hash.c \
dbus-hash.h \
dbus-internals.c \
#include "dbus-message-handler.h"
#include "dbus-threads.h"
#include "dbus-protocol.h"
+#include "dbus-dataslot.h"
/**
* @defgroup DBusConnection DBusConnection
static dbus_bool_t _dbus_modify_sigpipe = TRUE;
-/** Opaque typedef for DBusDataSlot */
-typedef struct DBusDataSlot DBusDataSlot;
-/** DBusDataSlot is used to store application data on the connection */
-struct DBusDataSlot
-{
- void *data; /**< The application data */
- DBusFreeFunction free_data_func; /**< Free the application data */
-};
-
/**
* Implementation details of DBusConnection. All fields are private.
*/
DBusHashTable *handler_table; /**< Table of registered DBusMessageHandler */
DBusList *filter_list; /**< List of filters. */
- DBusDataSlot *data_slots; /**< Data slots */
- int n_slots; /**< Slots allocated so far. */
+
+ DBusDataSlotList slot_list; /**< Data stored by allocated integer ID */
DBusHashTable *pending_replies; /**< Hash of message serials and their message handlers. */
DBusCounter *connection_counter; /**< Counter that we decrement when finalized */
static void reply_handler_data_free (ReplyHandlerData *data);
-static void _dbus_connection_free_data_slots_nolock (DBusConnection *connection);
static void _dbus_connection_remove_timeout_locked (DBusConnection *connection,
DBusTimeout *timeout);
connection->pending_replies = pending_replies;
connection->filter_list = NULL;
- connection->data_slots = NULL;
- connection->n_slots = 0;
+ _dbus_data_slot_list_init (&connection->slot_list);
+
connection->client_serial = 1;
connection->disconnect_message_link = disconnect_link;
_dbus_timeout_list_free (connection->timeouts);
connection->timeouts = NULL;
-
- _dbus_connection_free_data_slots_nolock (connection);
+
+ /* calls out to application code... */
+ _dbus_data_slot_list_free (&connection->slot_list);
_dbus_hash_iter_init (connection->handler_table, &iter);
while (_dbus_hash_iter_next (&iter))
* 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.
+ *
+ * @todo I think we should rename this function family
+ * dbus_connection_send(), send_with_reply(), etc. (i.e.
+ * drop the "message" part), the names are too long.
*
* @param connection the connection
* @param message the message to send
* @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.
- *
*/
dbus_bool_t
dbus_connection_send_message_with_reply (DBusConnection *connection,
* wrong, result is set to whatever is appropriate, such as
* #DBUS_RESULT_NO_MEMORY.
*
- * @todo I believe if we get EINTR or otherwise interrupt the
- * do_iteration call in here, we won't block the required length of
- * time. I think there probably has to be a loop: "while (!timeout_elapsed)
- * { check_for_reply_in_queue(); iterate_with_remaining_timeout(); }"
+ * @todo could use performance improvements (it keeps scanning
+ * the whole message queue for example) and has thread issues,
+ * see comments in source
*
* @param connection the connection
* @param message the message to send
{
dbus_int32_t client_serial;
DBusList *link;
+ long start_tv_sec, start_tv_usec;
+ long end_tv_sec, end_tv_usec;
+ long tv_sec, tv_usec;
if (timeout_milliseconds == -1)
timeout_milliseconds = DEFAULT_TIMEOUT_VALUE;
+
+ /* it would probably seem logical to pass in _DBUS_INT_MAX
+ * for infinite timeout, but then math below would get
+ * all overflow-prone, so smack that down.
+ */
+ if (timeout_milliseconds > _DBUS_ONE_HOUR_IN_MILLISECONDS * 6)
+ timeout_milliseconds = _DBUS_ONE_HOUR_IN_MILLISECONDS * 6;
if (!dbus_connection_send_message (connection, message, &client_serial, result))
return NULL;
+ message = NULL;
+
/* Flush message queue */
dbus_connection_flush (connection);
dbus_mutex_lock (connection->mutex);
+
+ _dbus_get_current_time (&start_tv_sec, &start_tv_usec);
+ end_tv_sec = start_tv_sec + timeout_milliseconds / 1000;
+ end_tv_usec = start_tv_usec + (timeout_milliseconds % 1000) * 1000;
+ end_tv_sec += end_tv_usec / _DBUS_USEC_PER_SECOND;
+ end_tv_usec = end_tv_usec % _DBUS_USEC_PER_SECOND;
+
+ _dbus_verbose ("will block %d milliseconds from %ld sec %ld usec to %ld sec %ld usec\n",
+ timeout_milliseconds,
+ start_tv_sec, start_tv_usec,
+ end_tv_sec, end_tv_usec);
/* Now we wait... */
/* THREAD TODO: This is busted. What if a dispatch_message or pop_message
* gets the message before we do?
*/
+ block_again:
+
_dbus_connection_do_iteration (connection,
DBUS_ITERATION_DO_READING |
DBUS_ITERATION_BLOCK,
if (_dbus_message_get_reply_serial (reply) == client_serial)
{
_dbus_list_remove (&connection->incoming_messages, link);
- dbus_message_ref (message);
+ dbus_message_ref (reply);
if (result)
*result = DBUS_RESULT_SUCCESS;
link = _dbus_list_get_next_link (&connection->incoming_messages, link);
}
- if (result)
- *result = DBUS_RESULT_NO_REPLY;
+ _dbus_get_current_time (&tv_sec, &tv_usec);
+
+ if (tv_sec < start_tv_sec)
+ ; /* clock set backward, bail out */
+ else if (connection->disconnect_message_link == NULL)
+ ; /* we're disconnected, bail out */
+ else if (tv_sec < end_tv_sec ||
+ (tv_sec == end_tv_sec && tv_usec < end_tv_usec))
+ {
+ timeout_milliseconds = (end_tv_sec - tv_sec) * 1000 +
+ (end_tv_usec - tv_usec) / 1000;
+ _dbus_verbose ("%d milliseconds remain\n", timeout_milliseconds);
+ _dbus_assert (timeout_milliseconds > 0);
+
+ goto block_again; /* not expired yet */
+ }
+
+ if (dbus_connection_get_is_connected (connection))
+ dbus_set_result (result, DBUS_RESULT_NO_REPLY);
+ else
+ dbus_set_result (result, DBUS_RESULT_DISCONNECTED);
dbus_mutex_unlock (connection->mutex);
* 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.
+ *
+ * @todo the messages_to_handle arg may be more convenient if it's a
+ * single string instead of an array. Though right now MessageHandler
+ * is sort of designed to say be associated with an entire object with
+ * multiple methods, that's why for example the connection only
+ * weakrefs it. So maybe the "manual" API should be different.
*
* @param connection the connection
* @param handler the handler
dbus_mutex_unlock (connection->mutex);
}
-static int *allocated_slots = NULL;
-static int n_allocated_slots = 0;
-static int n_used_slots = 0;
-static DBusMutex *allocated_slots_lock = NULL;
+static DBusDataSlotAllocator slot_allocator;
/**
- * Initialize the mutex used for #DBusConnecton data
+ * Initialize the mutex used for #DBusConnection data
* slot reservations.
*
* @returns the mutex
*/
DBusMutex *
-_dbus_allocated_slots_init_lock (void)
+_dbus_connection_slots_init_lock (void)
{
- allocated_slots_lock = dbus_mutex_new ();
- return allocated_slots_lock;
+ if (!_dbus_data_slot_allocator_init (&slot_allocator))
+ return NULL;
+ else
+ return slot_allocator.lock;
}
-
/**
* Allocates an integer ID to be used for storing application-specific
* data on any DBusConnection. The allocated ID may then be used
int
dbus_connection_allocate_data_slot (void)
{
- int slot;
-
- if (!dbus_mutex_lock (allocated_slots_lock))
- return -1;
-
- if (n_used_slots < n_allocated_slots)
- {
- slot = 0;
- while (slot < n_allocated_slots)
- {
- if (allocated_slots[slot] < 0)
- {
- allocated_slots[slot] = slot;
- n_used_slots += 1;
- break;
- }
- ++slot;
- }
-
- _dbus_assert (slot < n_allocated_slots);
- }
- else
- {
- int *tmp;
-
- slot = -1;
- tmp = dbus_realloc (allocated_slots,
- sizeof (int) * (n_allocated_slots + 1));
- if (tmp == NULL)
- goto out;
-
- allocated_slots = tmp;
- slot = n_allocated_slots;
- n_allocated_slots += 1;
- n_used_slots += 1;
- allocated_slots[slot] = slot;
- }
-
- _dbus_assert (slot >= 0);
- _dbus_assert (slot < n_allocated_slots);
-
- out:
- dbus_mutex_unlock (allocated_slots_lock);
- return slot;
+ return _dbus_data_slot_allocator_alloc (&slot_allocator);
}
/**
void
dbus_connection_free_data_slot (int slot)
{
- dbus_mutex_lock (allocated_slots_lock);
-
- _dbus_assert (slot < n_allocated_slots);
- _dbus_assert (allocated_slots[slot] == slot);
-
- allocated_slots[slot] = -1;
- n_used_slots -= 1;
-
- if (n_used_slots == 0)
- {
- dbus_free (allocated_slots);
- allocated_slots = NULL;
- n_allocated_slots = 0;
- }
-
- dbus_mutex_unlock (allocated_slots_lock);
+ _dbus_data_slot_allocator_free (&slot_allocator, slot);
}
/**
{
DBusFreeFunction old_free_func;
void *old_data;
+ dbus_bool_t retval;
dbus_mutex_lock (connection->mutex);
- _dbus_assert (slot < n_allocated_slots);
- _dbus_assert (allocated_slots[slot] == slot);
-
- if (slot >= connection->n_slots)
- {
- DBusDataSlot *tmp;
- int i;
-
- tmp = dbus_realloc (connection->data_slots,
- sizeof (DBusDataSlot) * (slot + 1));
- if (tmp == NULL)
- {
- dbus_mutex_unlock (connection->mutex);
- return FALSE;
- }
-
- connection->data_slots = tmp;
- i = connection->n_slots;
- connection->n_slots = slot + 1;
- while (i < connection->n_slots)
- {
- connection->data_slots[i].data = NULL;
- connection->data_slots[i].free_data_func = NULL;
- ++i;
- }
- }
-
- _dbus_assert (slot < connection->n_slots);
-
- old_data = connection->data_slots[slot].data;
- old_free_func = connection->data_slots[slot].free_data_func;
-
- connection->data_slots[slot].data = data;
- connection->data_slots[slot].free_data_func = free_data_func;
+ retval = _dbus_data_slot_list_set (&slot_allocator,
+ &connection->slot_list,
+ slot, data, free_data_func,
+ &old_free_func, &old_data);
+
dbus_mutex_unlock (connection->mutex);
- /* Do the actual free outside the connection lock */
- if (old_free_func)
- (* old_free_func) (old_data);
+ if (retval)
+ {
+ /* Do the actual free outside the connection lock */
+ if (old_free_func)
+ (* old_free_func) (old_data);
+ }
- return TRUE;
+ return retval;
}
/**
void *res;
dbus_mutex_lock (connection->mutex);
-
- _dbus_assert (slot < n_allocated_slots);
- _dbus_assert (allocated_slots[slot] == slot);
-
- if (slot >= connection->n_slots)
- res = NULL;
- else
- res = connection->data_slots[slot].data;
+ res = _dbus_data_slot_list_get (&slot_allocator,
+ &connection->slot_list,
+ slot);
+
dbus_mutex_unlock (connection->mutex);
return res;
_dbus_modify_sigpipe = will_modify_sigpipe;
}
-/* This must be called with the connection lock not held to avoid
- * holding it over the free_data callbacks, so it can basically
- * only be called at last unref
- */
-static void
-_dbus_connection_free_data_slots_nolock (DBusConnection *connection)
-{
- int i;
-
- i = 0;
- while (i < connection->n_slots)
- {
- if (connection->data_slots[i].free_data_func)
- (* connection->data_slots[i].free_data_func) (connection->data_slots[i].data);
- connection->data_slots[i].data = NULL;
- connection->data_slots[i].free_data_func = NULL;
- ++i;
- }
-
- dbus_free (connection->data_slots);
- connection->data_slots = NULL;
- connection->n_slots = 0;
-}
-
/**
* Specifies the maximum size message this connection is allowed to
* receive. Larger messages will result in disconnecting the
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-dataslot.c storing data on objects
+ *
+ * Copyright (C) 2003 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 "dbus-dataslot.h"
+#include "dbus-threads.h"
+
+/**
+ * @defgroup DBusDataSlot Data slots
+ * @ingroup DBusInternals
+ * @brief Storing data by ID
+ *
+ * Types and functions related to storing data by an
+ * allocated ID. This is used for dbus_connection_set_data(),
+ * dbus_server_set_data(), etc.
+ * @{
+ */
+
+/**
+ * Initializes a data slot allocator object, used to assign
+ * integer IDs for data slots.
+ *
+ * @param allocator the allocator to initialize
+ */
+dbus_bool_t
+_dbus_data_slot_allocator_init (DBusDataSlotAllocator *allocator)
+{
+ allocator->allocated_slots = NULL;
+ allocator->n_allocated_slots = 0;
+ allocator->n_used_slots = 0;
+ allocator->lock = dbus_mutex_new ();
+ if (allocator->lock == NULL)
+ return FALSE;
+ else
+ return TRUE;
+}
+
+/**
+ * Allocates an integer ID to be used for storing data
+ * in a #DBusDataSlotList.
+ *
+ * @param allocator the allocator
+ * @returns the integer ID, or -1 on failure
+ */
+int
+_dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator)
+{
+ int slot;
+
+ if (!dbus_mutex_lock (allocator->lock))
+ return -1;
+
+ if (allocator->n_used_slots < allocator->n_allocated_slots)
+ {
+ slot = 0;
+ while (slot < allocator->n_allocated_slots)
+ {
+ if (allocator->allocated_slots[slot] < 0)
+ {
+ allocator->allocated_slots[slot] = slot;
+ allocator->n_used_slots += 1;
+ break;
+ }
+ ++slot;
+ }
+
+ _dbus_assert (slot < allocator->n_allocated_slots);
+ }
+ else
+ {
+ int *tmp;
+
+ slot = -1;
+ tmp = dbus_realloc (allocator->allocated_slots,
+ sizeof (int) * (allocator->n_allocated_slots + 1));
+ if (tmp == NULL)
+ goto out;
+
+ allocator->allocated_slots = tmp;
+ slot = allocator->n_allocated_slots;
+ allocator->n_allocated_slots += 1;
+ allocator->n_used_slots += 1;
+ allocator->allocated_slots[slot] = slot;
+ }
+
+ _dbus_assert (slot >= 0);
+ _dbus_assert (slot < allocator->n_allocated_slots);
+
+ out:
+ dbus_mutex_unlock (allocator->lock);
+ return slot;
+}
+
+/**
+ * Deallocates an ID previously allocated with
+ * _dbus_data_slot_allocator_alloc(). Existing data stored on
+ * existing #DBusDataList objects with this ID will be freed when the
+ * data list is finalized, but may not be retrieved (and may only be
+ * replaced if someone else reallocates the slot).
+ *
+ * @param allocator the allocator
+ * @param slot the slot to deallocate
+ */
+void
+_dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator,
+ int slot)
+{
+ dbus_mutex_lock (allocator->lock);
+
+ _dbus_assert (slot < allocator->n_allocated_slots);
+ _dbus_assert (allocator->allocated_slots[slot] == slot);
+
+ allocator->allocated_slots[slot] = -1;
+ allocator->n_used_slots -= 1;
+
+ if (allocator->n_used_slots == 0)
+ {
+ dbus_free (allocator->allocated_slots);
+ allocator->allocated_slots = NULL;
+ allocator->n_allocated_slots = 0;
+ }
+
+ dbus_mutex_unlock (allocator->lock);
+}
+
+/**
+ * Initializes a slot list.
+ * @param list the list to initialize.
+ */
+void
+_dbus_data_slot_list_init (DBusDataSlotList *list)
+{
+ list->slots = NULL;
+ list->n_slots = 0;
+}
+
+/**
+ * Stores a pointer in the data slot list, along with an optional
+ * function to be used for freeing the data when the data is set
+ * again, or when the slot list is finalized. The slot number must
+ * have been allocated with _dbus_data_slot_allocator_alloc() for the
+ * same allocator passed in here. The same allocator has to be used
+ * with the slot list every time.
+ *
+ * @param allocator the allocator to use
+ * @param list the data slot list
+ * @param slot the slot number
+ * @param data the data to store
+ * @param free_data_func finalizer function for the data
+ * @param old_free_func free function for any previously-existing data
+ * @param old_data previously-existing data, should be freed with old_free_func
+ * @returns #TRUE if there was enough memory to store the data
+ */
+dbus_bool_t
+_dbus_data_slot_list_set (DBusDataSlotAllocator *allocator,
+ DBusDataSlotList *list,
+ int slot,
+ void *data,
+ DBusFreeFunction free_data_func,
+ DBusFreeFunction *old_free_func,
+ void **old_data)
+{
+ _dbus_assert (slot < allocator->n_allocated_slots);
+ _dbus_assert (allocator->allocated_slots[slot] == slot);
+
+ if (slot >= list->n_slots)
+ {
+ DBusDataSlot *tmp;
+ int i;
+
+ tmp = dbus_realloc (list->slots,
+ sizeof (DBusDataSlot) * (slot + 1));
+ if (tmp == NULL)
+ return FALSE;
+
+ list->slots = tmp;
+ i = list->n_slots;
+ list->n_slots = slot + 1;
+ while (i < list->n_slots)
+ {
+ list->slots[i].data = NULL;
+ list->slots[i].free_data_func = NULL;
+ ++i;
+ }
+ }
+
+ _dbus_assert (slot < list->n_slots);
+
+ *old_data = list->slots[slot].data;
+ *old_free_func = list->slots[slot].free_data_func;
+
+ list->slots[slot].data = data;
+ list->slots[slot].free_data_func = free_data_func;
+
+ return TRUE;
+}
+
+/**
+ * Retrieves data previously set with _dbus_data_slot_list_set_data().
+ * The slot must still be allocated (must not have been freed).
+ *
+ * @param allocator the allocator slot was allocated from
+ * @param list the data slot list
+ * @param slot the slot to get data from
+ * @returns the data, or #NULL if not found
+ */
+void*
+_dbus_data_slot_list_get (DBusDataSlotAllocator *allocator,
+ DBusDataSlotList *list,
+ int slot)
+{
+ _dbus_assert (slot < allocator->n_allocated_slots);
+ _dbus_assert (allocator->allocated_slots[slot] == slot);
+
+ if (slot >= list->n_slots)
+ return NULL;
+ else
+ return list->slots[slot].data;
+}
+
+/**
+ * Frees the data slot list and all data slots contained
+ * in it, calling application-provided free functions
+ * if they exist.
+ *
+ * @param list the list to free
+ */
+void
+_dbus_data_slot_list_free (DBusDataSlotList *list)
+{
+ int i;
+
+ i = 0;
+ while (i < list->n_slots)
+ {
+ if (list->slots[i].free_data_func)
+ (* list->slots[i].free_data_func) (list->slots[i].data);
+ list->slots[i].data = NULL;
+ list->slots[i].free_data_func = NULL;
+ ++i;
+ }
+
+ dbus_free (list->slots);
+ list->slots = NULL;
+ list->n_slots = 0;
+}
+
+/** @} */
+
+#ifdef DBUS_BUILD_TESTS
+#include "dbus-test.h"
+#include <stdio.h>
+
+static int free_counter;
+
+static void
+test_free_slot_data_func (void *data)
+{
+ int i = _DBUS_POINTER_TO_INT (data);
+
+ _dbus_assert (free_counter == i);
+ ++free_counter;
+}
+
+/**
+ * Test function for data slots
+ */
+dbus_bool_t
+_dbus_data_slot_test (void)
+{
+ DBusDataSlotAllocator allocator;
+ DBusDataSlotList list;
+ int i;
+ DBusFreeFunction old_free_func;
+ void *old_data;
+
+ if (!_dbus_data_slot_allocator_init (&allocator))
+ _dbus_assert_not_reached ("no memory for allocator");
+
+ _dbus_data_slot_list_init (&list);
+
+#define N_SLOTS 100
+
+ i = 0;
+ while (i < N_SLOTS)
+ {
+ /* we don't really want apps to rely on this ordered
+ * allocation, but it simplifies things to rely on it
+ * here.
+ */
+ if (_dbus_data_slot_allocator_alloc (&allocator) != i)
+ _dbus_assert_not_reached ("did not allocate slots in numeric order\n");
+
+ ++i;
+ }
+
+ i = 0;
+ while (i < N_SLOTS)
+ {
+ if (!_dbus_data_slot_list_set (&allocator, &list,
+ i,
+ _DBUS_INT_TO_POINTER (i),
+ test_free_slot_data_func,
+ &old_free_func, &old_data))
+ _dbus_assert_not_reached ("no memory to set data");
+
+ _dbus_assert (old_free_func == NULL);
+ _dbus_assert (old_data == NULL);
+
+ _dbus_assert (_dbus_data_slot_list_get (&allocator, &list, i) ==
+ _DBUS_INT_TO_POINTER (i));
+
+ ++i;
+ }
+
+ free_counter = 0;
+ i = 0;
+ while (i < N_SLOTS)
+ {
+ if (!_dbus_data_slot_list_set (&allocator, &list,
+ i,
+ _DBUS_INT_TO_POINTER (i),
+ test_free_slot_data_func,
+ &old_free_func, &old_data))
+ _dbus_assert_not_reached ("no memory to set data");
+
+ _dbus_assert (old_free_func == test_free_slot_data_func);
+ _dbus_assert (_DBUS_POINTER_TO_INT (old_data) == i);
+
+ (* old_free_func) (old_data);
+ _dbus_assert (i == (free_counter - 1));
+
+ _dbus_assert (_dbus_data_slot_list_get (&allocator, &list, i) ==
+ _DBUS_INT_TO_POINTER (i));
+
+ ++i;
+ }
+
+ free_counter = 0;
+ _dbus_data_slot_list_free (&list);
+
+ _dbus_assert (N_SLOTS == free_counter);
+
+ i = 0;
+ while (i < N_SLOTS)
+ {
+ _dbus_data_slot_allocator_free (&allocator, i);
+ ++i;
+ }
+
+ return TRUE;
+}
+
+#endif /* DBUS_BUILD_TESTS */
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-dataslot.h storing data on objects
+ *
+ * Copyright (C) 2003 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 DBUS_DATASLOT_H
+#define DBUS_DATASLOT_H
+
+#include <dbus/dbus-internals.h>
+
+DBUS_BEGIN_DECLS;
+
+typedef struct DBusDataSlotAllocator DBusDataSlotAllocator;
+typedef struct DBusDataSlotList DBusDataSlotList;
+
+/** Opaque typedef for DBusDataSlot */
+typedef struct DBusDataSlot DBusDataSlot;
+/** DBusDataSlot is used to store application data on the connection */
+struct DBusDataSlot
+{
+ void *data; /**< The application data */
+ DBusFreeFunction free_data_func; /**< Free the application data */
+};
+
+struct DBusDataSlotAllocator
+{
+ int *allocated_slots; /**< Allocated slots */
+ int n_allocated_slots; /**< number of slots malloc'd */
+ int n_used_slots; /**< number of slots used */
+ DBusMutex *lock; /**< thread lock */
+};
+
+struct DBusDataSlotList
+{
+ DBusDataSlot *slots; /**< Data slots */
+ int n_slots; /**< Slots we have storage for in data_slots */
+};
+
+dbus_bool_t _dbus_data_slot_allocator_init (DBusDataSlotAllocator *allocator);
+int _dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator);
+void _dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator,
+ int slot_id);
+
+void _dbus_data_slot_list_init (DBusDataSlotList *list);
+dbus_bool_t _dbus_data_slot_list_set (DBusDataSlotAllocator *allocator,
+ DBusDataSlotList *list,
+ int slot,
+ void *data,
+ DBusFreeFunction free_data_func,
+ DBusFreeFunction *old_free_func,
+ void **old_data);
+void* _dbus_data_slot_list_get (DBusDataSlotAllocator *allocator,
+ DBusDataSlotList *list,
+ int slot);
+void _dbus_data_slot_list_free (DBusDataSlotList *list);
+
+DBUS_END_DECLS;
+
+#endif /* DBUS_DATASLOT_H */
#define _DBUS_MAX_SUN_PATH_LENGTH 99
#define _DBUS_ONE_KILOBYTE 1024
#define _DBUS_ONE_MEGABYTE 1024 * _DBUS_ONE_KILOBYTE
+#define _DBUS_ONE_HOUR_IN_MILLISECONDS (1000 * 60 * 60)
+#define _DBUS_USEC_PER_SECOND (1000000)
#undef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif /* !DBUS_BUILD_TESTS */
/* Thread initializers */
-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);
-DBusMutex *_dbus_user_info_init_lock (void);
-
+DBusMutex *_dbus_list_init_lock (void);
+DBusMutex *_dbus_connection_slots_init_lock (void);
+DBusMutex *_dbus_server_slots_init_lock (void);
+DBusMutex *_dbus_atomic_init_lock (void);
+DBusMutex *_dbus_message_handler_init_lock (void);
+DBusMutex *_dbus_user_info_init_lock (void);
DBUS_END_DECLS;
*/
/** Maximum number of timeouts waiting for lock before we decide it's stale */
-#define MAX_LOCK_TIMEOUTS 16
+#define MAX_LOCK_TIMEOUTS 32
/** Length of each timeout while waiting for a lock */
#define LOCK_TIMEOUT_MILLISECONDS 250
int field,
int *len)
{
- int offset = message->header_fields[field].offset;
+ int offset;
const char *data;
+
+ offset = message->header_fields[field].offset;
+
+ _dbus_assert (field < FIELD_LAST);
if (offset < 0)
return NULL;
static dbus_int32_t
get_int_field (DBusMessage *message,
- int field)
+ int field)
{
- int offset = message->header_fields[field].offset;
+ int offset;
+
+ _dbus_assert (field < FIELD_LAST);
+
+ offset = message->header_fields[field].offset;
if (offset < 0)
return -1; /* useless if -1 is a valid value of course */
-
+
return _dbus_demarshal_int32 (&message->header,
message->byte_order,
offset,
FIELD_SENDER, NULL);
name = get_string_field (original_message,
FIELD_NAME, NULL);
-
- _dbus_assert (sender != NULL);
+
+ /* sender is allowed to be null here in peer-to-peer case */
message = dbus_message_new (sender, name);
* ref/unref is kind of annoying to deal with, and slower too.
* This implies not ref'ing the message from the iter.
*
+ * @todo I'd also name this dbus_message_iter_new() or
+ * for the static object dbus_message_iter_init() rather
+ * than making it a method on the message
+ *
* @param message the message
* @returns a new iter.
*/
#include <dbus/dbus-timeout.h>
#include <dbus/dbus-watch.h>
#include <dbus/dbus-resources.h>
+#include <dbus/dbus-dataslot.h>
DBUS_BEGIN_DECLS;
*/
int max_connections; /**< Max number of connections allowed at once. */
+
+ DBusDataSlotList slot_list; /**< Data stored by allocated integer ID */
DBusNewConnectionFunction new_connection_function;
/**< Callback to invoke when a new connection is created. */
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-server.c DBusServer object
*
- * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
* A DBusServer represents a server that other applications
* can connect to. Each connection from another application
* is represented by a DBusConnection.
+ *
+ * @todo Thread safety hasn't been looked at for #DBusServer
+ * @todo Need notification to apps of disconnection, may matter for some transports
*/
/**
}
server->max_connections = 256; /* same as an X server, seems like a nice default */
+
+ _dbus_data_slot_list_init (&server->slot_list);
return TRUE;
}
void
_dbus_server_finalize_base (DBusServer *server)
{
+ /* calls out to application code... */
+ _dbus_data_slot_list_free (&server->slot_list);
+
dbus_server_set_new_connection_function (server, NULL, NULL, NULL);
if (!server->disconnected)
return _dbus_counter_get_value (server->connection_counter);
}
+
+static DBusDataSlotAllocator slot_allocator;
+
+/**
+ * Initialize the mutex used for #DBusConnection data
+ * slot reservations.
+ *
+ * @returns the mutex
+ */
+DBusMutex *
+_dbus_server_slots_init_lock (void)
+{
+ if (!_dbus_data_slot_allocator_init (&slot_allocator))
+ return NULL;
+ else
+ return slot_allocator.lock;
+}
+
+/**
+ * Allocates an integer ID to be used for storing application-specific
+ * data on any DBusServer. The allocated ID may then be used
+ * with dbus_server_set_data() and dbus_server_get_data().
+ * If allocation fails, -1 is returned. Again, the allocated
+ * slot is global, i.e. all DBusServer objects will
+ * have a slot with the given integer ID reserved.
+ *
+ * @returns -1 on failure, otherwise the data slot ID
+ */
+int
+dbus_server_allocate_data_slot (void)
+{
+ return _dbus_data_slot_allocator_alloc (&slot_allocator);
+}
+
+/**
+ * Deallocates a global ID for server data slots.
+ * dbus_server_get_data() and dbus_server_set_data()
+ * may no longer be used with this slot.
+ * Existing data stored on existing DBusServer objects
+ * will be freed when the server is finalized,
+ * but may not be retrieved (and may only be replaced
+ * if someone else reallocates the slot).
+ *
+ * @param slot the slot to deallocate
+ */
+void
+dbus_server_free_data_slot (int slot)
+{
+ _dbus_data_slot_allocator_free (&slot_allocator, slot);
+}
+
+/**
+ * Stores a pointer on a DBusServer, along
+ * with an optional function to be used for freeing
+ * the data when the data is set again, or when
+ * the server is finalized. The slot number
+ * must have been allocated with dbus_server_allocate_data_slot().
+ *
+ * @param server the server
+ * @param slot the slot number
+ * @param data the data to store
+ * @param free_data_func finalizer function for the data
+ * @returns #TRUE if there was enough memory to store the data
+ */
+dbus_bool_t
+dbus_server_set_data (DBusServer *server,
+ int slot,
+ void *data,
+ DBusFreeFunction free_data_func)
+{
+ DBusFreeFunction old_free_func;
+ void *old_data;
+ dbus_bool_t retval;
+
+#if 0
+ dbus_mutex_lock (server->mutex);
+#endif
+
+ retval = _dbus_data_slot_list_set (&slot_allocator,
+ &server->slot_list,
+ slot, data, free_data_func,
+ &old_free_func, &old_data);
+
+#if 0
+ dbus_mutex_unlock (server->mutex);
+#endif
+
+ if (retval)
+ {
+ /* Do the actual free outside the server lock */
+ if (old_free_func)
+ (* old_free_func) (old_data);
+ }
+
+ return retval;
+}
+
+/**
+ * Retrieves data previously set with dbus_server_set_data().
+ * The slot must still be allocated (must not have been freed).
+ *
+ * @param server the server
+ * @param slot the slot to get data from
+ * @returns the data, or #NULL if not found
+ */
+void*
+dbus_server_get_data (DBusServer *server,
+ int slot)
+{
+ void *res;
+
+#if 0
+ dbus_mutex_lock (server->mutex);
+#endif
+
+ res = _dbus_data_slot_list_get (&slot_allocator,
+ &server->slot_list,
+ slot);
+
+#if 0
+ dbus_mutex_unlock (server->mutex);
+#endif
+
+ return res;
+}
+
/** @} */
int dbus_server_get_n_connections (DBusServer *server);
+int dbus_server_allocate_data_slot (void);
+void dbus_server_free_data_slot (int slot);
+dbus_bool_t dbus_server_set_data (DBusServer *server,
+ int slot,
+ void *data,
+ DBusFreeFunction free_data_func);
+void* dbus_server_get_data (DBusServer *server,
+ int slot);
+
DBUS_END_DECLS;
#endif /* DBUS_SERVER_H */
if (!_dbus_string_test ())
die ("strings");
+ printf ("%s: running data slot tests\n", "dbus-test");
+ if (!_dbus_data_slot_test ())
+ die ("dataslot");
+
printf ("%s: running keyring tests\n", "dbus-test");
if (!_dbus_keyring_test ())
die ("keyring");
_DBUS_MESSAGE_UNKNOWN
} DBusMessageValidity;
-dbus_bool_t _dbus_hash_test (void);
-dbus_bool_t _dbus_list_test (void);
-dbus_bool_t _dbus_marshal_test (void);
-dbus_bool_t _dbus_mem_pool_test (void);
-dbus_bool_t _dbus_string_test (void);
-dbus_bool_t _dbus_address_test (void);
-dbus_bool_t _dbus_message_test (const char *test_data_dir);
-dbus_bool_t _dbus_auth_test (const char *test_data_dir);
-dbus_bool_t _dbus_md5_test (void);
-dbus_bool_t _dbus_sha_test (const char *test_data_dir);
-dbus_bool_t _dbus_keyring_test (void);
+dbus_bool_t _dbus_hash_test (void);
+dbus_bool_t _dbus_list_test (void);
+dbus_bool_t _dbus_marshal_test (void);
+dbus_bool_t _dbus_mem_pool_test (void);
+dbus_bool_t _dbus_string_test (void);
+dbus_bool_t _dbus_address_test (void);
+dbus_bool_t _dbus_message_test (const char *test_data_dir);
+dbus_bool_t _dbus_auth_test (const char *test_data_dir);
+dbus_bool_t _dbus_md5_test (void);
+dbus_bool_t _dbus_sha_test (const char *test_data_dir);
+dbus_bool_t _dbus_keyring_test (void);
+dbus_bool_t _dbus_data_slot_test (void);
void dbus_internal_do_not_use_run_tests (const char *test_data_dir);
dbus_bool_t dbus_internal_do_not_use_try_message_file (const DBusString *filename,
DBusMutex *mutex;
} static_locks[] = {
{&_dbus_list_init_lock},
- {&_dbus_allocated_slots_init_lock},
+ {&_dbus_server_slots_init_lock},
+ {&_dbus_connection_slots_init_lock},
{&_dbus_atomic_init_lock},
{&_dbus_message_handler_init_lock},
{&_dbus_user_info_init_lock}
_dbus_watch_unref (unix_transport->write_watch);
unix_transport->write_watch = NULL;
}
-
+ else
+ {
+ _dbus_verbose ("Write watch is unchanged from %p on fd %d\n",
+ unix_transport->write_watch, unix_transport->fd);
+ }
+
out:
_dbus_transport_unref (transport);
}
_dbus_transport_ref (transport);
- need_read_watch =
- _dbus_counter_get_value (transport->live_messages_size) < transport->max_live_messages_size;
+ if (_dbus_transport_get_is_authenticated (transport))
+ need_read_watch =
+ _dbus_counter_get_value (transport->live_messages_size) < transport->max_live_messages_size;
+ else
+ need_read_watch = transport->receive_credentials_pending ||
+ _dbus_auth_do_work (transport->auth) == DBUS_AUTH_STATE_WAITING_FOR_INPUT;
+ _dbus_verbose ("need_read_watch = %d authenticated = %d\n",
+ need_read_watch, _dbus_transport_get_is_authenticated (transport));
+
if (transport->disconnected)
need_read_watch = FALSE;
_dbus_watch_unref (unix_transport->read_watch);
unix_transport->read_watch = NULL;
}
-
+ else
+ {
+ _dbus_verbose ("Read watch is unchanged from %p on fd %d\n",
+ unix_transport->read_watch, unix_transport->fd);
+ }
+
out:
_dbus_transport_unref (transport);
}
}
out:
+ check_read_watch (transport);
check_write_watch (transport);
_dbus_transport_unref (transport);
}
dbus_bool_t do_select;
int select_res;
- _dbus_verbose (" iteration flags = %s%s timeout = %d\n",
+ _dbus_verbose (" iteration flags = %s%s timeout = %d read_watch = %p write_watch = %p\n",
flags & DBUS_ITERATION_DO_READING ? "read" : "",
flags & DBUS_ITERATION_DO_WRITING ? "write" : "",
- timeout_milliseconds);
+ timeout_milliseconds,
+ unix_transport->read_watch,
+ unix_transport->write_watch);
/* "again" has to be up here because on EINTR the fd sets become
* undefined
auth_state = _dbus_auth_do_work (transport->auth);
- if (auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
+ if (transport->receive_credentials_pending ||
+ auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT)
{
FD_SET (unix_transport->fd, &read_set);
do_select = TRUE;
}
- if (auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
+ if (transport->send_credentials_pending ||
+ auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND)
{
FD_SET (unix_transport->fd, &write_set);
do_select = TRUE;
{
_dbus_assert (transport->vtable->do_iteration != NULL);
+ _dbus_verbose ("Transport iteration flags 0x%x timeout %d connected = %d\n",
+ flags, timeout_milliseconds, !transport->disconnected);
+
if ((flags & (DBUS_ITERATION_DO_WRITING |
DBUS_ITERATION_DO_READING)) == 0)
return; /* Nothing to do */
#include <dbus/dbus.h>
#include <glib.h>
-void dbus_gthread_init (void);
-void dbus_connection_hookup_with_g_main (DBusConnection *connection);
+void dbus_gthread_init (void);
+void dbus_connection_setup_with_g_main (DBusConnection *connection);
+void dbus_server_setup_with_g_main (DBusServer *server);
#endif /* DBUS_GLIB_H */
#include "dbus-glib.h"
#include <glib.h>
-typedef struct _DBusGSource DBusGSource;
+/**
+ * @defgroup DBusGLib GLib bindings
+ * @ingroup DBus
+ * @brief API for using D-BUS with GLib
+ *
+ * Convenience functions are provided for using D-BUS
+ * with the GLib library (see http://www.gtk.org for GLib
+ * information).
+ *
+ */
-struct _DBusGSource
+/**
+ * @defgroup DBusGLibInternals GLib bindings implementation details
+ * @ingroup DBusInternals
+ * @brief Implementation details of GLib bindings
+ *
+ * @{
+ */
+
+/** @typedef DBusGSource
+ * A GSource representing a #DBusConnection or #DBusServer
+ */
+typedef struct DBusGSource DBusGSource;
+
+struct DBusGSource
{
- GSource source;
+ GSource source; /**< the parent GSource */
- DBusConnection *connection;
+ GList *poll_fds; /**< descriptors we're watching */
+ GHashTable *watches; /**< hash of DBusWatch objects */
- GList *poll_fds;
- GHashTable *watches;
+ void *connection_or_server; /**< DBusConnection or DBusServer */
};
+static GStaticMutex connection_slot_lock = G_STATIC_MUTEX_INIT;
static int connection_slot = -1;
+static GStaticMutex server_slot_lock = G_STATIC_MUTEX_INIT;
+static int server_slot = -1;
static gboolean dbus_connection_prepare (GSource *source,
- gint *timeout);
+ gint *timeout);
static gboolean dbus_connection_check (GSource *source);
static gboolean dbus_connection_dispatch (GSource *source,
- GSourceFunc callback,
- gpointer user_data);
-
-
-static GSourceFuncs dbus_funcs = {
+ GSourceFunc callback,
+ gpointer user_data);
+static gboolean dbus_server_prepare (GSource *source,
+ gint *timeout);
+static gboolean dbus_server_check (GSource *source);
+static gboolean dbus_server_dispatch (GSource *source,
+ GSourceFunc callback,
+ gpointer user_data);
+
+static GSourceFuncs dbus_connection_funcs = {
dbus_connection_prepare,
dbus_connection_check,
dbus_connection_dispatch,
NULL
};
+static GSourceFuncs dbus_server_funcs = {
+ dbus_server_prepare,
+ dbus_server_check,
+ dbus_server_dispatch,
+ NULL
+};
+
static gboolean
dbus_connection_prepare (GSource *source,
gint *timeout)
{
- DBusConnection *connection = ((DBusGSource *)source)->connection;
+ DBusConnection *connection = ((DBusGSource *)source)->connection_or_server;
*timeout = -1;
}
static gboolean
-dbus_connection_check (GSource *source)
+dbus_server_prepare (GSource *source,
+ gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean
+dbus_gsource_check (GSource *source)
{
DBusGSource *dbus_source = (DBusGSource *)source;
GList *list;
}
static gboolean
-dbus_connection_dispatch (GSource *source,
- GSourceFunc callback,
- gpointer user_data)
+dbus_connection_check (GSource *source)
+{
+ return dbus_gsource_check (source);
+}
+
+static gboolean
+dbus_server_check (GSource *source)
+{
+ return dbus_gsource_check (source);
+}
+
+static gboolean
+dbus_gsource_dispatch (GSource *source,
+ GSourceFunc callback,
+ gpointer user_data,
+ dbus_bool_t is_server)
{
DBusGSource *dbus_source = (DBusGSource *)source;
GList *copy, *list;
condition |= DBUS_WATCH_ERROR;
if (poll_fd->revents & G_IO_HUP)
condition |= DBUS_WATCH_HANGUP;
-
- dbus_connection_handle_watch (dbus_source->connection, watch, condition);
+
+ if (is_server)
+ dbus_server_handle_watch (dbus_source->connection_or_server,
+ watch, condition);
+ else
+ dbus_connection_handle_watch (dbus_source->connection_or_server,
+ watch, condition);
}
list = list->next;
}
- g_list_free (copy);
-
- /* Dispatch messages */
- while (dbus_connection_dispatch_message (dbus_source->connection));
+ g_list_free (copy);
return TRUE;
}
+static gboolean
+dbus_connection_dispatch (GSource *source,
+ GSourceFunc callback,
+ gpointer user_data)
+{
+ DBusGSource *dbus_source = (DBusGSource *)source;
+ DBusConnection *connection = dbus_source->connection_or_server;
+
+ dbus_connection_ref (connection);
+
+ dbus_gsource_dispatch (source, callback, user_data,
+ FALSE);
+
+ /* Dispatch messages */
+ while (dbus_connection_dispatch_message (connection))
+ ;
+
+ dbus_connection_unref (connection);
+
+ return TRUE;
+}
+
+static gboolean
+dbus_server_dispatch (GSource *source,
+ GSourceFunc callback,
+ gpointer user_data)
+{
+ DBusGSource *dbus_source = (DBusGSource *)source;
+ DBusServer *server = dbus_source->connection_or_server;
+
+ dbus_server_ref (server);
+
+ dbus_gsource_dispatch (source, callback, user_data,
+ TRUE);
+
+ dbus_server_unref (server);
+
+ return TRUE;
+}
+
static void
add_watch (DBusWatch *watch,
gpointer data)
return FALSE;
}
-
static void
add_timeout (DBusTimeout *timeout,
void *data)
guint timeout_tag;
timeout_tag = GPOINTER_TO_UINT (dbus_timeout_get_data (timeout));
-
+
g_source_remove (timeout_tag);
}
g_source_destroy (source);
}
-void
-dbus_connection_hookup_with_g_main (DBusConnection *connection)
+/** @} */ /* End of GLib bindings internals */
+
+/** @addtogroup DBusGLib
+ * @{
+ */
+
+static GSource*
+create_source (void *connection_or_server,
+ GSourceFuncs *funcs)
{
GSource *source;
DBusGSource *dbus_source;
- source = g_source_new (&dbus_funcs, sizeof (DBusGSource));
+ source = g_source_new (funcs, sizeof (DBusGSource));
dbus_source = (DBusGSource *)source;
dbus_source->watches = g_hash_table_new (NULL, NULL);
- dbus_source->connection = connection;
+ dbus_source->connection_or_server = connection_or_server;
+
+ return source;
+}
+
+/**
+ * Sets the watch and timeout functions of a #DBusConnection
+ * to integrate the connection with the GLib main loop.
+ *
+ * @param connection the connection
+ */
+void
+dbus_connection_setup_with_g_main (DBusConnection *connection)
+{
+ GSource *source;
+
+ source = create_source (connection, &dbus_connection_funcs);
dbus_connection_set_watch_functions (connection,
- add_watch,
- remove_watch,
- source, NULL);
- dbus_connection_set_timeout_functions (connection,
- add_timeout,
- remove_timeout,
- NULL, NULL);
+ add_watch,
+ remove_watch,
+ source, NULL);
+ dbus_connection_set_timeout_functions (connection,
+ add_timeout,
+ remove_timeout,
+ NULL, NULL);
+
g_source_attach (source, NULL);
+ g_static_mutex_lock (&connection_slot_lock);
if (connection_slot == -1 )
connection_slot = dbus_connection_allocate_data_slot ();
+ g_static_mutex_unlock (&connection_slot_lock);
- dbus_connection_set_data (connection, connection_slot, source,
- (DBusFreeFunction)free_source);
-
+ if (connection_slot < 0)
+ goto nomem;
+
+ if (!dbus_connection_set_data (connection, connection_slot, source,
+ (DBusFreeFunction)free_source))
+ goto nomem;
+
+ return;
+
+ nomem:
+ g_error ("Not enough memory to set up DBusConnection for use with GLib");
+}
+
+/**
+ * Sets the watch and timeout functions of a #DBusServer
+ * to integrate the server with the GLib main loop.
+ *
+ * @param server the server
+ */
+void
+dbus_server_setup_with_g_main (DBusServer *server)
+{
+ GSource *source;
+
+ source = create_source (server, &dbus_server_funcs);
+
+ dbus_server_set_watch_functions (server,
+ add_watch,
+ remove_watch,
+ source, NULL);
+
+ dbus_server_set_timeout_functions (server,
+ add_timeout,
+ remove_timeout,
+ NULL, NULL);
+
+ g_source_attach (source, NULL);
+
+ g_static_mutex_lock (&server_slot_lock);
+ if (server_slot == -1 )
+ server_slot = dbus_server_allocate_data_slot ();
+ g_static_mutex_unlock (&server_slot_lock);
+
+ if (server_slot < 0)
+ goto nomem;
+
+ if (!dbus_server_set_data (server, server_slot, source,
+ (DBusFreeFunction)free_source))
+ goto nomem;
+
+ return;
+
+ nomem:
+ g_error ("Not enough memory to set up DBusServer for use with GLib");
}
+
+/** @} */ /* end of public API */
#include <dbus/dbus.h>
#include "dbus-glib.h"
+/** @addtogroup DBusGLibInternals
+ * @{
+ */
+
static DBusMutex * dbus_gmutex_new (void);
static void dbus_gmutex_free (DBusMutex *mutex);
static dbus_bool_t dbus_gmutex_lock (DBusMutex *mutex);
g_cond_broadcast ((GCond *)cond);
}
+/** @} End of internals */
+/** @addtogroup DBusGLib
+ * @{
+ */
+/**
+ * Initializes the D-BUS thread system to use
+ * GLib threads. This function may only be called
+ * once and must be called prior to calling any
+ * other function in the D-BUS API.
+ */
void
dbus_gthread_init (void)
{
dbus_threads_init (&functions);
}
+
+/** @} end of public API */
return 1;
}
- dbus_connection_hookup_with_g_main (connection);
+ dbus_connection_setup_with_g_main (connection);
message = dbus_message_new ("org.freedesktop.DBus", "org.freedesktop.DBus.Hello");
projects / platform / upstream / dbus.git / commitdiff