+2003-06-22 Havoc Pennington <hp@pobox.com>
+
+ * dbus/dbus-dataslot.c (_dbus_data_slot_allocator_unref)
+ (_dbus_data_slot_allocator_alloc): rework these to keep a
+ reference count on each slot and automatically manage a global
+ slot ID variable passed in by address
+
+ * bus/bus.c: convert to new dataslot API
+
+ * dbus/dbus-bus.c: convert to new dataslot API
+
+ * dbus/dbus-connection.c: convert to new dataslot API
+
+ * dbus/dbus-server.c: convert to new dataslot API
+
+ * glib/dbus-gmain.c: ditto
+
+ * bus/test.c: ditto
+
+ * bus/connection.c: ditto
+
2003-06-22 Anders Carlsson <andersca@codefactory.se>
* configure.in: Add AM_PROG_GCJ and move AM_PROG_LIBTOOL
BusLimits limits;
};
-static int server_data_slot = -1;
-static int server_data_slot_refcount = 0;
+static dbus_int32_t server_data_slot = -1;
typedef struct
{
#define BUS_SERVER_DATA(server) (dbus_server_get_data ((server), server_data_slot))
-static dbus_bool_t
-server_data_slot_ref (void)
-{
- if (server_data_slot < 0)
- {
- server_data_slot = dbus_server_allocate_data_slot ();
-
- if (server_data_slot < 0)
- return FALSE;
-
- _dbus_assert (server_data_slot_refcount == 0);
- }
-
- server_data_slot_refcount += 1;
-
- return TRUE;
-}
-
-static void
-server_data_slot_unref (void)
-{
- _dbus_assert (server_data_slot_refcount > 0);
-
- server_data_slot_refcount -= 1;
-
- if (server_data_slot_refcount == 0)
- {
- dbus_server_free_data_slot (server_data_slot);
- server_data_slot = -1;
- }
-}
-
static BusContext*
server_get_context (DBusServer *server)
{
BusContext *context;
BusServerData *bd;
- if (!server_data_slot_ref ())
+ if (!dbus_server_allocate_data_slot (&server_data_slot))
return NULL;
bd = BUS_SERVER_DATA (server);
if (bd == NULL)
{
- server_data_slot_unref ();
+ dbus_server_free_data_slot (&server_data_slot);
return NULL;
}
context = bd->context;
- server_data_slot_unref ();
+ dbus_server_free_data_slot (&server_data_slot);
return context;
}
return NULL;
}
- if (!server_data_slot_ref ())
+ if (!dbus_server_allocate_data_slot (&server_data_slot))
{
BUS_SET_OOM (error);
_dbus_string_free (&full_address);
/* we need another ref of the server data slot for the context
* to own
*/
- if (!server_data_slot_ref ())
+ if (!dbus_server_allocate_data_slot (&server_data_slot))
_dbus_assert_not_reached ("second ref of server data slot failed");
context->user_database = _dbus_user_database_new ();
bus_config_parser_unref (parser);
_dbus_string_free (&full_address);
dbus_free_string_array (auth_mechanisms);
- server_data_slot_unref ();
+ dbus_server_free_data_slot (&server_data_slot);
return context;
_dbus_string_free (&full_address);
dbus_free_string_array (auth_mechanisms);
- server_data_slot_unref ();
+ dbus_server_free_data_slot (&server_data_slot);
return NULL;
}
dbus_free (context);
- server_data_slot_unref ();
+ dbus_server_free_data_slot (&server_data_slot);
}
}
DBusTimeout *expire_timeout; /**< Timeout for expiring incomplete connections. */
};
-static int connection_data_slot = -1;
-static int connection_data_slot_refcount = 0;
+static dbus_int32_t connection_data_slot = -1;
typedef struct
{
#define BUS_CONNECTION_DATA(connection) (dbus_connection_get_data ((connection), connection_data_slot))
-static dbus_bool_t
-connection_data_slot_ref (void)
-{
- if (connection_data_slot < 0)
- {
- connection_data_slot = dbus_connection_allocate_data_slot ();
-
- if (connection_data_slot < 0)
- return FALSE;
-
- _dbus_assert (connection_data_slot_refcount == 0);
- }
-
- connection_data_slot_refcount += 1;
-
- return TRUE;
-
-}
-
-static void
-connection_data_slot_unref (void)
-{
- _dbus_assert (connection_data_slot_refcount > 0);
-
- connection_data_slot_refcount -= 1;
-
- if (connection_data_slot_refcount == 0)
- {
- dbus_connection_free_data_slot (connection_data_slot);
- connection_data_slot = -1;
- }
-}
-
static DBusLoop*
connection_get_loop (DBusConnection *connection)
{
{
BusConnections *connections;
- if (!connection_data_slot_ref ())
+ if (!dbus_connection_allocate_data_slot (&connection_data_slot))
goto failed_0;
connections = dbus_new0 (BusConnections, 1);
failed_2:
dbus_free (connections);
failed_1:
- connection_data_slot_unref ();
+ dbus_connection_free_data_slot (&connection_data_slot);
failed_0:
return NULL;
}
dbus_free (connections);
- connection_data_slot_unref ();
+ dbus_connection_free_data_slot (&connection_data_slot);
}
}
#include <dbus/dbus-internals.h>
#include <string.h>
-static int message_handler_slot = -1;
-static int message_handler_slot_refcount;
+static dbus_int32_t message_handler_slot = -1;
typedef struct
{
return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
-static dbus_bool_t
-message_handler_slot_ref (void)
-{
- if (message_handler_slot < 0)
- {
- message_handler_slot = dbus_connection_allocate_data_slot ();
-
- if (message_handler_slot < 0)
- return FALSE;
-
- _dbus_assert (message_handler_slot_refcount == 0);
- }
-
- message_handler_slot_refcount += 1;
-
- return TRUE;
-}
-
-static void
-message_handler_slot_unref (void)
-{
- _dbus_assert (message_handler_slot_refcount > 0);
-
- message_handler_slot_refcount -= 1;
-
- if (message_handler_slot_refcount == 0)
- {
- dbus_connection_free_data_slot (message_handler_slot);
- message_handler_slot = -1;
- }
-}
-
static void
free_message_handler (void *data)
{
DBusMessageHandler *handler = data;
_dbus_assert (message_handler_slot >= 0);
- _dbus_assert (message_handler_slot_refcount > 0);
dbus_message_handler_unref (handler);
- message_handler_slot_unref ();
+ dbus_connection_free_data_slot (&message_handler_slot);
}
dbus_bool_t
{
DBusMessageHandler *handler;
- if (!message_handler_slot_ref ())
+ if (!dbus_connection_allocate_data_slot (&message_handler_slot))
return FALSE;
handler = dbus_message_handler_new (bus_dispatch_message_handler, NULL, NULL);
if (handler == NULL)
{
- message_handler_slot_unref ();
+ dbus_connection_free_data_slot (&message_handler_slot);
return FALSE;
}
if (!dbus_connection_add_filter (connection, handler))
{
dbus_message_handler_unref (handler);
- message_handler_slot_unref ();
+ dbus_connection_free_data_slot (&message_handler_slot);
return FALSE;
}
_dbus_assert (message_handler_slot >= 0);
- _dbus_assert (message_handler_slot_refcount > 0);
if (!dbus_connection_set_data (connection,
message_handler_slot,
free_message_handler))
{
dbus_message_handler_unref (handler);
- message_handler_slot_unref ();
+ dbus_connection_free_data_slot (&message_handler_slot);
return FALSE;
}
return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
-static int handler_slot = -1;
-static int handler_slot_refcount = 0;
-
-static dbus_bool_t
-handler_slot_ref (void)
-{
- if (handler_slot < 0)
- {
- handler_slot = dbus_connection_allocate_data_slot ();
-
- if (handler_slot < 0)
- return FALSE;
-
- _dbus_assert (handler_slot_refcount == 0);
- }
-
- handler_slot_refcount += 1;
-
- return TRUE;
-
-}
-
-static void
-handler_slot_unref (void)
-{
- _dbus_assert (handler_slot_refcount > 0);
-
- handler_slot_refcount -= 1;
-
- if (handler_slot_refcount == 0)
- {
- dbus_connection_free_data_slot (handler_slot);
- handler_slot = -1;
- }
-}
+static dbus_int32_t handler_slot = -1;
static void
free_handler (void *data)
DBusMessageHandler *handler = data;
dbus_message_handler_unref (handler);
- handler_slot_unref ();
+ dbus_connection_free_data_slot (&handler_slot);
}
dbus_bool_t
if (!_dbus_list_append (&clients, connection))
goto out;
- if (!handler_slot_ref ())
+ if (!dbus_connection_allocate_data_slot (&handler_slot))
goto out;
/* Set up handler to be destroyed */
disconnect_handler,
free_handler))
{
- handler_slot_unref ();
+ dbus_connection_free_data_slot (&handler_slot);
goto out;
}
unsigned int is_well_known : 1; /**< Is one of the well-known connections in our global array */
} BusData;
-/** The slot we have reserved to store BusData
+/** The slot we have reserved to store BusData.
*/
-static int bus_data_slot = -1;
-/** Number of connections using the slot
- */
-static int bus_data_slot_refcount = 0;
+static dbus_int32_t bus_data_slot = -1;
/** Number of bus types */
#define N_BUS_TYPES 3
return initialized;
}
-static dbus_bool_t
-data_slot_ref (void)
-{
- _DBUS_LOCK (bus);
-
- if (bus_data_slot < 0)
- {
- bus_data_slot = dbus_connection_allocate_data_slot ();
-
- if (bus_data_slot < 0)
- {
- _DBUS_UNLOCK (bus);
- return FALSE;
- }
-
- _dbus_assert (bus_data_slot_refcount == 0);
- }
-
- bus_data_slot_refcount += 1;
-
- _DBUS_UNLOCK (bus);
-
- return TRUE;
-}
-
-static void
-data_slot_unref (void)
-{
- _DBUS_LOCK (bus);
-
- _dbus_assert (bus_data_slot_refcount > 0);
- _dbus_assert (bus_data_slot >= 0);
-
- bus_data_slot_refcount -= 1;
-
- if (bus_data_slot_refcount == 0)
- {
- dbus_connection_free_data_slot (bus_data_slot);
- bus_data_slot = -1;
- }
-
- _DBUS_UNLOCK (bus);
-}
-
static void
bus_data_free (void *data)
{
dbus_free (bd->base_service);
dbus_free (bd);
- data_slot_unref ();
+ dbus_connection_free_data_slot (&bus_data_slot);
}
static BusData*
{
BusData *bd;
- if (!data_slot_ref ())
+ if (!dbus_connection_allocate_data_slot (&bus_data_slot))
return NULL;
bd = dbus_connection_get_data (connection, bus_data_slot);
bd = dbus_new0 (BusData, 1);
if (bd == NULL)
{
- data_slot_unref ();
+ dbus_connection_free_data_slot (&bus_data_slot);
return NULL;
}
bus_data_free))
{
dbus_free (bd);
- data_slot_unref ();
+ dbus_connection_free_data_slot (&bus_data_slot);
return NULL;
}
}
else
{
- data_slot_unref ();
+ dbus_connection_free_data_slot (&bus_data_slot);
}
return bd;
* Allocates an integer ID to be used for storing application-specific
* data on any DBusConnection. The allocated ID may then be used
* with dbus_connection_set_data() and dbus_connection_get_data().
- * If allocation fails, -1 is returned. Again, the allocated
- * slot is global, i.e. all DBusConnection objects will
+ * The passed-in slot must be initialized to -1, and is filled in
+ * with the slot ID. If the passed-in slot is not -1, it's assumed
+ * to be already allocated, and its refcount is incremented.
+ *
+ * The allocated slot is global, i.e. all DBusConnection objects will
* have a slot with the given integer ID reserved.
*
- * @returns -1 on failure, otherwise the data slot ID
+ * @param slot_p address of a global variable storing the slot
+ * @returns #FALSE on failure (no memory)
*/
-int
-dbus_connection_allocate_data_slot (void)
+dbus_bool_t
+dbus_connection_allocate_data_slot (dbus_int32_t *slot_p)
{
return _dbus_data_slot_allocator_alloc (&slot_allocator,
- _DBUS_LOCK_NAME (connection_slots));
+ _DBUS_LOCK_NAME (connection_slots),
+ slot_p);
}
/**
* Deallocates a global ID for connection data slots.
- * dbus_connection_get_data() and dbus_connection_set_data()
- * may no longer be used with this slot.
- * Existing data stored on existing DBusConnection objects
- * will be freed when the connection is finalized,
- * but may not be retrieved (and may only be replaced
- * if someone else reallocates the slot).
+ * dbus_connection_get_data() and dbus_connection_set_data() may no
+ * longer be used with this slot. Existing data stored on existing
+ * DBusConnection objects will be freed when the connection is
+ * finalized, but may not be retrieved (and may only be replaced if
+ * someone else reallocates the slot). When the refcount on the
+ * passed-in slot reaches 0, it is set to -1.
*
- * @param slot the slot to deallocate
+ * @param slot_p address storing the slot to deallocate
*/
void
-dbus_connection_free_data_slot (int slot)
+dbus_connection_free_data_slot (dbus_int32_t *slot_p)
{
- _dbus_data_slot_allocator_free (&slot_allocator, slot);
+ _dbus_return_if_fail (*slot_p >= 0);
+
+ _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
}
/**
*/
dbus_bool_t
dbus_connection_set_data (DBusConnection *connection,
- int slot,
+ dbus_int32_t slot,
void *data,
DBusFreeFunction free_data_func)
{
*/
void*
dbus_connection_get_data (DBusConnection *connection,
- int slot)
+ dbus_int32_t slot)
{
void *res;
int n_messages);
-int dbus_connection_allocate_data_slot (void);
-void dbus_connection_free_data_slot (int slot);
+dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t *slot_p);
+void dbus_connection_free_data_slot (dbus_int32_t *slot_p);
dbus_bool_t dbus_connection_set_data (DBusConnection *connection,
- int slot,
+ dbus_int32_t slot,
void *data,
DBusFreeFunction free_data_func);
void* dbus_connection_get_data (DBusConnection *connection,
- int slot);
+ dbus_int32_t slot);
void dbus_connection_set_change_sigpipe (dbus_bool_t will_modify_sigpipe);
/**
* Allocates an integer ID to be used for storing data
- * in a #DBusDataSlotList.
- *
- * @todo all over the code we have foo_slot and foo_slot_refcount,
- * would be better to add an interface for that to
- * DBusDataSlotAllocator so it isn't cut-and-pasted everywhere.
+ * in a #DBusDataSlotList. If the value at *slot_id_p is
+ * not -1, this function just increments the refcount for
+ * the existing slot ID. If the value is -1, a new slot ID
+ * is allocated and stored at *slot_id_p.
*
* @param allocator the allocator
* @param mutex the lock for this allocator
- * @returns the integer ID, or -1 on failure
+ * @param slot_id_p address to fill with the slot ID
+ * @returns #TRUE on success
*/
-int
+dbus_bool_t
_dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator,
- DBusMutex *mutex)
+ DBusMutex *mutex,
+ dbus_int32_t *slot_id_p)
{
- int slot;
+ dbus_int32_t slot;
if (!dbus_mutex_lock (mutex))
- return -1;
+ return FALSE;
if (allocator->n_allocated_slots == 0)
{
}
else
_dbus_assert (allocator->lock == mutex);
+
+ if (*slot_id_p >= 0)
+ {
+ slot = *slot_id_p;
+
+ _dbus_assert (slot < allocator->n_allocated_slots);
+ _dbus_assert (allocator->allocated_slots[slot].slot_id == slot);
+
+ allocator->allocated_slots[slot].refcount += 1;
+
+ goto out;
+ }
+
+ _dbus_assert (*slot_id_p < 0);
if (allocator->n_used_slots < allocator->n_allocated_slots)
{
slot = 0;
while (slot < allocator->n_allocated_slots)
{
- if (allocator->allocated_slots[slot] < 0)
+ if (allocator->allocated_slots[slot].slot_id < 0)
{
- allocator->allocated_slots[slot] = slot;
+ allocator->allocated_slots[slot].slot_id = slot;
+ allocator->allocated_slots[slot].refcount = 1;
allocator->n_used_slots += 1;
break;
}
}
else
{
- int *tmp;
+ DBusAllocatedSlot *tmp;
slot = -1;
tmp = dbus_realloc (allocator->allocated_slots,
- sizeof (int) * (allocator->n_allocated_slots + 1));
+ sizeof (DBusAllocatedSlot) * (allocator->n_allocated_slots + 1));
if (tmp == NULL)
goto out;
slot = allocator->n_allocated_slots;
allocator->n_allocated_slots += 1;
allocator->n_used_slots += 1;
- allocator->allocated_slots[slot] = slot;
+ allocator->allocated_slots[slot].slot_id = slot;
+ allocator->allocated_slots[slot].refcount = 1;
}
_dbus_assert (slot >= 0);
_dbus_assert (slot < allocator->n_allocated_slots);
-
+ _dbus_assert (*slot_id_p < 0);
+ _dbus_assert (allocator->allocated_slots[slot].slot_id == slot);
+ _dbus_assert (allocator->allocated_slots[slot].refcount == 1);
+
+ *slot_id_p = slot;
+
_dbus_verbose ("Allocated slot %d on allocator %p total %d slots allocated %d used\n",
slot, allocator, allocator->n_allocated_slots, allocator->n_used_slots);
out:
dbus_mutex_unlock (allocator->lock);
- return slot;
+ return slot >= 0;
}
/**
* 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).
+ * The slot value is reset to -1 if this is the last unref.
*
* @param allocator the allocator
- * @param slot the slot to deallocate
+ * @param slot_id_p address where we store the slot
*/
void
_dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator,
- int slot)
+ dbus_int32_t *slot_id_p)
{
dbus_mutex_lock (allocator->lock);
- _dbus_assert (slot < allocator->n_allocated_slots);
- _dbus_assert (allocator->allocated_slots[slot] == slot);
+ _dbus_assert (*slot_id_p < allocator->n_allocated_slots);
+ _dbus_assert (allocator->allocated_slots[*slot_id_p].slot_id == *slot_id_p);
+ _dbus_assert (allocator->allocated_slots[*slot_id_p].refcount > 0);
+
+ allocator->allocated_slots[*slot_id_p].refcount -= 1;
+
+ if (allocator->allocated_slots[*slot_id_p].refcount > 0)
+ {
+ dbus_mutex_unlock (allocator->lock);
+ return;
+ }
+
+ /* refcount is 0, free the slot */
+ _dbus_verbose ("Freeing slot %d on allocator %p total %d allocated %d used\n",
+ *slot_id_p, allocator, allocator->n_allocated_slots, allocator->n_used_slots);
+
+ allocator->allocated_slots[*slot_id_p].slot_id = -1;
+ *slot_id_p = -1;
- allocator->allocated_slots[slot] = -1;
allocator->n_used_slots -= 1;
-
- _dbus_verbose ("Freed slot %d on allocator %p total %d allocated %d used\n",
- slot, allocator, allocator->n_allocated_slots, allocator->n_used_slots);
if (allocator->n_used_slots == 0)
{
if (!dbus_mutex_lock (allocator->lock))
return FALSE;
_dbus_assert (slot < allocator->n_allocated_slots);
- _dbus_assert (allocator->allocated_slots[slot] == slot);
+ _dbus_assert (allocator->allocated_slots[slot].slot_id == slot);
dbus_mutex_unlock (allocator->lock);
#endif
return FALSE;
_dbus_assert (slot >= 0);
_dbus_assert (slot < allocator->n_allocated_slots);
- _dbus_assert (allocator->allocated_slots[slot] == slot);
+ _dbus_assert (allocator->allocated_slots[slot].slot_id == slot);
dbus_mutex_unlock (allocator->lock);
#endif
* allocation, but it simplifies things to rely on it
* here.
*/
- if (_dbus_data_slot_allocator_alloc (&allocator, mutex) != i)
+ dbus_int32_t tmp = -1;
+
+ _dbus_data_slot_allocator_alloc (&allocator, mutex, &tmp);
+
+ if (tmp != i)
_dbus_assert_not_reached ("did not allocate slots in numeric order\n");
++i;
i = 0;
while (i < N_SLOTS)
{
- _dbus_data_slot_allocator_free (&allocator, i);
+ dbus_int32_t tmp = i;
+
+ _dbus_data_slot_allocator_free (&allocator, &tmp);
+ _dbus_assert (tmp == -1);
++i;
}
DBusFreeFunction free_data_func; /**< Free the application data */
};
+typedef struct DBusAllocatedSlot DBusAllocatedSlot;
+struct DBusAllocatedSlot
+{
+ dbus_int32_t slot_id; /**< ID of this slot */
+ int refcount; /**< Number of uses of the slot */
+};
+
struct DBusDataSlotAllocator
{
- int *allocated_slots; /**< Allocated slots */
+ DBusAllocatedSlot *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 */
};
dbus_bool_t _dbus_data_slot_allocator_init (DBusDataSlotAllocator *allocator);
-int _dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator,
- DBusMutex *mutex);
+dbus_bool_t _dbus_data_slot_allocator_alloc (DBusDataSlotAllocator *allocator,
+ DBusMutex *mutex,
+ int *slot_id_p);
void _dbus_data_slot_allocator_free (DBusDataSlotAllocator *allocator,
- int slot_id);
+ int *slot_id_p);
void _dbus_data_slot_list_init (DBusDataSlotList *list);
dbus_bool_t _dbus_data_slot_list_set (DBusDataSlotAllocator *allocator,
DBusDataSlotList *list,
* 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
+ * The slot must be initialized with -1. If a nonnegative
+ * slot is passed in, the refcount is incremented on that
+ * slot, rather than creating a new slot.
+ *
+ * The allocated slot is global, i.e. all DBusServer objects will have
+ * a slot with the given integer ID reserved.
+ *
+ * @param slot_p address of global variable storing the slot ID
+ * @returns #FALSE on no memory
*/
-int
-dbus_server_allocate_data_slot (void)
+dbus_bool_t
+dbus_server_allocate_data_slot (dbus_int32_t *slot_p)
{
return _dbus_data_slot_allocator_alloc (&slot_allocator,
- _DBUS_LOCK_NAME (server_slots));
+ _DBUS_LOCK_NAME (server_slots),
+ slot_p);
}
/**
* but may not be retrieved (and may only be replaced
* if someone else reallocates the slot).
*
- * @param slot the slot to deallocate
+ * @param slot_p address of the slot to deallocate
*/
void
-dbus_server_free_data_slot (int slot)
+dbus_server_free_data_slot (dbus_int32_t *slot_p)
{
- _dbus_return_if_fail (slot >= 0);
+ _dbus_return_if_fail (*slot_p >= 0);
- _dbus_data_slot_allocator_free (&slot_allocator, slot);
+ _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
}
/**
dbus_bool_t dbus_server_set_auth_mechanisms (DBusServer *server,
const char **mechanisms);
-int dbus_server_allocate_data_slot (void);
-void dbus_server_free_data_slot (int slot);
+dbus_bool_t dbus_server_allocate_data_slot (dbus_int32_t *slot_p);
+void dbus_server_free_data_slot (dbus_int32_t *slot_p);
dbus_bool_t dbus_server_set_data (DBusServer *server,
int slot,
void *data,
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 dbus_int32_t connection_slot = -1;
+static dbus_int32_t server_slot = -1;
static gboolean gsource_connection_prepare (GSource *source,
gint *timeout);
g_source_attach (source, context);
- 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);
-
+ /* FIXME we never free the slot, so its refcount just keeps growing,
+ * which is kind of broken.
+ */
+ dbus_connection_allocate_data_slot (&connection_slot);
if (connection_slot < 0)
goto nomem;
g_source_attach (source, context);
- 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);
-
+ /* FIXME we never free the slot, so its refcount just keeps growing,
+ * which is kind of broken.
+ */
+ dbus_server_allocate_data_slot (&server_slot);
if (server_slot < 0)
goto nomem;
static DBusMessageHandler *disconnect_handler;
static DBusMessageHandler *filter_handler;
-static int handler_slot;
+static dbus_int32_t handler_slot = -1;
static DBusHandlerResult
handle_test_message (DBusMessageHandler *handler,
return 1;
}
- handler_slot = dbus_connection_allocate_data_slot ();
+ if (!dbus_connection_allocate_data_slot (&handler_slot))
+ g_error ("no memory for data slot");
filter_handler =
dbus_message_handler_new (handle_filter, NULL, NULL);
projects / platform / upstream / dbus.git / commitdiff