25 #ifndef DOXYGEN_SHOULD_SKIP_THIS 27 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 28 #include "dbus-message-factory.h" 29 #include "dbus-message-private.h" 30 #include "dbus-signature.h" 31 #include "dbus-test.h" 32 #include <dbus/dbus-test-tap.h> 41 #define BYTE_ORDER_OFFSET 0 43 #define BODY_LENGTH_OFFSET 4 44 #define FIELDS_ARRAY_LENGTH_OFFSET 12 47 iter_recurse (DBusMessageDataIter *iter)
50 _dbus_assert (iter->depth < _DBUS_MESSAGE_DATA_MAX_NESTING);
55 iter_get_sequence (DBusMessageDataIter *iter)
58 return iter->sequence_nos[iter->depth];
62 iter_set_sequence (DBusMessageDataIter *iter,
66 iter->sequence_nos[iter->depth] = sequence;
70 iter_unrecurse (DBusMessageDataIter *iter)
77 iter_next (DBusMessageDataIter *iter)
79 iter->sequence_nos[iter->depth] += 1;
83 iter_first_in_series (DBusMessageDataIter *iter)
88 while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
90 if (iter->sequence_nos[i] != 0)
97 typedef dbus_bool_t (* DBusInnerGeneratorFunc) (DBusMessageDataIter *iter,
99 typedef dbus_bool_t (* DBusMessageGeneratorFunc) (DBusMessageDataIter *iter,
107 _dbus_test_fatal (
"oom");
109 _dbus_test_fatal (
"oom");
113 generate_trivial_inner (DBusMessageDataIter *iter,
118 switch (iter_get_sequence (iter))
123 "org.freedesktop.DocumentFactory",
128 set_reply_serial (message);
132 "org.freedesktop.DocumentFactory",
139 "org.freedesktop.TestErrorName"))
140 _dbus_test_fatal (
"oom");
144 const char *v_STRING =
"This is an error";
150 _dbus_test_fatal (
"oom");
153 set_reply_serial (message);
160 _dbus_test_fatal (
"oom");
162 *message_p = message;
168 generate_many_bodies_inner (DBusMessageDataIter *iter,
182 _dbus_test_fatal (
"oom");
186 set_reply_serial (message);
189 _dbus_test_fatal (
"oom");
191 if (_dbus_test_generate_bodies (iter_get_sequence (iter), byte_order,
194 const char *v_SIGNATURE;
196 v_SIGNATURE = _dbus_string_get_const_data (&signature);
201 _dbus_test_fatal (
"oom");
204 _dbus_test_fatal (
"oom");
207 _dbus_string_get_length (&message->
body),
210 *message_p = message;
221 return *message_p !=
NULL;
237 _dbus_test_fatal (
"oom");
240 data, _dbus_string_get_length (data)))
241 _dbus_test_fatal (
"oom");
245 generate_outer (DBusMessageDataIter *iter,
248 DBusInnerGeneratorFunc func)
253 if (!(*func)(iter, &message))
260 generate_from_message (data, expected_validity, message);
268 generate_trivial (DBusMessageDataIter *iter,
272 return generate_outer (iter, data, expected_validity,
273 generate_trivial_inner);
277 generate_many_bodies (DBusMessageDataIter *iter,
281 return generate_outer (iter, data, expected_validity,
282 generate_many_bodies_inner);
286 simple_method_call (
void)
295 _dbus_test_fatal (
"oom");
307 _dbus_test_fatal (
"oom");
312 simple_method_return (
void)
317 _dbus_test_fatal (
"oom");
319 set_reply_serial (message);
330 _dbus_test_fatal (
"oom");
333 _dbus_test_fatal (
"oom");
335 set_reply_serial (message);
341 message_with_nesting_levels (
int levels)
344 dbus_int32_t v_INT32;
359 message = simple_method_call ();
370 _dbus_test_fatal (
"oom");
372 parents[i] = children[i-1];
377 _dbus_test_fatal (
"oom");
382 _dbus_test_fatal (
"oom");
393 generate_special (DBusMessageDataIter *iter,
400 dbus_int32_t v_INT32;
407 item_seq = iter_get_sequence (iter);
411 message = simple_method_call ();
417 _dbus_test_fatal (
"oom");
422 generate_from_message (data, expected_validity, message);
425 _dbus_string_set_byte (data, pos + 1,
'$');
427 *expected_validity = DBUS_INVALID_UNKNOWN_TYPECODE;
429 else if (item_seq == 1)
432 const char *v_STRING;
435 message = simple_method_call ();
441 _dbus_test_fatal (
"oom");
456 _dbus_test_fatal (
"oom");
461 generate_from_message (data, expected_validity, message);
463 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;
465 else if (item_seq == 2)
468 const char *v_STRING;
471 message = simple_method_call ();
477 _dbus_test_fatal (
"oom");
501 _dbus_test_fatal (
"oom");
506 generate_from_message (data, expected_validity, message);
508 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;
510 else if (item_seq == 3)
512 message = simple_method_call ();
518 _dbus_test_fatal (
"oom");
523 generate_from_message (data, expected_validity, message);
527 *expected_validity = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;
529 else if (item_seq == 4)
531 message = simple_method_call ();
537 _dbus_test_fatal (
"oom");
542 generate_from_message (data, expected_validity, message);
546 *expected_validity = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;
548 else if (item_seq == 5)
550 message = simple_method_call ();
556 _dbus_test_fatal (
"oom");
561 generate_from_message (data, expected_validity, message);
566 *expected_validity = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;
568 else if (item_seq == 6)
570 message = simple_method_call ();
571 generate_from_message (data, expected_validity, message);
575 *expected_validity = DBUS_INVALID_BAD_MESSAGE_TYPE;
577 else if (item_seq == 7)
580 message = simple_method_call ();
581 generate_from_message (data, expected_validity, message);
587 else if (item_seq == 8)
591 message = simple_method_call ();
593 generate_from_message (data, expected_validity, message);
601 *expected_validity = DBUS_INVALID_MESSAGE_TOO_LONG;
603 else if (item_seq == 9)
605 const char *v_STRING =
"not a valid bus name";
606 message = simple_method_call ();
611 _dbus_test_fatal (
"oom");
613 generate_from_message (data, expected_validity, message);
615 *expected_validity = DBUS_INVALID_BAD_SENDER;
617 else if (item_seq == 10)
619 message = simple_method_call ();
622 _dbus_test_fatal (
"oom");
624 generate_from_message (data, expected_validity, message);
626 *expected_validity = DBUS_INVALID_USES_LOCAL_INTERFACE;
628 else if (item_seq == 11)
630 message = simple_method_call ();
633 _dbus_test_fatal (
"oom");
635 generate_from_message (data, expected_validity, message);
637 *expected_validity = DBUS_INVALID_USES_LOCAL_PATH;
639 else if (item_seq == 12)
642 message = simple_method_call ();
645 _dbus_test_fatal (
"oom");
647 generate_from_message (data, expected_validity, message);
651 else if (item_seq == 13)
654 message = simple_signal ();
657 _dbus_test_fatal (
"oom");
659 generate_from_message (data, expected_validity, message);
661 *expected_validity = DBUS_INVALID_MISSING_INTERFACE;
663 else if (item_seq == 14)
665 message = simple_method_return ();
668 _dbus_test_fatal (
"oom");
670 generate_from_message (data, expected_validity, message);
672 *expected_validity = DBUS_INVALID_MISSING_REPLY_SERIAL;
674 else if (item_seq == 15)
676 message = simple_error ();
679 _dbus_test_fatal (
"oom");
681 generate_from_message (data, expected_validity, message);
683 *expected_validity = DBUS_INVALID_MISSING_ERROR_NAME;
685 else if (item_seq == 16)
688 const char *v_STRING;
692 message = simple_method_call ();
698 _dbus_test_fatal (
"oom");
728 _dbus_test_fatal (
"oom");
733 generate_from_message (data, expected_validity, message);
735 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION;
737 else if (item_seq == 17)
739 message = simple_method_call ();
745 _dbus_test_fatal (
"oom");
750 generate_from_message (data, expected_validity, message);
755 *expected_validity = DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED;
757 else if (item_seq == 18)
759 message = simple_method_call ();
765 _dbus_test_fatal (
"oom");
770 generate_from_message (data, expected_validity, message);
774 *expected_validity = DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED;
776 else if (item_seq == 19)
778 message = simple_method_call ();
784 _dbus_test_fatal (
"oom");
789 generate_from_message (data, expected_validity, message);
795 *expected_validity = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS;
797 else if (item_seq == 20)
800 message = message_with_nesting_levels(64);
802 generate_from_message (data, expected_validity, message);
806 else if (item_seq == 21)
809 message = message_with_nesting_levels(65);
811 generate_from_message (data, expected_validity, message);
813 *expected_validity = DBUS_INVALID_NESTED_TOO_DEEPLY;
828 generate_wrong_length (DBusMessageDataIter *iter,
832 int lengths[] = { -42, -17, -16, -15, -9, -8, -7, -6, -5, -4, -3, -2, -1,
833 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 30 };
838 len_seq = iter_get_sequence (iter);
845 if (!generate_many_bodies (iter, data, expected_validity))
847 iter_set_sequence (iter, 0);
848 iter_unrecurse (iter);
852 iter_unrecurse (iter);
854 adjust = lengths[len_seq];
862 *expected_validity = DBUS_INVALID_FOR_UNKNOWN_REASON;
867 _dbus_test_fatal (
"oom");
884 _dbus_assert (old_body_len < _dbus_string_get_length (data));
885 new_body_len = old_body_len + adjust;
886 if (new_body_len < 0)
890 *expected_validity = DBUS_VALIDITY_UNKNOWN;
893 _dbus_verbose (
"changing body len from %u to %u by adjust %d\n",
894 old_body_len, new_body_len, adjust);
905 generate_byte_changed (DBusMessageDataIter *iter,
918 if (!generate_many_bodies (iter, data, expected_validity))
922 byte_seq = iter_get_sequence (iter);
924 iter_unrecurse (iter);
926 if (byte_seq == _dbus_string_get_length (data))
931 iter_set_sequence (iter, 0);
932 iter_unrecurse (iter);
938 iter_set_sequence (iter, iter_get_sequence (iter) - 1);
941 _dbus_assert (byte_seq < _dbus_string_get_length (data));
942 v_BYTE = _dbus_string_get_byte (data, byte_seq);
944 _dbus_string_set_byte (data, byte_seq, v_BYTE);
945 *expected_validity = DBUS_VALIDITY_UNKNOWN;
954 find_next_typecode (DBusMessageDataIter *iter,
962 base_depth = iter->depth;
968 body_seq = iter_get_sequence (iter);
970 if (!generate_many_bodies (iter, data, expected_validity))
973 iter_set_sequence (iter, body_seq);
980 byte_seq = iter_get_sequence (iter);
982 _dbus_assert (byte_seq <= _dbus_string_get_length (data));
984 if (byte_seq == _dbus_string_get_length (data))
987 iter_set_sequence (iter, 0);
988 iter_unrecurse (iter);
994 _dbus_assert (byte_seq < _dbus_string_get_length (data));
1003 _dbus_assert (byte_seq < _dbus_string_get_length (data));
1005 iter_unrecurse (iter);
1012 static const int typecodes[] = {
1037 generate_typecode_changed (DBusMessageDataIter *iter,
1045 base_depth = iter->depth;
1051 if (!find_next_typecode (iter, data, expected_validity))
1054 iter_recurse (iter);
1055 byte_seq = iter_get_sequence (iter);
1057 _dbus_assert (byte_seq < _dbus_string_get_length (data));
1059 iter_recurse (iter);
1060 typecode_seq = iter_get_sequence (iter);
1068 iter_set_sequence (iter, 0);
1069 iter_unrecurse (iter);
1072 iter_unrecurse (iter);
1078 iter_unrecurse (iter);
1080 iter_unrecurse (iter);
1084 _dbus_test_diag (
"Changing byte %d in message %d to %c",
1085 byte_seq, iter_get_sequence (iter), typecodes[typecode_seq]);
1088 _dbus_string_set_byte (data, byte_seq, typecodes[typecode_seq]);
1089 *expected_validity = DBUS_VALIDITY_UNKNOWN;
1097 dbus_uint32_t value;
1100 static const UIntChange uint32_changes[] = {
1101 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -1 },
1102 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -2 },
1103 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -3 },
1104 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 1 },
1105 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 2 },
1106 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 3 },
1108 { CHANGE_TYPE_ABSOLUTE, 0 },
1109 { CHANGE_TYPE_ABSOLUTE, 1 },
1110 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX - 1 },
1111 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX - 5 }
1115 generate_uint32_changed (DBusMessageDataIter *iter,
1122 dbus_uint32_t v_UINT32;
1124 const UIntChange *change;
1131 base_depth = iter->depth;
1136 body_seq = iter_get_sequence (iter);
1138 if (!generate_many_bodies (iter, data, expected_validity))
1143 iter_set_sequence (iter, body_seq);
1144 iter_recurse (iter);
1147 change_seq = iter_get_sequence (iter);
1152 iter_set_sequence (iter, 0);
1153 iter_unrecurse (iter);
1160 iter_recurse (iter);
1162 byte_seq = iter_get_sequence (iter);
1168 iter_unrecurse (iter);
1170 _dbus_assert (_DBUS_ALIGN_VALUE (byte_seq, 4) == (
unsigned) byte_seq);
1171 if (byte_seq >= (_dbus_string_get_length (data) - 4))
1175 iter_recurse (iter);
1177 iter_set_sequence (iter, 0);
1178 iter_unrecurse (iter);
1184 _dbus_assert (byte_seq <= (_dbus_string_get_length (data) - 4));
1190 change = &uint32_changes[change_seq];
1192 if (change->type == CHANGE_TYPE_ADJUST)
1194 v_UINT32 += (int) change->value;
1198 v_UINT32 = change->value;
1202 _dbus_test_diag (
"body %d change %d pos %d ",
1203 body_seq, change_seq, byte_seq);
1205 if (change->type == CHANGE_TYPE_ADJUST)
1206 _dbus_test_diag (
"adjust by %d", (
int) change->value);
1208 _dbus_test_diag (
"set to %u", change->value);
1210 _dbus_test_diag (
" \t%u -> %u",
1216 *expected_validity = DBUS_VALIDITY_UNKNOWN;
1219 iter_unrecurse (iter);
1228 DBusMessageGeneratorFunc func;
1229 } DBusMessageGenerator;
1231 static const DBusMessageGenerator generators[] = {
1232 {
"trivial example of each message type", generate_trivial },
1233 {
"assorted arguments", generate_many_bodies },
1234 {
"assorted special cases", generate_special },
1235 {
"each uint32 modified", generate_uint32_changed },
1236 {
"wrong body lengths", generate_wrong_length },
1237 {
"each byte modified", generate_byte_changed },
1240 {
"change each typecode", generate_typecode_changed }
1245 _dbus_message_data_free (DBusMessageData *data)
1251 _dbus_message_data_iter_init (DBusMessageDataIter *iter)
1257 while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
1259 iter->sequence_nos[i] = 0;
1266 _dbus_message_data_iter_get_and_next (DBusMessageDataIter *iter,
1267 DBusMessageData *data)
1269 DBusMessageGeneratorFunc func;
1273 generator = iter_get_sequence (iter);
1278 iter_recurse (iter);
1280 if (iter_first_in_series (iter))
1282 _dbus_test_diag (
" testing message loading: %s ", generators[generator].name);
1285 func = generators[generator].func;
1288 _dbus_test_fatal (
"oom");
1290 if ((*func)(iter, &data->data, &data->expected_validity))
1294 iter_set_sequence (iter, 0);
1295 iter_unrecurse (iter);
1298 _dbus_test_diag (
"%d test loads cumulative", iter->count);
1301 iter_unrecurse (iter);
#define DBUS_TYPE_UINT16
Type code marking a 16-bit unsigned integer.
void dbus_message_lock(DBusMessage *message)
Locks a message.
#define NULL
A null pointer, defined appropriately for C or C++.
trailing junk makes it invalid
void _dbus_marshal_set_uint32(DBusString *str, int pos, dbus_uint32_t value, int byte_order)
Sets the 4 bytes at the given offset to a marshaled unsigned integer, replacing anything found there ...
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
dbus_bool_t dbus_message_set_interface(DBusMessage *message, const char *iface)
Sets the interface this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or the interface...
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
#define DBUS_HEADER_FIELD_SIGNATURE
Header field code for the type signature of a message.
dbus_bool_t dbus_message_iter_close_container(DBusMessageIter *iter, DBusMessageIter *sub)
Closes a container-typed value appended to the message; may write out more information to the message...
#define DBUS_MAXIMUM_TYPE_RECURSION_DEPTH
Depth of recursion in the type tree.
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
DBusString body
Body network data.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
DBusMessage * dbus_message_new(int message_type)
Constructs a new message of the given message type.
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message.
#define DBUS_TYPE_BYTE
Type code marking an 8-bit unsigned integer.
#define DBUS_INTERFACE_LOCAL
This is a special interface whose methods can only be invoked by the local implementation (messages f...
#define DBUS_MESSAGE_TYPE_ERROR
Message type of an error reply message, see dbus_message_get_type()
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
#define DBUS_MESSAGE_TYPE_METHOD_RETURN
Message type of a method return message, see dbus_message_get_type()
DBusMessage * dbus_message_new_signal(const char *path, const char *iface, const char *name)
Constructs a new message representing a signal emission.
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
#define DBUS_DICT_ENTRY_BEGIN_CHAR
Code marking the start of a dict entry type in a type signature.
DBusValidity
This is primarily used in unit testing, so we can verify that each invalid message is invalid for the...
#define DBUS_STRUCT_END_CHAR
Code marking the end of a struct type in a type signature.
DBusMessageIter struct; contains no public fields.
#define DBUS_TYPE_DOUBLE
Type code marking an 8-byte double in IEEE 754 format.
#define DBUS_PATH_LOCAL
The object path used in local/in-process-generated messages.
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type.
#define DBUS_TYPE_INT64
Type code marking a 64-bit signed integer.
dbus_bool_t dbus_message_set_error_name(DBusMessage *message, const char *error_name)
Sets the name of the error (DBUS_MESSAGE_TYPE_ERROR).
#define BYTE_ORDER_OFFSET
Offset to byte order from start of header.
#define TYPE_OFFSET
Offset to type from start of header.
Internals of DBusMessage.
dbus_bool_t _dbus_string_move(DBusString *source, int start, DBusString *dest, int insert_at)
Moves the end of one string into another string.
#define BODY_LENGTH_OFFSET
Offset to body length from start of header.
#define DBUS_MINIMUM_HEADER_SIZE
The smallest header size that can occur.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
DBusHeader header
Header network data and associated cache.
#define _DBUS_UINT32_MAX
Maximum value of type "uint32".
#define DBUS_TYPE_INT32_AS_STRING
DBUS_TYPE_INT32 as a string literal instead of a int literal
#define DBUS_TYPE_VARIANT_AS_STRING
DBUS_TYPE_VARIANT as a string literal instead of a int literal
dbus_bool_t dbus_message_set_path(DBusMessage *message, const char *object_path)
Sets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or the one a s...
#define DBUS_TYPE_INT32
Type code marking a 32-bit signed integer.
#define DBUS_TYPE_SIGNATURE
Type code marking a D-Bus type signature.
dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type,...)
Appends fields to a message given a variable argument list.
#define DBUS_TYPE_UINT64
Type code marking a 64-bit unsigned integer.
#define DBUS_STRUCT_BEGIN_CHAR
Code marking the start of a struct type in a type signature.
#define DBUS_TYPE_VARIANT
Type code marking a D-Bus variant type.
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer.
DBusMessage * dbus_message_new_method_call(const char *destination, const char *path, const char *iface, const char *method)
Constructs a new message to invoke a method on a remote object.
dbus_bool_t _dbus_header_delete_field(DBusHeader *header, int field)
Deletes a field, if it exists.
#define DBUS_MESSAGE_TYPE_INVALID
This value is never a valid message type, see dbus_message_get_type()
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as #_DBUS_STRING_I...
#define TRUE
Expands to "1".
dbus_bool_t _dbus_header_set_field_basic(DBusHeader *header, int field, int type, const void *value)
Sets the value of a field with basic type.
#define DBUS_HEADER_FIELD_SENDER
Header field code for the sender of a message; usually initialized by the message bus...
#define DBUS_TYPE_OBJECT_PATH
Type code marking a D-Bus object path.
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor.
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code.
dbus_bool_t dbus_message_set_reply_serial(DBusMessage *message, dbus_uint32_t reply_serial)
Sets the reply serial of a message (the serial of the message this is a reply to).
#define DBUS_TYPE_INT16
Type code marking a 16-bit signed integer.
#define DBUS_TYPE_BOOLEAN
Type code marking a boolean.
#define FIELDS_ARRAY_LENGTH_OFFSET
Offset to fields array length from start of header.
char _dbus_header_get_byte_order(const DBusHeader *header)
Returns the header's byte order.
dbus_bool_t dbus_message_iter_open_container(DBusMessageIter *iter, int type, const char *contained_signature, DBusMessageIter *sub)
Appends a container-typed value to the message.
dbus_bool_t _dbus_header_get_field_raw(DBusHeader *header, int field, const DBusString **str, int *pos)
Gets the raw marshaled data for a field.
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message.
#define FALSE
Expands to "0".
#define DBUS_HEADER_FIELD_REPLY_SERIAL
Header field code for a reply serial, used to match a DBUS_MESSAGE_TYPE_METHOD_RETURN message with th...
#define DBUS_DICT_ENTRY_END_CHAR
Code marking the end of a dict entry type in a type signature.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0...
dbus_bool_t dbus_type_is_valid(int typecode)
Return TRUE if the argument is a valid typecode.
void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
Sets the serial number of a message.
#define DBUS_MAXIMUM_MESSAGE_LENGTH
The maximum total message size including header and body; similar rationale to max array size...
dbus_uint32_t _dbus_marshal_read_uint32(const DBusString *str, int pos, int byte_order, int *new_pos)
Convenience function to demarshal a 32 bit unsigned integer.