diff options
Diffstat (limited to 'dbus')
| -rw-r--r-- | dbus/dbus-auth.c | 2 | ||||
| -rw-r--r-- | dbus/dbus-connection-internal.h | 3 | ||||
| -rw-r--r-- | dbus/dbus-connection.c | 19 | ||||
| -rw-r--r-- | dbus/dbus-marshal.c | 55 | ||||
| -rw-r--r-- | dbus/dbus-message.c | 2 | ||||
| -rw-r--r-- | dbus/dbus-object-registry.c | 43 | ||||
| -rw-r--r-- | dbus/dbus-objectid.c | 288 | ||||
| -rw-r--r-- | dbus/dbus-objectid.h | 34 | ||||
| -rw-r--r-- | dbus/dbus-protocol.h | 9 | ||||
| -rw-r--r-- | dbus/dbus-string.c | 2 |
10 files changed, 310 insertions, 147 deletions
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)) |