+2003-08-28 Havoc Pennington <hp@pobox.com>
+
+ purge DBusObjectID
+
+ * dbus/dbus-connection.c: port to no ObjectID, create a
+ DBusObjectTree, rename ObjectTree to ObjectPath in public API
+
+ * dbus/dbus-connection.h (struct DBusObjectTreeVTable): delete
+ everything except UnregisterFunction and MessageFunction
+
+ * dbus/dbus-marshal.c: port away from DBusObjectID,
+ add DBUS_TYPE_OBJECT_PATH
+
+ * dbus/dbus-object-registry.[hc], dbus/dbus-object.[hc],
+ dbus/dbus-objectid.[hc]: remove these, we are moving to
+ path-based object IDs
+
2003-08-25 Havoc Pennington <hp@pobox.com>
Just noticed that dbus_message_test is hosed, I wonder when I
dbus-memory.h \
dbus-message.h \
dbus-message-handler.h \
- dbus-object.h \
- dbus-objectid.h \
dbus-pending-call.h \
dbus-protocol.h \
dbus-server.h \
dbus-message.c \
dbus-message-handler.c \
dbus-message-internal.h \
- dbus-object.c \
- dbus-objectid.c \
- dbus-object-registry.c \
- dbus-object-registry.h \
dbus-object-tree.c \
dbus-object-tree.h \
dbus-pending-call.c \
#include "dbus-bus.h"
#include "dbus-protocol.h"
#include "dbus-internals.h"
+#include "dbus-message.h"
#include <string.h>
/**
DBusHandlerResult _dbus_message_handler_handle_message (DBusMessageHandler *handler,
DBusConnection *connection,
DBusMessage *message);
-void _dbus_connection_init_id (DBusConnection *connection,
- DBusObjectID *id);
+
DBusPendingCall* _dbus_pending_call_new (DBusConnection *connection,
int timeout_milliseconds,
DBusTimeoutHandler timeout_handler);
#include "dbus-threads.h"
#include "dbus-protocol.h"
#include "dbus-dataslot.h"
-#include "dbus-object-registry.h"
#include "dbus-string.h"
#include "dbus-pending-call.h"
+#include "dbus-object-tree.h"
#if 0
#define CONNECTION_LOCK(connection) do { \
DBusList *link_cache; /**< A cache of linked list links to prevent contention
* for the global linked list mempool lock
*/
- DBusObjectRegistry *objects; /**< Objects registered with this connection */
+ DBusObjectTree *objects; /**< Object path handlers registered with this connection */
};
static void _dbus_connection_remove_timeout_locked (DBusConnection *connection,
DBusList *disconnect_link;
DBusMessage *disconnect_message;
DBusCounter *outgoing_counter;
- DBusObjectRegistry *objects;
+ DBusObjectTree *objects;
watch_list = NULL;
connection = NULL;
if (outgoing_counter == NULL)
goto error;
- objects = _dbus_object_registry_new (connection);
+ objects = _dbus_object_tree_new (connection);
if (objects == NULL)
goto error;
_dbus_counter_unref (outgoing_counter);
if (objects)
- _dbus_object_registry_unref (objects);
+ _dbus_object_tree_unref (objects);
return NULL;
}
return retval;
}
-/**
- * Get the server ID to be used in the object ID for an object
- * registered with this connection.
- *
- * @todo implement this function
- *
- * @param connection the connection.
- * @returns the portion of the object ID
- */
-void
-_dbus_connection_init_id (DBusConnection *connection,
- DBusObjectID *object_id)
-{
- /* FIXME */
- dbus_object_id_set_server_bits (object_id, 15);
- dbus_object_id_set_client_bits (object_id, 31);
- dbus_object_id_set_is_server_bit (object_id, FALSE);
-}
-
/** @} */
/**
_dbus_assert (!_dbus_transport_get_is_connected (connection->transport));
/* ---- We're going to call various application callbacks here, hope it doesn't break anything... */
- _dbus_object_registry_free_all_unlocked (connection->objects);
+ _dbus_object_tree_free_all_unlocked (connection->objects);
dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
dbus_connection_set_wakeup_main_function (connection, NULL, NULL, NULL);
link = next;
}
- _dbus_object_registry_unref (connection->objects);
+ _dbus_object_tree_unref (connection->objects);
_dbus_hash_table_unref (connection->pending_replies);
connection->pending_replies = NULL;
dbus_message_get_interface (message) :
"no interface");
- result = _dbus_object_registry_handle_and_unlock (connection->objects,
- message);
+ result = _dbus_object_tree_dispatch_and_unlock (connection->objects,
+ message);
CONNECTION_LOCK (connection);
}
/**
- * Registers an object with the connection. This object is assigned an
- * object ID, and will be visible under this ID and with the provided
- * interfaces to the peer application on the other end of the
- * connection. The object instance should be passed in as object_impl;
- * the instance can be any datatype, as long as it fits in a void*.
+ * Registers a handler for a given subsection of the object hierarchy.
+ * The given vtable handles messages at or below the given path.
*
- * As a side effect of calling this function, the "registered"
- * callback in the #DBusObjectVTable will be invoked.
- *
- * If the object is deleted, be sure to unregister it with
- * dbus_connection_unregister_object() or it will continue to get
- * messages.
*
- * @param connection the connection to register the instance with
- * @param interfaces #NULL-terminated array of interface names the instance supports
- * @param vtable virtual table of functions for manipulating the instance
- * @param object_impl object instance
- * @param object_id if non-#NULL, object ID to initialize with the new object's ID
- * @returns #FALSE if not enough memory to register the object instance
+ * @param connection the connection
+ * @param path #NULL-terminated array of path elements
+ * @param vtable the virtual table
+ * @param user_data data to pass to functions in the vtable
+ * @returns #FALSE if not enough memory
*/
dbus_bool_t
-dbus_connection_register_object (DBusConnection *connection,
- const char **interfaces,
- const DBusObjectVTable *vtable,
- void *object_impl,
- DBusObjectID *object_id)
+dbus_connection_register_object_path (DBusConnection *connection,
+ const char **path,
+ const DBusObjectPathVTable *vtable,
+ void *user_data)
{
+ dbus_bool_t retval;
+
_dbus_return_val_if_fail (connection != NULL, FALSE);
+ _dbus_return_val_if_fail (path != NULL, FALSE);
+ _dbus_return_val_if_fail (path[0] != NULL, FALSE);
_dbus_return_val_if_fail (vtable != NULL, FALSE);
- _dbus_return_val_if_fail (vtable->dbus_internal_pad1 == NULL, FALSE);
- _dbus_return_val_if_fail (vtable->dbus_internal_pad2 == NULL, FALSE);
- _dbus_return_val_if_fail (vtable->dbus_internal_pad3 == NULL, FALSE);
-
+
CONNECTION_LOCK (connection);
- return _dbus_object_registry_add_and_unlock (connection->objects,
- interfaces,
- vtable,
- object_impl,
- object_id);
+ retval = _dbus_object_tree_register (connection->objects, path, vtable,
+ user_data);
+
+ CONNECTION_UNLOCK (connection);
+
+ return retval;
}
/**
- * Reverses the effects of dbus_connection_register_object(),
- * and invokes the "unregistered" callback in the #DBusObjectVTable
- * for the given object. The passed-in object ID must be a valid,
- * registered object ID or the results are undefined.
+ * Unregisters the handler registered with exactly the given path.
+ * It's a bug to call this function for a path that isn't registered.
*
- * @param connection the connection to unregister the object ID from
- * @param object_id the object ID to unregister
+ * @param connection the connection
+ * @param path the #NULL-terminated array of path elements
*/
void
-dbus_connection_unregister_object (DBusConnection *connection,
- const DBusObjectID *object_id)
+dbus_connection_unregister_object_path (DBusConnection *connection,
+ const char **path)
{
- _dbus_return_if_fail (connection != NULL);
+ _dbus_return_if_fail (connection != NULL);
+ _dbus_return_if_fail (path != NULL);
+ _dbus_return_if_fail (path[0] != NULL);
CONNECTION_LOCK (connection);
- return _dbus_object_registry_remove_and_unlock (connection->objects,
- object_id);
+ return _dbus_object_tree_unregister_and_unlock (connection->objects,
+ path);
}
static DBusDataSlotAllocator slot_allocator;
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-connection.h DBusConnection object
*
- * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
#include <dbus/dbus-errors.h>
#include <dbus/dbus-memory.h>
-#include <dbus/dbus-object.h>
+#include <dbus/dbus-message.h>
DBUS_BEGIN_DECLS;
typedef struct DBusMessageHandler DBusMessageHandler;
typedef struct DBusPreallocatedSend DBusPreallocatedSend;
typedef struct DBusPendingCall DBusPendingCall;
+typedef struct DBusConnection DBusConnection;
+typedef struct DBusObjectPathVTable DBusObjectPathVTable;
typedef enum
{
DBUS_DISPATCH_NEED_MEMORY /**< More memory is needed to continue. */
} DBusDispatchStatus;
+typedef enum
+{
+ DBUS_HANDLER_RESULT_HANDLED, /**< Message has had its effect */
+ DBUS_HANDLER_RESULT_NOT_YET_HANDLED, /**< Message has not had any effect */
+ DBUS_HANDLER_RESULT_NEED_MEMORY /**< Need more memory to return another result */
+} DBusHandlerResult;
+
typedef dbus_bool_t (* DBusAddWatchFunction) (DBusWatch *watch,
void *data);
typedef void (* DBusWatchToggledFunction) (DBusWatch *watch,
void dbus_connection_remove_filter (DBusConnection *connection,
DBusMessageHandler *handler);
-/* Objects */
-dbus_bool_t dbus_connection_register_object (DBusConnection *connection,
- const char **interfaces,
- const DBusObjectVTable *vtable,
- void *object_impl,
- DBusObjectID *object_id);
-void dbus_connection_unregister_object (DBusConnection *connection,
- const DBusObjectID *object_id);
-
-
/* Other */
dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t *slot_p);
void dbus_connection_free_data_slot (dbus_int32_t *slot_p);
/* Object tree functionality */
-typedef struct DBusObjectTreeVTable DBusObjectTreeVTable;
-
-typedef void (* DBusObjectTreeUnregisterFunction) (DBusConnection *connection,
+typedef void (* DBusObjectPathUnregisterFunction) (DBusConnection *connection,
const char **path,
void *user_data);
-typedef DBusHandlerResult (* DBusObjectTreeMessageFunction) (DBusConnection *connection,
+typedef DBusHandlerResult (* DBusObjectPathMessageFunction) (DBusConnection *connection,
DBusMessage *message,
void *user_data);
-typedef dbus_bool_t (* DBusObjectTreeSubdirsFunction) (DBusConnection *connection,
- const char **path,
- char ***subdirs,
- int *n_subdirs,
- void *user_data);
-typedef dbus_bool_t (* DBusObjectTreeObjectsFunction) (DBusConnection *connection,
- const char **path,
- DBusObjectID **object_ids,
- int *n_object_ids,
- void *user_data);
-typedef dbus_bool_t (* DBusObjectTreeMethodsFunction) (DBusConnection *connection,
- const char **path,
- DBusObjectID **object_ids,
- int *n_object_ids,
- void *user_data);
-struct DBusObjectTreeVTable
+struct DBusObjectPathVTable
{
- DBusObjectTreeUnregisterFunction unregister_function;
- DBusObjectTreeMessageFunction message_function;
- DBusObjectTreeSubdirsFunction subdirs_function;
- DBusObjectTreeObjectsFunction objects_function;
- DBusObjectTreeMethodsFunction methods_function;
+ DBusObjectPathUnregisterFunction unregister_function;
+ DBusObjectPathMessageFunction message_function;
void (* dbus_internal_pad1) (void *);
void (* dbus_internal_pad2) (void *);
void (* dbus_internal_pad4) (void *);
};
-dbus_bool_t dbus_connection_register_object_tree (DBusConnection *connection,
+dbus_bool_t dbus_connection_register_object_path (DBusConnection *connection,
const char **path,
- const DBusObjectTreeVTable *vtable,
+ const DBusObjectPathVTable *vtable,
void *user_data);
-void dbus_connection_unregister_object_tree (DBusConnection *connection,
+void dbus_connection_unregister_object_path (DBusConnection *connection,
const char **path);
_DBUS_DECLARE_GLOBAL_LOCK (message_slots);
_DBUS_DECLARE_GLOBAL_LOCK (atomic);
_DBUS_DECLARE_GLOBAL_LOCK (message_handler);
-_DBUS_DECLARE_GLOBAL_LOCK (callback_object);
_DBUS_DECLARE_GLOBAL_LOCK (bus);
_DBUS_DECLARE_GLOBAL_LOCK (shutdown_funcs);
_DBUS_DECLARE_GLOBAL_LOCK (system_users);
dbus_uint64_t u;
#endif
double d;
- DBusObjectID object_id;
} DBusOctets8;
static DBusOctets8
}
/**
- * Sets the existing marshaled object ID at the given offset to a new
- * value. The given offset must point to an existing object ID or this
+ * Sets the existing marshaled object path at the given offset to a new
+ * value. The given offset must point to an existing object path or this
* function doesn't make sense.
*
- * @param str the string to write the marshalled string to
- * @param offset the byte offset where string should be written
+ * @todo implement this function
+ *
+ * @param str the string to write the marshalled path to
+ * @param offset the byte offset where path should be written
* @param byte_order the byte order to use
- * @param value the new value
+ * @param path the new path
+ * @param path_len number of elements in the path
*/
void
-_dbus_marshal_set_object_id (DBusString *str,
- int byte_order,
- int offset,
- const DBusObjectID *value)
+_dbus_marshal_set_object_path (DBusString *str,
+ int byte_order,
+ int offset,
+ const char **path,
+ int path_len)
{
- DBusOctets8 r;
-
- r.object_id = *value;
-
- set_8_octets (str, byte_order, offset, r);
+
+ /* FIXME */
}
static dbus_bool_t
}
/**
- * Marshals an object ID value.
+ * Marshals an object path value.
*
+ * @todo implement this function
+ *
* @param str the string to append the marshalled value to
* @param byte_order the byte order to use
- * @param value the value
+ * @param path the path
+ * @param path_len length of the path
* @returns #TRUE on success
*/
dbus_bool_t
-_dbus_marshal_object_id (DBusString *str,
- int byte_order,
- const DBusObjectID *value)
+_dbus_marshal_object_path (DBusString *str,
+ int byte_order,
+ const char **path,
+ int path_len)
{
- DBusOctets8 r;
-
- r.object_id = *value;
-
- return marshal_8_octets (str, byte_order, r);
+ return TRUE;
}
static dbus_uint32_t
}
/**
- * Demarshals an object ID.
+ * Demarshals an object path.
*
+ * @todo implement this function
+ *
* @param str the string containing the data
* @param byte_order the byte order
* @param pos the position in the string
* @param new_pos the new position of the string
- * @param value address to store new object ID
+ * @param path address to store new object path
+ * @param path_len length of stored path
*/
-void
-_dbus_demarshal_object_id (const DBusString *str,
- int byte_order,
- int pos,
- int *new_pos,
- DBusObjectID *value)
+dbus_bool_t
+_dbus_demarshal_object_path (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos,
+ char ***path,
+ int *path_len)
{
- DBusOctets8 r;
-
- r = demarshal_8_octets (str, byte_order, pos, new_pos);
-
- *value = r.object_id;
+
}
/**
case DBUS_TYPE_INT64:
case DBUS_TYPE_UINT64:
- case DBUS_TYPE_OBJECT_ID:
case DBUS_TYPE_DOUBLE:
*end_pos = _DBUS_ALIGN_VALUE (pos, 8) + 8;
*end_pos = pos + len;
}
break;
-
+
+ case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_ARRAY:
{
int len;
case DBUS_TYPE_NIL:
break;
+ case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_STRING:
case DBUS_TYPE_NAMED:
case DBUS_TYPE_ARRAY:
case DBUS_TYPE_INT64:
case DBUS_TYPE_UINT64:
case DBUS_TYPE_DOUBLE:
- case DBUS_TYPE_OBJECT_ID:
/* Call validate arg one time to check alignment padding
* at start of array
*/
*
* @todo For array types that can't be invalid, we should not
* walk the whole array validating it. e.g. just skip all the
- * int values in an int array.
+ * int values in an int array. (maybe this is already done now -hp)
+ *
+ * @todo support DBUS_TYPE_OBJECT_PATH
*
* @param str a string
* @param byte_order the byte order to use
case DBUS_TYPE_INT64:
case DBUS_TYPE_UINT64:
case DBUS_TYPE_DOUBLE:
- case DBUS_TYPE_OBJECT_ID:
{
int align_8 = _DBUS_ALIGN_VALUE (pos, 8);
#endif
char *s;
DBusString t;
- DBusObjectID obj_id, obj_id2;
if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!(_dbus_demarshal_uint64 (&str, DBUS_LITTLE_ENDIAN, pos, &pos) == DBUS_UINT64_CONSTANT (0x123456789abc7)))
_dbus_assert_not_reached ("demarshal failed");
#endif /* DBUS_HAVE_INT64 */
-
- /* Marshal object IDs */
- dbus_object_id_set_server_bits (&obj_id, 0xfffe);
- dbus_object_id_set_client_bits (&obj_id, 0xaacc);
- dbus_object_id_set_instance_bits (&obj_id, 0x70f00f0f);
-
- if (!_dbus_marshal_object_id (&str, DBUS_BIG_ENDIAN, &obj_id))
- _dbus_assert_not_reached ("could not marshal object ID value");
- _dbus_demarshal_object_id (&str, DBUS_BIG_ENDIAN, pos, &pos, &obj_id2);
- if (!dbus_object_id_equal (&obj_id, &obj_id2))
- _dbus_assert_not_reached ("demarshal failed");
-
- if (!_dbus_marshal_object_id (&str, DBUS_LITTLE_ENDIAN, &obj_id))
- _dbus_assert_not_reached ("could not marshal object ID value");
- _dbus_demarshal_object_id (&str, DBUS_LITTLE_ENDIAN, pos, &pos, &obj_id2);
- if (!dbus_object_id_equal (&obj_id, &obj_id2))
- _dbus_assert_not_reached ("demarshal failed");
/* Marshal strings */
tmp1 = "This is the dbus test string";
#include <dbus/dbus-types.h>
#include <dbus/dbus-arch-deps.h>
#include <dbus/dbus-string.h>
-#include <dbus/dbus-objectid.h>
#ifndef PACKAGE
#error "config.h not included here"
dbus_uint64_t value);
#endif /* DBUS_HAVE_INT64 */
-dbus_bool_t _dbus_marshal_set_string (DBusString *str,
- int byte_order,
- int offset,
- const DBusString *value,
- int len);
-void _dbus_marshal_set_object_id (DBusString *str,
- int byte_order,
- int offset,
- const DBusObjectID *value);
+dbus_bool_t _dbus_marshal_set_string (DBusString *str,
+ int byte_order,
+ int offset,
+ const DBusString *value,
+ int len);
+void _dbus_marshal_set_object_path (DBusString *str,
+ int byte_order,
+ int offset,
+ const char **path,
+ int path_len);
dbus_bool_t _dbus_marshal_int32 (DBusString *str,
int byte_order,
int byte_order,
const char **value,
int len);
-dbus_bool_t _dbus_marshal_object_id (DBusString *str,
+dbus_bool_t _dbus_marshal_object_path (DBusString *str,
int byte_order,
- const DBusObjectID *value);
+ const char **path,
+ int path_len);
double _dbus_demarshal_double (const DBusString *str,
int byte_order,
int *new_pos,
char ***array,
int *array_len);
-void _dbus_demarshal_object_id (const DBusString *str,
+dbus_bool_t _dbus_demarshal_object_path (const DBusString *str,
int byte_order,
int pos,
int *new_pos,
- DBusObjectID *value);
+ char ***path,
+ int *path_len);
dbus_bool_t _dbus_marshal_get_arg_end_pos (const DBusString *str,
int byte_order,
+++ /dev/null
-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-object-registry.c DBusObjectRegistry (internals of DBusConnection)
- *
- * 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-object-registry.h"
-#include "dbus-connection-internal.h"
-#include "dbus-internals.h"
-#include "dbus-hash.h"
-#include "dbus-protocol.h"
-#include <string.h>
-
-/**
- * @defgroup DBusObjectRegistry Map object IDs to implementations
- * @ingroup DBusInternals
- * @brief DBusObjectRegistry is used by DBusConnection to track object IDs
- *
- * Types and functions related to DBusObjectRegistry. These
- * are all internal.
- *
- * @todo interface entries and signal connections are handled pretty
- * much identically, with lots of duplicate code. Once we're sure
- * they will always be the same, we could merge this code.
- *
- * @{
- */
-
-typedef struct DBusObjectEntry DBusObjectEntry;
-typedef struct DBusInterfaceEntry DBusInterfaceEntry;
-typedef struct DBusSignalEntry DBusSignalEntry;
-
-#define DBUS_MAX_OBJECTS_PER_INTERFACE 65535
-struct DBusInterfaceEntry
-{
- unsigned int n_objects : 16; /**< Number of objects with this interface */
- unsigned int n_allocated : 16; /**< Allocated size of objects array */
- dbus_uint16_t *objects; /**< Index of each object with the interface */
- char name[4]; /**< Name of interface (actually allocated larger) */
-};
-
-#define DBUS_MAX_CONNECTIONS_PER_SIGNAL 65535
-struct DBusSignalEntry
-{
- unsigned int n_connections : 16; /**< Number of connections to this signal */
- unsigned int n_allocated : 16; /**< Allocated size of objects array */
- dbus_uint16_t *connections; /**< Index of each object connected (can have dups for multiple
- * connections)
- */
- char name[4]; /**< Interface of signal, nul, then name of signal (actually allocated larger) */
-};
-
- /* 14 bits for object index, 32K objects */
-#define DBUS_OBJECT_INDEX_BITS (14)
-#define DBUS_OBJECT_INDEX_MASK (0x3fff)
-#define DBUS_MAX_OBJECTS_PER_CONNECTION DBUS_OBJECT_INDEX_MASK
-struct DBusObjectEntry
-{
- unsigned int id_index : 14; /**< Index of this entry in the entries array */
- unsigned int id_times_used : 18; /**< Count of times entry has been used; avoids recycling IDs too often */
-
- void *object_impl; /**< Pointer to application-supplied implementation */
- const DBusObjectVTable *vtable; /**< Virtual table for this object */
- DBusInterfaceEntry **interfaces; /**< NULL-terminated list of interfaces */
- DBusSignalEntry **signals; /**< Signal connections (contains dups, one each time we connect) */
-};
-
-struct DBusObjectRegistry
-{
- int refcount;
- DBusConnection *connection;
-
- DBusObjectEntry *entries;
- int n_entries_allocated;
- int n_entries_used;
-
- DBusHashTable *interface_table;
-
- DBusHashTable *signal_table;
-};
-
-static void
-free_interface_entry (void *entry)
-{
- DBusInterfaceEntry *iface = entry;
-
- if (iface == NULL) /* DBusHashTable stupidity */
- return;
-
- dbus_free (iface->objects);
- dbus_free (iface);
-}
-
-static void
-free_signal_entry (void *entry)
-{
- DBusSignalEntry *signal = entry;
-
- if (signal == NULL) /* DBusHashTable stupidity */
- return;
-
- dbus_free (signal->connections);
- dbus_free (signal);
-}
-
-DBusObjectRegistry*
-_dbus_object_registry_new (DBusConnection *connection)
-{
- DBusObjectRegistry *registry;
- DBusHashTable *interface_table;
- DBusHashTable *signal_table;
-
- /* the connection passed in here isn't fully constructed,
- * so don't do anything more than store a pointer to
- * it
- */
-
- registry = NULL;
- interface_table = NULL;
- signal_table = NULL;
-
- registry = dbus_new0 (DBusObjectRegistry, 1);
- if (registry == NULL)
- goto oom;
-
- interface_table = _dbus_hash_table_new (DBUS_HASH_STRING,
- NULL, free_interface_entry);
- if (interface_table == NULL)
- goto oom;
-
- signal_table = _dbus_hash_table_new (DBUS_HASH_TWO_STRINGS,
- NULL, free_signal_entry);
- if (signal_table == NULL)
- goto oom;
-
- registry->refcount = 1;
- registry->connection = connection;
- registry->interface_table = interface_table;
- registry->signal_table = signal_table;
-
- return registry;
-
- oom:
- if (registry)
- dbus_free (registry);
- if (interface_table)
- _dbus_hash_table_unref (interface_table);
- if (signal_table)
- _dbus_hash_table_unref (signal_table);
-
- return NULL;
-}
-
-void
-_dbus_object_registry_ref (DBusObjectRegistry *registry)
-{
- _dbus_assert (registry->refcount > 0);
-
- registry->refcount += 1;
-}
-
-void
-_dbus_object_registry_unref (DBusObjectRegistry *registry)
-{
- _dbus_assert (registry->refcount > 0);
-
- registry->refcount -= 1;
-
- if (registry->refcount == 0)
- {
- int i;
-
- _dbus_assert (registry->n_entries_used == 0);
- _dbus_assert (_dbus_hash_table_get_n_entries (registry->interface_table) == 0);
- _dbus_assert (_dbus_hash_table_get_n_entries (registry->signal_table) == 0);
-
- i = 0;
- while (i < registry->n_entries_allocated)
- {
- if (registry->entries[i].interfaces)
- dbus_free (registry->entries[i].interfaces);
- if (registry->entries[i].signals)
- dbus_free (registry->entries[i].signals);
- ++i;
- }
-
- _dbus_hash_table_unref (registry->interface_table);
- _dbus_hash_table_unref (registry->signal_table);
- dbus_free (registry->entries);
- dbus_free (registry);
- }
-}
-
-#define ENTRY_TO_ID(entry) \
- (((dbus_uint32_t) (entry)->id_index) | \
- (((dbus_uint32_t)(entry)->id_times_used) << DBUS_OBJECT_INDEX_BITS))
-
-#define ID_TO_INDEX(id) \
- (((dbus_uint32_t) (id)) & DBUS_OBJECT_INDEX_MASK)
-
-#define ID_TO_TIMES_USED(id) \
- (((dbus_uint32_t) (id)) >> DBUS_OBJECT_INDEX_BITS)
-
-static DBusObjectEntry*
-validate_id (DBusObjectRegistry *registry,
- const DBusObjectID *object_id)
-{
- int idx;
- int times_used;
- dbus_uint32_t instance_bits;
-
- instance_bits = dbus_object_id_get_instance_bits (object_id);
-
- /* Verify that connection ID bits are the same */
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- {
- DBusObjectID tmp_id;
-
- _dbus_connection_init_id (registry->connection,
- &tmp_id);
- dbus_object_id_set_instance_bits (&tmp_id, instance_bits);
-
- if (!dbus_object_id_equal (&tmp_id, object_id))
- return NULL;
- }
-
- idx = ID_TO_INDEX (instance_bits);
- times_used = ID_TO_TIMES_USED (instance_bits);
-
- if (idx >= registry->n_entries_allocated)
- return NULL;
- if (registry->entries[idx].vtable == NULL)
- return NULL;
- if (registry->entries[idx].id_times_used != times_used)
- return NULL;
- _dbus_assert (registry->entries[idx].id_index == idx);
- _dbus_assert (registry->n_entries_used > 0);
-
- return ®istry->entries[idx];
-}
-
-static void
-id_from_entry (DBusObjectRegistry *registry,
- DBusObjectID *object_id,
- DBusObjectEntry *entry)
-{
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_init_id (registry->connection,
- object_id);
-#ifdef DBUS_BUILD_TESTS
- else
- {
- dbus_object_id_set_server_bits (object_id, 1);
- dbus_object_id_set_client_bits (object_id, 2);
- }
-#endif
-
- _dbus_assert (dbus_object_id_get_server_bits (object_id) != 0);
- _dbus_assert (dbus_object_id_get_client_bits (object_id) != 0);
-
- dbus_object_id_set_instance_bits (object_id,
- ENTRY_TO_ID (entry));
-
- _dbus_assert (dbus_object_id_get_instance_bits (object_id) != 0);
-}
-
-static void
-info_from_entry (DBusObjectRegistry *registry,
- DBusObjectInfo *info,
- DBusObjectEntry *entry)
-{
- info->connection = registry->connection;
- info->object_impl = entry->object_impl;
-
- id_from_entry (registry, &info->object_id, entry);
-}
-
-static DBusInterfaceEntry*
-lookup_interface (DBusObjectRegistry *registry,
- const char *name,
- dbus_bool_t create_if_not_found)
-{
- DBusInterfaceEntry *entry;
- int sz;
- int len;
-
- entry = _dbus_hash_table_lookup_string (registry->interface_table,
- name);
- if (entry != NULL || !create_if_not_found)
- return entry;
-
- _dbus_assert (create_if_not_found);
-
- len = strlen (name);
- sz = _DBUS_STRUCT_OFFSET (DBusInterfaceEntry, name) + len + 1;
- entry = dbus_malloc (sz);
- if (entry == NULL)
- return NULL;
- entry->n_objects = 0;
- entry->n_allocated = 0;
- entry->objects = NULL;
- memcpy (entry->name, name, len + 1);
-
- if (!_dbus_hash_table_insert_string (registry->interface_table,
- entry->name, entry))
- {
- dbus_free (entry);
- return NULL;
- }
-
- return entry;
-}
-
-static void
-delete_interface (DBusObjectRegistry *registry,
- DBusInterfaceEntry *entry)
-{
- _dbus_hash_table_remove_string (registry->interface_table,
- entry->name);
-}
-
-static dbus_bool_t
-interface_entry_add_object (DBusInterfaceEntry *entry,
- dbus_uint16_t object_index)
-{
- if (entry->n_objects == entry->n_allocated)
- {
- unsigned int new_alloc;
- dbus_uint16_t *new_objects;
-
- if (entry->n_allocated == 0)
- new_alloc = 2;
- else
- new_alloc = entry->n_allocated * 2;
-
- /* Right now MAX_OBJECTS_PER_INTERFACE can't possibly be reached
- * since the max number of objects _total_ is smaller, but the
- * code is here for future robustness.
- */
-
- if (new_alloc > DBUS_MAX_OBJECTS_PER_INTERFACE)
- new_alloc = DBUS_MAX_OBJECTS_PER_INTERFACE;
- if (new_alloc == entry->n_allocated)
- {
- _dbus_warn ("Attempting to register another instance with interface %s, but max count %d reached\n",
- entry->name, DBUS_MAX_OBJECTS_PER_INTERFACE);
- return FALSE;
- }
-
- new_objects = dbus_realloc (entry->objects, new_alloc * sizeof (dbus_uint16_t));
- if (new_objects == NULL)
- return FALSE;
- entry->objects = new_objects;
- entry->n_allocated = new_alloc;
- }
-
- _dbus_assert (entry->n_objects < entry->n_allocated);
-
- entry->objects[entry->n_objects] = object_index;
- entry->n_objects += 1;
-
- return TRUE;
-}
-
-static void
-interface_entry_remove_object (DBusInterfaceEntry *entry,
- dbus_uint16_t object_index)
-{
- unsigned int i;
-
- i = 0;
- while (i < entry->n_objects)
- {
- if (entry->objects[i] == object_index)
- break;
- ++i;
- }
-
- if (i == entry->n_objects)
- {
- _dbus_assert_not_reached ("Tried to remove object from an interface that didn't list that object\n");
- return;
- }
-
- memmove (&entry->objects[i],
- &entry->objects[i+1],
- (entry->n_objects - i - 1) * sizeof (entry->objects[0]));
- entry->n_objects -= 1;
-}
-
-static void
-object_remove_from_interfaces (DBusObjectRegistry *registry,
- DBusObjectEntry *entry)
-{
- if (entry->interfaces != NULL)
- {
- int i;
-
- i = 0;
- while (entry->interfaces[i] != NULL)
- {
- DBusInterfaceEntry *iface = entry->interfaces[i];
-
- interface_entry_remove_object (iface, entry->id_index);
- if (iface->n_objects == 0)
- delete_interface (registry, iface);
- ++i;
- }
- }
-}
-
-static DBusSignalEntry*
-lookup_signal (DBusObjectRegistry *registry,
- const char *signal_interface,
- const char *signal_name,
- dbus_bool_t create_if_not_found)
-{
- DBusSignalEntry *entry;
- int sz;
- size_t len_interface, len_name;
- char buf[2 * DBUS_MAXIMUM_NAME_LENGTH + 2];
-
- /* This is all a little scary and maybe we shouldn't jump
- * through these hoops just to save some bytes.
- */
-
- len_interface = strlen (signal_interface);
- len_name = strlen (signal_name);
-
- _dbus_assert (len_interface + len_name + 2 <= sizeof (buf));
-
- memcpy (buf, signal_interface, len_interface + 1);
- memcpy (buf + len_interface + 1, signal_name, len_name + 1);
-
- entry = _dbus_hash_table_lookup_two_strings (registry->signal_table,
- buf);
- if (entry != NULL || !create_if_not_found)
- return entry;
-
- _dbus_assert (create_if_not_found);
-
- sz = _DBUS_STRUCT_OFFSET (DBusSignalEntry, name) + len_interface + len_name + 2;
- entry = dbus_malloc (sz);
- if (entry == NULL)
- return NULL;
- entry->n_connections = 0;
- entry->n_allocated = 0;
- entry->connections = NULL;
- memcpy (entry->name, buf, len_interface + len_name + 2);
-
- if (!_dbus_hash_table_insert_two_strings (registry->signal_table,
- entry->name, entry))
- {
- dbus_free (entry);
- return NULL;
- }
-
- return entry;
-}
-
-static void
-delete_signal (DBusObjectRegistry *registry,
- DBusSignalEntry *entry)
-{
- _dbus_hash_table_remove_two_strings (registry->signal_table,
- entry->name);
-}
-
-static dbus_bool_t
-signal_entry_add_object (DBusSignalEntry *entry,
- dbus_uint16_t object_index)
-{
- if (entry->n_connections == entry->n_allocated)
- {
- unsigned int new_alloc;
- dbus_uint16_t *new_objects;
-
- if (entry->n_allocated == 0)
- new_alloc = 2;
- else
- new_alloc = entry->n_allocated * 2;
-
- /* Right now MAX_CONNECTIONS_PER_SIGNAL can't possibly be reached
- * since the max number of objects _total_ is smaller, but the
- * code is here for future robustness.
- */
-
- if (new_alloc > DBUS_MAX_CONNECTIONS_PER_SIGNAL)
- new_alloc = DBUS_MAX_CONNECTIONS_PER_SIGNAL;
- if (new_alloc == entry->n_allocated)
- {
- _dbus_warn ("Attempting to register another instance with signal %s, but max count %d reached\n",
- entry->name, DBUS_MAX_CONNECTIONS_PER_SIGNAL);
- return FALSE;
- }
-
- new_objects = dbus_realloc (entry->connections, new_alloc * sizeof (dbus_uint16_t));
- if (new_objects == NULL)
- return FALSE;
- entry->connections = new_objects;
- entry->n_allocated = new_alloc;
- }
-
- _dbus_assert (entry->n_connections < entry->n_allocated);
-
- entry->connections[entry->n_connections] = object_index;
- entry->n_connections += 1;
-
- return TRUE;
-}
-
-static void
-signal_entry_remove_object (DBusSignalEntry *entry,
- dbus_uint16_t object_index)
-{
- unsigned int i;
-
- i = 0;
- while (i < entry->n_connections)
- {
- if (entry->connections[i] == object_index)
- break;
- ++i;
- }
-
- if (i == entry->n_connections)
- {
- _dbus_assert_not_reached ("Tried to remove object from an signal that didn't list that object\n");
- return;
- }
-
- memmove (&entry->connections[i],
- &entry->connections[i+1],
- (entry->n_connections - i - 1) * sizeof (entry->connections[0]));
- entry->n_connections -= 1;
-}
-
-static void
-object_remove_from_signals (DBusObjectRegistry *registry,
- DBusObjectEntry *entry)
-{
- if (entry->signals != NULL)
- {
- int i;
-
- i = 0;
- while (entry->signals[i] != NULL)
- {
- DBusSignalEntry *signal = entry->signals[i];
-
- signal_entry_remove_object (signal, entry->id_index);
- if (signal->n_connections == 0)
- delete_signal (registry, signal);
- ++i;
- }
- }
-}
-
-/**
- * Connect this object to the given signal, such that if a
- * signal emission message is received with the given
- * signal name, the message will be routed to the
- * given object.
- *
- * Must be called with #DBusConnection lock held.
- *
- * @param registry the object registry
- * @param object_id object that would like to see the signal
- * @param signal_interface signal interface name
- * @param signal_name signal member name
- *
- * @returns #FALSE if no memory
- */
-dbus_bool_t
-_dbus_object_registry_connect_locked (DBusObjectRegistry *registry,
- const DBusObjectID *object_id,
- const char *signal_interface,
- const char *signal_name)
-{
- DBusSignalEntry **new_signals;
- DBusSignalEntry *signal;
- DBusObjectEntry *entry;
- int i;
-
- _dbus_assert (signal_interface != NULL);
- _dbus_assert (signal_name != NULL);
-
- entry = validate_id (registry, object_id);
- if (entry == NULL)
- {
- _dbus_warn ("Tried to connect a nonexistent D-BUS object ID to signal \"%s\"\n",
- signal_name);
-
- return FALSE;
- }
-
- /* O(n) in number of connections unfortunately, but in practice I
- * don't think it will matter. It's marginally a space-time
- * tradeoff (save an n_signals field) but the NULL termination is
- * just as large as an n_signals once we have even a single
- * connection.
- */
- i = 0;
- if (entry->signals != NULL)
- {
- while (entry->signals[i] != NULL)
- ++i;
- }
-
- new_signals = dbus_realloc (entry->signals,
- (i + 2) * sizeof (DBusSignalEntry*));
-
- if (new_signals == NULL)
- return FALSE;
-
- entry->signals = new_signals;
-
- signal = lookup_signal (registry, signal_interface, signal_name, TRUE);
- if (signal == NULL)
- goto oom;
-
- if (!signal_entry_add_object (signal, entry->id_index))
- goto oom;
-
- entry->signals[i] = signal;
- ++i;
- entry->signals[i] = NULL;
-
- return TRUE;
-
- oom:
- if (signal && signal->n_connections == 0)
- delete_signal (registry, signal);
-
- return FALSE;
-}
-
-/**
- * Reverses effects of _dbus_object_registry_disconnect_locked().
- *
- * @param registry the object registry
- * @param object_id object that would like to see the signal
- * @param signal_interface signal interface
- * @param signal_name signal name
- */
-void
-_dbus_object_registry_disconnect_locked (DBusObjectRegistry *registry,
- const DBusObjectID *object_id,
- const char *signal_interface,
- const char *signal_name)
-{
- DBusObjectEntry *entry;
- DBusSignalEntry *signal;
-
- _dbus_assert (signal_interface != NULL);
- _dbus_assert (signal_name != NULL);
-
- entry = validate_id (registry, object_id);
- if (entry == NULL)
- {
- _dbus_warn ("Tried to disconnect signal \"%s\"::\"%s\" from a nonexistent D-BUS object ID\n",
- signal_interface, signal_name);
-
- return;
- }
-
- signal = lookup_signal (registry, signal_interface, signal_name, FALSE);
- if (signal == NULL)
- {
- _dbus_warn ("Tried to disconnect signal \"%s\"::\"%s\" but no such signal is connected\n",
- signal_interface, signal_name);
- return;
- }
-
- signal_entry_remove_object (signal, entry->id_index);
-
- if (signal->n_connections == 0)
- delete_signal (registry, signal);
-}
-
-static DBusHandlerResult
-handle_method_call_and_unlock (DBusObjectRegistry *registry,
- DBusMessage *message)
-{
- DBusInterfaceEntry *iface_entry;
- DBusObjectEntry *object_entry;
- DBusObjectInfo info;
- const DBusObjectVTable *vtable;
-
- _dbus_assert (registry != NULL);
- _dbus_assert (message != NULL);
-
- /* FIXME handle calls to an object ID instead of just an
- * interface name
- */
-
- /* If the message isn't to a specific object ID, we send
- * it to the first object that supports the given interface.
- */
- iface_entry = lookup_interface (registry,
- dbus_message_get_interface (message),
- FALSE);
-
- if (iface_entry == NULL)
- {
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- }
-
- _dbus_assert (iface_entry->n_objects > 0);
- _dbus_assert (iface_entry->objects != NULL);
-
- object_entry = ®istry->entries[iface_entry->objects[0]];
-
-
- /* Once we have an object entry, pass message to the object */
-
- _dbus_assert (object_entry->vtable != NULL);
-
- info_from_entry (registry, &info, object_entry);
- vtable = object_entry->vtable;
-
- /* Drop lock and invoke application code */
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- (* vtable->message) (&info, message);
-
- return DBUS_HANDLER_RESULT_HANDLED;
-}
-
-typedef struct
-{
- DBusObjectID id;
-} ObjectEmitData;
-
-static DBusHandlerResult
-handle_signal_and_unlock (DBusObjectRegistry *registry,
- DBusMessage *message)
-{
- DBusSignalEntry *signal_entry;
- int i;
- ObjectEmitData *objects;
- int n_objects;
-
- _dbus_assert (registry != NULL);
- _dbus_assert (message != NULL);
-
- signal_entry = lookup_signal (registry,
- dbus_message_get_interface (message),
- dbus_message_get_member (message),
- FALSE);
-
- if (signal_entry == NULL)
- {
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- }
-
- _dbus_assert (signal_entry->n_connections > 0);
- _dbus_assert (signal_entry->connections != NULL);
-
- /* make a copy for safety vs. reentrancy */
-
- /* FIXME (?) if you disconnect a signal during (vs. before)
- * emission, you still receive that signal. To fix this uses more
- * memory because we don't have a per-connection object at the
- * moment. You would have to introduce a connection object and
- * refcount it and have a "disconnected" flag. This is more like
- * GObject semantics but also maybe not important at this level (the
- * GObject/Qt wrappers can mop it up).
- */
-
- n_objects = signal_entry->n_connections;
- objects = dbus_new (ObjectEmitData, n_objects);
-
- if (objects == NULL)
- {
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
- }
-
- i = 0;
- while (i < signal_entry->n_connections)
- {
- DBusObjectEntry *object_entry;
- int idx;
-
- idx = signal_entry->connections[i];
-
- object_entry = ®istry->entries[idx];
-
- _dbus_assert (object_entry->vtable != NULL);
-
- id_from_entry (registry,
- &objects[i].id,
- object_entry);
-
- ++i;
- }
-
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_ref_unlocked (registry->connection);
- _dbus_object_registry_ref (registry);
- dbus_message_ref (message);
-
- i = 0;
- while (i < n_objects)
- {
- DBusObjectEntry *object_entry;
-
- /* If an object ID no longer exists, don't send the
- * signal
- */
- object_entry = validate_id (registry, &objects[i].id);
- if (object_entry != NULL)
- {
- const DBusObjectVTable *vtable;
- DBusObjectInfo info;
-
- info_from_entry (registry, &info, object_entry);
- vtable = object_entry->vtable;
-
- /* Drop lock and invoke application code */
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- (* vtable->message) (&info, message);
-
- /* Reacquire lock */
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_lock (registry->connection);
- }
- ++i;
- }
-
- dbus_message_unref (message);
- _dbus_object_registry_unref (registry);
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unref_unlocked (registry->connection);
-
- dbus_free (objects);
-
- /* Drop lock a final time */
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- return DBUS_HANDLER_RESULT_HANDLED;
-}
-
-/**
- * Handle a message, passing it to any objects in the registry that
- * should receive it.
- *
- * @todo handle messages to an object ID, not just those to
- * an interface name.
- *
- * @param registry the object registry
- * @param message the message to handle
- * @returns what to do with the message next
- */
-DBusHandlerResult
-_dbus_object_registry_handle_and_unlock (DBusObjectRegistry *registry,
- DBusMessage *message)
-{
- int type;
-
- _dbus_assert (registry != NULL);
- _dbus_assert (message != NULL);
-
- type = dbus_message_get_type (message);
-
- switch (type)
- {
- case DBUS_MESSAGE_TYPE_METHOD_CALL:
- return handle_method_call_and_unlock (registry, message);
- case DBUS_MESSAGE_TYPE_SIGNAL:
- return handle_signal_and_unlock (registry, message);
- default:
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- }
-}
-
-dbus_bool_t
-_dbus_object_registry_add_and_unlock (DBusObjectRegistry *registry,
- const char **interfaces,
- const DBusObjectVTable *vtable,
- void *object_impl,
- DBusObjectID *object_id)
-{
- int idx;
- int i;
- DBusObjectInfo info;
-
- if (registry->n_entries_used == registry->n_entries_allocated)
- {
- DBusObjectEntry *new_entries;
- int new_alloc;
-
- if (registry->n_entries_allocated == 0)
- new_alloc = 16;
- else
- {
- if (registry->n_entries_allocated == DBUS_MAX_OBJECTS_PER_CONNECTION)
- {
- _dbus_warn ("Attempting to register a new D-BUS object, but maximum object count of %d reached\n",
- DBUS_MAX_OBJECTS_PER_CONNECTION);
- goto out_0;
- }
-
- new_alloc = registry->n_entries_allocated * 2;
- if (new_alloc > DBUS_MAX_OBJECTS_PER_CONNECTION)
- new_alloc = DBUS_MAX_OBJECTS_PER_CONNECTION;
- }
-
- new_entries = dbus_realloc (registry->entries,
- new_alloc * sizeof (DBusObjectEntry));
-
- if (new_entries == NULL)
- goto out_0;
-
- memset (&new_entries[registry->n_entries_allocated],
- '\0',
- sizeof (DBusObjectEntry) * (new_alloc - registry->n_entries_allocated));
-
- registry->entries = new_entries;
- registry->n_entries_allocated = new_alloc;
- }
- _dbus_assert (registry->n_entries_used < registry->n_entries_allocated);
-
- /* We linear search for an available entry. However, short-circuit
- * the hopefully-common situation where we don't have a sparse
- * array.
- */
- if (registry->entries[registry->n_entries_used].vtable == NULL)
- {
- idx = registry->n_entries_used;
- }
- else
- {
- /* If we do have a sparse array, we try to get rid of it rather
- * than using empty slots on the end, so we won't hit this case
- * next time.
- */
-
- /* If index n_entries_used is occupied, then
- * there is at least one entry outside of
- * the range [0, n_entries_used). Thus, there is
- * at least one blank entry inside that range.
- */
- idx = 0;
- while (idx < registry->n_entries_used)
- {
- if (registry->entries[idx].vtable == NULL)
- break;
- ++idx;
- }
-
- _dbus_assert (idx < registry->n_entries_used);
- }
-
- registry->entries[idx].id_index = idx;
- /* Overflow is OK here, but zero isn't as it's a null ID */
- registry->entries[idx].id_times_used += 1;
- if (registry->entries[idx].id_times_used == 0)
- registry->entries[idx].id_times_used += 1;
-
- registry->entries[idx].vtable = vtable;
- registry->entries[idx].object_impl = object_impl;
-
- registry->n_entries_used += 1;
-
- i = 0;
- if (interfaces != NULL)
- {
- while (interfaces[i] != NULL)
- ++i;
- }
-
- if (i > 0)
- {
- DBusInterfaceEntry **new_interfaces;
-
- new_interfaces =
- dbus_realloc (registry->entries[idx].interfaces,
- (i + 1) * sizeof (DBusInterfaceEntry*));
-
- if (new_interfaces == NULL)
- {
- /* maintain invariant that .interfaces array points to something
- * valid in oom handler (entering this function it pointed to
- * stale data but a valid malloc block)
- */
- dbus_free (registry->entries[idx].interfaces);
- registry->entries[idx].interfaces = NULL;
- goto out_1;
- }
-
- /* NULL-init so it's NULL-terminated and the OOM
- * case can see how far we got
- */
- while (i >= 0)
- {
- new_interfaces[i] = NULL;
- --i;
- }
-
- registry->entries[idx].interfaces = new_interfaces;
- }
- else
- {
- dbus_free (registry->entries[idx].interfaces);
- registry->entries[idx].interfaces = NULL;
- }
-
- /* Fill in interfaces */
- if (interfaces != NULL)
- {
- i = 0;
- while (interfaces[i] != NULL)
- {
- DBusInterfaceEntry *iface;
-
- iface = lookup_interface (registry, interfaces[i],
- TRUE);
- if (iface == NULL)
- goto out_1;
-
- if (!interface_entry_add_object (iface, idx))
- {
- if (iface->n_objects == 0)
- delete_interface (registry, iface);
- goto out_1;
- }
-
- registry->entries[idx].interfaces[i] = iface;
-
- ++i;
- }
- }
-
- info_from_entry (registry, &info, ®istry->entries[idx]);
- if (object_id)
- *object_id = info.object_id;
-
- /* Drop lock and invoke application code */
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- (* vtable->registered) (&info);
-
- return TRUE;
-
- out_1:
- registry->entries[idx].vtable = NULL;
- registry->entries[idx].object_impl = NULL;
- registry->n_entries_used -= 1;
-
- object_remove_from_interfaces (registry,
- ®istry->entries[idx]);
-
- out_0:
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
- return FALSE;
-}
-
-void
-_dbus_object_registry_remove_and_unlock (DBusObjectRegistry *registry,
- const DBusObjectID *object_id)
-{
- DBusObjectInfo info;
- DBusObjectEntry *entry;
- const DBusObjectVTable *vtable;
-
- entry = validate_id (registry, object_id);
- if (entry == NULL)
- {
- _dbus_warn ("Tried to unregister a nonexistent D-BUS object ID\n");
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- return;
- }
-
- object_remove_from_signals (registry, entry);
- object_remove_from_interfaces (registry, entry);
-
- info_from_entry (registry, &info, entry);
- vtable = entry->vtable;
- entry->vtable = NULL;
- entry->object_impl = NULL;
- registry->n_entries_used -= 1;
-
- /* Drop lock and invoke application code */
-#ifdef DBUS_BUILD_TESTS
- if (registry->connection)
-#endif
- _dbus_connection_unlock (registry->connection);
-
- (* vtable->unregistered) (&info);
-}
-
-
-void
-_dbus_object_registry_free_all_unlocked (DBusObjectRegistry *registry)
-{
- int i;
-
- i = 0;
- while (registry->n_entries_used > 0)
- {
- _dbus_assert (i < registry->n_entries_allocated);
- if (registry->entries[i].vtable != NULL)
- {
- DBusObjectInfo info;
- const DBusObjectVTable *vtable;
-
- object_remove_from_interfaces (registry,
- ®istry->entries[i]);
-
- info_from_entry (registry, &info, ®istry->entries[i]);
- vtable = registry->entries[i].vtable;
- registry->entries[i].vtable = NULL;
- registry->entries[i].object_impl = NULL;
- registry->n_entries_used -= 1;
- _dbus_assert (registry->n_entries_used >= 0);
-
- (* vtable->unregistered) (&info);
- }
-
- ++i;
- }
-
- _dbus_assert (registry->n_entries_used == 0);
-}
-
-/** @} */
-
-#ifdef DBUS_BUILD_TESTS
-#include "dbus-test.h"
-#include <stdio.h>
-
-static void
-noop_message_function (DBusObjectInfo *info,
- DBusMessage *message)
-{
- /* nothing */
-}
-
-static void
-add_and_remove_objects (DBusObjectRegistry *registry)
-{
-#define N_OBJECTS 73
- DBusObjectID ids[N_OBJECTS];
- const char *zero_interfaces[] = { NULL };
- const char *one_interface[] = { "org.freedesktop.Test.Blah", NULL };
- const char *three_interfaces[] = { "org.freedesktop.Test.Blah",
- "org.freedesktop.Test.Baz",
- "org.freedesktop.Test.Foo",
- NULL };
- int i;
- DBusMessage *message;
-
- i = 0;
- while (i < N_OBJECTS)
- {
- DBusCallbackObject *callback;
- const char **interfaces;
-
- callback = dbus_callback_object_new (noop_message_function, NULL, NULL);
- if (callback == NULL)
- goto out;
-
- interfaces = NULL;
- switch (i % 3)
- {
- case 0:
- interfaces = zero_interfaces;
- break;
- case 1:
- interfaces = one_interface;
- break;
- case 2:
- interfaces = three_interfaces;
- break;
- }
- _dbus_assert (interfaces != NULL);
-
- if (!_dbus_object_registry_add_and_unlock (registry,
- interfaces,
- dbus_callback_object_vtable,
- callback,
- &ids[i]))
- {
- dbus_callback_object_unref (callback);
- goto out;
- }
-
- dbus_callback_object_unref (callback);
-
- ++i;
- }
-
- i = 0;
- while (i < N_OBJECTS)
- {
- if (i > (N_OBJECTS - 20) || (i % 3) == 0)
- {
- _dbus_object_registry_remove_and_unlock (registry,
- &ids[i]);
- dbus_object_id_set_null (&ids[i]);
- }
-
- ++i;
- }
-
- i = 0;
- while (i < N_OBJECTS)
- {
- if (dbus_object_id_is_null (&ids[i]))
- {
- DBusCallbackObject *callback;
- const char **interfaces;
-
- callback = dbus_callback_object_new (noop_message_function, NULL, NULL);
- if (callback == NULL)
- goto out;
-
- interfaces = NULL;
- switch (i % 4)
- {
- case 0:
- interfaces = NULL;
- break;
- case 1:
- interfaces = zero_interfaces;
- break;
- case 2:
- interfaces = one_interface;
- break;
- case 3:
- interfaces = three_interfaces;
- break;
- }
-
- if (!_dbus_object_registry_add_and_unlock (registry,
- interfaces,
- dbus_callback_object_vtable,
- callback,
- &ids[i]))
- {
- dbus_callback_object_unref (callback);
- goto out;
- }
-
- dbus_callback_object_unref (callback);
- }
-
- ++i;
- }
-
- message = dbus_message_new_method_call ("org.freedesktop.Test.Foo",
- "Bar", NULL);
- if (message != NULL)
- {
- if (_dbus_object_registry_handle_and_unlock (registry, message) !=
- DBUS_HANDLER_RESULT_HANDLED)
- _dbus_assert_not_reached ("message not handled\n");
- dbus_message_unref (message);
- }
-
- message = dbus_message_new_method_call ("org.freedesktop.Test.Blah",
- "Baz", NULL);
- if (message != NULL)
- {
- if (_dbus_object_registry_handle_and_unlock (registry, message) !=
- DBUS_HANDLER_RESULT_HANDLED)
- _dbus_assert_not_reached ("message not handled\n");
- dbus_message_unref (message);
- }
-
- message = dbus_message_new_method_call ("org.freedesktop.Test.NotRegisteredIface",
- "Boo", NULL);
- if (message != NULL)
- {
- if (_dbus_object_registry_handle_and_unlock (registry, message) !=
- DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
- _dbus_assert_not_reached ("message handled but no handler was registered\n");
- dbus_message_unref (message);
- }
-
- i = 0;
- while (i < (N_OBJECTS - 30))
- {
- _dbus_assert (!dbus_object_id_is_null (&ids[i]));
-
- _dbus_object_registry_remove_and_unlock (registry,
- &ids[i]);
- ++i;
- }
-
- out:
- /* unregister the rest this way, to test this function */
- _dbus_object_registry_free_all_unlocked (registry);
-}
-
-static dbus_bool_t
-object_registry_test_iteration (void *data)
-{
- DBusObjectRegistry *registry;
-
- registry = _dbus_object_registry_new (NULL);
- if (registry == NULL)
- return TRUE;
-
- /* we do this twice since realloc behavior will differ each time,
- * and the IDs will get recycled leading to slightly different
- * codepaths
- */
- add_and_remove_objects (registry);
- add_and_remove_objects (registry);
-
- _dbus_object_registry_unref (registry);
-
- return TRUE;
-}
-
-/**
- * @ingroup DBusObjectRegistry
- * Unit test for DBusObjectRegistry
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_object_registry_test (void)
-{
- _dbus_test_oom_handling ("object registry",
- object_registry_test_iteration,
- NULL);
-
- return TRUE;
-}
-
-#endif /* DBUS_BUILD_TESTS */
+++ /dev/null
-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-object-registry.h DBusObjectRegistry (internals of DBusConnection)
- *
- * 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_OBJECT_REGISTRY_H
-#define DBUS_OBJECT_REGISTRY_H
-
-#include <dbus/dbus-object.h>
-
-DBUS_BEGIN_DECLS;
-
-typedef struct DBusObjectRegistry DBusObjectRegistry;
-
-DBusObjectRegistry* _dbus_object_registry_new (DBusConnection *connection);
-void _dbus_object_registry_ref (DBusObjectRegistry *registry);
-void _dbus_object_registry_unref (DBusObjectRegistry *registry);
-
-dbus_bool_t _dbus_object_registry_add_and_unlock (DBusObjectRegistry *registry,
- const char **interfaces,
- const DBusObjectVTable *vtable,
- void *object_impl,
- DBusObjectID *object_id);
-void _dbus_object_registry_remove_and_unlock (DBusObjectRegistry *registry,
- const DBusObjectID *object_id);
-DBusHandlerResult _dbus_object_registry_handle_and_unlock (DBusObjectRegistry *registry,
- DBusMessage *message);
-void _dbus_object_registry_free_all_unlocked (DBusObjectRegistry *registry);
-dbus_bool_t _dbus_object_registry_connect_locked (DBusObjectRegistry *registry,
- const DBusObjectID *object_id,
- const char *signal_interface,
- const char *signal_name);
-void _dbus_object_registry_disconnect_locked (DBusObjectRegistry *registry,
- const DBusObjectID *object_id,
- const char *signal_interface,
- const char *signal_name);
-
-DBUS_END_DECLS;
-
-#endif /* DBUS_OBJECT_REGISTRY_H */
typedef struct DBusObjectSubtree DBusObjectSubtree;
DBusObjectSubtree* _dbus_object_subtree_new (const char **path,
- const DBusObjectTreeVTable *vtable,
+ const DBusObjectPathVTable *vtable,
void *user_data);
void _dbus_object_subtree_ref (DBusObjectSubtree *subtree);
void _dbus_object_subtree_unref (DBusObjectSubtree *subtree);
int refcount;
char **path;
int n_path_elements;
- DBusObjectTreeVTable vtable;
+ DBusObjectPathVTable vtable;
void *user_data;
};
dbus_bool_t
_dbus_object_tree_register (DBusObjectTree *tree,
const char **path,
- const DBusObjectTreeVTable *vtable,
+ const DBusObjectPathVTable *vtable,
void *user_data)
{
DBusObjectSubtree *subtree;
}
/**
+ * Free all the handlers in the tree. Lock on tree's connection
+ * must not be held.
+ *
+ * @todo implement
+ *
+ * @param tree the object tree
+ */
+void
+_dbus_object_tree_free_all_unlocked (DBusObjectTree *tree)
+{
+
+
+}
+
+/**
* Tries to dispatch a message by directing it to the object tree
* node listed in the message header, if any.
*
+ * @todo implement
+ *
* @param tree the global object tree
* @param message the message to dispatch
* @returns whether message was handled successfully
DBusObjectSubtree*
_dbus_object_subtree_new (const char **path,
- const DBusObjectTreeVTable *vtable,
+ const DBusObjectPathVTable *vtable,
void *user_data)
{
DBusObjectSubtree *subtree;
DBusObjectSubtree *subtree1;
DBusObjectSubtree *subtree2;
dbus_bool_t retval;
- DBusObjectTreeVTable vtable;
+ DBusObjectPathVTable vtable;
_DBUS_ZERO (vtable);
dbus_bool_t _dbus_object_tree_register (DBusObjectTree *tree,
const char **path,
- const DBusObjectTreeVTable *vtable,
+ const DBusObjectPathVTable *vtable,
void *user_data);
void _dbus_object_tree_unregister_and_unlock (DBusObjectTree *tree,
const char **path);
DBusHandlerResult _dbus_object_tree_dispatch_and_unlock (DBusObjectTree *tree,
DBusMessage *message);
+void _dbus_object_tree_free_all_unlocked (DBusObjectTree *tree);
DBUS_END_DECLS;
+++ /dev/null
-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-object.c 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 <config.h>
-#include "dbus-internals.h"
-#include "dbus-object.h"
-
-/**
- * @defgroup DBusCallbackObjectInternals DBusCallbackObject implementation details
- * @ingroup DBusInternals
- * @brief DBusCallbackObject private implementation details.
- *
- * The guts of DBusCallbackObject and its methods.
- *
- * @{
- */
-
-_DBUS_DEFINE_GLOBAL_LOCK (callback_object);
-
-/**
- * @brief Internals of DBusCallbackObject
- *
- * Object that can send and receive messages.
- */
-struct DBusCallbackObject
-{
- DBusAtomic refcount; /**< reference count */
- DBusObjectMessageFunction function; /**< callback function */
- void *user_data; /**< user data for function */
- DBusFreeFunction free_user_data; /**< free the user data */
-};
-
-static void
-callback_object_registered (DBusObjectInfo *info)
-{
- DBusCallbackObject *callback = info->object_impl;
-
- dbus_callback_object_ref (callback);
-}
-
-static void
-callback_object_unregistered (DBusObjectInfo *info)
-{
- DBusCallbackObject *callback = info->object_impl;
-
- dbus_callback_object_unref (callback);
-}
-
-static void
-callback_object_message (DBusObjectInfo *info,
- DBusMessage *message)
-{
- DBusCallbackObject *callback = info->object_impl;
-
- if (callback->function)
- (* callback->function) (info, message);
-}
-
-/** @} */
-
-/**
- * @defgroup DBusObject DBusObjectInfo, DBusObjectVTable, DBusCallbackObject
- * @ingroup DBus
- * @brief support for object instances
- *
- * Behind each DBusConnection are object instances. An object instance
- * may be a GObject (using GLib), a QObject (using Qt), a built-in
- * object type called DBusCallbackObject, or any other representation
- * of an object; it's even permissible to have an object that's simply
- * an integer value or a pointer to a struct.
- *
- * Objects are registered with one or more DBusConnection. Registered
- * objects receive an object ID, represented by the DBusObjectID type.
- * Object IDs can be passed over a DBusConnection and used by the
- * remote application to refer to objects. Remote applications can
- * also refer to objects by dynamically locating objects that support
- * a particular interface.
- *
- * To define an object, you simply provide three callbacks: one to be
- * called when the object is registered with a new connection, one
- * to be called when the object is unregistered, and one to be called
- * when the object receives a message from the peer on the other end
- * of the DBusConnection. The three callbacks are specified in a
- * DBusObjectVTable struct.
- *
- * The DBusObjectInfo struct is used to pass the object pointer
- * (object_impl), connection, and object ID to each of the callbacks
- * in the virtual table. This struct should be treated as read-only.
- *
- * DBusCallbackObject is provided for convenience as a way to
- * implement an object quickly by writing only one callback function,
- * the callback that processes messages. To use DBusCallbackObject,
- * simply create one, then call dbus_connection_register_object()
- * passing in the provided DBusObjectVTable
- * dbus_callback_object_vtable. This is the simplest possible object;
- * it simply contains a function to be called whenever a message is
- * received.
- *
- * The DBusCallbackObject will be strong-referenced by the
- * DBusConnection, so may be unreferenced once it's registered, and
- * will go away either on unregistration or when the connection is
- * freed.
- *
- * One DBusCallbackObject may be registered with any number of
- * DBusConnection.
- *
- * @{
- */
-
-/**
- * @typedef DBusCallbackObject
- *
- * Opaque data type representing a callback object.
- */
-
-static const DBusObjectVTable callback_object_vtable = {
- callback_object_registered,
- callback_object_unregistered,
- callback_object_message,
- NULL, NULL, NULL
-};
-
-/**
- * Virtual table for a DBusCallbackObject, used to register the
- * callback object with dbus_connection_register_object().
- */
-const DBusObjectVTable* dbus_callback_object_vtable = &callback_object_vtable;
-
-/**
- * Creates a new callback object. The callback function
- * may be #NULL for a no-op callback or a callback to
- * be assigned a function later.
- *
- * Use dbus_connection_register_object() along with
- * dbus_callback_object_vtable to register the callback object with
- * one or more connections. Each connection will add a reference to
- * the callback object, so once it's registered it may be unreferenced
- * with dbus_callback_object_unref().
- *
- * @param function function to call to handle a message
- * @param user_data data to pass to the function
- * @param free_user_data function to call to free the user data
- * @returns a new DBusCallbackObject or #NULL if no memory.
- */
-DBusCallbackObject*
-dbus_callback_object_new (DBusObjectMessageFunction function,
- void *user_data,
- DBusFreeFunction free_user_data)
-{
- DBusCallbackObject *callback;
-
- callback = dbus_new0 (DBusCallbackObject, 1);
- if (callback == NULL)
- return NULL;
-
- callback->refcount.value = 1;
- callback->function = function;
- callback->user_data = user_data;
- callback->free_user_data = free_user_data;
-
- return callback;
-}
-
-/**
- * Increments the reference count on a callback object.
- *
- * @param callback the callback
- */
-void
-dbus_callback_object_ref (DBusCallbackObject *callback)
-{
- _dbus_return_if_fail (callback != NULL);
-
- _dbus_atomic_inc (&callback->refcount);
-}
-
-
-/**
- * Decrements the reference count on a callback object,
- * freeing the callback if the count reaches 0.
- *
- * @param callback the callback
- */
-void
-dbus_callback_object_unref (DBusCallbackObject *callback)
-{
- dbus_bool_t last_unref;
-
- _dbus_return_if_fail (callback != NULL);
-
- last_unref = (_dbus_atomic_dec (&callback->refcount) == 1);
-
- if (last_unref)
- {
- if (callback->free_user_data)
- (* callback->free_user_data) (callback->user_data);
-
- dbus_free (callback);
- }
-}
-
-/**
- * Gets the user data for the callback.
- *
- * @param callback the callback
- * @returns the user data
- */
-void*
-dbus_callback_object_get_data (DBusCallbackObject *callback)
-{
- void* user_data;
-
- _dbus_return_val_if_fail (callback != NULL, NULL);
-
- _DBUS_LOCK (callback_object);
- user_data = callback->user_data;
- _DBUS_UNLOCK (callback_object);
- return user_data;
-}
-
-
-/**
- * Sets the user data for the callback. Frees any previously-existing
- * user data with the previous free_user_data function.
- *
- * @param callback the callback
- * @param user_data the user data
- * @param free_user_data free function for the data
- */
-void
-dbus_callback_object_set_data (DBusCallbackObject *callback,
- void *user_data,
- DBusFreeFunction free_user_data)
-{
- DBusFreeFunction old_free_func;
- void *old_user_data;
-
- _dbus_return_if_fail (callback != NULL);
-
- _DBUS_LOCK (callback_object);
- old_free_func = callback->free_user_data;
- old_user_data = callback->user_data;
-
- callback->user_data = user_data;
- callback->free_user_data = free_user_data;
- _DBUS_UNLOCK (callback_object);
-
- if (old_free_func)
- (* old_free_func) (old_user_data);
-}
-
-/**
- * Sets the function to be used to handle messages to the
- * callback object.
- *
- * @todo the thread locking on DBusCallbackObject is hosed; in this
- * function in particular it's a joke since we don't take the same
- * lock when _calling_ the callback function.
- *
- * @param callback the callback
- * @param function the function
- */
-void
-dbus_callback_object_set_function (DBusCallbackObject *callback,
- DBusObjectMessageFunction function)
-{
- _dbus_return_if_fail (callback != NULL);
-
- _DBUS_LOCK (callback_object);
- callback->function = function;
- _DBUS_UNLOCK (callback_object);
-}
-
-/** @} */
-
-#ifdef DBUS_BUILD_TESTS
-#include "dbus-test.h"
-#include <stdio.h>
-
-static void
-test_message_function (DBusObjectInfo *info,
- DBusMessage *message)
-{
- /* nothing */
-}
-
-static void
-free_test_data (void *data)
-{
- /* does nothing */
-}
-
-/**
- * @ingroup DBusCallbackObjectInternals
- * Unit test for DBusCallbackObject.
- *
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_object_test (void)
-{
- DBusCallbackObject *callback;
-
-#define TEST_DATA ((void*) 0xcafebabe)
-
- callback = dbus_callback_object_new (test_message_function,
- TEST_DATA,
- free_test_data);
-
- _dbus_assert (callback != NULL);
- _dbus_assert (callback->function == test_message_function);
-
- if (dbus_callback_object_get_data (callback) != TEST_DATA)
- _dbus_assert_not_reached ("got wrong data");
-
- dbus_callback_object_set_data (callback, NULL, NULL);
- if (dbus_callback_object_get_data (callback) != NULL)
- _dbus_assert_not_reached ("got wrong data after set");
-
- dbus_callback_object_set_function (callback, NULL);
- _dbus_assert (callback->function == NULL);
-
- dbus_callback_object_ref (callback);
- dbus_callback_object_unref (callback);
- dbus_callback_object_unref (callback);
-
- return TRUE;
-}
-#endif /* DBUS_BUILD_TESTS */
+++ /dev/null
-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-object.h 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
- *
- */
-#if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
-#error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
-#endif
-
-#ifndef DBUS_OBJECT_H
-#define DBUS_OBJECT_H
-
-#include <dbus/dbus-arch-deps.h>
-#include <dbus/dbus-types.h>
-#include <dbus/dbus-message.h>
-#include <dbus/dbus-objectid.h>
-
-DBUS_BEGIN_DECLS;
-
-typedef struct DBusConnection DBusConnection;
-typedef struct DBusObjectVTable DBusObjectVTable;
-typedef struct DBusObjectInfo DBusObjectInfo;
-typedef struct DBusCallbackObject DBusCallbackObject;
-
-typedef enum
-{
- DBUS_HANDLER_RESULT_HANDLED, /**< Remove this message, no further processing. */
- DBUS_HANDLER_RESULT_NOT_YET_HANDLED, /**< Run any additional handlers that are interested in this message. */
- DBUS_HANDLER_RESULT_NEED_MEMORY /**< Need more memory to handle this message. */
-} DBusHandlerResult;
-
-struct DBusObjectInfo
-{
- void *object_impl; /**< Object implementation pointer provided by app */
- DBusObjectID object_id; /**< Object ID */
- DBusConnection *connection; /**< The connection object ID is for */
- void *dbus_internal_pad1; /**< Padding, do not use */
- void *dbus_internal_pad2; /**< Padding, do not use */
-};
-
-typedef void (* DBusObjectRegisteredFunction) (DBusObjectInfo *info);
-typedef void (* DBusObjectUnregisteredFunction) (DBusObjectInfo *info);
-typedef void (* DBusObjectMessageFunction) (DBusObjectInfo *info,
- DBusMessage *message);
-
-struct DBusObjectVTable
-{
- DBusObjectRegisteredFunction registered;
- DBusObjectUnregisteredFunction unregistered;
- DBusObjectMessageFunction message;
- void (* dbus_internal_pad1) (void *);
- void (* dbus_internal_pad2) (void *);
- void (* dbus_internal_pad3) (void *);
-};
-
-extern const DBusObjectVTable *dbus_callback_object_vtable;
-
-DBusCallbackObject* dbus_callback_object_new (DBusObjectMessageFunction function,
- void *user_data,
- DBusFreeFunction free_user_data);
-void dbus_callback_object_ref (DBusCallbackObject *callback);
-void dbus_callback_object_unref (DBusCallbackObject *callback);
-void* dbus_callback_object_get_data (DBusCallbackObject *callback);
-void dbus_callback_object_set_data (DBusCallbackObject *callback,
- void *data,
- DBusFreeFunction free_user_data);
-void dbus_callback_object_set_function (DBusCallbackObject *callback,
- DBusObjectMessageFunction function);
-
-
-DBUS_END_DECLS;
-
-#endif /* DBUS_OBJECT_H */
+++ /dev/null
-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-objectid.c DBusObjectID type
- *
- * 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-objectid.h"
-#include "dbus-internals.h"
-
-#ifdef DBUS_HAVE_INT64
-#define VALUE(objid) ((objid)->dbus_do_not_use_dummy1)
-#define SERVER_MASK DBUS_UINT64_CONSTANT (0xffff000000000000)
-#define CLIENT_MASK DBUS_UINT64_CONSTANT (0x0000ffff00000000)
-#define IS_SERVER_MASK DBUS_UINT64_CONSTANT (0x0000000080000000)
-#define INSTANCE_MASK DBUS_UINT64_CONSTANT (0x000000007fffffff)
-#define SERVER_BITS(objid) ((dbus_uint16_t) (VALUE (obj_id) >> 48))
-#define CLIENT_BITS(objid) ((dbus_uint16_t) ((VALUE (obj_id) & CLIENT_MASK) >> 32))
-#define IS_SERVER_BIT(objid) ((VALUE (obj_id) & IS_SERVER_MASK) != 0)
-#define INSTANCE_BITS(objid) ((dbus_uint32_t) (VALUE (obj_id) & INSTANCE_MASK))
-#else
-/* We care about the exact packing since in dbus-marshal.c we
- * just use the DBusObjectID struct as-is.
- */
-#ifdef WORDS_BIGENDIAN
-#define HIGH_VALUE(objid) ((objid)->dbus_do_not_use_dummy2)
-#define LOW_VALUE(objid) ((objid)->dbus_do_not_use_dummy3)
-#else
-#define HIGH_VALUE(objid) ((objid)->dbus_do_not_use_dummy3)
-#define LOW_VALUE(objid) ((objid)->dbus_do_not_use_dummy2)
-#endif
-#define SERVER_MASK (0xffff0000)
-#define CLIENT_MASK (0x0000ffff)
-#define IS_SERVER_MASK (0x80000000)
-#define INSTANCE_MASK (0x7fffffff)
-#define SERVER_BITS(objid) ((HIGH_VALUE (objid) & SERVER_MASK) >> 16)
-#define CLIENT_BITS(objid) (HIGH_VALUE (objid) & CLIENT_MASK)
-#define IS_SERVER_BIT(objid) ((LOW_VALUE (objid) & IS_SERVER_MASK) != 0)
-#define INSTANCE_BITS(objid) (LOW_VALUE (objid) & INSTANCE_MASK)
-#endif
-
-/**
- * @defgroup DBusObjectID object IDs
- * @ingroup DBusObjectID
- * @brief object ID datatype
- *
- * Value type representing an object ID, i.e. an object in the remote
- * application that can be communicated with.
- *
- * An object ID has three parts. 16 bits are provided by the server
- * side of a connection, and used for the high 16 bits of all object
- * IDs created by the client. 16 bits are provided by the client side
- * and used as the next 16 bits of all object IDs created by the
- * client. The next single bit is 1 if the object ID represents an
- * object on the server side of the connection and 0 otherwise. Then
- * 31 bits are provided by the side creating an object instance and
- * differ for each instance created (each app should make a best
- * effort to avoid recycling the instance values).
- *
- * 0 is an invalid value for the server bits, the client bits,
- * and the object instance bits. An object ID is the null ID
- * if all 64 bits are 0.
- *
- * @{
- */
-
-/**
- * Checks whether two object IDs have the same value.
- *
- * @param a the first object ID
- * @param b the second object ID
- * @returns #TRUE if they are equal
- */
-dbus_bool_t
-dbus_object_id_equal (const DBusObjectID *a,
- const DBusObjectID *b)
-{
-#ifdef DBUS_HAVE_INT64
- return VALUE (a) == VALUE (b);
-#else
- return LOW_VALUE (a) == LOW_VALUE (b) && HIGH_VALUE (a) == HIGH_VALUE (b);
-#endif
-}
-
-/**
- * Compares two object IDs, appropriate for
- * qsort(). Higher/lower IDs have no significance,
- * but the comparison can be used for data structures
- * that require ordering.
- *
- * @param a the first object ID
- * @param b the second object ID
- * @returns -1, 0, 1 as with strcmp()
- */
-int
-dbus_object_id_compare (const DBusObjectID *a,
- const DBusObjectID *b)
-{
-#ifdef DBUS_HAVE_INT64
- if (VALUE (a) > VALUE (b))
- return 1;
- else if (VALUE (a) < VALUE (b))
- return -1;
- else
- return 0;
-#else
- if (HIGH_VALUE (a) > HIGH_VALUE (b))
- return 1;
- else if (HIGH_VALUE (a) < HIGH_VALUE (b))
- return -1;
- else if (LOW_VALUE (a) > LOW_VALUE (b))
- return 1;
- else if (LOW_VALUE (a) < LOW_VALUE (b))
- return -1;
- else
- return 0;
-#endif
-}
-
-
-/**
- * An object ID contains 64 bits of data. This function
- * returns the 16 bits that were provided by the server
- * side of the connection.
- *
- * @param obj_id the object ID
- * @returns the server bits of the ID
- *
- */
-dbus_uint16_t
-dbus_object_id_get_server_bits (const DBusObjectID *obj_id)
-{
- return SERVER_BITS (obj_id);
-}
-
-/**
- * An object ID contains 64 bits of data. This function
- * returns the 16 bits that were provided by the client
- * side of the connection.
- *
- * @param obj_id the object ID
- * @returns the client bits of the ID
- *
- */
-dbus_uint16_t
-dbus_object_id_get_client_bits (const DBusObjectID *obj_id)
-{
- return CLIENT_BITS (obj_id);
-}
-
-/**
- * An object ID contains 64 bits of data. This function
- * returns the bit flagging whether the object ID comes
- * from the client or the server side of the connection.
- *
- * There is no secure guarantee that the bit is accurate;
- * object ID values are simply conventional, to make
- * collisions relatively unlikely.
- *
- * @param obj_id the object ID
- * @returns the server-side bit of the ID
- *
- */
-dbus_bool_t
-dbus_object_id_get_is_server_bit (const DBusObjectID *obj_id)
-{
- return IS_SERVER_BIT (obj_id);
-}
-
-/**
- * An object ID contains 64 bits of data. This function
- * returns the 31 bits that identify the object instance.
- *
- * @param obj_id the object ID
- * @returns the instance bits of the ID
- *
- */
-dbus_uint32_t
-dbus_object_id_get_instance_bits (const DBusObjectID *obj_id)
-{
- return INSTANCE_BITS (obj_id);
-}
-
-/**
- * An object ID contains 64 bits of data. This function sets the 16
- * bits provided by the server side of a connection.
- *
- * @param obj_id the object ID
- * @param value the new value of the server bits
- *
- */
-void
-dbus_object_id_set_server_bits (DBusObjectID *obj_id,
- dbus_uint16_t value)
-{
-#ifdef DBUS_HAVE_INT64
- VALUE (obj_id) &= ~ SERVER_MASK;
- VALUE (obj_id) |= ((dbus_uint64_t) value) << 48;
-#else
- HIGH_VALUE (obj_id) &= ~ SERVER_MASK;
- HIGH_VALUE (obj_id) |= ((dbus_uint32_t) value) << 16;
-#endif
-}
-
-/**
- * An object ID contains 64 bits of data. This function sets the 16
- * bits provided by the client side of a connection.
- *
- * @param obj_id the object ID
- * @param value the new value of the client bits
- *
- */
-void
-dbus_object_id_set_client_bits (DBusObjectID *obj_id,
- dbus_uint16_t value)
-{
-#ifdef DBUS_HAVE_INT64
- VALUE (obj_id) &= ~ CLIENT_MASK;
- VALUE (obj_id) |= ((dbus_uint64_t) value) << 32;
-#else
- HIGH_VALUE (obj_id) &= ~ CLIENT_MASK;
- HIGH_VALUE (obj_id) |= (dbus_uint32_t) value;
-#endif
-}
-
-/**
- * An object ID contains 64 bits of data. This function sets the
- * single bit that flags an instance as server-side or client-side.
- *
- * @param obj_id the object ID
- * @param value the new value of the server-side bit
- *
- */
-void
-dbus_object_id_set_is_server_bit (DBusObjectID *obj_id,
- dbus_bool_t value)
-{
-#ifdef DBUS_HAVE_INT64
- if (value)
- VALUE (obj_id) |= IS_SERVER_MASK;
- else
- VALUE (obj_id) &= ~ IS_SERVER_MASK;
-#else
- if (value)
- LOW_VALUE (obj_id) |= IS_SERVER_MASK;
- else
- LOW_VALUE (obj_id) &= ~ IS_SERVER_MASK;
-#endif
-}
-
-/**
- * An object ID contains 64 bits of data. This function sets the 31
- * bits identifying the object instance.
- *
- * @param obj_id the object ID
- * @param value the new value of the instance bits
- *
- */
-void
-dbus_object_id_set_instance_bits (DBusObjectID *obj_id,
- dbus_uint32_t value)
-{
-#ifdef DBUS_HAVE_INT64
- VALUE (obj_id) &= ~ INSTANCE_MASK;
- VALUE (obj_id) |= (dbus_uint64_t) value;
-#else
- LOW_VALUE (obj_id) &= ~ INSTANCE_MASK;
- LOW_VALUE (obj_id) |= (dbus_uint32_t) value;
-#endif
-}
-
-/**
- * Set the object ID to an invalid value that cannot
- * correspond to a valid object.
- *
- * @param obj_id the object ID
- */
-void
-dbus_object_id_set_null (DBusObjectID *obj_id)
-{
- memset (obj_id, '\0', sizeof (DBusObjectID));
-}
-
-/**
- * Check whether the object ID is set to a null value
- *
- * @param obj_id the object ID
- * @returns #TRUE if null
- */
-dbus_bool_t
-dbus_object_id_is_null (const DBusObjectID *obj_id)
-{
-#ifdef DBUS_HAVE_INT64
- return VALUE (obj_id) == 0;
-#else
- return HIGH_VALUE (obj_id) == 0 && LOW_VALUE (obj_id) == 0;
-#endif
-}
-
-#ifdef DBUS_HAVE_INT64
-/**
- * An object ID contains 64 bits of data. This function
- * returns all of them as a 64-bit integer.
- *
- * Use this function only if you are willing to limit portability to
- * compilers with a 64-bit type (this includes C99 compilers and
- * almost all other compilers).
- *
- * This function only exists if DBUS_HAVE_INT64 is defined.
- *
- * @param obj_id the object ID
- * @returns the object ID as a 64-bit integer.
- */
-dbus_uint64_t
-dbus_object_id_get_as_integer (const DBusObjectID *obj_id)
-{
- return VALUE (obj_id);
-}
-
-/**
- * An object ID contains 64 bits of data. This function sets all of
- * them as a 64-bit integer.
- *
- * Use this function only if you are willing to limit portability to
- * compilers with a 64-bit type (this includes C99 compilers and
- * almost all other compilers).
- *
- * This function only exists if #DBUS_HAVE_INT64 is defined.
- *
- * @param obj_id the object ID
- * @param value the new value of the object ID
- */
-void
-dbus_object_id_set_as_integer (DBusObjectID *obj_id,
- dbus_uint64_t value)
-{
- VALUE (obj_id) = value;
-}
-#endif /* DBUS_HAVE_INT64 */
-
-/** @} */
-
-#ifdef DBUS_BUILD_TESTS
-#include "dbus-test.h"
-#include <stdio.h>
-
-/**
- * Test for object ID routines.
- *
- * @returns #TRUE on success
- */
-dbus_bool_t
-_dbus_object_id_test (void)
-{
- DBusObjectID tmp;
- DBusObjectID tmp2;
-
- /* Check basic get/set */
-
- dbus_object_id_set_server_bits (&tmp, 340);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 340);
-
- dbus_object_id_set_client_bits (&tmp, 1492);
- _dbus_assert (dbus_object_id_get_client_bits (&tmp) == 1492);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 340);
-
- dbus_object_id_set_is_server_bit (&tmp, TRUE);
- _dbus_assert (dbus_object_id_get_client_bits (&tmp) == 1492);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 340);
- _dbus_assert (dbus_object_id_get_is_server_bit (&tmp) == TRUE);
-
- dbus_object_id_set_instance_bits (&tmp, 2001);
- _dbus_assert (dbus_object_id_get_client_bits (&tmp) == 1492);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 340);
- _dbus_assert (dbus_object_id_get_is_server_bit (&tmp) == TRUE);
- _dbus_assert (dbus_object_id_get_instance_bits (&tmp) == 2001);
-
- /* check equality check */
- tmp2 = tmp;
- _dbus_assert (dbus_object_id_equal (&tmp, &tmp2));
-
- /* check get/set as integer */
-#ifdef DBUS_HAVE_INT64
- _dbus_assert (dbus_object_id_get_as_integer (&tmp) ==
- ((DBUS_UINT64_CONSTANT (340) << 48) |
- (DBUS_UINT64_CONSTANT (1492) << 32) |
- (DBUS_UINT64_CONSTANT (1) << 31) |
- (DBUS_UINT64_CONSTANT (2001))));
-
- dbus_object_id_set_as_integer (&tmp, _DBUS_UINT64_MAX);
- _dbus_assert (dbus_object_id_get_as_integer (&tmp) ==
- _DBUS_UINT64_MAX);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) ==
- 0xffff);
- _dbus_assert (dbus_object_id_get_client_bits (&tmp) ==
- 0xffff);
- _dbus_assert (dbus_object_id_get_is_server_bit (&tmp) ==
- TRUE);
- _dbus_assert (dbus_object_id_get_instance_bits (&tmp) ==
- 0x7fffffff);
-
- dbus_object_id_set_as_integer (&tmp, 1);
- dbus_object_id_set_as_integer (&tmp2, 2);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == -1);
- dbus_object_id_set_as_integer (&tmp2, 0);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 1);
- dbus_object_id_set_as_integer (&tmp2, 1);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 0);
-#endif
-
- /* Check comparison */
- tmp2 = tmp;
-
- dbus_object_id_set_server_bits (&tmp, 1);
- dbus_object_id_set_server_bits (&tmp2, 2);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == -1);
- dbus_object_id_set_server_bits (&tmp2, 0);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 1);
- dbus_object_id_set_server_bits (&tmp2, 1);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 0);
-
- dbus_object_id_set_client_bits (&tmp, 1);
-
- dbus_object_id_set_client_bits (&tmp2, 2);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == -1);
- dbus_object_id_set_client_bits (&tmp2, 0);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 1);
- dbus_object_id_set_client_bits (&tmp2, 1);
- _dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 0);
-
- /* Check get/set again with high-limit numbers */
-
- dbus_object_id_set_server_bits (&tmp, 0xf0f0);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 0xf0f0);
-
- dbus_object_id_set_client_bits (&tmp, 0xf00f);
- _dbus_assert (dbus_object_id_get_client_bits (&tmp) == 0xf00f);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 0xf0f0);
-
- dbus_object_id_set_is_server_bit (&tmp, TRUE);
- _dbus_assert (dbus_object_id_get_client_bits (&tmp) == 0xf00f);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 0xf0f0);
- _dbus_assert (dbus_object_id_get_is_server_bit (&tmp) == TRUE);
-
- dbus_object_id_set_instance_bits (&tmp, 0x7fffffff);
- _dbus_assert (dbus_object_id_get_client_bits (&tmp) == 0xf00f);
- _dbus_assert (dbus_object_id_get_server_bits (&tmp) == 0xf0f0);
- _dbus_assert (dbus_object_id_get_is_server_bit (&tmp) == TRUE);
- _dbus_assert (dbus_object_id_get_instance_bits (&tmp) == 0x7fffffff);
-
- return TRUE;
-}
-
-#endif /* DBUS_BUILD_TESTS */
+++ /dev/null
-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-objectid.h DBusObjectID type
- *
- * 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
- *
- */
-#if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
-#error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
-#endif
-
-#ifndef DBUS_OBJECTID_H
-#define DBUS_OBJECTID_H
-
-#include <dbus/dbus-arch-deps.h>
-#include <dbus/dbus-types.h>
-
-DBUS_BEGIN_DECLS;
-
-typedef struct DBusObjectID DBusObjectID;
-
-struct DBusObjectID
-{
-#ifdef DBUS_HAVE_INT64
- dbus_uint64_t dbus_do_not_use_dummy1;
-#else
- dbus_uint32_t dbus_do_not_use_dummy2;
- dbus_uint32_t dbus_do_not_use_dummy3;
-#endif
-};
-
-dbus_bool_t dbus_object_id_equal (const DBusObjectID *a,
- const DBusObjectID *b);
-int dbus_object_id_compare (const DBusObjectID *a,
- const DBusObjectID *b);
-dbus_uint16_t dbus_object_id_get_server_bits (const DBusObjectID *obj_id);
-dbus_uint16_t dbus_object_id_get_client_bits (const DBusObjectID *obj_id);
-dbus_uint32_t dbus_object_id_get_connection_bits (const DBusObjectID *obj_id);
-dbus_bool_t dbus_object_id_get_is_server_bit (const DBusObjectID *obj_id);
-dbus_uint32_t dbus_object_id_get_instance_bits (const DBusObjectID *obj_id);
-void dbus_object_id_set_server_bits (DBusObjectID *obj_id,
- dbus_uint16_t value);
-void dbus_object_id_set_client_bits (DBusObjectID *obj_id,
- dbus_uint16_t value);
-void dbus_object_id_set_is_server_bit (DBusObjectID *obj_id,
- dbus_bool_t value);
-void dbus_object_id_set_instance_bits (DBusObjectID *obj_id,
- dbus_uint32_t value);
-void dbus_object_id_set_null (DBusObjectID *obj_id);
-dbus_bool_t dbus_object_id_is_null (const DBusObjectID *obj_id);
-
-#ifdef DBUS_HAVE_INT64
-dbus_uint64_t dbus_object_id_get_as_integer (const DBusObjectID *obj_id);
-void dbus_object_id_set_as_integer (DBusObjectID *obj_id,
- dbus_uint64_t value);
-#endif
-
-DBUS_END_DECLS;
-
-#endif /* DBUS_OBJECTID_H */
#define DBUS_TYPE_NAMED 10
#define DBUS_TYPE_ARRAY 11
#define DBUS_TYPE_DICT 12
-#define DBUS_TYPE_OBJECT_ID 13
+#define DBUS_TYPE_OBJECT_PATH 13
-#define DBUS_TYPE_LAST DBUS_TYPE_OBJECT_ID
+#define DBUS_TYPE_LAST DBUS_TYPE_OBJECT_PATH
/* Max length in bytes of a service or interface or member name */
#define DBUS_MAXIMUM_NAME_LENGTH 256
check_memleaks ();
- printf ("%s: running object ID tests\n", "dbus-test");
- if (!_dbus_object_id_test ())
- die ("object ID");
-
- check_memleaks ();
-
- printf ("%s: running object registry tests\n", "dbus-test");
- if (!_dbus_object_registry_test ())
- die ("object registry");
-
- check_memleaks ();
-
printf ("%s: running object tree tests\n", "dbus-test");
if (!_dbus_object_tree_test ())
die ("object tree");
check_memleaks ();
- printf ("%s: running object tests\n", "dbus-test");
- if (!_dbus_object_test ())
- die ("object");
-
- check_memleaks ();
-
printf ("%s: running marshalling tests\n", "dbus-test");
if (!_dbus_marshal_test ())
die ("marshalling");
dbus_bool_t _dbus_spawn_test (const char *test_data_dir);
dbus_bool_t _dbus_userdb_test (const char *test_data_dir);
dbus_bool_t _dbus_memory_test (void);
-dbus_bool_t _dbus_object_test (void);
-dbus_bool_t _dbus_object_id_test (void);
-dbus_bool_t _dbus_object_registry_test (void);
dbus_bool_t _dbus_object_tree_test (void);
dbus_bool_t _dbus_pending_call_test (const char *test_data_dir);
LOCK_ADDR (message_slots),
LOCK_ADDR (atomic),
LOCK_ADDR (message_handler),
- LOCK_ADDR (callback_object),
LOCK_ADDR (bus),
LOCK_ADDR (shutdown_funcs),
LOCK_ADDR (system_users)
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus.h Convenience header including all other headers
*
- * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
#include <dbus/dbus-macros.h>
#include <dbus/dbus-message.h>
#include <dbus/dbus-message-handler.h>
-#include <dbus/dbus-object.h>
-#include <dbus/dbus-objectid.h>
#include <dbus/dbus-pending-call.h>
#include <dbus/dbus-protocol.h>
#include <dbus/dbus-server.h>
DBusConnection *connection;
char *service;
char *interface;
- DBusObjectID object_id;
+ char *path;
};
#define LOCK_PROXY(proxy) (g_static_mutex_lock (&(proxy)->lock))
{
/* FIXME */
}
- if (!dbus_object_id_is_null (&proxy->object_id))
+ if (proxy->path)
{
/* FIXME */
}
const char *service_name,
const char *interface_name,
GError **error);
-DBusGProxy* dbus_gproxy_new_for_object_id (DBusConnection *connection,
- const DBusObjectID *object_id,
+DBusGProxy* dbus_gproxy_new_for_object_path (DBusConnection *connection,
+ const char *path,
const char *interface_name);
DBusGProxy* dbus_gproxy_new_for_interface (DBusConnection *connection,
const char *interface_name);
projects / platform / upstream / dbus.git / commitdiff