summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--ChangeLog29
-rw-r--r--dbus/dbus-auth.c2
-rw-r--r--dbus/dbus-connection-internal.h3
-rw-r--r--dbus/dbus-connection.c19
-rw-r--r--dbus/dbus-marshal.c55
-rw-r--r--dbus/dbus-message.c2
-rw-r--r--dbus/dbus-object-registry.c43
-rw-r--r--dbus/dbus-objectid.c288
-rw-r--r--dbus/dbus-objectid.h34
-rw-r--r--dbus/dbus-protocol.h9
-rw-r--r--dbus/dbus-string.c2
11 files changed, 339 insertions, 147 deletions
diff --git a/ChangeLog b/ChangeLog
index 3f74ff4b..e7daf2bc 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,32 @@
+2003-08-01 Havoc Pennington <hp@pobox.com>
+
+ * dbus/dbus-protocol.h (DBUS_MESSAGE_TYPE_*): introduce
+ a message type enum to distinguish kinds of message
+ (DBUS_HEADER_FLAG_NO_REPLY_EXPECTED): flag for a message
+ that need not be replied to
+
+2003-08-01 Havoc Pennington <hp@pobox.com>
+
+ * dbus/dbus-marshal.c: adapt to DBusObjectID changes
+ (unpack_8_octets): fix no-64-bit-int bug
+
+ * dbus/dbus-object-registry.c (validate_id): validate the
+ connection ID bits, not just the instance ID.
+
+ * dbus/dbus-connection.c (_dbus_connection_init_id): initialize
+ the connection-global 33 bits of the object ID
+
+ * dbus/dbus-object-registry.c (info_from_entry): fill in
+ object ID in the new way
+
+ * dbus/dbus-objectid.h: rather than high/low bits, specifically
+ define server/client/instance bits.
+
+2003-07-30 Havoc Pennington <hp@pobox.com>
+
+ * dbus/dbus-connection.c (dbus_connection_register_object): fix
+ build
+
2003-07-13 Havoc Pennington <hp@pobox.com>
* dbus/dbus-object.h (struct DBusObjectVTable): add padding
diff --git a/dbus/dbus-auth.c b/dbus/dbus-auth.c
index b496dba0..95910445 100644
--- a/dbus/dbus-auth.c
+++ b/dbus/dbus-auth.c
@@ -28,8 +28,6 @@
#include "dbus-sha.h"
#include "dbus-userdb.h"
-/* See doc/dbus-sasl-profile.txt */
-
/**
* @defgroup DBusAuth Authentication
* @ingroup DBusInternals
diff --git a/dbus/dbus-connection-internal.h b/dbus/dbus-connection-internal.h
index eaa35955..5bcbcc2f 100644
--- a/dbus/dbus-connection-internal.h
+++ b/dbus/dbus-connection-internal.h
@@ -81,7 +81,8 @@ void _dbus_message_handler_remove_connection (DBusMessageHandl
DBusHandlerResult _dbus_message_handler_handle_message (DBusMessageHandler *handler,
DBusConnection *connection,
DBusMessage *message);
-dbus_uint32_t _dbus_connection_get_id (DBusConnection *connection);
+void _dbus_connection_init_id (DBusConnection *connection,
+ DBusObjectID *id);
DBUS_END_DECLS;
diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c
index d604bfcb..4b72d600 100644
--- a/dbus/dbus-connection.c
+++ b/dbus/dbus-connection.c
@@ -910,19 +910,22 @@ _dbus_connection_handle_watch (DBusWatch *watch,
}
/**
- * Get the ID to be used in the high bits of an object ID for an object
+ * 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 connection portion of the object ID
+ * @returns the portion of the object ID
*/
-dbus_uint32_t
-_dbus_connection_get_id (DBusConnection *connection)
+void
+_dbus_connection_init_id (DBusConnection *connection,
+ DBusObjectID *object_id)
{
/* FIXME */
- return 1492;
+ 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);
}
/** @} */
@@ -2793,9 +2796,9 @@ dbus_connection_register_object (DBusConnection *connection,
{
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (vtable != NULL, FALSE);
- _dbus_return_val_if_fail (vtable->dbus_internal_pad1 == NULL);
- _dbus_return_val_if_fail (vtable->dbus_internal_pad2 == NULL);
- _dbus_return_val_if_fail (vtable->dbus_internal_pad3 == NULL);
+ _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);
diff --git a/dbus/dbus-marshal.c b/dbus/dbus-marshal.c
index 2399a282..aaf97c7c 100644
--- a/dbus/dbus-marshal.c
+++ b/dbus/dbus-marshal.c
@@ -80,19 +80,7 @@ typedef union
dbus_uint64_t u;
#endif
double d;
-#ifdef WORDS_BIGENDIAN
- struct
- {
- dbus_uint32_t high;
- dbus_uint32_t low;
- } bits;
-#else
- struct
- {
- dbus_uint32_t low;
- dbus_uint32_t high;
- } bits;
-#endif
+ DBusObjectID object_id;
} DBusOctets8;
static DBusOctets8
@@ -111,7 +99,8 @@ unpack_8_octets (int byte_order,
r.u = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);
#else
r.d = *(double*)data;
- swap_bytes (&r, sizeof (r));
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ swap_bytes ((unsigned char*) &r, sizeof (r));
#endif
return r;
@@ -453,14 +442,8 @@ _dbus_marshal_set_object_id (DBusString *str,
const DBusObjectID *value)
{
DBusOctets8 r;
-#ifdef DBUS_HAVE_INT64
- r.u = dbus_object_id_get_as_integer (value);
-#else
- r.bits.low = dbus_object_id_get_low_bits (value);
- r.bits.high = dbus_object_id_get_high_bits (value);
-#endif
- _dbus_assert (r.bits.low == dbus_object_id_get_low_bits (value));
- _dbus_assert (r.bits.high == dbus_object_id_get_high_bits (value));
+
+ r.object_id = *value;
set_8_octets (str, byte_order, offset, r);
}
@@ -724,7 +707,7 @@ marshal_8_octets_array (DBusString *str,
#ifdef DBUS_HAVE_INT64
*((dbus_uint64_t*)d) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)d));
#else
- swap_bytes (d, 8);
+ swap_bytes ((unsigned char*) d, 8);
#endif
d += 8;
}
@@ -900,14 +883,8 @@ _dbus_marshal_object_id (DBusString *str,
const DBusObjectID *value)
{
DBusOctets8 r;
-#ifdef DBUS_HAVE_INT64
- r.u = dbus_object_id_get_as_integer (value);
-#else
- r.bits.low = dbus_object_id_get_low_bits (value);
- r.bits.high = dbus_object_id_get_high_bits (value);
-#endif
- _dbus_assert (r.bits.low == dbus_object_id_get_low_bits (value));
- _dbus_assert (r.bits.high == dbus_object_id_get_high_bits (value));
+
+ r.object_id = *value;
return marshal_8_octets (str, byte_order, r);
}
@@ -1242,7 +1219,7 @@ demarshal_8_octets_array (const DBusString *str,
#ifdef DBUS_HAVE_INT64
retval[i].u = DBUS_UINT64_SWAP_LE_BE (retval[i].u);
#else
- swap_bytes (&retval[i], 8);
+ swap_bytes ((unsigned char *) &retval[i], 8);
#endif
}
}
@@ -1481,14 +1458,7 @@ _dbus_demarshal_object_id (const DBusString *str,
r = demarshal_8_octets (str, byte_order, pos, new_pos);
-#ifdef DBUS_HAVE_INT64
- dbus_object_id_set_as_integer (value, r.u);
-#else
- dbus_object_id_set_low_bits (value, r.bits.low);
- dbus_object_id_set_high_bits (value, r.bits.high);
-#endif
- _dbus_assert (dbus_object_id_get_low_bits (value) == r.bits.low);
- _dbus_assert (dbus_object_id_get_high_bits (value) == r.bits.high);
+ *value = r.object_id;
}
/**
@@ -2312,8 +2282,9 @@ _dbus_marshal_test (void)
#endif /* DBUS_HAVE_INT64 */
/* Marshal object IDs */
- dbus_object_id_set_high_bits (&obj_id, 0xfffe);
- dbus_object_id_set_low_bits (&obj_id, 0xaacc);
+ 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");
diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c
index fab37720..52226603 100644
--- a/dbus/dbus-message.c
+++ b/dbus/dbus-message.c
@@ -5855,10 +5855,12 @@ _dbus_message_test (const char *test_data_dir)
_DBUS_N_ELEMENTS (our_uint32_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, our_int32_array,
_DBUS_N_ELEMENTS (our_int32_array),
+#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, our_uint64_array,
_DBUS_N_ELEMENTS (our_uint64_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, our_int64_array,
_DBUS_N_ELEMENTS (our_int64_array),
+#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, our_string_array,
_DBUS_N_ELEMENTS (our_string_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, our_double_array,
diff --git a/dbus/dbus-object-registry.c b/dbus/dbus-object-registry.c
index 64320179..a550f8e2 100644
--- a/dbus/dbus-object-registry.c
+++ b/dbus/dbus-object-registry.c
@@ -177,12 +177,27 @@ validate_id (DBusObjectRegistry *registry,
{
int idx;
int times_used;
- dbus_uint32_t low_bits;
-
- low_bits = dbus_object_id_get_low_bits (object_id);
+ dbus_uint32_t instance_bits;
+
+ instance_bits = dbus_object_id_get_instance_bits (object_id);
- idx = ID_TO_INDEX (low_bits);
- times_used = ID_TO_TIMES_USED (low_bits);
+ /* 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;
@@ -206,15 +221,23 @@ info_from_entry (DBusObjectRegistry *registry,
#ifdef DBUS_BUILD_TESTS
if (registry->connection)
#endif
- dbus_object_id_set_high_bits (&info->object_id,
- _dbus_connection_get_id (registry->connection));
+ _dbus_connection_init_id (registry->connection,
+ &info->object_id);
#ifdef DBUS_BUILD_TESTS
else
- dbus_object_id_set_high_bits (&info->object_id, 1);
+ {
+ dbus_object_id_set_server_bits (&info->object_id, 1);
+ dbus_object_id_set_client_bits (&info->object_id, 2);
+ }
#endif
+
+ _dbus_assert (dbus_object_id_get_server_bits (&info->object_id) != 0);
+ _dbus_assert (dbus_object_id_get_client_bits (&info->object_id) != 0);
- dbus_object_id_set_low_bits (&info->object_id,
- ENTRY_TO_ID (entry));
+ dbus_object_id_set_instance_bits (&info->object_id,
+ ENTRY_TO_ID (entry));
+
+ _dbus_assert (dbus_object_id_get_instance_bits (&info->object_id) != 0);
}
static DBusInterfaceEntry*
diff --git a/dbus/dbus-objectid.c b/dbus/dbus-objectid.c
index 55ae0d48..f2b27b61 100644
--- a/dbus/dbus-objectid.c
+++ b/dbus/dbus-objectid.c
@@ -25,12 +25,34 @@
#include "dbus-internals.h"
#ifdef DBUS_HAVE_INT64
-#define VALUE(objid) ((objid)->dbus_do_not_use_dummy1)
-#define HIGH_BITS(objid) ((dbus_uint32_t) (VALUE (obj_id) >> 32))
-#define LOW_BITS(objid) ((dbus_uint32_t) (VALUE (obj_id) & DBUS_UINT64_CONSTANT (0x00000000ffffffff)))
+#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
-#define HIGH_BITS(objid) ((objid)->dbus_do_not_use_dummy1)
-#define LOW_BITS(objid) ((objid)->dbus_do_not_use_dummy2)
+/* 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
/**
@@ -41,6 +63,20 @@
* 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.
+ *
* @{
*/
@@ -58,8 +94,7 @@ dbus_object_id_equal (const DBusObjectID *a,
#ifdef DBUS_HAVE_INT64
return VALUE (a) == VALUE (b);
#else
- return HIGH_BITS (a) == HIGH_BITS (b) &&
- LOW_BITS (a) == LOW_BITS (b);
+ return LOW_VALUE (a) == LOW_VALUE (b) && HIGH_VALUE (a) == HIGH_VALUE (b);
#endif
}
@@ -85,95 +120,168 @@ dbus_object_id_compare (const DBusObjectID *a,
else
return 0;
#else
- if (HIGH_BITS (a) > HIGH_BITS (b))
+ if (HIGH_VALUE (a) > HIGH_VALUE (b))
return 1;
- else if (HIGH_BITS (a) < HIGH_BITS (b))
+ else if (HIGH_VALUE (a) < HIGH_VALUE (b))
return -1;
- else if (LOW_BITS (a) > LOW_BITS (b))
+ else if (LOW_VALUE (a) > LOW_VALUE (b))
return 1;
- else if (LOW_BITS (a) < LOW_BITS (b))
+ 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 half of those bits. If you are willing to limit
- * portability to compilers with a 64-bit type (this includes
- * C99 compilers and almost all other compilers) consider
- * dbus_object_id_get_as_integer() instead.
+ * returns the 16 bits that were provided by the server
+ * side of the connection.
*
* @param obj_id the object ID
- * @returns the high bits of the ID
+ * @returns the server bits of the ID
*
*/
-dbus_uint32_t
-dbus_object_id_get_high_bits (const DBusObjectID *obj_id)
+dbus_uint16_t
+dbus_object_id_get_server_bits (const DBusObjectID *obj_id)
{
- return HIGH_BITS (obj_id);
+ return SERVER_BITS (obj_id);
}
/**
* An object ID contains 64 bits of data. This function
- * returns half of those bits. If you are willing to limit
- * portability to compilers with a 64-bit type (this includes
- * C99 compilers and almost all other compilers) consider
- * dbus_object_id_get_as_integer() instead.
+ * returns the 16 bits that were provided by the client
+ * side of the connection.
*
* @param obj_id the object ID
- * @returns the low bits of the ID
+ * @returns the client bits of the ID
*
*/
-dbus_uint32_t
-dbus_object_id_get_low_bits (const DBusObjectID *obj_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 LOW_BITS (obj_id);
+ return IS_SERVER_BIT (obj_id);
}
/**
* An object ID contains 64 bits of data. This function
- * sets half of those bits. If you are willing to limit
- * portability to compilers with a 64-bit type (this includes
- * C99 compilers and almost all other compilers) consider
- * dbus_object_id_set_as_integer() instead.
+ * returns the 31 bits that identify the object instance.
*
* @param obj_id the object ID
- * @param value the new value of the high bits
+ * @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_high_bits (DBusObjectID *obj_id,
- dbus_uint32_t value)
+dbus_object_id_set_server_bits (DBusObjectID *obj_id,
+ dbus_uint16_t value)
{
#ifdef DBUS_HAVE_INT64
- VALUE (obj_id) = (((dbus_uint64_t) value) << 32) | LOW_BITS (obj_id);
+ VALUE (obj_id) &= ~ SERVER_MASK;
+ VALUE (obj_id) |= ((dbus_uint64_t) value) << 48;
#else
- HIGH_BITS (obj_id) = value;
+ 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 half of those bits. If you are willing to limit
- * portability to compilers with a 64-bit type (this includes
- * C99 compilers and almost all other compilers) consider
- * dbus_object_id_set_as_integer() instead.
+ * 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 low bits
+ * @param value the new value of the client bits
*
*/
void
-dbus_object_id_set_low_bits (DBusObjectID *obj_id,
- dbus_uint32_t value)
+dbus_object_id_set_client_bits (DBusObjectID *obj_id,
+ dbus_uint16_t value)
{
#ifdef DBUS_HAVE_INT64
- VALUE (obj_id) = ((dbus_uint64_t) value) |
- (((dbus_uint64_t) HIGH_BITS (obj_id)) << 32);
+ VALUE (obj_id) &= ~ CLIENT_MASK;
+ VALUE (obj_id) |= ((dbus_uint64_t) value) << 32;
#else
- LOW_BITS (obj_id) = value;
+ 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
}
@@ -201,7 +309,7 @@ dbus_object_id_is_null (const DBusObjectID *obj_id)
#ifdef DBUS_HAVE_INT64
return VALUE (obj_id) == 0;
#else
- return HIGH_BITS (obj_id) == 0 && LOW_BITS (obj_id) == 0;
+ return HIGH_VALUE (obj_id) == 0 && LOW_VALUE (obj_id) == 0;
#endif
}
@@ -263,28 +371,49 @@ _dbus_object_id_test (void)
DBusObjectID tmp;
DBusObjectID tmp2;
- dbus_object_id_set_high_bits (&tmp, 340);
- _dbus_assert (dbus_object_id_get_high_bits (&tmp) == 340);
-
- dbus_object_id_set_low_bits (&tmp, 1492);
- _dbus_assert (dbus_object_id_get_low_bits (&tmp) == 1492);
- _dbus_assert (dbus_object_id_get_high_bits (&tmp) == 340);
+ /* 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) << 32) |
- DBUS_UINT64_CONSTANT (1492)));
+ ((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_high_bits (&tmp) ==
- _DBUS_UINT_MAX);
- _dbus_assert (dbus_object_id_get_low_bits (&tmp) ==
- _DBUS_UINT_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);
@@ -295,24 +424,45 @@ _dbus_object_id_test (void)
_dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 0);
#endif
+ /* Check comparison */
tmp2 = tmp;
- dbus_object_id_set_high_bits (&tmp, 1);
- dbus_object_id_set_high_bits (&tmp2, 2);
+ 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_high_bits (&tmp2, 0);
+ dbus_object_id_set_server_bits (&tmp2, 0);
_dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 1);
- dbus_object_id_set_high_bits (&tmp2, 1);
+ dbus_object_id_set_server_bits (&tmp2, 1);
_dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 0);
- dbus_object_id_set_low_bits (&tmp, 1);
+ dbus_object_id_set_client_bits (&tmp, 1);
- dbus_object_id_set_low_bits (&tmp2, 2);
+ dbus_object_id_set_client_bits (&tmp2, 2);
_dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == -1);
- dbus_object_id_set_low_bits (&tmp2, 0);
+ dbus_object_id_set_client_bits (&tmp2, 0);
_dbus_assert (dbus_object_id_compare (&tmp, &tmp2) == 1);
- dbus_object_id_set_low_bits (&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;
}
diff --git a/dbus/dbus-objectid.h b/dbus/dbus-objectid.h
index ad8ea1c5..9539f9be 100644
--- a/dbus/dbus-objectid.h
+++ b/dbus/dbus-objectid.h
@@ -39,23 +39,31 @@ struct DBusObjectID
#ifdef DBUS_HAVE_INT64
dbus_uint64_t dbus_do_not_use_dummy1;
#else
- dbus_uint32_t dbus_do_not_use_dummy1;
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_uint32_t dbus_object_id_get_high_bits (const DBusObjectID *obj_id);
-dbus_uint32_t dbus_object_id_get_low_bits (const DBusObjectID *obj_id);
-void dbus_object_id_set_high_bits (DBusObjectID *obj_id,
- dbus_uint32_t value);
-void dbus_object_id_set_low_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);
+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,
diff --git a/dbus/dbus-protocol.h b/dbus/dbus-protocol.h
index 82bb6e3c..04988862 100644
--- a/dbus/dbus-protocol.h
+++ b/dbus/dbus-protocol.h
@@ -60,8 +60,15 @@ extern "C" {
/* Max length in bytes of a service or message name */
#define DBUS_MAXIMUM_NAME_LENGTH 256
+/* Types of message */
+#define DBUS_MESSAGE_TYPE_METHOD_CALL 1
+#define DBUS_MESSAGE_TYPE_METHOD_RETURN 2
+#define DBUS_MESSAGE_TYPE_ERROR 3
+#define DBUS_MESSAGE_TYPE_SIGNAL 4
+
/* Header flags */
-#define DBUS_HEADER_FLAG_ERROR 0x1
+#define DBUS_HEADER_FLAG_ERROR 0x1
+#define DBUS_HEADER_FLAG_NO_REPLY_EXPECTED 0x2
/* Header fields */
#define DBUS_HEADER_FIELD_NAME "name"
diff --git a/dbus/dbus-string.c b/dbus/dbus-string.c
index c6f929a8..60c25461 100644
--- a/dbus/dbus-string.c
+++ b/dbus/dbus-string.c
@@ -964,7 +964,7 @@ _dbus_string_append_8_aligned (DBusString *str,
p = (dbus_uint64_t*) (real->str + (real->len - 8));
*p = *((dbus_uint64_t*)octets);
#else
- char *p;
+ unsigned char *p;
DBUS_STRING_PREAMBLE (str);
if (!align_length_then_lengthen (str, 8, 8))