From fe195a911d86d0a71349988360de65cfac1b3f86 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sat, 2 Aug 2003 01:59:14 +0000 Subject: 2003-08-01 Havoc Pennington * 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 * 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. --- dbus/dbus-message.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'dbus/dbus-message.c') 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, -- cgit From 9c5d01f0fe1ba855c0f7518c4f27d75a609b8faa Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sat, 2 Aug 2003 03:39:35 +0000 Subject: 2003-08-01 Havoc Pennington * dbus/dbus-object-registry.c (_dbus_object_registry_handle_and_unlock): implement * dbus/dbus-message.c (dbus_message_get_type): new function * doc/dbus-specification.sgml: add "type" byte to messages --- dbus/dbus-message.c | 174 +++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 132 insertions(+), 42 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 52226603..c39ca3b4 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -73,6 +73,11 @@ typedef struct */ } HeaderField; +#define BYTE_ORDER_OFFSET 0 +#define TYPE_OFFSET 1 +#define FLAGS_OFFSET 2 +#define VERSION_OFFSET 3 + /** * @brief Internals of DBusMessage * @@ -803,6 +808,7 @@ _dbus_message_remove_size_counter (DBusMessage *message, static dbus_bool_t dbus_message_create_header (DBusMessage *message, + int type, const char *name, const char *service) { @@ -811,6 +817,9 @@ dbus_message_create_header (DBusMessage *message, if (!_dbus_string_append_byte (&message->header, message->byte_order)) return FALSE; + if (!_dbus_string_append_byte (&message->header, type)) + return FALSE; + flags = 0; if (!_dbus_string_append_byte (&message->header, flags)) return FALSE; @@ -818,9 +827,6 @@ dbus_message_create_header (DBusMessage *message, if (!_dbus_string_append_byte (&message->header, DBUS_MAJOR_PROTOCOL_VERSION)) return FALSE; - if (!_dbus_string_append_byte (&message->header, 0)) - return FALSE; - message->header_fields[FIELD_HEADER_LENGTH].offset = 4; if (!_dbus_marshal_uint32 (&message->header, message->byte_order, 0)) return FALSE; @@ -944,10 +950,11 @@ dbus_message_new_empty_header (void) /** - * Constructs a new message. Returns #NULL if memory can't be - * allocated for the message. The service may be #NULL in which case - * no service is set; this is appropriate when using D-BUS in a - * peer-to-peer context (no message bus). + * Constructs a new message to invoke a method on a remote + * object. Returns #NULL if memory can't be allocated for the + * message. The service may be #NULL in which case no service is set; + * this is appropriate when using D-BUS in a peer-to-peer context (no + * message bus). * * @param name name of the message * @param destination_service service that the message should be sent to or #NULL @@ -955,8 +962,8 @@ dbus_message_new_empty_header (void) * @see dbus_message_unref() */ DBusMessage* -dbus_message_new (const char *name, - const char *destination_service) +dbus_message_new_method_call (const char *name, + const char *destination_service) { DBusMessage *message; @@ -966,7 +973,9 @@ dbus_message_new (const char *name, if (message == NULL) return NULL; - if (!dbus_message_create_header (message, name, destination_service)) + if (!dbus_message_create_header (message, + DBUS_MESSAGE_TYPE_METHOD_CALL, + name, destination_service)) { dbus_message_unref (message); return NULL; @@ -976,37 +985,43 @@ dbus_message_new (const char *name, } /** - * Constructs a message that is a reply to some other - * message. Returns #NULL if memory can't be allocated - * for the message. + * Constructs a message that is a reply to a method call. Returns + * #NULL if memory can't be allocated for the message. * - * @param original_message the message which the created + * @param method_call the message which the created * message is a reply to. * @returns a new DBusMessage, free with dbus_message_unref() - * @see dbus_message_new(), dbus_message_unref() + * @see dbus_message_new_method_call(), dbus_message_unref() */ DBusMessage* -dbus_message_new_reply (DBusMessage *original_message) +dbus_message_new_method_return (DBusMessage *method_call) { DBusMessage *message; const char *sender, *name; - _dbus_return_val_if_fail (original_message != NULL, NULL); + _dbus_return_val_if_fail (method_call != NULL, NULL); - sender = get_string_field (original_message, + sender = get_string_field (method_call, FIELD_SENDER, NULL); - name = get_string_field (original_message, + name = get_string_field (method_call, FIELD_NAME, NULL); /* sender is allowed to be null here in peer-to-peer case */ - - message = dbus_message_new (name, sender); - + + message = dbus_message_new_empty_header (); if (message == NULL) return NULL; + + if (!dbus_message_create_header (message, + DBUS_MESSAGE_TYPE_METHOD_RETURN, + name, sender)) + { + dbus_message_unref (message); + return NULL; + } if (!dbus_message_set_reply_serial (message, - dbus_message_get_serial (original_message))) + dbus_message_get_serial (method_call))) { dbus_message_unref (message); return NULL; @@ -1015,41 +1030,79 @@ dbus_message_new_reply (DBusMessage *original_message) return message; } +/** + * Constructs a new message representing a signal emission. Returns + * #NULL if memory can't be allocated for the message. The name + * passed in is the name of the signal. + * + * @param name name of the signal + * @returns a new DBusMessage, free with dbus_message_unref() + * @see dbus_message_unref() + */ +DBusMessage* +dbus_message_new_signal (const char *name) +{ + DBusMessage *message; + + _dbus_return_val_if_fail (name != NULL, NULL); + + message = dbus_message_new_empty_header (); + if (message == NULL) + return NULL; + + if (!dbus_message_create_header (message, + DBUS_MESSAGE_TYPE_SIGNAL, + name, NULL)) + { + dbus_message_unref (message); + return NULL; + } + + return message; +} + /** * Creates a new message that is an error reply to a certain message. + * Error replies are possible in response to method calls primarily. * - * @param original_message the original message + * @param reply_to the original message * @param error_name the error name * @param error_message the error message string or #NULL for none * @returns a new error message */ DBusMessage* -dbus_message_new_error_reply (DBusMessage *original_message, - const char *error_name, - const char *error_message) +dbus_message_new_error (DBusMessage *reply_to, + const char *error_name, + const char *error_message) { DBusMessage *message; const char *sender; DBusMessageIter iter; - _dbus_return_val_if_fail (original_message != NULL, NULL); + _dbus_return_val_if_fail (reply_to != NULL, NULL); _dbus_return_val_if_fail (error_name != NULL, NULL); - sender = get_string_field (original_message, + sender = get_string_field (reply_to, FIELD_SENDER, NULL); /* sender may be NULL for non-message-bus case or * when the message bus is dealing with an unregistered * connection. */ - - message = dbus_message_new (error_name, sender); - + message = dbus_message_new_empty_header (); if (message == NULL) return NULL; + + if (!dbus_message_create_header (message, + DBUS_MESSAGE_TYPE_ERROR, + error_name, sender)) + { + dbus_message_unref (message); + return NULL; + } if (!dbus_message_set_reply_serial (message, - dbus_message_get_serial (original_message))) + dbus_message_get_serial (reply_to))) { dbus_message_unref (message); return NULL; @@ -1200,6 +1253,28 @@ dbus_message_unref (DBusMessage *message) } } +/** + * Gets the type of a message. Types include + * DBUS_MESSAGE_TYPE_METHOD_CALL, DBUS_MESSAGE_TYPE_METHOD_RETURN, + * DBUS_MESSAGE_TYPE_ERROR, DBUS_MESSAGE_TYPE_SIGNAL, but other types + * are allowed and all code must silently ignore messages of unknown + * type. DBUS_MESSAGE_TYPE_INVALID will never be returned, however. + * + * + * @param message the message + * @returns the type of the message + */ +int +dbus_message_get_type (DBusMessage *message) +{ + int type; + + type = _dbus_string_get_byte (&message->header, 1); + _dbus_assert (type != DBUS_MESSAGE_TYPE_INVALID); + + return type; +} + /** * Gets the name of a message. * @@ -3704,7 +3779,7 @@ dbus_message_set_is_error (DBusMessage *message, _dbus_return_if_fail (message != NULL); _dbus_return_if_fail (!message->locked); - header = _dbus_string_get_data_len (&message->header, 1, 1); + header = _dbus_string_get_data_len (&message->header, FLAGS_OFFSET, 1); if (is_error_reply) *header |= DBUS_HEADER_FLAG_ERROR; @@ -3726,7 +3801,7 @@ dbus_message_get_is_error (DBusMessage *message) _dbus_return_val_if_fail (message != NULL, FALSE); - header = _dbus_string_get_const_data_len (&message->header, 1, 1); + header = _dbus_string_get_const_data_len (&message->header, FLAGS_OFFSET, 1); return (*header & DBUS_HEADER_FLAG_ERROR) != 0; } @@ -4298,6 +4373,9 @@ _dbus_message_loader_return_buffer (DBusMessageLoader *loader, /** * Converts buffered data into messages. * + * @todo we need to check that the proper named header fields exist + * for each message type. + * * @param loader the loader. * @returns #TRUE if we had enough memory to finish. */ @@ -4311,22 +4389,22 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) { DBusMessage *message; const char *header_data; - int byte_order, header_len, body_len, header_padding; + int byte_order, message_type, header_len, body_len, header_padding; dbus_uint32_t header_len_unsigned, body_len_unsigned; header_data = _dbus_string_get_const_data_len (&loader->data, 0, 16); _dbus_assert (_DBUS_ALIGN_ADDRESS (header_data, 4) == header_data); - if (header_data[2] != DBUS_MAJOR_PROTOCOL_VERSION) + if (header_data[VERSION_OFFSET] != DBUS_MAJOR_PROTOCOL_VERSION) { _dbus_verbose ("Message has protocol version %d ours is %d\n", - (int) header_data[2], DBUS_MAJOR_PROTOCOL_VERSION); + (int) header_data[VERSION_OFFSET], DBUS_MAJOR_PROTOCOL_VERSION); loader->corrupted = TRUE; return TRUE; } - byte_order = header_data[0]; + byte_order = header_data[BYTE_ORDER_OFFSET]; if (byte_order != DBUS_LITTLE_ENDIAN && byte_order != DBUS_BIG_ENDIAN) @@ -4337,6 +4415,18 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) return TRUE; } + /* Unknown types are ignored, but INVALID is + * disallowed + */ + message_type = header_data[TYPE_OFFSET]; + if (message_type == DBUS_MESSAGE_TYPE_INVALID) + { + _dbus_verbose ("Message with bad type '%d' received\n", + message_type); + loader->corrupted = TRUE; + return TRUE; + } + header_len_unsigned = _dbus_unpack_uint32 (byte_order, header_data + 4); body_len_unsigned = _dbus_unpack_uint32 (byte_order, header_data + 8); @@ -5821,7 +5911,7 @@ _dbus_message_test (const char *test_data_dir) _dbus_assert (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter)); - message = dbus_message_new ("test.Message", "org.freedesktop.DBus.Test"); + message = dbus_message_new_method_call ("test.Message", "org.freedesktop.DBus.Test"); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.Test")); _dbus_message_set_serial (message, 1234); dbus_message_set_sender (message, "org.foo.bar"); @@ -5840,7 +5930,7 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); /* Test the vararg functions */ - message = dbus_message_new ("test.Message", "org.freedesktop.DBus.Test"); + message = dbus_message_new_method_call ("test.Message", "org.freedesktop.DBus.Test"); _dbus_message_set_serial (message, 1); dbus_message_append_args (message, DBUS_TYPE_INT32, -0x12345678, @@ -5906,7 +5996,7 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); dbus_message_unref (copy); - message = dbus_message_new ("test.Message", "org.freedesktop.DBus.Test"); + message = dbus_message_new_method_call ("test.Message", "org.freedesktop.DBus.Test"); _dbus_message_set_serial (message, 1); dbus_message_set_reply_serial (message, 0x12345678); -- cgit From ff8908f1e98eda82b0a77abb449ecff36abf14aa Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sat, 2 Aug 2003 14:58:33 +0000 Subject: 2003-08-02 Havoc Pennington * dbus/dbus-message.c (dbus_message_get_no_reply) (dbus_message_set_no_reply): add these and remove set_is_error/get_is_error * dbus/dbus-protocol.h, doc/dbus-specification.sgml: remove the ERROR flag, since there's now an ERROR type --- dbus/dbus-message.c | 45 +++++++++++++++++++++++---------------------- 1 file changed, 23 insertions(+), 22 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index c39ca3b4..8ea653f0 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -1117,8 +1117,6 @@ dbus_message_new_error (DBusMessage *reply_to, return NULL; } } - - dbus_message_set_is_error (message, TRUE); return message; } @@ -3764,15 +3762,18 @@ dbus_message_set_sender (DBusMessage *message, } /** - * Sets a flag indicating that the message is an error reply - * message, i.e. an "exception" rather than a normal response. + * Sets a flag indicating that the message does not want a reply; if + * this flag is set, the other end of the connection may (but is not + * required to) optimize by not sending method return or error + * replies. If this flag is set, there is no way to know whether the + * message successfully arrived at the remote end. * * @param message the message - * @param is_error_reply #TRUE if this is an error message. + * @param no_reply #TRUE if no reply is desired */ void -dbus_message_set_is_error (DBusMessage *message, - dbus_bool_t is_error_reply) +dbus_message_set_no_reply (DBusMessage *message, + dbus_bool_t no_reply) { char *header; @@ -3781,21 +3782,21 @@ dbus_message_set_is_error (DBusMessage *message, header = _dbus_string_get_data_len (&message->header, FLAGS_OFFSET, 1); - if (is_error_reply) - *header |= DBUS_HEADER_FLAG_ERROR; + if (no_reply) + *header |= DBUS_HEADER_FLAG_NO_REPLY_EXPECTED; else - *header &= ~DBUS_HEADER_FLAG_ERROR; + *header &= ~DBUS_HEADER_FLAG_NO_REPLY_EXPECTED; } /** - * Returns #TRUE if the message is an error - * reply to some previous message we sent. + * Returns #TRUE if the message does not expect + * a reply. * * @param message the message - * @returns #TRUE if the message is an error + * @returns #TRUE if the message sender isn't waiting for a reply */ dbus_bool_t -dbus_message_get_is_error (DBusMessage *message) +dbus_message_get_no_reply (DBusMessage *message) { const char *header; @@ -3803,7 +3804,7 @@ dbus_message_get_is_error (DBusMessage *message) header = _dbus_string_get_const_data_len (&message->header, FLAGS_OFFSET, 1); - return (*header & DBUS_HEADER_FLAG_ERROR) != 0; + return (*header & DBUS_HEADER_FLAG_NO_REPLY_EXPECTED) != 0; } /** @@ -3908,7 +3909,7 @@ dbus_message_has_sender (DBusMessage *message, /** * Sets a #DBusError based on the contents of the given * message. The error is only set if the message - * is an error message, as in dbus_message_get_is_error(). + * is an error message, as in DBUS_MESSAGE_TYPE_ERROR. * The name of the error is set to the name of the message, * and the error message is set to the first argument * if the argument exists and is a string. @@ -3931,7 +3932,7 @@ dbus_set_error_from_message (DBusError *error, _dbus_return_val_if_fail (message != NULL, FALSE); _dbus_return_val_if_error_is_set (error, FALSE); - if (!dbus_message_get_is_error (message)) + if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR) return FALSE; str = NULL; @@ -5921,11 +5922,11 @@ _dbus_message_test (const char *test_data_dir) _dbus_assert (dbus_message_get_serial (message) == 1234); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.Test")); - _dbus_assert (dbus_message_get_is_error (message) == FALSE); - dbus_message_set_is_error (message, TRUE); - _dbus_assert (dbus_message_get_is_error (message) == TRUE); - dbus_message_set_is_error (message, FALSE); - _dbus_assert (dbus_message_get_is_error (message) == FALSE); + _dbus_assert (dbus_message_get_no_reply (message) == FALSE); + dbus_message_set_no_reply (message, TRUE); + _dbus_assert (dbus_message_get_no_reply (message) == TRUE); + dbus_message_set_no_reply (message, FALSE); + _dbus_assert (dbus_message_get_no_reply (message) == FALSE); dbus_message_unref (message); -- cgit From b29ea9115ea3277354b7ccbe442026279220f4ac Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Mon, 11 Aug 2003 02:11:58 +0000 Subject: 2003-08-10 Havoc Pennington * tools/dbus-send.c (main): add --type argument, for now supporting only method_call and signal types. * tools/dbus-print-message.c: print message type * dbus/dbus-connection.c (_dbus_connection_new_for_transport): init connection->objects * doc/dbus-specification.sgml: fix sgml * bus/*.c: port over to object-instance API changes * test/test-service.c: ditto * dbus/dbus-message.c (dbus_message_create_header): allow #NULL name, we will have to fix up the rest of the code to also handle this (dbus_message_new): generic message-creation call (set_string_field): allow appending name field --- dbus/dbus-message.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 100 insertions(+), 6 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 8ea653f0..8f25e076 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -593,6 +593,14 @@ set_string_field (DBusMessage *message, return append_string_field (message, field, DBUS_HEADER_FIELD_SENDER, value); + case FIELD_NAME: + return append_string_field (message, field, + DBUS_HEADER_FIELD_NAME, + value); + case FIELD_SERVICE: + return append_string_field (message, field, + DBUS_HEADER_FIELD_SERVICE, + value); default: _dbus_assert_not_reached ("appending a string field we don't support appending"); return FALSE; @@ -849,12 +857,14 @@ dbus_message_create_header (DBusMessage *message, return FALSE; } - _dbus_assert (name != NULL); - if (!append_string_field (message, - FIELD_NAME, - DBUS_HEADER_FIELD_NAME, - name)) - return FALSE; + if (name != NULL) + { + if (!append_string_field (message, + FIELD_NAME, + DBUS_HEADER_FIELD_NAME, + name)) + return FALSE; + } return TRUE; } @@ -948,6 +958,35 @@ dbus_message_new_empty_header (void) return message; } +/** + * Constructs a new message of the given message type. + * Types include #DBUS_MESSAGE_TYPE_METHOD_CALL, + * #DBUS_MESSAGE_TYPE_SIGNAL, and so forth. + * + * @param message_type type of message + * @returns new message or #NULL If no memory + */ +DBusMessage* +dbus_message_new (int message_type) +{ + DBusMessage *message; + + _dbus_return_val_if_fail (message_type != DBUS_MESSAGE_TYPE_INVALID, NULL); + + message = dbus_message_new_empty_header (); + if (message == NULL) + return NULL; + + if (!dbus_message_create_header (message, + message_type, + NULL, NULL)) + { + dbus_message_unref (message); + return NULL; + } + + return message; +} /** * Constructs a new message to invoke a method on a remote @@ -1273,6 +1312,34 @@ dbus_message_get_type (DBusMessage *message) return type; } + +/** + * Sets the message name. + * + * @param message the message + * @param name the name + * @returns #FALSE if not enough memory + */ +dbus_bool_t +dbus_message_set_name (DBusMessage *message, + const char *name) +{ + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (!message->locked, FALSE); + + if (name == NULL) + { + delete_string_field (message, FIELD_NAME); + return TRUE; + } + else + { + return set_string_field (message, + FIELD_NAME, + name); + } +} + /** * Gets the name of a message. * @@ -1287,6 +1354,33 @@ dbus_message_get_name (DBusMessage *message) return get_string_field (message, FIELD_NAME, NULL); } +/** + * Sets the message's destination service. + * + * @param message the message + * @param destination the destination service name + * @returns #FALSE if not enough memory + */ +dbus_bool_t +dbus_message_set_destination (DBusMessage *message, + const char *destination) +{ + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (!message->locked, FALSE); + + if (destination == NULL) + { + delete_string_field (message, FIELD_SERVICE); + return TRUE; + } + else + { + return set_string_field (message, + FIELD_SERVICE, + destination); + } +} + /** * Gets the destination service of a message. * -- cgit From 7c3693a53b4eba0db1aebe1edab5ded21eb7757f Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sat, 16 Aug 2003 21:28:47 +0000 Subject: 2003-08-16 Havoc Pennington * dbus/dbus-object-registry.c (add_and_remove_objects): remove broken assertion * glib/dbus-gproxy.c: some hacking --- dbus/dbus-message.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 8f25e076..5f3d01e0 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -4471,6 +4471,10 @@ _dbus_message_loader_return_buffer (DBusMessageLoader *loader, * @todo we need to check that the proper named header fields exist * for each message type. * + * @todo If a message has unknown type, we should probably eat it + * right here rather than passing it out to applications. However + * it's not an error to see messages of unknown type. + * * @param loader the loader. * @returns #TRUE if we had enough memory to finish. */ -- cgit From 95717a938b237d12211935f6a7467ef610288fe5 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Mon, 18 Aug 2003 15:27:33 +0000 Subject: 2003-08-17 Havoc Pennington This doesn't compile yet, but syncing up so I can hack on it from work. What are branches for if not broken code? ;-) * dbus/dbus-protocol.h: remove DBUS_HEADER_FIELD_NAME, add DBUS_HEADER_FIELD_INTERFACE, DBUS_HEADER_FIELD_MEMBER, DBUS_HEADER_FIELD_ERROR_NAME * dbus/dbus-hash.c: Introduce DBUS_HASH_TWO_STRINGS as hack to use for the interface+member pairs (string_hash): change to use g_str_hash algorithm (find_direct_function, find_string_function): refactor these to share most code. * dbus/dbus-message.c: port all of this over to support interface/member fields instead of name field * dbus/dbus-object-registry.c: port over * dbus/dbus-string.c (_dbus_string_validate_interface): rename from _dbus_string_validate_name * bus/dbus-daemon-1.1: change file format for the / stuff to match new message naming scheme * bus/policy.c: port over * bus/config-parser.c: parse new format --- dbus/dbus-message.c | 386 ++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 315 insertions(+), 71 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 5f3d01e0..e5bbcab1 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -47,7 +47,9 @@ enum FIELD_HEADER_LENGTH, FIELD_BODY_LENGTH, FIELD_CLIENT_SERIAL, - FIELD_NAME, + FIELD_INTERFACE, + FIELD_MEMBER, + FIELD_ERROR_NAME, FIELD_SERVICE, FIELD_SENDER, FIELD_REPLY_SERIAL, @@ -60,7 +62,9 @@ static dbus_bool_t field_is_named[FIELD_LAST] = FALSE, /* FIELD_HEADER_LENGTH */ FALSE, /* FIELD_BODY_LENGTH */ FALSE, /* FIELD_CLIENT_SERIAL */ - TRUE, /* FIELD_NAME */ + TRUE, /* FIELD_INTERFACE */ + TRUE, /* FIELD_MEMBER */ + TRUE, /* FIELD_ERROR_NAME */ TRUE, /* FIELD_SERVICE */ TRUE, /* FIELD_SENDER */ TRUE /* FIELD_REPLY_SERIAL */ @@ -593,9 +597,17 @@ set_string_field (DBusMessage *message, return append_string_field (message, field, DBUS_HEADER_FIELD_SENDER, value); - case FIELD_NAME: + case FIELD_INTERFACE: return append_string_field (message, field, - DBUS_HEADER_FIELD_NAME, + DBUS_HEADER_FIELD_INTERFACE, + value); + case FIELD_MEMBER: + return append_string_field (message, field, + DBUS_HEADER_FIELD_MEMBER, + value); + case FIELD_ERROR_NAME: + return append_string_field (message, field, + DBUS_HEADER_FIELD_ERROR_NAME, value); case FIELD_SERVICE: return append_string_field (message, field, @@ -817,10 +829,16 @@ _dbus_message_remove_size_counter (DBusMessage *message, static dbus_bool_t dbus_message_create_header (DBusMessage *message, int type, - const char *name, + const char *interface, + const char *member, + const char *error_name, const char *service) { unsigned int flags; + + _dbus_assert ((interface && member) || + (error_name) || + !(interface || member || error_name)); if (!_dbus_string_append_byte (&message->header, message->byte_order)) return FALSE; @@ -857,12 +875,30 @@ dbus_message_create_header (DBusMessage *message, return FALSE; } - if (name != NULL) + if (interface != NULL) + { + if (!append_string_field (message, + FIELD_INTERFACE, + DBUS_HEADER_FIELD_INTERFACE, + interface)) + return FALSE; + } + + if (member != NULL) { if (!append_string_field (message, - FIELD_NAME, - DBUS_HEADER_FIELD_NAME, - name)) + FIELD_MEMBER, + DBUS_HEADER_FIELD_MEMBER, + member)) + return FALSE; + } + + if (error_name != NULL) + { + if (!append_string_field (message, + FIELD_ERROR_NAME, + DBUS_HEADER_FIELD_ERROR_NAME, + error_name)) return FALSE; } @@ -979,7 +1015,7 @@ dbus_message_new (int message_type) if (!dbus_message_create_header (message, message_type, - NULL, NULL)) + NULL, NULL, NULL, NULL)) { dbus_message_unref (message); return NULL; @@ -995,18 +1031,21 @@ dbus_message_new (int message_type) * this is appropriate when using D-BUS in a peer-to-peer context (no * message bus). * - * @param name name of the message + * @param interface interface to invoke method on + * @param method method to invoke * @param destination_service service that the message should be sent to or #NULL * @returns a new DBusMessage, free with dbus_message_unref() * @see dbus_message_unref() */ DBusMessage* -dbus_message_new_method_call (const char *name, +dbus_message_new_method_call (const char *interface, + const char *method, const char *destination_service) { DBusMessage *message; - _dbus_return_val_if_fail (name != NULL, NULL); + _dbus_return_val_if_fail (interface != NULL, NULL); + _dbus_return_val_if_fail (method != NULL, NULL); message = dbus_message_new_empty_header (); if (message == NULL) @@ -1014,7 +1053,7 @@ dbus_message_new_method_call (const char *name, if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_METHOD_CALL, - name, destination_service)) + interface, method, NULL, destination_service)) { dbus_message_unref (message); return NULL; @@ -1036,14 +1075,12 @@ DBusMessage* dbus_message_new_method_return (DBusMessage *method_call) { DBusMessage *message; - const char *sender, *name; + const char *sender; _dbus_return_val_if_fail (method_call != NULL, NULL); sender = get_string_field (method_call, FIELD_SENDER, NULL); - name = get_string_field (method_call, - FIELD_NAME, NULL); /* sender is allowed to be null here in peer-to-peer case */ @@ -1053,7 +1090,7 @@ dbus_message_new_method_return (DBusMessage *method_call) if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_METHOD_RETURN, - name, sender)) + NULL, NULL, NULL, sender)) { dbus_message_unref (message); return NULL; @@ -1071,15 +1108,18 @@ dbus_message_new_method_return (DBusMessage *method_call) /** * Constructs a new message representing a signal emission. Returns - * #NULL if memory can't be allocated for the message. The name - * passed in is the name of the signal. + * #NULL if memory can't be allocated for the message. + * A signal is identified by its originating interface, and + * the name of the signal. * + * @param interface the interface the signal is emitted from * @param name name of the signal * @returns a new DBusMessage, free with dbus_message_unref() * @see dbus_message_unref() */ DBusMessage* -dbus_message_new_signal (const char *name) +dbus_message_new_signal (const char *interface, + const char *name) { DBusMessage *message; @@ -1091,7 +1131,7 @@ dbus_message_new_signal (const char *name) if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_SIGNAL, - name, NULL)) + interface, name, NULL, NULL)) { dbus_message_unref (message); return NULL; @@ -1134,7 +1174,7 @@ dbus_message_new_error (DBusMessage *reply_to, if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_ERROR, - error_name, sender)) + NULL, NULL, error_name, sender)) { dbus_message_unref (message); return NULL; @@ -1312,46 +1352,139 @@ dbus_message_get_type (DBusMessage *message) return type; } +/** + * Sets the interface this message is being sent to + * (for DBUS_MESSAGE_TYPE_METHOD_CALL) or + * the interface a signal is being emitted from + * (for DBUS_MESSAGE_TYPE_SIGNAL). + * + * @param message the message + * @param interface the interface + * @returns #FALSE if not enough memory + */ +dbus_bool_t +dbus_message_set_interface (DBusMessage *message, + const char *interface) +{ + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (!message->locked, FALSE); + + if (interface == NULL) + { + delete_string_field (message, FIELD_INTERFACE); + return TRUE; + } + else + { + return set_string_field (message, + FIELD_INTERFACE, + interface); + } +} /** - * Sets the message name. + * Gets the interface this message is being sent to + * (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitted + * from (for DBUS_MESSAGE_TYPE_SIGNAL). + * The interface name is fully-qualified (namespaced). * * @param message the message - * @param name the name + * @returns the message interface (should not be freed) + */ +const char* +dbus_message_get_interface (DBusMessage *message) +{ + _dbus_return_val_if_fail (message != NULL, NULL); + + return get_string_field (message, FIELD_INTERFACE, NULL); +} + +/** + * Sets the interface member being invoked + * (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted + * (DBUS_MESSAGE_TYPE_SIGNAL). + * The interface name is fully-qualified (namespaced). + * + * @param message the message + * @param member the member * @returns #FALSE if not enough memory */ dbus_bool_t -dbus_message_set_name (DBusMessage *message, - const char *name) +dbus_message_set_member (DBusMessage *message, + const char *member) { _dbus_return_val_if_fail (message != NULL, FALSE); _dbus_return_val_if_fail (!message->locked, FALSE); - if (name == NULL) + if (member == NULL) { - delete_string_field (message, FIELD_NAME); + delete_string_field (message, FIELD_MEMBER); return TRUE; } else { return set_string_field (message, - FIELD_NAME, - name); + FIELD_MEMBER, + member); } } /** - * Gets the name of a message. + * Gets the interface member being invoked + * (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted + * (DBUS_MESSAGE_TYPE_SIGNAL). + * + * @param message the message + * @returns the member name (should not be freed) + */ +const char* +dbus_message_get_member (DBusMessage *message) +{ + _dbus_return_val_if_fail (message != NULL, NULL); + + return get_string_field (message, FIELD_MEMBER, NULL); +} + +/** + * Sets the name of the error (DBUS_MESSAGE_TYPE_ERROR). + * The name is fully-qualified (namespaced). * * @param message the message - * @returns the message name (should not be freed) + * @param name the name + * @returns #FALSE if not enough memory + */ +dbus_bool_t +dbus_message_set_error_name (DBusMessage *message, + const char *error_name) +{ + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (!message->locked, FALSE); + + if (error_name == NULL) + { + delete_string_field (message, FIELD_ERROR_NAME); + return TRUE; + } + else + { + return set_string_field (message, + FIELD_ERROR_NAME, + error_name); + } +} + +/** + * Gets the error name (DBUS_MESSAGE_TYPE_ERROR only). + * + * @param message the message + * @returns the error name (should not be freed) */ const char* -dbus_message_get_name (DBusMessage *message) +dbus_message_get_error_name (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_NAME, NULL); + return get_string_field (message, FIELD_ERROR_NAME, NULL); } /** @@ -3917,27 +4050,54 @@ dbus_message_get_sender (DBusMessage *message) } /** - * Checks whether the message has the given name. - * If the message has no name or has a different - * name, returns #FALSE. + * Checks whether the message has the given interface field. If the + * message has no interface field or has a different one, returns + * #FALSE. + * + * @param message the message + * @param interface the name to check (must not be #NULL) + * + * @returns #TRUE if the message has the given name + */ +dbus_bool_t +dbus_message_has_interface (DBusMessage *message, + const char *interface) +{ + const char *n; + + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (interface != NULL, FALSE); + + n = dbus_message_get_interface (message); + + if (n && strcmp (n, interface) == 0) + return TRUE; + else + return FALSE; +} + + +/** + * Checks whether the message has the given member field. If the + * message has no member field or has a different one, returns #FALSE. * * @param message the message - * @param name the name to check (must not be #NULL) + * @param member the name to check (must not be #NULL) * * @returns #TRUE if the message has the given name */ dbus_bool_t -dbus_message_has_name (DBusMessage *message, - const char *name) +dbus_message_has_member (DBusMessage *message, + const char *member) { const char *n; _dbus_return_val_if_fail (message != NULL, FALSE); - _dbus_return_val_if_fail (name != NULL, FALSE); + _dbus_return_val_if_fail (member != NULL, FALSE); - n = dbus_message_get_name (message); + n = dbus_message_get_member (message); - if (n && strcmp (n, name) == 0) + if (n && strcmp (n, member) == 0) return TRUE; else return FALSE; @@ -4034,7 +4194,7 @@ dbus_set_error_from_message (DBusError *error, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID); - dbus_set_error (error, dbus_message_get_name (message), + dbus_set_error (error, dbus_message_get_error_name (message), str ? "%s" : NULL, str); dbus_free (str); @@ -4216,9 +4376,17 @@ _dbus_message_loader_get_buffer (DBusMessageLoader *loader, (((dbus_uint32_t)c) << 8) | \ ((dbus_uint32_t)d)) -/** DBUS_HEADER_FIELD_NAME packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_NAME_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('n', 'a', 'm', 'e') +/** DBUS_HEADER_FIELD_INTERFACE packed into a dbus_uint32_t */ +#define DBUS_HEADER_FIELD_INTERFACE_AS_UINT32 \ + FOUR_CHARS_TO_UINT32 ('i', 'f', 'c', 'e') + +/** DBUS_HEADER_FIELD_MEMBER packed into a dbus_uint32_t */ +#define DBUS_HEADER_FIELD_MEMBER_AS_UINT32 \ + FOUR_CHARS_TO_UINT32 ('m', 'e', 'b', 'r') + +/** DBUS_HEADER_FIELD_ERROR_NAME packed into a dbus_uint32_t */ +#define DBUS_HEADER_FIELD_ERROR_NAME_AS_UINT32 \ + FOUR_CHARS_TO_UINT32 ('e', 'r', 'n', 'm') /** DBUS_HEADER_FIELD_SERVICE packed into a dbus_uint32_t */ #define DBUS_HEADER_FIELD_SERVICE_AS_UINT32 \ @@ -4267,23 +4435,41 @@ decode_string_field (const DBusString *data, _dbus_string_init_const (&tmp, _dbus_string_get_const_data (data) + string_data_pos); - if (field == FIELD_NAME) + if (field == FIELD_INTERFACE) { - if (!_dbus_string_validate_name (&tmp, 0, _dbus_string_get_length (&tmp))) + if (!_dbus_string_validate_interface (&tmp, 0, _dbus_string_get_length (&tmp))) { _dbus_verbose ("%s field has invalid content \"%s\"\n", field_name, _dbus_string_get_const_data (&tmp)); return FALSE; } - if (_dbus_string_starts_with_c_str (&tmp, - DBUS_NAMESPACE_LOCAL_MESSAGE)) + if (_dbus_string_equal_c_str (&tmp, + DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL)) { - _dbus_verbose ("Message is in the local namespace\n"); + _dbus_verbose ("Message is on the local interface\n"); return FALSE; } } - else + else if (field == FIELD_MEMBER) + { + if (!_dbus_string_validate_member (&tmp, 0, _dbus_string_get_length (&tmp))) + { + _dbus_verbose ("%s field has invalid content \"%s\"\n", + field_name, _dbus_string_get_const_data (&tmp)); + return FALSE; + } + } + else if (field == FIELD_ERROR_NAME) + { + if (!_dbus_string_validate_error_name (&tmp, 0, _dbus_string_get_length (&tmp))) + { + _dbus_verbose ("%s field has invalid content \"%s\"\n", + field_name, _dbus_string_get_const_data (&tmp)); + return FALSE; + } + } + else if (field == FIELD_SERVICE) { if (!_dbus_string_validate_service (&tmp, 0, _dbus_string_get_length (&tmp))) { @@ -4292,6 +4478,10 @@ decode_string_field (const DBusString *data, return FALSE; } } + else + { + _dbus_assert_not_reached ("Unknown field\n"); + } fields[field].offset = _DBUS_ALIGN_VALUE (pos, 4); @@ -4307,6 +4497,7 @@ static dbus_bool_t decode_header_data (const DBusString *data, int header_len, int byte_order, + int message_type, HeaderField fields[FIELD_LAST], int *message_padding) { @@ -4375,13 +4566,27 @@ decode_header_data (const DBusString *data, return FALSE; break; - case DBUS_HEADER_FIELD_NAME_AS_UINT32: + case DBUS_HEADER_FIELD_INTERFACE_AS_UINT32: + if (!decode_string_field (data, fields, pos, type, + FIELD_INTERFACE, + DBUS_HEADER_FIELD_INTERFACE)) + return FALSE; + break; + + case DBUS_HEADER_FIELD_MEMBER_AS_UINT32: if (!decode_string_field (data, fields, pos, type, - FIELD_NAME, - DBUS_HEADER_FIELD_NAME)) + FIELD_MEMBER, + DBUS_HEADER_FIELD_MEMBER)) return FALSE; break; + case DBUS_HEADER_FIELD_ERROR_NAME_AS_UINT32: + if (!decode_string_field (data, fields, pos, type, + FIELD_ERROR_NAME, + DBUS_HEADER_FIELD_ERROR_NAME)) + return FALSE; + break; + case DBUS_HEADER_FIELD_SENDER_AS_UINT32: if (!decode_string_field (data, fields, pos, type, FIELD_SENDER, @@ -4430,12 +4635,37 @@ decode_header_data (const DBusString *data, } } - /* Name field is mandatory */ - if (fields[FIELD_NAME].offset < 0) + /* Depending on message type, enforce presence of certain fields. */ + switch (message_type) { - _dbus_verbose ("No %s field provided\n", - DBUS_HEADER_FIELD_NAME); - return FALSE; + case DBUS_MESSAGE_TYPE_SIGNAL: + case DBUS_MESSAGE_TYPE_METHOD_CALL: + if (fields[FIELD_INTERFACE].offset < 0) + { + _dbus_verbose ("No %s field provided\n", + DBUS_HEADER_FIELD_INTERFACE); + return FALSE; + } + if (fields[FIELD_MEMBER].offset < 0) + { + _dbus_verbose ("No %s field provided\n", + DBUS_HEADER_FIELD_MEMBER); + return FALSE; + } + break; + case DBUS_MESSAGE_TYPE_ERROR: + if (fields[FIELD_ERROR_NAME].offset < 0) + { + _dbus_verbose ("No %s field provided\n", + DBUS_HEADER_FIELD_ERROR_NAME); + return FALSE; + } + break; + case DBUS_MESSAGE_TYPE_METHOD_RETURN: + break; + default: + /* An unknown type, spec requires us to ignore it */ + break; } if (message_padding) @@ -4579,7 +4809,8 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) #if 0 _dbus_verbose_bytes_of_string (&loader->data, 0, header_len + body_len); #endif - if (!decode_header_data (&loader->data, header_len, byte_order, + if (!decode_header_data (&loader->data, message_type, + header_len, byte_order, fields, &header_padding)) { _dbus_verbose ("Header was invalid\n"); @@ -6010,15 +6241,19 @@ _dbus_message_test (const char *test_data_dir) _dbus_assert (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter)); - message = dbus_message_new_method_call ("test.Message", "org.freedesktop.DBus.Test"); - _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.Test")); + message = dbus_message_new_method_call ("Foo.TestInterface", + "TestMethod", + "org.freedesktop.DBus.TestService"); + _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); + _dbus_assert (dbus_message_has_interface (message, "Foo.TestInterface")); + _dbus_assert (dbus_message_has_member (message, "TestMethod")); _dbus_message_set_serial (message, 1234); dbus_message_set_sender (message, "org.foo.bar"); _dbus_assert (dbus_message_has_sender (message, "org.foo.bar")); dbus_message_set_sender (message, NULL); _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar")); _dbus_assert (dbus_message_get_serial (message) == 1234); - _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.Test")); + _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); _dbus_assert (dbus_message_get_no_reply (message) == FALSE); dbus_message_set_no_reply (message, TRUE); @@ -6029,7 +6264,9 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); /* Test the vararg functions */ - message = dbus_message_new_method_call ("test.Message", "org.freedesktop.DBus.Test"); + message = dbus_message_new_method_call ("Foo.TestInterface", + "TestMethod", + "org.freedesktop.DBus.TestService"); _dbus_message_set_serial (message, 1); dbus_message_append_args (message, DBUS_TYPE_INT32, -0x12345678, @@ -6087,15 +6324,22 @@ _dbus_message_test (const char *test_data_dir) verify_test_message (copy); - name1 = dbus_message_get_name (message); - name2 = dbus_message_get_name (copy); + name1 = dbus_message_get_interface (message); + name2 = dbus_message_get_interface (copy); + + _dbus_assert (strcmp (name1, name2) == 0); + + name1 = dbus_message_get_member (message); + name2 = dbus_message_get_member (copy); _dbus_assert (strcmp (name1, name2) == 0); dbus_message_unref (message); dbus_message_unref (copy); - - message = dbus_message_new_method_call ("test.Message", "org.freedesktop.DBus.Test"); + + message = dbus_message_new_method_call ("Foo.TestInterface", + "TestMethod", + "org.freedesktop.DBus.TestService"); _dbus_message_set_serial (message, 1); dbus_message_set_reply_serial (message, 0x12345678); -- cgit From 68a3c593b9e77b33614726363c7b6fd85d113021 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Mon, 18 Aug 2003 22:43:30 +0000 Subject: 2003-08-18 Havoc Pennington * dbus/dbus-hash.c (_dbus_hash_table_insert_two_strings): fix * dbus/dbus-message.c (_dbus_message_loader_queue_messages): fix dumb bug created earlier (wrong order of args to decode_header_data()) * tools/dbus-send.c: port * tools/dbus-print-message.c (print_message): port * test/data/*messages: port all messages over * dbus/dbus-message-builder.c: support including message type * bus/driver.c: port over * bus/dispatch.c: port over to new stuff * dbus/dbus-connection.c (_dbus_connection_new_for_transport): rename disconnect signal to "Disconnected" --- dbus/dbus-message.c | 130 +++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 99 insertions(+), 31 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index e5bbcab1..c062c934 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -4049,55 +4049,115 @@ dbus_message_get_sender (DBusMessage *message) return get_string_field (message, FIELD_SENDER, NULL); } +static dbus_bool_t +_dbus_message_has_type_interface_member (DBusMessage *message, + int type, + const char *interface, + const char *method) +{ + const char *n; + + _dbus_assert (message != NULL); + _dbus_assert (interface != NULL); + _dbus_assert (method != NULL); + + if (dbus_message_get_type (message) != type) + return FALSE; + + /* Optimize by checking the short method name first + * instead of the longer interface name + */ + + n = dbus_message_get_member (message); + + if (n && strcmp (n, method) == 0) + { + n = dbus_message_get_interface (message); + + if (n && strcmp (n, interface) == 0) + return TRUE; + } + + return FALSE; +} + /** - * Checks whether the message has the given interface field. If the - * message has no interface field or has a different one, returns - * #FALSE. + * Checks whether the message is a method call with the given + * interface and member fields. If the message is not + * #DBUS_MESSAGE_TYPE_METHOD_CALL, or has a different interface or member field, + * returns #FALSE. * * @param message the message * @param interface the name to check (must not be #NULL) + * @param method the name to check (must not be #NULL) * - * @returns #TRUE if the message has the given name + * @returns #TRUE if the message is the specified method call */ dbus_bool_t -dbus_message_has_interface (DBusMessage *message, - const char *interface) +dbus_message_is_method_call (DBusMessage *message, + const char *interface, + const char *method) { - const char *n; - _dbus_return_val_if_fail (message != NULL, FALSE); _dbus_return_val_if_fail (interface != NULL, FALSE); - - n = dbus_message_get_interface (message); + _dbus_return_val_if_fail (method != NULL, FALSE); - if (n && strcmp (n, interface) == 0) - return TRUE; - else - return FALSE; + return _dbus_message_has_type_interface_member (message, + DBUS_MESSAGE_TYPE_METHOD_CALL, + interface, method); } +/** + * Checks whether the message is a signal with the given + * interface and member fields. If the message is not + * #DBUS_MESSAGE_TYPE_SIGNAL, or has a different interface or member field, + * returns #FALSE. + * + * @param message the message + * @param interface the name to check (must not be #NULL) + * @param signal_name the name to check (must not be #NULL) + * + * @returns #TRUE if the message is the specified signal + */ +dbus_bool_t +dbus_message_is_signal (DBusMessage *message, + const char *interface, + const char *signal_name) +{ + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (interface != NULL, FALSE); + _dbus_return_val_if_fail (signal_name != NULL, FALSE); + + return _dbus_message_has_type_interface_member (message, + DBUS_MESSAGE_TYPE_SIGNAL, + interface, signal_name); +} /** - * Checks whether the message has the given member field. If the - * message has no member field or has a different one, returns #FALSE. + * Checks whether the message is an error reply with the given error + * name. If the message is not #DBUS_MESSAGE_TYPE_ERROR, or has a + * different name, returns #FALSE. * * @param message the message - * @param member the name to check (must not be #NULL) + * @param error_name the name to check (must not be #NULL) * - * @returns #TRUE if the message has the given name + * @returns #TRUE if the message is the specified error */ dbus_bool_t -dbus_message_has_member (DBusMessage *message, - const char *member) +dbus_message_is_error (DBusMessage *message, + const char *error_name) { const char *n; - - _dbus_return_val_if_fail (message != NULL, FALSE); - _dbus_return_val_if_fail (member != NULL, FALSE); + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (error_name != NULL, FALSE); + + if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR) + return FALSE; + n = dbus_message_get_member (message); - if (n && strcmp (n, member) == 0) + if (n && strcmp (n, error_name) == 0) return TRUE; else return FALSE; @@ -4507,7 +4567,10 @@ decode_header_data (const DBusString *data, int type; if (header_len < 16) - return FALSE; + { + _dbus_verbose ("Header length %d is too short\n", header_len); + return FALSE; + } i = 0; while (i < FIELD_LAST) @@ -4532,7 +4595,10 @@ decode_header_data (const DBusString *data, pos = _DBUS_ALIGN_VALUE (pos, 4); if ((pos + 4) > header_len) - return FALSE; + { + _dbus_verbose ("not enough space remains in header for header field value\n"); + return FALSE; + } field =_dbus_string_get_const_data_len (data, pos, 4); pos += 4; @@ -4809,8 +4875,9 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) #if 0 _dbus_verbose_bytes_of_string (&loader->data, 0, header_len + body_len); #endif - if (!decode_header_data (&loader->data, message_type, + if (!decode_header_data (&loader->data, header_len, byte_order, + message_type, fields, &header_padding)) { _dbus_verbose ("Header was invalid\n"); @@ -5919,10 +5986,11 @@ process_test_subdir (const DBusString *test_base_dir, printf (" %s\n", _dbus_string_get_const_data (&filename)); - _dbus_verbose (" expecting %s\n", + _dbus_verbose (" expecting %s for %s\n", validity == _DBUS_MESSAGE_VALID ? "valid" : (validity == _DBUS_MESSAGE_INVALID ? "invalid" : - (validity == _DBUS_MESSAGE_INCOMPLETE ? "incomplete" : "unknown"))); + (validity == _DBUS_MESSAGE_INCOMPLETE ? "incomplete" : "unknown")), + _dbus_string_get_const_data (&filename)); if (! (*function) (&full_path, is_raw, validity, user_data)) { @@ -6245,8 +6313,8 @@ _dbus_message_test (const char *test_data_dir) "TestMethod", "org.freedesktop.DBus.TestService"); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); - _dbus_assert (dbus_message_has_interface (message, "Foo.TestInterface")); - _dbus_assert (dbus_message_has_member (message, "TestMethod")); + _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface", + "TestMethod")); _dbus_message_set_serial (message, 1234); dbus_message_set_sender (message, "org.foo.bar"); _dbus_assert (dbus_message_has_sender (message, "org.foo.bar")); -- cgit From d0c588575e3e2911eacb098fac26f02d1010cbfd Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Wed, 20 Aug 2003 14:48:04 +0000 Subject: 2003-08-19 Havoc Pennington * dbus/dbus-message.c (decode_string_field): support FIELD_SENDER (dbus_message_is_error): fix this function * bus/dbus-daemon-1.1: clarify logic on when / rules match * bus/policy.c (bus_client_policy_check_can_receive): fix code to reflect clarified man page (bus_client_policy_check_can_send): ditto * bus/session.conf.in: fixup * bus/system.conf.in: fixup --- dbus/dbus-message.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index c062c934..9b87c3d9 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -4155,7 +4155,7 @@ dbus_message_is_error (DBusMessage *message, if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR) return FALSE; - n = dbus_message_get_member (message); + n = dbus_message_get_error_name (message); if (n && strcmp (n, error_name) == 0) return TRUE; @@ -4529,7 +4529,8 @@ decode_string_field (const DBusString *data, return FALSE; } } - else if (field == FIELD_SERVICE) + else if (field == FIELD_SERVICE || + field == FIELD_SENDER) { if (!_dbus_string_validate_service (&tmp, 0, _dbus_string_get_length (&tmp))) { @@ -4537,7 +4538,7 @@ decode_string_field (const DBusString *data, field_name, _dbus_string_get_const_data (&tmp)); return FALSE; } - } + } else { _dbus_assert_not_reached ("Unknown field\n"); -- cgit From 5fd1e389e1c1c12ad4a55c2af6abdc8e7a2f6d41 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sun, 31 Aug 2003 01:51:44 +0000 Subject: 2003-08-30 Havoc Pennington * test/data/valid-config-files/system.d/test.conf: change to root for the user so warnings don't get printed * dbus/dbus-message.c: add dbus_message_get_path, dbus_message_set_path * dbus/dbus-object-tree.c (do_test_dispatch): add test of dispatching to a path * dbus/dbus-string.c (_dbus_string_validate_path): add * dbus/dbus-marshal.c (_dbus_demarshal_object_path): implement (_dbus_marshal_object_path): implement * dbus/dbus-protocol.h (DBUS_HEADER_FIELD_PATH): new header field to contain the path to the target object (DBUS_HEADER_FIELD_SENDER_SERVICE): rename DBUS_HEADER_FIELD_SENDER to explicitly say it's the sender service --- dbus/dbus-message.c | 291 ++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 237 insertions(+), 54 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 9b87c3d9..090bdfc7 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -47,11 +47,12 @@ enum FIELD_HEADER_LENGTH, FIELD_BODY_LENGTH, FIELD_CLIENT_SERIAL, + FIELD_PATH, FIELD_INTERFACE, FIELD_MEMBER, FIELD_ERROR_NAME, FIELD_SERVICE, - FIELD_SENDER, + FIELD_SENDER_SERVICE, FIELD_REPLY_SERIAL, FIELD_LAST @@ -62,11 +63,12 @@ static dbus_bool_t field_is_named[FIELD_LAST] = FALSE, /* FIELD_HEADER_LENGTH */ FALSE, /* FIELD_BODY_LENGTH */ FALSE, /* FIELD_CLIENT_SERIAL */ + TRUE, /* FIELD_PATH */ TRUE, /* FIELD_INTERFACE */ TRUE, /* FIELD_MEMBER */ TRUE, /* FIELD_ERROR_NAME */ TRUE, /* FIELD_SERVICE */ - TRUE, /* FIELD_SENDER */ + TRUE, /* FIELD_SENDER_SERVICE */ TRUE /* FIELD_REPLY_SERIAL */ }; @@ -289,6 +291,31 @@ get_string_field (DBusMessage *message, return data + (offset + 4); } +/* returns FALSE if no memory, TRUE with NULL path if no field */ +static dbus_bool_t +get_path_field_decomposed (DBusMessage *message, + int field, + char ***path) +{ + int offset; + + offset = message->header_fields[field].offset; + + _dbus_assert (field < FIELD_LAST); + + if (offset < 0) + { + *path = NULL; + return TRUE; + } + + return _dbus_demarshal_object_path (&message->header, + message->byte_order, + offset, + NULL, + path, NULL); +} + #ifdef DBUS_BUILD_TESTS static dbus_bool_t append_int_field (DBusMessage *message, @@ -394,6 +421,7 @@ append_uint_field (DBusMessage *message, static dbus_bool_t append_string_field (DBusMessage *message, int field, + int type, const char *name, const char *value) { @@ -411,7 +439,7 @@ append_string_field (DBusMessage *message, if (!_dbus_string_append_len (&message->header, name, 4)) goto failed; - if (!_dbus_string_append_byte (&message->header, DBUS_TYPE_STRING)) + if (!_dbus_string_append_byte (&message->header, type)) goto failed; if (!_dbus_string_align_length (&message->header, 4)) @@ -580,6 +608,7 @@ set_uint_field (DBusMessage *message, static dbus_bool_t set_string_field (DBusMessage *message, int field, + int type, const char *value) { int offset = message->header_fields[field].offset; @@ -593,24 +622,28 @@ set_string_field (DBusMessage *message, switch (field) { - case FIELD_SENDER: - return append_string_field (message, field, - DBUS_HEADER_FIELD_SENDER, + case FIELD_PATH: + return append_string_field (message, field, type, + DBUS_HEADER_FIELD_PATH, + value); + case FIELD_SENDER_SERVICE: + return append_string_field (message, field, type, + DBUS_HEADER_FIELD_SENDER_SERVICE, value); case FIELD_INTERFACE: - return append_string_field (message, field, + return append_string_field (message, field, type, DBUS_HEADER_FIELD_INTERFACE, value); case FIELD_MEMBER: - return append_string_field (message, field, + return append_string_field (message, field, type, DBUS_HEADER_FIELD_MEMBER, value); case FIELD_ERROR_NAME: - return append_string_field (message, field, + return append_string_field (message, field, type, DBUS_HEADER_FIELD_ERROR_NAME, value); case FIELD_SERVICE: - return append_string_field (message, field, + return append_string_field (message, field, type, DBUS_HEADER_FIELD_SERVICE, value); default: @@ -829,10 +862,11 @@ _dbus_message_remove_size_counter (DBusMessage *message, static dbus_bool_t dbus_message_create_header (DBusMessage *message, int type, + const char *service, + const char *path, const char *interface, const char *member, - const char *error_name, - const char *service) + const char *error_name) { unsigned int flags; @@ -865,11 +899,21 @@ dbus_message_create_header (DBusMessage *message, if (!_dbus_marshal_int32 (&message->header, message->byte_order, -1)) return FALSE; - /* Marshal message service */ + /* Marshal all the fields (Marshall Fields?) */ + + if (path != NULL) + { + if (!append_string_field (message, + FIELD_PATH, DBUS_TYPE_OBJECT_PATH, + DBUS_HEADER_FIELD_PATH, + path)) + return FALSE; + } + if (service != NULL) { if (!append_string_field (message, - FIELD_SERVICE, + FIELD_SERVICE, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_SERVICE, service)) return FALSE; @@ -878,7 +922,7 @@ dbus_message_create_header (DBusMessage *message, if (interface != NULL) { if (!append_string_field (message, - FIELD_INTERFACE, + FIELD_INTERFACE, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_INTERFACE, interface)) return FALSE; @@ -887,7 +931,7 @@ dbus_message_create_header (DBusMessage *message, if (member != NULL) { if (!append_string_field (message, - FIELD_MEMBER, + FIELD_MEMBER, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_MEMBER, member)) return FALSE; @@ -896,7 +940,7 @@ dbus_message_create_header (DBusMessage *message, if (error_name != NULL) { if (!append_string_field (message, - FIELD_ERROR_NAME, + FIELD_ERROR_NAME, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_ERROR_NAME, error_name)) return FALSE; @@ -1015,7 +1059,7 @@ dbus_message_new (int message_type) if (!dbus_message_create_header (message, message_type, - NULL, NULL, NULL, NULL)) + NULL, NULL, NULL, NULL, NULL)) { dbus_message_unref (message); return NULL; @@ -1029,22 +1073,27 @@ dbus_message_new (int message_type) * object. Returns #NULL if memory can't be allocated for the * message. The service may be #NULL in which case no service is set; * this is appropriate when using D-BUS in a peer-to-peer context (no - * message bus). - * + * message bus). The interface may be #NULL, which means that + * if multiple methods with the given name exist it is undefined + * which one will be invoked. + * + * @param service service that the message should be sent to or #NULL + * @param path object path the message should be sent to * @param interface interface to invoke method on * @param method method to invoke - * @param destination_service service that the message should be sent to or #NULL + * * @returns a new DBusMessage, free with dbus_message_unref() * @see dbus_message_unref() */ DBusMessage* -dbus_message_new_method_call (const char *interface, - const char *method, - const char *destination_service) +dbus_message_new_method_call (const char *service, + const char *path, + const char *interface, + const char *method) { DBusMessage *message; - _dbus_return_val_if_fail (interface != NULL, NULL); + _dbus_return_val_if_fail (path != NULL, NULL); _dbus_return_val_if_fail (method != NULL, NULL); message = dbus_message_new_empty_header (); @@ -1053,7 +1102,7 @@ dbus_message_new_method_call (const char *interface, if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_METHOD_CALL, - interface, method, NULL, destination_service)) + service, path, interface, method, NULL)) { dbus_message_unref (message); return NULL; @@ -1080,8 +1129,8 @@ dbus_message_new_method_return (DBusMessage *method_call) _dbus_return_val_if_fail (method_call != NULL, NULL); sender = get_string_field (method_call, - FIELD_SENDER, NULL); - + FIELD_SENDER_SERVICE, NULL); + /* sender is allowed to be null here in peer-to-peer case */ message = dbus_message_new_empty_header (); @@ -1090,7 +1139,7 @@ dbus_message_new_method_return (DBusMessage *method_call) if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_METHOD_RETURN, - NULL, NULL, NULL, sender)) + sender, NULL, NULL, NULL, NULL)) { dbus_message_unref (message); return NULL; @@ -1118,11 +1167,14 @@ dbus_message_new_method_return (DBusMessage *method_call) * @see dbus_message_unref() */ DBusMessage* -dbus_message_new_signal (const char *interface, +dbus_message_new_signal (const char *path, + const char *interface, const char *name) { DBusMessage *message; + _dbus_return_val_if_fail (path != NULL, NULL); + _dbus_return_val_if_fail (interface != NULL, NULL); _dbus_return_val_if_fail (name != NULL, NULL); message = dbus_message_new_empty_header (); @@ -1131,7 +1183,7 @@ dbus_message_new_signal (const char *interface, if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_SIGNAL, - interface, name, NULL, NULL)) + NULL, path, interface, name, NULL)) { dbus_message_unref (message); return NULL; @@ -1162,7 +1214,7 @@ dbus_message_new_error (DBusMessage *reply_to, _dbus_return_val_if_fail (error_name != NULL, NULL); sender = get_string_field (reply_to, - FIELD_SENDER, NULL); + FIELD_SENDER_SERVICE, NULL); /* sender may be NULL for non-message-bus case or * when the message bus is dealing with an unregistered @@ -1174,7 +1226,7 @@ dbus_message_new_error (DBusMessage *reply_to, if (!dbus_message_create_header (message, DBUS_MESSAGE_TYPE_ERROR, - NULL, NULL, error_name, sender)) + sender, NULL, NULL, NULL, error_name)) { dbus_message_unref (message); return NULL; @@ -1352,6 +1404,78 @@ dbus_message_get_type (DBusMessage *message) return type; } +/** + * Sets the object path this message is being sent to (for + * DBUS_MESSAGE_TYPE_METHOD_CALL) or the one a signal is being + * emitted from (for DBUS_MESSAGE_TYPE_SIGNAL). + * + * @param message the message + * @param object_path the path + * @returns #FALSE if not enough memory + */ +dbus_bool_t +dbus_message_set_path (DBusMessage *message, + const char *object_path) +{ + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (!message->locked, FALSE); + + if (object_path == NULL) + { + delete_string_field (message, FIELD_PATH); + return TRUE; + } + else + { + return set_string_field (message, + FIELD_PATH, + DBUS_TYPE_OBJECT_PATH, + object_path); + } +} + +/** + * Gets the object path this message is being sent to + * (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitted + * from (for DBUS_MESSAGE_TYPE_SIGNAL). + * + * @param message the message + * @returns the path (should not be freed) + */ +const char* +dbus_message_get_path (DBusMessage *message) +{ + _dbus_return_val_if_fail (message != NULL, NULL); + + return get_string_field (message, FIELD_PATH, NULL); +} + +/** + * Gets the object path this message is being sent to + * (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitted + * from (for DBUS_MESSAGE_TYPE_SIGNAL) in a decomposed + * format (one array element per path component). + * Free the returned array with dbus_free_string_array(). + * + * An empty but non-NULL path array means the path "/". + * So the path "/foo/bar" becomes { "foo", "bar", NULL } + * and the path "/" becomes { NULL }. + * + * @param message the message + * @param path place to store allocated array of path components; #NULL set here if no path field exists + * @returns #FALSE if no memory to allocate the array + */ +dbus_bool_t +dbus_message_get_path_decomposed (DBusMessage *message, + char ***path) +{ + _dbus_return_val_if_fail (message != NULL, FALSE); + _dbus_return_val_if_fail (path != NULL, FALSE); + + return get_path_field_decomposed (message, FIELD_PATH, + path); +} + /** * Sets the interface this message is being sent to * (for DBUS_MESSAGE_TYPE_METHOD_CALL) or @@ -1378,6 +1502,7 @@ dbus_message_set_interface (DBusMessage *message, { return set_string_field (message, FIELD_INTERFACE, + DBUS_TYPE_STRING, interface); } } @@ -1425,6 +1550,7 @@ dbus_message_set_member (DBusMessage *message, { return set_string_field (message, FIELD_MEMBER, + DBUS_TYPE_STRING, member); } } @@ -1469,6 +1595,7 @@ dbus_message_set_error_name (DBusMessage *message, { return set_string_field (message, FIELD_ERROR_NAME, + DBUS_TYPE_STRING, error_name); } } @@ -1510,6 +1637,7 @@ dbus_message_set_destination (DBusMessage *message, { return set_string_field (message, FIELD_SERVICE, + DBUS_TYPE_STRING, destination); } } @@ -3977,13 +4105,14 @@ dbus_message_set_sender (DBusMessage *message, if (sender == NULL) { - delete_string_field (message, FIELD_SENDER); + delete_string_field (message, FIELD_SENDER_SERVICE); return TRUE; } else { return set_string_field (message, - FIELD_SENDER, + FIELD_SENDER_SERVICE, + DBUS_TYPE_STRING, sender); } } @@ -4046,7 +4175,7 @@ dbus_message_get_sender (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_SENDER, NULL); + return get_string_field (message, FIELD_SENDER_SERVICE, NULL); } static dbus_bool_t @@ -4436,6 +4565,10 @@ _dbus_message_loader_get_buffer (DBusMessageLoader *loader, (((dbus_uint32_t)c) << 8) | \ ((dbus_uint32_t)d)) +/** DBUS_HEADER_FIELD_PATH packed into a dbus_uint32_t */ +#define DBUS_HEADER_FIELD_PATH_AS_UINT32 \ + FOUR_CHARS_TO_UINT32 ('p', 'a', 't', 'h') + /** DBUS_HEADER_FIELD_INTERFACE packed into a dbus_uint32_t */ #define DBUS_HEADER_FIELD_INTERFACE_AS_UINT32 \ FOUR_CHARS_TO_UINT32 ('i', 'f', 'c', 'e') @@ -4456,9 +4589,9 @@ _dbus_message_loader_get_buffer (DBusMessageLoader *loader, #define DBUS_HEADER_FIELD_REPLY_AS_UINT32 \ FOUR_CHARS_TO_UINT32 ('r', 'p', 'l', 'y') -/** DBUS_HEADER_FIELD_SENDER Packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_SENDER_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('s', 'n', 'd', 'r') +/** DBUS_HEADER_FIELD_SENDER_SERVICE Packed into a dbus_uint32_t */ +#define DBUS_HEADER_FIELD_SENDER_SERVICE_AS_UINT32 \ + FOUR_CHARS_TO_UINT32 ('s', 'd', 'r', 's') static dbus_bool_t decode_string_field (const DBusString *data, @@ -4530,7 +4663,7 @@ decode_string_field (const DBusString *data, } } else if (field == FIELD_SERVICE || - field == FIELD_SENDER) + field == FIELD_SENDER_SERVICE) { if (!_dbus_string_validate_service (&tmp, 0, _dbus_string_get_length (&tmp))) { @@ -4538,7 +4671,7 @@ decode_string_field (const DBusString *data, field_name, _dbus_string_get_const_data (&tmp)); return FALSE; } - } + } else { _dbus_assert_not_reached ("Unknown field\n"); @@ -4601,7 +4734,7 @@ decode_header_data (const DBusString *data, return FALSE; } - field =_dbus_string_get_const_data_len (data, pos, 4); + field = _dbus_string_get_const_data_len (data, pos, 4); pos += 4; _dbus_assert (_DBUS_ALIGN_ADDRESS (field, 4) == field); @@ -4654,12 +4787,51 @@ decode_header_data (const DBusString *data, return FALSE; break; - case DBUS_HEADER_FIELD_SENDER_AS_UINT32: + case DBUS_HEADER_FIELD_SENDER_SERVICE_AS_UINT32: if (!decode_string_field (data, fields, pos, type, - FIELD_SENDER, - DBUS_HEADER_FIELD_SENDER)) + FIELD_SENDER_SERVICE, + DBUS_HEADER_FIELD_SENDER_SERVICE)) return FALSE; break; + + case DBUS_HEADER_FIELD_PATH_AS_UINT32: + + /* Path was already validated as part of standard + * type validation, since there's an OBJECT_PATH + * type. + */ + + if (fields[FIELD_PATH].offset >= 0) + { + _dbus_verbose ("%s field provided twice\n", + DBUS_HEADER_FIELD_PATH); + return FALSE; + } + if (type != DBUS_TYPE_OBJECT_PATH) + { + _dbus_verbose ("%s field has wrong type\n", DBUS_HEADER_FIELD_PATH); + return FALSE; + } + + fields[FIELD_PATH].offset = _DBUS_ALIGN_VALUE (pos, 4); + + /* No forging signals from the local path */ + { + const char *s; + s = _dbus_string_get_const_data_len (data, + fields[FIELD_PATH].offset, + _dbus_string_get_length (data) - + fields[FIELD_PATH].offset); + if (strcmp (s, DBUS_PATH_ORG_FREEDESKTOP_LOCAL) == 0) + { + _dbus_verbose ("Message is on the local path\n"); + return FALSE; + } + } + + _dbus_verbose ("Found path at offset %d\n", + fields[FIELD_PATH].offset); + break; case DBUS_HEADER_FIELD_REPLY_AS_UINT32: if (fields[FIELD_REPLY_SERIAL].offset >= 0) @@ -4707,6 +4879,13 @@ decode_header_data (const DBusString *data, { case DBUS_MESSAGE_TYPE_SIGNAL: case DBUS_MESSAGE_TYPE_METHOD_CALL: + if (fields[FIELD_PATH].offset < 0) + { + _dbus_verbose ("No %s field provided\n", + DBUS_HEADER_FIELD_PATH); + return FALSE; + } + /* FIXME make this optional, at least for method calls */ if (fields[FIELD_INTERFACE].offset < 0) { _dbus_verbose ("No %s field provided\n", @@ -6310,9 +6489,10 @@ _dbus_message_test (const char *test_data_dir) _dbus_assert (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter)); - message = dbus_message_new_method_call ("Foo.TestInterface", - "TestMethod", - "org.freedesktop.DBus.TestService"); + message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", + "/org/freedesktop/TestPath", + "Foo.TestInterface", + "TestMethod"); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface", "TestMethod")); @@ -6333,9 +6513,10 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); /* Test the vararg functions */ - message = dbus_message_new_method_call ("Foo.TestInterface", - "TestMethod", - "org.freedesktop.DBus.TestService"); + message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", + "/org/freedesktop/TestPath", + "Foo.TestInterface", + "TestMethod"); _dbus_message_set_serial (message, 1); dbus_message_append_args (message, DBUS_TYPE_INT32, -0x12345678, @@ -6406,9 +6587,11 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); dbus_message_unref (copy); - message = dbus_message_new_method_call ("Foo.TestInterface", - "TestMethod", - "org.freedesktop.DBus.TestService"); + message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", + "/org/freedesktop/TestPath", + "Foo.TestInterface", + "TestMethod"); + _dbus_message_set_serial (message, 1); dbus_message_set_reply_serial (message, 0x12345678); -- cgit From 85ab0327d82e4945ad16630e583d8cc68df25a90 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Sun, 7 Sep 2003 23:04:54 +0000 Subject: 2003-09-07 Havoc Pennington * Make Doxygen contented. --- dbus/dbus-message.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 090bdfc7..d62cbf4f 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -72,6 +72,9 @@ static dbus_bool_t field_is_named[FIELD_LAST] = TRUE /* FIELD_REPLY_SERIAL */ }; +/** + * Cached information about a header field in the message + */ typedef struct { int offset; /**< Offset to start of field (location of name of field @@ -79,9 +82,13 @@ typedef struct */ } HeaderField; +/** Offset to byte order from start of header */ #define BYTE_ORDER_OFFSET 0 +/** Offset to type from start of header */ #define TYPE_OFFSET 1 +/** Offset to flags from start of header */ #define FLAGS_OFFSET 2 +/** Offset to version from start of header */ #define VERSION_OFFSET 3 /** @@ -1161,6 +1168,7 @@ dbus_message_new_method_return (DBusMessage *method_call) * A signal is identified by its originating interface, and * the name of the signal. * + * @param path the path to the object emitting the signal * @param interface the interface the signal is emitted from * @param name name of the signal * @returns a new DBusMessage, free with dbus_message_unref() @@ -1576,7 +1584,7 @@ dbus_message_get_member (DBusMessage *message) * The name is fully-qualified (namespaced). * * @param message the message - * @param name the name + * @param error_name the name * @returns #FALSE if not enough memory */ dbus_bool_t -- cgit From daf8d6579e1ae0ea748810b63180bd5eea2ab9c4 Mon Sep 17 00:00:00 2001 From: Mark McLoughlin Date: Sun, 21 Sep 2003 18:43:20 +0000 Subject: 2003-09-21 Mark McLoughlin * doc/dbus-specification.sgml: Change the header field name to be an enum and update the rest of the spec to reference the fields using the conventinal name. * dbus/dbus-protocol.h: update to reflect the spec. * doc/TODO: add item to remove the 4 byte alignment requirement. * dbus/dbus-message.c: Remove the code to generalise the header/body length and serial number header fields as named header fields so we can reference field names using the protocol values. (append_int_field), (append_uint_field), (append_string_field): Append the field name as a byte rather than four chars. (delete_int_or_uint_field), (delete_string_field): reflect the fact that the field name and typecode now occupy 4 bytes instead of 8. (decode_string_field), (decode_header_data): update to reflect protocol changes and move the field specific encoding from decode_string_field() back into decode_header_data(). * dbus/dbus-internals.[ch]: (_dbus_header_field_to_string): Add utility to aid debugging. * dbus/dbus-message-builder.c: (append_string_field), (_dbus_message_data_load): Update to reflect protocol changes; Change the FIELD_NAME directive to HEADER_FIELD and allow it to take the field's conventional name rather than the actual value. * test/data/*/*.message: Update to use HEADER_FIELD instead of FIELD_NAME; Always align the header on an 8 byte boundary *before* updating the header length. --- dbus/dbus-message.c | 525 ++++++++++++++++++++++------------------------------ 1 file changed, 226 insertions(+), 299 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index d62cbf4f..2ed421d7 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -42,36 +42,6 @@ * @{ */ -enum -{ - FIELD_HEADER_LENGTH, - FIELD_BODY_LENGTH, - FIELD_CLIENT_SERIAL, - FIELD_PATH, - FIELD_INTERFACE, - FIELD_MEMBER, - FIELD_ERROR_NAME, - FIELD_SERVICE, - FIELD_SENDER_SERVICE, - FIELD_REPLY_SERIAL, - - FIELD_LAST -}; - -static dbus_bool_t field_is_named[FIELD_LAST] = -{ - FALSE, /* FIELD_HEADER_LENGTH */ - FALSE, /* FIELD_BODY_LENGTH */ - FALSE, /* FIELD_CLIENT_SERIAL */ - TRUE, /* FIELD_PATH */ - TRUE, /* FIELD_INTERFACE */ - TRUE, /* FIELD_MEMBER */ - TRUE, /* FIELD_ERROR_NAME */ - TRUE, /* FIELD_SERVICE */ - TRUE, /* FIELD_SENDER_SERVICE */ - TRUE /* FIELD_REPLY_SERIAL */ -}; - /** * Cached information about a header field in the message */ @@ -83,13 +53,20 @@ typedef struct } HeaderField; /** Offset to byte order from start of header */ -#define BYTE_ORDER_OFFSET 0 +#define BYTE_ORDER_OFFSET 0 /** Offset to type from start of header */ -#define TYPE_OFFSET 1 +#define TYPE_OFFSET 1 /** Offset to flags from start of header */ -#define FLAGS_OFFSET 2 +#define FLAGS_OFFSET 2 /** Offset to version from start of header */ -#define VERSION_OFFSET 3 +#define VERSION_OFFSET 3 +/** Offset to header length from start of header */ +#define HEADER_LENGTH_OFFSET 4 +/** Offset to body length from start of header */ +#define BODY_LENGTH_OFFSET 8 +/** Offset to client serial from start of header */ +#define CLIENT_SERIAL_OFFSET 12 + /** * @brief Internals of DBusMessage @@ -107,9 +84,9 @@ struct DBusMessage * independently realloc it. */ - HeaderField header_fields[FIELD_LAST]; /**< Track the location - * of each field in "header" - */ + HeaderField header_fields[DBUS_HEADER_FIELD_LAST + 1]; /**< Track the location + * of each field in "header" + */ dbus_uint32_t client_serial; /**< Cached client serial value for speed */ dbus_uint32_t reply_serial; /**< Cached reply serial value for speed */ @@ -217,7 +194,7 @@ adjust_field_offsets (DBusMessage *message, return; i = 0; - while (i < FIELD_LAST) + while (i <= DBUS_HEADER_FIELD_LAST) { if (message->header_fields[i].offset > offsets_after) message->header_fields[i].offset += delta; @@ -234,7 +211,7 @@ get_int_field (DBusMessage *message, { int offset; - _dbus_assert (field < FIELD_LAST); + _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); offset = message->header_fields[field].offset; @@ -254,7 +231,7 @@ get_uint_field (DBusMessage *message, { int offset; - _dbus_assert (field < FIELD_LAST); + _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); offset = message->header_fields[field].offset; @@ -277,7 +254,7 @@ get_string_field (DBusMessage *message, offset = message->header_fields[field].offset; - _dbus_assert (field < FIELD_LAST); + _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); if (offset < 0) return NULL; @@ -308,7 +285,7 @@ get_path_field_decomposed (DBusMessage *message, offset = message->header_fields[field].offset; - _dbus_assert (field < FIELD_LAST); + _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); if (offset < 0) { @@ -327,7 +304,6 @@ get_path_field_decomposed (DBusMessage *message, static dbus_bool_t append_int_field (DBusMessage *message, int field, - const char *name, int value) { int orig_len; @@ -341,7 +317,7 @@ append_int_field (DBusMessage *message, if (!_dbus_string_align_length (&message->header, 4)) goto failed; - if (!_dbus_string_append_len (&message->header, name, 4)) + if (!_dbus_string_append_byte (&message->header, field)) goto failed; if (!_dbus_string_append_byte (&message->header, DBUS_TYPE_INT32)) @@ -378,8 +354,7 @@ append_int_field (DBusMessage *message, static dbus_bool_t append_uint_field (DBusMessage *message, int field, - const char *name, - int value) + int value) { int orig_len; @@ -392,7 +367,7 @@ append_uint_field (DBusMessage *message, if (!_dbus_string_align_length (&message->header, 4)) goto failed; - if (!_dbus_string_append_len (&message->header, name, 4)) + if (!_dbus_string_append_byte (&message->header, field)) goto failed; if (!_dbus_string_append_byte (&message->header, DBUS_TYPE_UINT32)) @@ -429,7 +404,6 @@ static dbus_bool_t append_string_field (DBusMessage *message, int field, int type, - const char *name, const char *value) { int orig_len; @@ -443,7 +417,7 @@ append_string_field (DBusMessage *message, if (!_dbus_string_align_length (&message->header, 4)) goto failed; - if (!_dbus_string_append_len (&message->header, name, 4)) + if (!_dbus_string_append_byte (&message->header, field)) goto failed; if (!_dbus_string_append_byte (&message->header, type)) @@ -488,23 +462,22 @@ delete_int_or_uint_field (DBusMessage *message, int offset = message->header_fields[field].offset; _dbus_assert (!message->locked); - _dbus_assert (field_is_named[field]); if (offset < 0) return; clear_header_padding (message); - /* The field typecode and name take up 8 bytes */ + /* The field typecode and name take up 4 bytes */ _dbus_string_delete (&message->header, - offset - 8, - 12); + offset - 4, + 8); message->header_fields[field].offset = -1; adjust_field_offsets (message, - offset - 8, - - 12); + offset - 4, + - 8); append_header_padding (message); } @@ -519,7 +492,6 @@ delete_string_field (DBusMessage *message, int delete_len; _dbus_assert (!message->locked); - _dbus_assert (field_is_named[field]); if (offset < 0) return; @@ -528,19 +500,19 @@ delete_string_field (DBusMessage *message, get_string_field (message, field, &len); - /* The field typecode and name take up 8 bytes, and the nul + /* The field typecode and name take up 4 bytes, and the nul * termination is 1 bytes, string length integer is 4 bytes */ - delete_len = 8 + 4 + 1 + len; + delete_len = 4 + 4 + 1 + len; _dbus_string_delete (&message->header, - offset - 8, + offset - 4, delete_len); message->header_fields[field].offset = -1; adjust_field_offsets (message, - offset - 8, + offset - 4, - delete_len); append_header_padding (message); @@ -593,10 +565,9 @@ set_uint_field (DBusMessage *message, switch (field) { - case FIELD_REPLY_SERIAL: - return append_uint_field (message, field, - DBUS_HEADER_FIELD_REPLY, - value); + case DBUS_HEADER_FIELD_REPLY_SERIAL: + return append_uint_field (message, field, value); + default: _dbus_assert_not_reached ("appending a uint field we don't support appending"); return FALSE; @@ -629,30 +600,14 @@ set_string_field (DBusMessage *message, switch (field) { - case FIELD_PATH: - return append_string_field (message, field, type, - DBUS_HEADER_FIELD_PATH, - value); - case FIELD_SENDER_SERVICE: - return append_string_field (message, field, type, - DBUS_HEADER_FIELD_SENDER_SERVICE, - value); - case FIELD_INTERFACE: - return append_string_field (message, field, type, - DBUS_HEADER_FIELD_INTERFACE, - value); - case FIELD_MEMBER: - return append_string_field (message, field, type, - DBUS_HEADER_FIELD_MEMBER, - value); - case FIELD_ERROR_NAME: - return append_string_field (message, field, type, - DBUS_HEADER_FIELD_ERROR_NAME, - value); - case FIELD_SERVICE: - return append_string_field (message, field, type, - DBUS_HEADER_FIELD_SERVICE, - value); + case DBUS_HEADER_FIELD_PATH: + case DBUS_HEADER_FIELD_SENDER_SERVICE: + case DBUS_HEADER_FIELD_INTERFACE: + case DBUS_HEADER_FIELD_MEMBER: + case DBUS_HEADER_FIELD_ERROR_NAME: + case DBUS_HEADER_FIELD_SERVICE: + return append_string_field (message, field, type, value); + default: _dbus_assert_not_reached ("appending a string field we don't support appending"); return FALSE; @@ -714,9 +669,12 @@ _dbus_message_set_serial (DBusMessage *message, { _dbus_assert (!message->locked); _dbus_assert (dbus_message_get_serial (message) == 0); - - set_uint_field (message, FIELD_CLIENT_SERIAL, - serial); + + _dbus_marshal_set_uint32 (&message->header, + message->byte_order, + CLIENT_SERIAL_OFFSET, + serial); + message->client_serial = serial; } @@ -734,7 +692,8 @@ dbus_message_set_reply_serial (DBusMessage *message, { _dbus_assert (!message->locked); - if (set_uint_field (message, FIELD_REPLY_SERIAL, + if (set_uint_field (message, + DBUS_HEADER_FIELD_REPLY_SERIAL, reply_serial)) { message->reply_serial = reply_serial; @@ -894,15 +853,12 @@ dbus_message_create_header (DBusMessage *message, if (!_dbus_string_append_byte (&message->header, DBUS_MAJOR_PROTOCOL_VERSION)) return FALSE; - message->header_fields[FIELD_HEADER_LENGTH].offset = 4; if (!_dbus_marshal_uint32 (&message->header, message->byte_order, 0)) return FALSE; - message->header_fields[FIELD_BODY_LENGTH].offset = 8; if (!_dbus_marshal_uint32 (&message->header, message->byte_order, 0)) return FALSE; - message->header_fields[FIELD_CLIENT_SERIAL].offset = 12; if (!_dbus_marshal_int32 (&message->header, message->byte_order, -1)) return FALSE; @@ -911,8 +867,8 @@ dbus_message_create_header (DBusMessage *message, if (path != NULL) { if (!append_string_field (message, - FIELD_PATH, DBUS_TYPE_OBJECT_PATH, DBUS_HEADER_FIELD_PATH, + DBUS_TYPE_OBJECT_PATH, path)) return FALSE; } @@ -920,8 +876,8 @@ dbus_message_create_header (DBusMessage *message, if (service != NULL) { if (!append_string_field (message, - FIELD_SERVICE, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_SERVICE, + DBUS_TYPE_STRING, service)) return FALSE; } @@ -929,8 +885,8 @@ dbus_message_create_header (DBusMessage *message, if (interface != NULL) { if (!append_string_field (message, - FIELD_INTERFACE, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_INTERFACE, + DBUS_TYPE_STRING, interface)) return FALSE; } @@ -938,8 +894,8 @@ dbus_message_create_header (DBusMessage *message, if (member != NULL) { if (!append_string_field (message, - FIELD_MEMBER, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_MEMBER, + DBUS_TYPE_STRING, member)) return FALSE; } @@ -947,8 +903,8 @@ dbus_message_create_header (DBusMessage *message, if (error_name != NULL) { if (!append_string_field (message, - FIELD_ERROR_NAME, DBUS_TYPE_STRING, DBUS_HEADER_FIELD_ERROR_NAME, + DBUS_TYPE_STRING, error_name)) return FALSE; } @@ -971,13 +927,15 @@ _dbus_message_lock (DBusMessage *message) if (!message->locked) { /* Fill in our lengths */ - set_uint_field (message, - FIELD_HEADER_LENGTH, - _dbus_string_get_length (&message->header)); + _dbus_marshal_set_uint32 (&message->header, + message->byte_order, + HEADER_LENGTH_OFFSET, + _dbus_string_get_length (&message->header)); - set_uint_field (message, - FIELD_BODY_LENGTH, - _dbus_string_get_length (&message->body)); + _dbus_marshal_set_uint32 (&message->header, + message->byte_order, + BODY_LENGTH_OFFSET, + _dbus_string_get_length (&message->body)); message->locked = TRUE; } @@ -1023,7 +981,7 @@ dbus_message_new_empty_header (void) _dbus_data_slot_list_init (&message->slot_list); i = 0; - while (i < FIELD_LAST) + while (i <= DBUS_HEADER_FIELD_LAST) { message->header_fields[i].offset = -1; ++i; @@ -1136,7 +1094,8 @@ dbus_message_new_method_return (DBusMessage *method_call) _dbus_return_val_if_fail (method_call != NULL, NULL); sender = get_string_field (method_call, - FIELD_SENDER_SERVICE, NULL); + DBUS_HEADER_FIELD_SENDER_SERVICE, + NULL); /* sender is allowed to be null here in peer-to-peer case */ @@ -1222,7 +1181,8 @@ dbus_message_new_error (DBusMessage *reply_to, _dbus_return_val_if_fail (error_name != NULL, NULL); sender = get_string_field (reply_to, - FIELD_SENDER_SERVICE, NULL); + DBUS_HEADER_FIELD_SENDER_SERVICE, + NULL); /* sender may be NULL for non-message-bus case or * when the message bus is dealing with an unregistered @@ -1319,7 +1279,7 @@ dbus_message_copy (const DBusMessage *message) return NULL; } - for (i = 0; i < FIELD_LAST; i++) + for (i = 0; i <= DBUS_HEADER_FIELD_LAST; i++) { retval->header_fields[i].offset = message->header_fields[i].offset; } @@ -1430,13 +1390,13 @@ dbus_message_set_path (DBusMessage *message, if (object_path == NULL) { - delete_string_field (message, FIELD_PATH); + delete_string_field (message, DBUS_HEADER_FIELD_PATH); return TRUE; } else { return set_string_field (message, - FIELD_PATH, + DBUS_HEADER_FIELD_PATH, DBUS_TYPE_OBJECT_PATH, object_path); } @@ -1455,7 +1415,7 @@ dbus_message_get_path (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_PATH, NULL); + return get_string_field (message, DBUS_HEADER_FIELD_PATH, NULL); } /** @@ -1480,7 +1440,8 @@ dbus_message_get_path_decomposed (DBusMessage *message, _dbus_return_val_if_fail (message != NULL, FALSE); _dbus_return_val_if_fail (path != NULL, FALSE); - return get_path_field_decomposed (message, FIELD_PATH, + return get_path_field_decomposed (message, + DBUS_HEADER_FIELD_PATH, path); } @@ -1503,13 +1464,13 @@ dbus_message_set_interface (DBusMessage *message, if (interface == NULL) { - delete_string_field (message, FIELD_INTERFACE); + delete_string_field (message, DBUS_HEADER_FIELD_INTERFACE); return TRUE; } else { return set_string_field (message, - FIELD_INTERFACE, + DBUS_HEADER_FIELD_INTERFACE, DBUS_TYPE_STRING, interface); } @@ -1529,7 +1490,7 @@ dbus_message_get_interface (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_INTERFACE, NULL); + return get_string_field (message, DBUS_HEADER_FIELD_INTERFACE, NULL); } /** @@ -1551,13 +1512,13 @@ dbus_message_set_member (DBusMessage *message, if (member == NULL) { - delete_string_field (message, FIELD_MEMBER); + delete_string_field (message, DBUS_HEADER_FIELD_MEMBER); return TRUE; } else { return set_string_field (message, - FIELD_MEMBER, + DBUS_HEADER_FIELD_MEMBER, DBUS_TYPE_STRING, member); } @@ -1576,7 +1537,9 @@ dbus_message_get_member (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_MEMBER, NULL); + return get_string_field (message, + DBUS_HEADER_FIELD_MEMBER, + NULL); } /** @@ -1596,13 +1559,14 @@ dbus_message_set_error_name (DBusMessage *message, if (error_name == NULL) { - delete_string_field (message, FIELD_ERROR_NAME); + delete_string_field (message, + DBUS_HEADER_FIELD_ERROR_NAME); return TRUE; } else { return set_string_field (message, - FIELD_ERROR_NAME, + DBUS_HEADER_FIELD_ERROR_NAME, DBUS_TYPE_STRING, error_name); } @@ -1619,7 +1583,9 @@ dbus_message_get_error_name (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_ERROR_NAME, NULL); + return get_string_field (message, + DBUS_HEADER_FIELD_ERROR_NAME, + NULL); } /** @@ -1638,13 +1604,13 @@ dbus_message_set_destination (DBusMessage *message, if (destination == NULL) { - delete_string_field (message, FIELD_SERVICE); + delete_string_field (message, DBUS_HEADER_FIELD_SERVICE); return TRUE; } else { return set_string_field (message, - FIELD_SERVICE, + DBUS_HEADER_FIELD_SERVICE, DBUS_TYPE_STRING, destination); } @@ -1661,7 +1627,9 @@ dbus_message_get_destination (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_SERVICE, NULL); + return get_string_field (message, + DBUS_HEADER_FIELD_SERVICE, + NULL); } /** @@ -4113,13 +4081,14 @@ dbus_message_set_sender (DBusMessage *message, if (sender == NULL) { - delete_string_field (message, FIELD_SENDER_SERVICE); + delete_string_field (message, + DBUS_HEADER_FIELD_SENDER_SERVICE); return TRUE; } else { return set_string_field (message, - FIELD_SENDER_SERVICE, + DBUS_HEADER_FIELD_SENDER_SERVICE, DBUS_TYPE_STRING, sender); } @@ -4183,7 +4152,9 @@ dbus_message_get_sender (DBusMessage *message) { _dbus_return_val_if_fail (message != NULL, NULL); - return get_string_field (message, FIELD_SENDER_SERVICE, NULL); + return get_string_field (message, + DBUS_HEADER_FIELD_SENDER_SERVICE, + NULL); } static dbus_bool_t @@ -4566,63 +4537,31 @@ _dbus_message_loader_get_buffer (DBusMessageLoader *loader, */ #define DBUS_MINIMUM_HEADER_SIZE 16 -/** Pack four characters as in "abcd" into a uint32 */ -#define FOUR_CHARS_TO_UINT32(a, b, c, d) \ - ((((dbus_uint32_t)a) << 24) | \ - (((dbus_uint32_t)b) << 16) | \ - (((dbus_uint32_t)c) << 8) | \ - ((dbus_uint32_t)d)) - -/** DBUS_HEADER_FIELD_PATH packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_PATH_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('p', 'a', 't', 'h') - -/** DBUS_HEADER_FIELD_INTERFACE packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_INTERFACE_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('i', 'f', 'c', 'e') - -/** DBUS_HEADER_FIELD_MEMBER packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_MEMBER_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('m', 'e', 'b', 'r') - -/** DBUS_HEADER_FIELD_ERROR_NAME packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_ERROR_NAME_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('e', 'r', 'n', 'm') - -/** DBUS_HEADER_FIELD_SERVICE packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_SERVICE_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('s', 'r', 'v', 'c') - -/** DBUS_HEADER_FIELD_REPLY packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_REPLY_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('r', 'p', 'l', 'y') - -/** DBUS_HEADER_FIELD_SENDER_SERVICE Packed into a dbus_uint32_t */ -#define DBUS_HEADER_FIELD_SENDER_SERVICE_AS_UINT32 \ - FOUR_CHARS_TO_UINT32 ('s', 'd', 'r', 's') - static dbus_bool_t decode_string_field (const DBusString *data, - HeaderField fields[FIELD_LAST], + int field, + HeaderField *header_field, + DBusString *field_data, int pos, - int type, - int field, - const char *field_name) + int type) { - DBusString tmp; int string_data_pos; + + _dbus_assert (header_field != NULL); + _dbus_assert (field_data != NULL); - if (fields[field].offset >= 0) + if (header_field->offset >= 0) { _dbus_verbose ("%s field provided twice\n", - field_name); + _dbus_header_field_to_string (field)); return FALSE; } if (type != DBUS_TYPE_STRING) { _dbus_verbose ("%s field has wrong type %s\n", - field_name, _dbus_type_to_string (type)); + _dbus_header_field_to_string (field), + _dbus_type_to_string (type)); return FALSE; } @@ -4633,63 +4572,15 @@ decode_string_field (const DBusString *data, string_data_pos = _DBUS_ALIGN_VALUE (pos, 4) + 4; _dbus_assert (string_data_pos < _dbus_string_get_length (data)); - _dbus_string_init_const (&tmp, + _dbus_string_init_const (field_data, _dbus_string_get_const_data (data) + string_data_pos); - if (field == FIELD_INTERFACE) - { - if (!_dbus_string_validate_interface (&tmp, 0, _dbus_string_get_length (&tmp))) - { - _dbus_verbose ("%s field has invalid content \"%s\"\n", - field_name, _dbus_string_get_const_data (&tmp)); - return FALSE; - } - - if (_dbus_string_equal_c_str (&tmp, - DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL)) - { - _dbus_verbose ("Message is on the local interface\n"); - return FALSE; - } - } - else if (field == FIELD_MEMBER) - { - if (!_dbus_string_validate_member (&tmp, 0, _dbus_string_get_length (&tmp))) - { - _dbus_verbose ("%s field has invalid content \"%s\"\n", - field_name, _dbus_string_get_const_data (&tmp)); - return FALSE; - } - } - else if (field == FIELD_ERROR_NAME) - { - if (!_dbus_string_validate_error_name (&tmp, 0, _dbus_string_get_length (&tmp))) - { - _dbus_verbose ("%s field has invalid content \"%s\"\n", - field_name, _dbus_string_get_const_data (&tmp)); - return FALSE; - } - } - else if (field == FIELD_SERVICE || - field == FIELD_SENDER_SERVICE) - { - if (!_dbus_string_validate_service (&tmp, 0, _dbus_string_get_length (&tmp))) - { - _dbus_verbose ("%s field has invalid content \"%s\"\n", - field_name, _dbus_string_get_const_data (&tmp)); - return FALSE; - } - } - else - { - _dbus_assert_not_reached ("Unknown field\n"); - } - - fields[field].offset = _DBUS_ALIGN_VALUE (pos, 4); + header_field->offset = _DBUS_ALIGN_VALUE (pos, 4); #if 0 - _dbus_verbose ("Found field %s name at offset %d\n", - field_name, fields[field].offset); + _dbus_verbose ("Found field %s at offset %d\n", + _dbus_header_field_to_string (field), + header_field->offset); #endif return TRUE; @@ -4700,12 +4591,13 @@ decode_header_data (const DBusString *data, int header_len, int byte_order, int message_type, - HeaderField fields[FIELD_LAST], + HeaderField fields[DBUS_HEADER_FIELD_LAST + 1], int *message_padding) { - const char *field; + DBusString field_data; int pos, new_pos; int i; + int field; int type; if (header_len < 16) @@ -4715,38 +4607,32 @@ decode_header_data (const DBusString *data, } i = 0; - while (i < FIELD_LAST) + while (i <= DBUS_HEADER_FIELD_LAST) { fields[i].offset = -1; ++i; } - fields[FIELD_HEADER_LENGTH].offset = 4; - fields[FIELD_BODY_LENGTH].offset = 8; - fields[FIELD_CLIENT_SERIAL].offset = 12; - - /* Now handle the named fields. A real named field is at least 4 - * bytes for the name, plus a type code (1 byte) plus padding. So - * if we have less than 8 bytes left, it must be alignment padding, - * not a field. While >= 8 bytes can't be entirely alignment - * padding. + /* Now handle the named fields. A real named field is at least 1 + * byte for the name, plus a type code (1 byte) plus padding, plus + * the field value. So if we have less than 8 bytes left, it must + * be alignment padding, not a field. While >= 8 bytes can't be + * entirely alignment padding. */ pos = 16; while ((pos + 7) < header_len) { pos = _DBUS_ALIGN_VALUE (pos, 4); - if ((pos + 4) > header_len) + if ((pos + 1) > header_len) { _dbus_verbose ("not enough space remains in header for header field value\n"); return FALSE; } - field = _dbus_string_get_const_data_len (data, pos, 4); - pos += 4; + field = _dbus_string_get_byte (data, pos); + pos += 1; - _dbus_assert (_DBUS_ALIGN_ADDRESS (field, 4) == field); - if (!_dbus_marshal_validate_type (data, pos, &type, &pos)) { _dbus_verbose ("Failed to validate type of named header field\n"); @@ -4765,71 +4651,112 @@ decode_header_data (const DBusString *data, return FALSE; } - switch (DBUS_UINT32_FROM_BE (*(int*)field)) + switch (field) { - case DBUS_HEADER_FIELD_SERVICE_AS_UINT32: - if (!decode_string_field (data, fields, pos, type, - FIELD_SERVICE, - DBUS_HEADER_FIELD_SERVICE)) + case DBUS_HEADER_FIELD_SERVICE: + if (!decode_string_field (data, field, &fields[field], + &field_data, pos, type)) return FALSE; + + if (!_dbus_string_validate_service (&field_data, 0, + _dbus_string_get_length (&field_data))) + { + _dbus_verbose ("service field has invalid content \"%s\"\n", + _dbus_string_get_const_data (&field_data)); + return FALSE; + } break; - case DBUS_HEADER_FIELD_INTERFACE_AS_UINT32: - if (!decode_string_field (data, fields, pos, type, - FIELD_INTERFACE, - DBUS_HEADER_FIELD_INTERFACE)) + case DBUS_HEADER_FIELD_INTERFACE: + if (!decode_string_field (data, field, &fields[field], + &field_data, pos, type)) return FALSE; + + if (!_dbus_string_validate_interface (&field_data, 0, + _dbus_string_get_length (&field_data))) + { + _dbus_verbose ("interface field has invalid content \"%s\"\n", + _dbus_string_get_const_data (&field_data)); + return FALSE; + } + + if (_dbus_string_equal_c_str (&field_data, + DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL)) + { + _dbus_verbose ("Message is on the local interface\n"); + return FALSE; + } break; - case DBUS_HEADER_FIELD_MEMBER_AS_UINT32: - if (!decode_string_field (data, fields, pos, type, - FIELD_MEMBER, - DBUS_HEADER_FIELD_MEMBER)) + case DBUS_HEADER_FIELD_MEMBER: + if (!decode_string_field (data, field, &fields[field], + &field_data, pos, type)) return FALSE; + + if (!_dbus_string_validate_member (&field_data, 0, + _dbus_string_get_length (&field_data))) + { + _dbus_verbose ("member field has invalid content \"%s\"\n", + _dbus_string_get_const_data (&field_data)); + return FALSE; + } break; - case DBUS_HEADER_FIELD_ERROR_NAME_AS_UINT32: - if (!decode_string_field (data, fields, pos, type, - FIELD_ERROR_NAME, - DBUS_HEADER_FIELD_ERROR_NAME)) + case DBUS_HEADER_FIELD_ERROR_NAME: + if (!decode_string_field (data, field, &fields[field], + &field_data, pos, type)) return FALSE; + + if (!_dbus_string_validate_error_name (&field_data, 0, + _dbus_string_get_length (&field_data))) + { + _dbus_verbose ("error-name field has invalid content \"%s\"\n", + _dbus_string_get_const_data (&field_data)); + return FALSE; + } break; - case DBUS_HEADER_FIELD_SENDER_SERVICE_AS_UINT32: - if (!decode_string_field (data, fields, pos, type, - FIELD_SENDER_SERVICE, - DBUS_HEADER_FIELD_SENDER_SERVICE)) + case DBUS_HEADER_FIELD_SENDER_SERVICE: + if (!decode_string_field (data, field, &fields[field], + &field_data, pos, type)) return FALSE; + + if (!_dbus_string_validate_service (&field_data, 0, + _dbus_string_get_length (&field_data))) + { + _dbus_verbose ("sender-service field has invalid content \"%s\"\n", + _dbus_string_get_const_data (&field_data)); + return FALSE; + } break; - case DBUS_HEADER_FIELD_PATH_AS_UINT32: + case DBUS_HEADER_FIELD_PATH: /* Path was already validated as part of standard * type validation, since there's an OBJECT_PATH * type. */ - if (fields[FIELD_PATH].offset >= 0) + if (fields[field].offset >= 0) { - _dbus_verbose ("%s field provided twice\n", - DBUS_HEADER_FIELD_PATH); + _dbus_verbose ("path field provided twice\n"); return FALSE; } if (type != DBUS_TYPE_OBJECT_PATH) { - _dbus_verbose ("%s field has wrong type\n", DBUS_HEADER_FIELD_PATH); + _dbus_verbose ("path field has wrong type\n"); return FALSE; } - fields[FIELD_PATH].offset = _DBUS_ALIGN_VALUE (pos, 4); + fields[field].offset = _DBUS_ALIGN_VALUE (pos, 4); /* No forging signals from the local path */ { const char *s; s = _dbus_string_get_const_data_len (data, - fields[FIELD_PATH].offset, + fields[field].offset, _dbus_string_get_length (data) - - fields[FIELD_PATH].offset); + fields[field].offset); if (strcmp (s, DBUS_PATH_ORG_FREEDESKTOP_LOCAL) == 0) { _dbus_verbose ("Message is on the local path\n"); @@ -4838,31 +4765,30 @@ decode_header_data (const DBusString *data, } _dbus_verbose ("Found path at offset %d\n", - fields[FIELD_PATH].offset); + fields[field].offset); break; - case DBUS_HEADER_FIELD_REPLY_AS_UINT32: - if (fields[FIELD_REPLY_SERIAL].offset >= 0) + case DBUS_HEADER_FIELD_REPLY_SERIAL: + if (fields[field].offset >= 0) { - _dbus_verbose ("%s field provided twice\n", - DBUS_HEADER_FIELD_REPLY); + _dbus_verbose ("reply field provided twice\n"); return FALSE; } if (type != DBUS_TYPE_UINT32) { - _dbus_verbose ("%s field has wrong type\n", DBUS_HEADER_FIELD_REPLY); + _dbus_verbose ("reply field has wrong type\n"); return FALSE; } - fields[FIELD_REPLY_SERIAL].offset = _DBUS_ALIGN_VALUE (pos, 4); + fields[field].offset = _DBUS_ALIGN_VALUE (pos, 4); _dbus_verbose ("Found reply serial at offset %d\n", - fields[FIELD_REPLY_SERIAL].offset); + fields[field].offset); break; default: - _dbus_verbose ("Ignoring an unknown header field: %.4s at offset %d\n", + _dbus_verbose ("Ignoring an unknown header field: %d at offset %d\n", field, pos); } @@ -4887,31 +4813,27 @@ decode_header_data (const DBusString *data, { case DBUS_MESSAGE_TYPE_SIGNAL: case DBUS_MESSAGE_TYPE_METHOD_CALL: - if (fields[FIELD_PATH].offset < 0) + if (fields[DBUS_HEADER_FIELD_PATH].offset < 0) { - _dbus_verbose ("No %s field provided\n", - DBUS_HEADER_FIELD_PATH); + _dbus_verbose ("No path field provided\n"); return FALSE; } /* FIXME make this optional, at least for method calls */ - if (fields[FIELD_INTERFACE].offset < 0) + if (fields[DBUS_HEADER_FIELD_INTERFACE].offset < 0) { - _dbus_verbose ("No %s field provided\n", - DBUS_HEADER_FIELD_INTERFACE); + _dbus_verbose ("No interface field provided\n"); return FALSE; } - if (fields[FIELD_MEMBER].offset < 0) + if (fields[DBUS_HEADER_FIELD_MEMBER].offset < 0) { - _dbus_verbose ("No %s field provided\n", - DBUS_HEADER_FIELD_MEMBER); + _dbus_verbose ("No member field provided\n"); return FALSE; } break; case DBUS_MESSAGE_TYPE_ERROR: - if (fields[FIELD_ERROR_NAME].offset < 0) + if (fields[DBUS_HEADER_FIELD_ERROR_NAME].offset < 0) { - _dbus_verbose ("No %s field provided\n", - DBUS_HEADER_FIELD_ERROR_NAME); + _dbus_verbose ("No error-name field provided\n"); return FALSE; } break; @@ -5056,7 +4978,7 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) if (_dbus_string_get_length (&loader->data) >= (header_len + body_len)) { - HeaderField fields[FIELD_LAST]; + HeaderField fields[DBUS_HEADER_FIELD_LAST + 1]; int i; int next_arg; @@ -5123,7 +5045,7 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) /* Copy in the offsets we found */ i = 0; - while (i < FIELD_LAST) + while (i <= DBUS_HEADER_FIELD_LAST) { message->header_fields[i] = fields[i]; ++i; @@ -5173,9 +5095,12 @@ _dbus_message_loader_queue_messages (DBusMessageLoader *loader) * earlier) */ message->reply_serial = get_uint_field (message, - FIELD_REPLY_SERIAL); - message->client_serial = get_uint_field (message, - FIELD_CLIENT_SERIAL); + DBUS_HEADER_FIELD_REPLY_SERIAL); + + message->client_serial = _dbus_demarshal_uint32 (&message->header, + message->byte_order, + CLIENT_SERIAL_OFFSET, + NULL); _dbus_verbose ("Loaded message %p\n", message); } @@ -5751,8 +5676,10 @@ check_message_handling (DBusMessage *message) client_serial = dbus_message_get_serial (message); /* can't use set_serial due to the assertions at the start of it */ - set_uint_field (message, FIELD_CLIENT_SERIAL, - client_serial); + _dbus_marshal_set_uint32 (&message->header, + message->byte_order, + CLIENT_SERIAL_OFFSET, + client_serial); if (client_serial != dbus_message_get_serial (message)) { -- cgit From 52f275a7f43a78f981d0ccc85d5882ff4c356bdd Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Tue, 23 Sep 2003 23:47:09 +0000 Subject: 2003-09-23 Havoc Pennington * glib/dbus-gproxy.c (dbus_gproxy_connect_signal): implement (dbus_gproxy_disconnect_signal): implement (dbus_gproxy_manager_remove_signal_match): implement (dbus_gproxy_manager_add_signal_match): implement (dbus_gproxy_oneway_call): implement --- dbus/dbus-message.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 2ed421d7..824d85bf 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -4818,7 +4818,7 @@ decode_header_data (const DBusString *data, _dbus_verbose ("No path field provided\n"); return FALSE; } - /* FIXME make this optional, at least for method calls */ + /* FIXME make this optional, only for method calls */ if (fields[DBUS_HEADER_FIELD_INTERFACE].offset < 0) { _dbus_verbose ("No interface field provided\n"); -- cgit From 46c072e1136ca101aefd5fdae35c457899d55bbb Mon Sep 17 00:00:00 2001 From: Mark McLoughlin Date: Thu, 25 Sep 2003 08:50:14 +0000 Subject: 2003-09-25 Mark McLoughlin * doc/dbus-specification.sgml: don't require header fields to be 4-byte aligned and specify that fields should be distinguished from padding by the fact that zero is not a valid field name. * doc/TODO: remove re-alignment item and add item to doc the OBJECT_PATH type. * dbus/dbus-message.c: (HeaderField): rename the original member to value_offset and introduce a name_offset member to keep track of where the field actually begins. (adjust_field_offsets): remove. (append_int_field), (append_uint_field), (append_string_field): don't align the start of the header field to a 4-byte boundary. (get_next_field): impl finding the next marhsalled field after a given field. (re_align_field_recurse): impl re-aligning a number of already marshalled fields. (delete_field): impl deleting a field of any type and re-aligning any following fields. (delete_int_or_uint_field), (delete_string_field): remove. (set_int_field), (set_uint_field): no need to re-check that we have the correct type for the field. (set_string_field): ditto and impl re-aligning any following fields. (decode_header_data): update to take into account that the fields aren't 4-byte aligned any more and the new way to distinguish padding from header fields. Also, don't exit when there is too much header padding. (process_test_subdir): print the directory. (_dbus_message_test): add test to make sure a following field is re-aligned correctly after field deletion. * dbus/dbus-string.[ch]: (_dbus_string_insert_bytes): rename from insert_byte and allow the insert of multiple bytes. (_dbus_string_test): test inserting multiple bytes. * dbus/dbus-marshal.c: (_dbus_marshal_set_string): add warning note to docs about having to re-align any marshalled values following the string. * dbus/dbus-message-builder.c: (append_string_field), (_dbus_message_data_load): don't align the header field. * dbus/dbus-auth.c: (process_test_subdir): print the directory. * test/break-loader.c: (randomly_add_one_byte): upd. for insert_byte change. * test/data/invalid-messages/bad-header-field-alignment.message: new test case. * test/data/valid-messages/unknown-header-field.message: shove a dict in the unknown field. --- dbus/dbus-message.c | 501 +++++++++++++++++++++++++++++++--------------------- 1 file changed, 299 insertions(+), 202 deletions(-) (limited to 'dbus/dbus-message.c') diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index 824d85bf..fe56e011 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -47,9 +47,8 @@ */ typedef struct { - int offset; /**< Offset to start of field (location of name of field - * for named fields) - */ + int name_offset; /**< Offset to name of field */ + int value_offset; /**< Offset to value of field */ } HeaderField; /** Offset to byte order from start of header */ @@ -183,26 +182,6 @@ append_header_padding (DBusMessage *message) return TRUE; } -static void -adjust_field_offsets (DBusMessage *message, - int offsets_after, - int delta) -{ - int i; - - if (delta == 0) - return; - - i = 0; - while (i <= DBUS_HEADER_FIELD_LAST) - { - if (message->header_fields[i].offset > offsets_after) - message->header_fields[i].offset += delta; - - ++i; - } -} - #ifdef DBUS_BUILD_TESTS /* tests-only until it's actually used */ static dbus_int32_t @@ -213,7 +192,7 @@ get_int_field (DBusMessage *message, _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); - offset = message->header_fields[field].offset; + offset = message->header_fields[field].value_offset; if (offset < 0) return -1; /* useless if -1 is a valid value of course */ @@ -233,7 +212,7 @@ get_uint_field (DBusMessage *message, _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); - offset = message->header_fields[field].offset; + offset = message->header_fields[field].value_offset; if (offset < 0) return -1; /* useless if -1 is a valid value of course */ @@ -252,7 +231,7 @@ get_string_field (DBusMessage *message, int offset; const char *data; - offset = message->header_fields[field].offset; + offset = message->header_fields[field].value_offset; _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); @@ -283,7 +262,7 @@ get_path_field_decomposed (DBusMessage *message, { int offset; - offset = message->header_fields[field].offset; + offset = message->header_fields[field].value_offset; _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); @@ -306,16 +285,12 @@ append_int_field (DBusMessage *message, int field, int value) { - int orig_len; - _dbus_assert (!message->locked); clear_header_padding (message); - orig_len = _dbus_string_get_length (&message->header); - - if (!_dbus_string_align_length (&message->header, 4)) - goto failed; + message->header_fields[field].name_offset = + _dbus_string_get_length (&message->header); if (!_dbus_string_append_byte (&message->header, field)) goto failed; @@ -326,7 +301,7 @@ append_int_field (DBusMessage *message, if (!_dbus_string_align_length (&message->header, 4)) goto failed; - message->header_fields[field].offset = + message->header_fields[field].value_offset = _dbus_string_get_length (&message->header); if (!_dbus_marshal_int32 (&message->header, message->byte_order, @@ -339,8 +314,10 @@ append_int_field (DBusMessage *message, return TRUE; failed: - message->header_fields[field].offset = -1; - _dbus_string_set_length (&message->header, orig_len); + _dbus_string_set_length (&message->header, + message->header_fields[field].name_offset); + message->header_fields[field].name_offset = -1; + message->header_fields[field].value_offset = -1; /* this must succeed because it was allocated on function entry and * DBusString doesn't ever realloc smaller @@ -356,16 +333,12 @@ append_uint_field (DBusMessage *message, int field, int value) { - int orig_len; - _dbus_assert (!message->locked); clear_header_padding (message); - orig_len = _dbus_string_get_length (&message->header); - - if (!_dbus_string_align_length (&message->header, 4)) - goto failed; + message->header_fields[field].name_offset = + _dbus_string_get_length (&message->header); if (!_dbus_string_append_byte (&message->header, field)) goto failed; @@ -376,7 +349,7 @@ append_uint_field (DBusMessage *message, if (!_dbus_string_align_length (&message->header, 4)) goto failed; - message->header_fields[field].offset = + message->header_fields[field].value_offset = _dbus_string_get_length (&message->header); if (!_dbus_marshal_uint32 (&message->header, message->byte_order, @@ -389,8 +362,10 @@ append_uint_field (DBusMessage *message, return TRUE; failed: - message->header_fields[field].offset = -1; - _dbus_string_set_length (&message->header, orig_len); + _dbus_string_set_length (&message->header, + message->header_fields[field].name_offset); + message->header_fields[field].name_offset = -1; + message->header_fields[field].value_offset = -1; /* this must succeed because it was allocated on function entry and * DBusString doesn't ever realloc smaller @@ -406,16 +381,12 @@ append_string_field (DBusMessage *message, int type, const char *value) { - int orig_len; - _dbus_assert (!message->locked); clear_header_padding (message); - orig_len = _dbus_string_get_length (&message->header); - - if (!_dbus_string_align_length (&message->header, 4)) - goto failed; + message->header_fields[field].name_offset = + _dbus_string_get_length (&message->header); if (!_dbus_string_append_byte (&message->header, field)) goto failed; @@ -426,7 +397,7 @@ append_string_field (DBusMessage *message, if (!_dbus_string_align_length (&message->header, 4)) goto failed; - message->header_fields[field].offset = + message->header_fields[field].value_offset = _dbus_string_get_length (&message->header); if (!_dbus_marshal_string (&message->header, message->byte_order, @@ -439,8 +410,10 @@ append_string_field (DBusMessage *message, return TRUE; failed: - message->header_fields[field].offset = -1; - _dbus_string_set_length (&message->header, orig_len); + _dbus_string_set_length (&message->header, + message->header_fields[field].name_offset); + message->header_fields[field].name_offset = -1; + message->header_fields[field].value_offset = -1; /* this must succeed because it was allocated on function entry and * DBusString doesn't ever realloc smaller @@ -451,71 +424,205 @@ append_string_field (DBusMessage *message, return FALSE; } -#ifdef DBUS_BUILD_TESTS -/* This isn't used, but building it when tests are enabled just to - * keep it compiling if we need it in future - */ -static void -delete_int_or_uint_field (DBusMessage *message, - int field) +static int +get_next_field (DBusMessage *message, + int field) { - int offset = message->header_fields[field].offset; + int offset = message->header_fields[field].name_offset; + int closest; + int i; + int retval = DBUS_HEADER_FIELD_INVALID; - _dbus_assert (!message->locked); - - if (offset < 0) - return; + i = 0; + closest = _DBUS_INT_MAX; + while (i < DBUS_HEADER_FIELD_LAST) + { + if (message->header_fields[i].name_offset > offset && + message->header_fields[i].name_offset < closest) + { + closest = message->header_fields[i].name_offset; + retval = i; + } + ++i; + } - clear_header_padding (message); - - /* The field typecode and name take up 4 bytes */ - _dbus_string_delete (&message->header, - offset - 4, - 8); + return retval; +} - message->header_fields[field].offset = -1; - - adjust_field_offsets (message, - offset - 4, - - 8); +static dbus_bool_t +re_align_field_recurse (DBusMessage *message, + int field, + int offset) +{ + int old_name_offset = message->header_fields[field].name_offset; + int old_value_offset = message->header_fields[field].value_offset; + int prev_padding, padding, delta; + int type; + int next_field; + int pos = offset; + + /* padding between the typecode byte and the value itself */ + prev_padding = old_value_offset - old_name_offset + 2; + + pos++; + type = _dbus_string_get_byte (&message->header, pos); + + pos++; + switch (type) + { + case DBUS_TYPE_NIL: + case DBUS_TYPE_BYTE: + case DBUS_TYPE_BOOLEAN: + padding = 0; + break; + case DBUS_TYPE_INT32: + case DBUS_TYPE_UINT32: + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + padding = _DBUS_ALIGN_VALUE (pos, 4) - pos; + break; + case DBUS_TYPE_INT64: + case DBUS_TYPE_UINT64: + case DBUS_TYPE_DOUBLE: + padding = _DBUS_ALIGN_VALUE (pos, 8) - pos; + break; + case DBUS_TYPE_NAMED: + case DBUS_TYPE_ARRAY: + case DBUS_TYPE_DICT: + _dbus_assert_not_reached ("no defined header fields may contain a named, array or dict value"); + break; + case DBUS_TYPE_INVALID: + default: + _dbus_assert_not_reached ("invalid type in marshalled header"); + break; + } + + delta = padding - prev_padding; + if (delta > 0) + { + if (!_dbus_string_insert_bytes (&message->header, pos, delta, 0)) + return FALSE; + } + else if (delta < 0) + { + _dbus_string_delete (&message->header, pos, -delta); + } + + next_field = get_next_field (message, field); + if (next_field != DBUS_HEADER_FIELD_INVALID) + { + int next_offset = message->header_fields[next_field].name_offset; + + _dbus_assert (next_offset > 0); + + if (!re_align_field_recurse (message, field, + pos + padding + (next_offset - old_value_offset))) + goto failed; + } + else + { + if (!append_header_padding (message)) + goto failed; + } + + message->header_fields[field].name_offset = offset; + message->header_fields[field].value_offset = pos + padding; + + return TRUE; + + failed: + if (delta > 0) + { + _dbus_string_delete (&message->header, pos, delta); + } + else if (delta < 0) + { + /* this must succeed because it was allocated on function entry and + * DBusString doesn't ever realloc smaller + */ + _dbus_string_insert_bytes (&message->header, pos, -delta, 0); + } - append_header_padding (message); + return FALSE; } -#endif -static void -delete_string_field (DBusMessage *message, - int field) +static dbus_bool_t +delete_field (DBusMessage *message, + int field) { - int offset = message->header_fields[field].offset; - int len; - int delete_len; - + int offset = message->header_fields[field].name_offset; + int next_field; + _dbus_assert (!message->locked); if (offset < 0) - return; + return FALSE; clear_header_padding (message); - - get_string_field (message, field, &len); - - /* The field typecode and name take up 4 bytes, and the nul - * termination is 1 bytes, string length integer is 4 bytes - */ - delete_len = 4 + 4 + 1 + len; - - _dbus_string_delete (&message->header, - offset - 4, - delete_len); - message->header_fields[field].offset = -1; - - adjust_field_offsets (message, - offset - 4, - - delete_len); + next_field = get_next_field (message, field); + if (next_field == DBUS_HEADER_FIELD_INVALID) + { + _dbus_string_set_length (&message->header, offset); - append_header_padding (message); + message->header_fields[field].name_offset = -1; + message->header_fields[field].value_offset = -1; + + /* this must succeed because it was allocated on function entry and + * DBusString doesn't ever realloc smaller + */ + if (!append_header_padding (message)) + _dbus_assert_not_reached ("failed to reappend header padding"); + + return TRUE; + } + else + { + DBusString deleted; + int next_offset = message->header_fields[next_field].name_offset; + + _dbus_assert (next_offset > 0); + + if (!_dbus_string_init (&deleted)) + goto failed; + + if (!_dbus_string_move_len (&message->header, + offset, next_offset - offset, + &deleted, 0)) + { + _dbus_string_free (&deleted); + goto failed; + } + + /* appends the header padding */ + if (!re_align_field_recurse (message, next_field, offset)) + { + /* this must succeed because it was allocated on function entry and + * DBusString doesn't ever realloc smaller + */ + if (!_dbus_string_copy (&deleted, 0, &message->header, offset)) + _dbus_assert_not_reached ("failed to revert to original field"); + + _dbus_string_free (&deleted); + goto failed; + } + + _dbus_string_free (&deleted); + + message->header_fields[field].name_offset = -1; + message->header_fields[field].value_offset = -1; + + return TRUE; + + failed: + /* this must succeed because it was allocated on function entry and + * DBusString doesn't ever realloc smaller + */ + if (!append_header_padding (message)) + _dbus_assert_not_reached ("failed to reappend header padding"); + + return FALSE; + } } #ifdef DBUS_BUILD_TESTS @@ -524,20 +631,14 @@ set_int_field (DBusMessage *message, int field, int value) { - int offset = message->header_fields[field].offset; + int offset = message->header_fields[field].value_offset; _dbus_assert (!message->locked); if (offset < 0) { /* need to append the field */ - - switch (field) - { - default: - _dbus_assert_not_reached ("appending an int field we don't support appending"); - return FALSE; - } + return append_int_field (message, field, value); } else { @@ -555,23 +656,14 @@ set_uint_field (DBusMessage *message, int field, dbus_uint32_t value) { - int offset = message->header_fields[field].offset; + int offset = message->header_fields[field].value_offset; _dbus_assert (!message->locked); if (offset < 0) { /* need to append the field */ - - switch (field) - { - case DBUS_HEADER_FIELD_REPLY_SERIAL: - return append_uint_field (message, field, value); - - default: - _dbus_assert_not_reached ("appending a uint field we don't support appending"); - return FALSE; - } + return append_uint_field (message, field, value); } else { @@ -589,7 +681,7 @@ set_string_field (DBusMessage *message, int type, const char *value) { - int offset = message->header_fields[field].offset; + int offset = message->header_fields[field].value_offset; _dbus_assert (!message->locked); _dbus_assert (value != NULL); @@ -597,52 +689,59 @@ set_string_field (DBusMessage *message, if (offset < 0) { /* need to append the field */ - - switch (field) - { - case DBUS_HEADER_FIELD_PATH: - case DBUS_HEADER_FIELD_SENDER_SERVICE: - case DBUS_HEADER_FIELD_INTERFACE: - case DBUS_HEADER_FIELD_MEMBER: - case DBUS_HEADER_FIELD_ERROR_NAME: - case DBUS_HEADER_FIELD_SERVICE: - return append_string_field (message, field, type, value); - - default: - _dbus_assert_not_reached ("appending a string field we don't support appending"); - return FALSE; - } + return append_string_field (message, field, type, value); } else { DBusString v; - int old_len; - int new_len; + char *old_value; + int next_field; + int next_offset; int len; clear_header_padding (message); - - old_len = _dbus_string_get_length (&message->header); + + old_value = _dbus_demarshal_string (&message->header, + message->byte_order, + offset, + &next_offset); + if (!old_value) + goto failed; len = strlen (value); - + _dbus_string_init_const_len (&v, value, len + 1); /* include nul */ if (!_dbus_marshal_set_string (&message->header, message->byte_order, - offset, &v, - len)) - goto failed; - - new_len = _dbus_string_get_length (&message->header); + offset, &v, len)) + { + dbus_free (old_value); + goto failed; + } - adjust_field_offsets (message, - offset, - new_len - old_len); + next_field = get_next_field (message, field); + if (next_field != DBUS_HEADER_FIELD_INVALID) + { + /* re-appends the header padding */ + if (!re_align_field_recurse (message, next_field, next_offset)) + { + len = strlen (old_value); + + _dbus_string_init_const_len (&v, old_value, + len + 1); /* include nul */ + if (!_dbus_marshal_set_string (&message->header, + message->byte_order, + offset, &v, len)) + _dbus_assert_not_reached ("failed to revert to original string"); + + dbus_free (old_value); + goto failed; + } + } + + dbus_free (old_value); - if (!append_header_padding (message)) - goto failed; - return TRUE; failed: @@ -983,7 +1082,8 @@ dbus_message_new_empty_header (void) i = 0; while (i <= DBUS_HEADER_FIELD_LAST) { - message->header_fields[i].offset = -1; + message->header_fields[i].name_offset = -1; + message->header_fields[i].value_offset = -1; ++i; } @@ -1281,7 +1381,7 @@ dbus_message_copy (const DBusMessage *message) for (i = 0; i <= DBUS_HEADER_FIELD_LAST; i++) { - retval->header_fields[i].offset = message->header_fields[i].offset; + retval->header_fields[i] = message->header_fields[i]; } return retval; @@ -1390,7 +1490,7 @@ dbus_message_set_path (DBusMessage *message, if (object_path == NULL) { - delete_string_field (message, DBUS_HEADER_FIELD_PATH); + delete_field (message, DBUS_HEADER_FIELD_PATH); return TRUE; } else @@ -1464,7 +1564,7 @@ dbus_message_set_interface (DBusMessage *message, if (interface == NULL) { - delete_string_field (message, DBUS_HEADER_FIELD_INTERFACE); + delete_field (message, DBUS_HEADER_FIELD_INTERFACE); return TRUE; } else @@ -1512,7 +1612,7 @@ dbus_message_set_member (DBusMessage *message, if (member == NULL) { - delete_string_field (message, DBUS_HEADER_FIELD_MEMBER); + delete_field (message, DBUS_HEADER_FIELD_MEMBER); return TRUE; } else @@ -1559,8 +1659,7 @@ dbus_message_set_error_name (DBusMessage *message, if (error_name == NULL) { - delete_string_field (message, - DBUS_HEADER_FIELD_ERROR_NAME); + delete_field (message, DBUS_HEADER_FIELD_ERROR_NAME); return TRUE; } else @@ -1604,7 +1703,7 @@ dbus_message_set_destination (DBusMessage *message, if (destination == NULL) { - delete_string_field (message, DBUS_HEADER_FIELD_SERVICE); + delete_field (message, DBUS_HEADER_FIELD_SERVICE); return TRUE; } else @@ -4081,8 +4180,7 @@ dbus_message_set_sender (DBusMessage *message, if (sender == NULL) { - delete_string_field (message, - DBUS_HEADER_FIELD_SENDER_SERVICE); + delete_field (message, DBUS_HEADER_FIELD_SENDER_SERVICE); return TRUE; } else @@ -4550,7 +4648,7 @@ decode_string_field (const DBusString *data, _dbus_assert (header_field != NULL); _dbus_assert (field_data != NULL); - if (header_field->offset >= 0) + if (header_field->name_offset >= 0) { _dbus_verbose ("%s field provided twice\n", _dbus_header_field_to_string (field)); @@ -4575,12 +4673,13 @@ decode_string_field (const DBusString *data, _dbus_string_init_const (field_data, _dbus_string_get_const_data (data) + string_data_pos); - header_field->offset = _DBUS_ALIGN_VALUE (pos, 4); + header_field->name_offset = pos; + header_field->value_offset = _DBUS_ALIGN_VALUE (pos, 4); #if 0 _dbus_verbose ("Found field %s at offset %d\n", _dbus_header_field_to_string (field), - header_field->offset); + header_field->value_offset); #endif return TRUE; @@ -4609,29 +4708,18 @@ decode_header_data (const DBusString *data, i = 0; while (i <= DBUS_HEADER_FIELD_LAST) { - fields[i].offset = -1; + fields[i].name_offset = -1; + fields[i].value_offset = -1; ++i; } - /* Now handle the named fields. A real named field is at least 1 - * byte for the name, plus a type code (1 byte) plus padding, plus - * the field value. So if we have less than 8 bytes left, it must - * be alignment padding, not a field. While >= 8 bytes can't be - * entirely alignment padding. - */ pos = 16; - while ((pos + 7) < header_len) + while (pos < header_len) { - pos = _DBUS_ALIGN_VALUE (pos, 4); - - if ((pos + 1) > header_len) - { - _dbus_verbose ("not enough space remains in header for header field value\n"); - return FALSE; - } - field = _dbus_string_get_byte (data, pos); - pos += 1; + if (field == DBUS_HEADER_FIELD_INVALID) + break; /* Must be padding */ + pos++; if (!_dbus_marshal_validate_type (data, pos, &type, &pos)) { @@ -4737,7 +4825,7 @@ decode_header_data (const DBusString *data, * type. */ - if (fields[field].offset >= 0) + if (fields[field].name_offset >= 0) { _dbus_verbose ("path field provided twice\n"); return FALSE; @@ -4748,15 +4836,16 @@ decode_header_data (const DBusString *data, return FALSE; } - fields[field].offset = _DBUS_ALIGN_VALUE (pos, 4); + fields[field].name_offset = pos; + fields[field].value_offset = _DBUS_ALIGN_VALUE (pos, 4); /* No forging signals from the local path */ { const char *s; s = _dbus_string_get_const_data_len (data, - fields[field].offset, + fields[field].value_offset, _dbus_string_get_length (data) - - fields[field].offset); + fields[field].value_offset); if (strcmp (s, DBUS_PATH_ORG_FREEDESKTOP_LOCAL) == 0) { _dbus_verbose ("Message is on the local path\n"); @@ -4765,11 +4854,11 @@ decode_header_data (const DBusString *data, } _dbus_verbose ("Found path at offset %d\n", - fields[field].offset); + fields[field].value_offset); break; case DBUS_HEADER_FIELD_REPLY_SERIAL: - if (fields[field].offset >= 0) + if (fields[field].name_offset >= 0) { _dbus_verbose ("reply field provided twice\n"); return FALSE; @@ -4781,10 +4870,11 @@ decode_header_data (const DBusString *data, return FALSE; } - fields[field].offset = _DBUS_ALIGN_VALUE (pos, 4); + fields[field].name_offset = pos; + fields[field].value_offset = _DBUS_ALIGN_VALUE (pos, 4); _dbus_verbose ("Found reply serial at offset %d\n", - fields[field].offset); + fields[field].value_offset); break; default: @@ -4798,7 +4888,11 @@ decode_header_data (const DBusString *data, if (pos < header_len) { /* Alignment padding, verify that it's nul */ - _dbus_assert ((header_len - pos) < 8); + if ((header_len - pos) >= 8) + { + _dbus_verbose ("too much header alignment padding\n"); + return FALSE; + } if (!_dbus_string_validate_nul (data, pos, (header_len - pos))) @@ -4813,25 +4907,25 @@ decode_header_data (const DBusString *data, { case DBUS_MESSAGE_TYPE_SIGNAL: case DBUS_MESSAGE_TYPE_METHOD_CALL: - if (fields[DBUS_HEADER_FIELD_PATH].offset < 0) + if (fields[DBUS_HEADER_FIELD_PATH].value_offset < 0) { _dbus_verbose ("No path field provided\n"); return FALSE; } /* FIXME make this optional, only for method calls */ - if (fields[DBUS_HEADER_FIELD_INTERFACE].offset < 0) + if (fields[DBUS_HEADER_FIELD_INTERFACE].value_offset < 0) { _dbus_verbose ("No interface field provided\n"); return FALSE; } - if (fields[DBUS_HEADER_FIELD_MEMBER].offset < 0) + if (fields[DBUS_HEADER_FIELD_MEMBER].value_offset < 0) { _dbus_verbose ("No member field provided\n"); return FALSE; } break; case DBUS_MESSAGE_TYPE_ERROR: - if (fields[DBUS_HEADER_FIELD_ERROR_NAME].offset < 0) + if (fields[DBUS_HEADER_FIELD_ERROR_NAME].value_offset < 0) { _dbus_verbose ("No error-name field provided\n"); return FALSE; @@ -6069,7 +6163,7 @@ process_test_subdir (const DBusString *test_base_dir, goto failed; } - printf ("Testing:\n"); + printf ("Testing %s:\n", subdir); next: while (_dbus_directory_get_next_file (dir, &filename, &error)) @@ -6432,11 +6526,14 @@ _dbus_message_test (const char *test_data_dir) _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface", "TestMethod")); _dbus_message_set_serial (message, 1234); - dbus_message_set_sender (message, "org.foo.bar"); - _dbus_assert (dbus_message_has_sender (message, "org.foo.bar")); + /* string length including nul byte not a multiple of 4 */ + dbus_message_set_sender (message, "org.foo.bar1"); + _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1")); + dbus_message_set_reply_serial (message, 5678); dbus_message_set_sender (message, NULL); - _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar")); + _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1")); _dbus_assert (dbus_message_get_serial (message) == 1234); + _dbus_assert (dbus_message_get_reply_serial (message) == 5678); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); _dbus_assert (dbus_message_get_no_reply (message) == FALSE); -- cgit