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"    40 #define BYTE_ORDER_OFFSET  0    42 #define BODY_LENGTH_OFFSET 4    43 #define FIELDS_ARRAY_LENGTH_OFFSET 12    46 iter_recurse (DBusMessageDataIter *iter)
    49   _dbus_assert (iter->depth < _DBUS_MESSAGE_DATA_MAX_NESTING);
    54 iter_get_sequence (DBusMessageDataIter *iter)
    57   return iter->sequence_nos[iter->depth];
    61 iter_set_sequence (DBusMessageDataIter *iter,
    65   iter->sequence_nos[iter->depth] = sequence;
    69 iter_unrecurse (DBusMessageDataIter *iter)
    76 iter_next (DBusMessageDataIter *iter)
    78   iter->sequence_nos[iter->depth] += 1;
    82 iter_first_in_series (DBusMessageDataIter *iter)
    87   while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
    89       if (iter->sequence_nos[i] != 0)
    96 typedef dbus_bool_t (* DBusInnerGeneratorFunc)   (DBusMessageDataIter *iter,
    98 typedef dbus_bool_t (* DBusMessageGeneratorFunc) (DBusMessageDataIter *iter,
   112 generate_trivial_inner (DBusMessageDataIter *iter,
   117   switch (iter_get_sequence (iter))
   122                                               "org.freedesktop.DocumentFactory",
   127       set_reply_serial (message);
   131                                          "org.freedesktop.DocumentFactory",
   138                                         "org.freedesktop.TestErrorName"))
   143         const char *v_STRING = 
"This is an error";
   152       set_reply_serial (message);
   161   *message_p = message;
   167 generate_many_bodies_inner (DBusMessageDataIter *iter,
   185   set_reply_serial (message);
   190   if (dbus_internal_do_not_use_generate_bodies (iter_get_sequence (iter),
   194       const char *v_SIGNATURE;
   196       v_SIGNATURE = _dbus_string_get_const_data (&signature);
   207                                 _dbus_string_get_length (&message->
body),
   210       *message_p = message;
   221   return *message_p != 
NULL;
   240                           data, _dbus_string_get_length (data)))
   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)
   312 simple_method_return (
void)
   319   set_reply_serial (message);
   335   set_reply_serial (message);
   341 message_with_nesting_levels (
int levels)
   359   message = simple_method_call ();
   372       parents[i] = children[i-1];
   393 generate_special (DBusMessageDataIter   *iter,
   407   item_seq = iter_get_sequence (iter);
   411       message = simple_method_call ();
   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 ();
   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 ();
   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 ();
   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 ();
   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 ();
   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 ();
   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 ();
   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 ();
   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 ();
   647       generate_from_message (data, expected_validity, message);
   651   else if (item_seq == 13)
   654       message = simple_signal ();
   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 ();
   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 ();
   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 ();
   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 ();
   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 ();
   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 ();
   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;
   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   printf (
"Changing byte %d in message %d to %c\n",
  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;
  1100 static const UIntChange uint32_changes[] = {
  1108   { CHANGE_TYPE_ABSOLUTE, 0 },
  1109   { CHANGE_TYPE_ABSOLUTE, 1 },
  1115 generate_uint32_changed (DBusMessageDataIter *iter,
  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   printf (
"body %d change %d pos %d ",
  1203           body_seq, change_seq, byte_seq);
  1205   if (change->type == CHANGE_TYPE_ADJUST)
  1206     printf (
"adjust by %d", (
int) change->value);
  1208     printf (
"set to %u", change->value);
  1210   printf (
" \t%u -> %u\n",
  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       printf (
" testing message loading: %s ", generators[generator].name);
  1286   func = generators[generator].func;
  1291   if ((*func)(iter, &data->data, &data->expected_validity))
  1295       iter_set_sequence (iter, 0);
  1296       iter_unrecurse (iter);
  1299       printf (
"%d test loads cumulative\n", iter->count);
  1302   iter_unrecurse (iter);
 unsigned int dbus_uint32_t
A 32-bit unsigned integer on all platforms. 
#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(). 
#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_assert_not_reached(explanation)
Aborts with an error message if called. 
#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. 
int dbus_int32_t
A 32-bit signed integer on all platforms. 
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.