26 #include "dbus-internals.h" 
   27 #include "dbus-test.h" 
   28 #include "dbus-message-private.h" 
   29 #include "dbus-marshal-recursive.h" 
   30 #include "dbus-string.h" 
   31 #ifdef HAVE_UNIX_FD_PASSING 
   32 #include "dbus-sysdeps-unix.h" 
   37 #include <sys/types.h> 
   57 #ifdef HAVE_UNIX_FD_PASSING 
   58   return message->n_unix_fds;
 
   64 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
   86   _dbus_return_val_if_fail (iter != 
NULL, 
FALSE);
 
   87   _dbus_return_val_if_error_is_set (error, 
FALSE);
 
   89   va_start (var_args, first_arg_type);
 
   99 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
  100 #include "dbus-test.h" 
  101 #include "dbus-message-factory.h" 
  105 static int validities_seen[DBUS_VALIDITY_LAST + _DBUS_NEGATIVE_VALIDITY_COUNT];
 
  108 reset_validities_seen (
void)
 
  114       validities_seen[i] = 0;
 
  122   validities_seen[validity + _DBUS_NEGATIVE_VALIDITY_COUNT] += 1;
 
  132       if ((i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_VALIDITY_UNKNOWN ||
 
  133           (i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_INVALID_FOR_UNKNOWN_REASON)
 
  135       else if ((not_seen && validities_seen[i] == 0) ||
 
  136                (!not_seen && validities_seen[i] > 0))
 
  137         printf (
"validity %3d seen %d times\n",
 
  138                 i - _DBUS_NEGATIVE_VALIDITY_COUNT,
 
  145 check_memleaks (
void)
 
  149   if (_dbus_get_malloc_blocks_outstanding () != 0)
 
  151       _dbus_warn (
"%d dbus_malloc blocks were not freed in %s",
 
  152                   _dbus_get_malloc_blocks_outstanding (), __FILE__);
 
  158 struct DBusInitialFDs {
 
  164 _dbus_check_fdleaks_enter (
void)
 
  171   fds = malloc (
sizeof (DBusInitialFDs));
 
  176   if ((d = opendir (
"/proc/self/fd")))
 
  180       while ((de = readdir(d)))
 
  186           if (de->d_name[0] == 
'.')
 
  190           l = strtol (de->d_name, &e, 10);
 
  201           if (fd >= FD_SETSIZE)
 
  203               _dbus_verbose (
"FD %d unexpectedly large; cannot track whether " 
  204                              "it is leaked\n", fd);
 
  208           FD_SET (fd, &fds->set);
 
  221 _dbus_check_fdleaks_leave (DBusInitialFDs *fds)
 
  228   if ((d = opendir (
"/proc/self/fd")))
 
  232       while ((de = readdir(d)))
 
  238           if (de->d_name[0] == 
'.')
 
  242           l = strtol (de->d_name, &e, 10);
 
  253           if (fd >= FD_SETSIZE)
 
  255               _dbus_verbose (
"FD %d unexpectedly large; cannot track whether " 
  256                              "it is leaked\n", fd);
 
  260           if (FD_ISSET (fd, &fds->set))
 
  263           _dbus_warn (
"file descriptor %i leaked in %s.", fd, __FILE__);
 
  287       _dbus_warn (
"loader corrupted on message that was expected to be valid; invalid reason %d",
 
  295       _dbus_warn (
"didn't load message that was expected to be valid (message not popped)");
 
  299   if (_dbus_string_get_length (&loader->
data) > 0)
 
  301       _dbus_warn (
"had leftover bytes from expected-to-be-valid single message");
 
  311   if (!check_message_handling (message))
 
  336       _dbus_warn (
"loader not corrupted on message that was expected to be invalid");
 
  342   if (expected_validity != DBUS_INVALID_FOR_UNKNOWN_REASON &&
 
  345       _dbus_warn (
"expected message to be corrupted for reason %d and was corrupted for %d instead",
 
  367       _dbus_warn (
"loader corrupted on message that was expected to be valid (but incomplete), corruption reason %d",
 
  375       _dbus_warn (
"loaded message that was expected to be incomplete");
 
  379   record_validity_seen (DBUS_VALID_BUT_INCOMPLETE);
 
  396     return check_have_valid_message (loader);
 
  397   else if (expected_validity == DBUS_VALID_BUT_INCOMPLETE)
 
  398     return check_incomplete_message (loader);
 
  399   else if (expected_validity == DBUS_VALIDITY_UNKNOWN)
 
  411     return check_invalid_message (loader, expected_validity);
 
  422 dbus_internal_do_not_use_load_message_file (
const DBusString    *filename,
 
  430   _dbus_verbose (
"Loading raw %s\n", _dbus_string_get_const_data (filename));
 
  433       _dbus_warn (
"Could not load message file %s: %s",
 
  434                   _dbus_string_get_const_data (filename),
 
  456 dbus_internal_do_not_use_try_message_file (
const DBusString    *filename,
 
  467   if (!dbus_internal_do_not_use_load_message_file (filename, &data))
 
  470   retval = dbus_internal_do_not_use_try_message_data (&data, expected_validity);
 
  476       if (_dbus_string_get_length (&data) > 0)
 
  478                                        _dbus_string_get_length (&data));
 
  480       _dbus_warn (
"Failed message loader test on %s",
 
  481                   _dbus_string_get_const_data (filename));
 
  498 dbus_internal_do_not_use_try_message_data (
const DBusString    *data,
 
  519   len = _dbus_string_get_length (data);
 
  520   for (i = 0; i < len; i++)
 
  526                                      _dbus_string_get_byte (data, i)))
 
  531   if (!check_loader_results (loader, expected_validity))
 
  548                             _dbus_string_get_length (buffer)))
 
  553   if (!check_loader_results (loader, expected_validity))
 
  565   len = _dbus_string_get_length (data);
 
  566   for (i = 0; i < len; i += 2)
 
  572                                      _dbus_string_get_byte (data, i)))
 
  578                                          _dbus_string_get_byte (data, i+1)))
 
  585   if (!check_loader_results (loader, expected_validity))
 
  602 process_test_subdir (
const DBusString          *test_base_dir,
 
  605                      DBusForeachMessageFileFunc 
function,
 
  637                   _dbus_string_get_const_data (&test_directory),
 
  643   printf (
"Testing %s:\n", subdir);
 
  665               printf (
"SKIP: Could not load %s, message builder language no longer supported\n",
 
  666                       _dbus_string_get_const_data (&filename));
 
  669           _dbus_verbose (
"Skipping non-.message file %s\n",
 
  670                          _dbus_string_get_const_data (&filename));
 
  676               _dbus_string_get_const_data (&filename));
 
  678       if (! (*
function) (&full_path,
 
  679                          expected_validity, user_data))
 
  690       _dbus_warn (
"Could not get next file in %s: %s",
 
  691                   _dbus_string_get_const_data (&test_directory),
 
  719 dbus_internal_do_not_use_foreach_message_file (
const char                *test_data_dir,
 
  720                                                DBusForeachMessageFileFunc func,
 
  730   if (!process_test_subdir (&test_directory, 
"valid-messages",
 
  736   if (!process_test_subdir (&test_directory, 
"invalid-messages",
 
  737                             DBUS_INVALID_FOR_UNKNOWN_REASON, func, user_data))
 
  742   if (!process_test_subdir (&test_directory, 
"incomplete-messages",
 
  743                             DBUS_VALID_BUT_INCOMPLETE, func, user_data))
 
  758 #define GET_AND_CHECK(iter, typename, literal)                                  \ 
  760     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \ 
  761       _dbus_assert_not_reached ("got wrong argument type from message iter");   \ 
  762     dbus_message_iter_get_basic (&iter, &v_##typename);                         \ 
  763     if (v_##typename != literal)                                                \ 
  764       _dbus_assert_not_reached ("got wrong value from message iter");           \ 
  767 #define GET_AND_CHECK_STRCMP(iter, typename, literal)                           \ 
  769     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \ 
  770       _dbus_assert_not_reached ("got wrong argument type from message iter");   \ 
  771     dbus_message_iter_get_basic (&iter, &v_##typename);                         \ 
  772     if (strcmp (v_##typename, literal) != 0)                                    \ 
  773       _dbus_assert_not_reached ("got wrong value from message iter");           \ 
  776 #define GET_AND_CHECK_AND_NEXT(iter, typename, literal)         \ 
  778     GET_AND_CHECK(iter, typename, literal);                     \ 
  779     if (!dbus_message_iter_next (&iter))                        \ 
  780       _dbus_assert_not_reached ("failed to move iter to next"); \ 
  783 #define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal)  \ 
  785     GET_AND_CHECK_STRCMP(iter, typename, literal);              \ 
  786     if (!dbus_message_iter_next (&iter))                        \ 
  787       _dbus_assert_not_reached ("failed to move iter to next"); \ 
  794   const char *v_STRING;
 
  802   unsigned char v_BYTE;
 
  810   GET_AND_CHECK_STRCMP_AND_NEXT (iter, STRING, 
"Test string");
 
  811   GET_AND_CHECK_AND_NEXT (iter, INT32, -0x12345678);
 
  812   GET_AND_CHECK_AND_NEXT (iter, UINT32, 0xedd1e);
 
  813   GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
 
  823   GET_AND_CHECK_AND_NEXT (array, DOUBLE, 1.5);
 
  824   GET_AND_CHECK (array, DOUBLE, 2.5);
 
  832   GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
 
  849   GET_AND_CHECK (iter, BYTE, 0xF0);
 
  869   unsigned char our_byte_1, our_byte_2;
 
  871   int our_uint32_array_len;
 
  873   int our_int32_array_len;
 
  877   int our_uint64_array_len;
 
  878   const dbus_int64_t *our_int64_array = (
void*)0xdeadbeef;
 
  879   int our_int64_array_len;
 
  880   const double *our_double_array = (
void*)0xdeadbeef;
 
  881   int our_double_array_len;
 
  882   const unsigned char *our_byte_array = (
void*)0xdeadbeef;
 
  883   int our_byte_array_len;
 
  884   const dbus_bool_t *our_boolean_array = (
void*)0xdeadbeef;
 
  885   int our_boolean_array_len;
 
  886   char **our_string_array;
 
  887   int our_string_array_len;
 
  891   if (!dbus_message_iter_get_args (&iter, &error,
 
  904                                    &our_uint32_array, &our_uint32_array_len,
 
  906                                    &our_int32_array, &our_int32_array_len,
 
  908                                    &our_uint64_array, &our_uint64_array_len,
 
  910                                    &our_int64_array, &our_int64_array_len,
 
  912                                    &our_double_array, &our_double_array_len,
 
  914                                    &our_byte_array, &our_byte_array_len,
 
  916                                    &our_boolean_array, &our_boolean_array_len,
 
  918                                    &our_string_array, &our_string_array_len,
 
  926   if (our_int16 != -0x123)
 
  929   if (our_uint16 != 0x123)
 
  932   if (our_int != -0x12345678)
 
  935   if (our_uint != 0x12300042)
 
  947   if (strcmp (our_str, 
"Test string") != 0)
 
  953   if (our_byte_1 != 42)
 
  956   if (our_byte_2 != 24)
 
  959   if (our_uint32_array_len != 4 ||
 
  960       our_uint32_array[0] != 0x12345678 ||
 
  961       our_uint32_array[1] != 0x23456781 ||
 
  962       our_uint32_array[2] != 0x34567812 ||
 
  963       our_uint32_array[3] != 0x45678123)
 
  966   if (our_int32_array_len != 4 ||
 
  967       our_int32_array[0] != 0x12345678 ||
 
  968       our_int32_array[1] != -0x23456781 ||
 
  969       our_int32_array[2] != 0x34567812 ||
 
  970       our_int32_array[3] != -0x45678123)
 
  973   if (our_uint64_array_len != 4 ||
 
  974       our_uint64_array[0] != 0x12345678 ||
 
  975       our_uint64_array[1] != 0x23456781 ||
 
  976       our_uint64_array[2] != 0x34567812 ||
 
  977       our_uint64_array[3] != 0x45678123)
 
  980   if (our_int64_array_len != 4 ||
 
  981       our_int64_array[0] != 0x12345678 ||
 
  982       our_int64_array[1] != -0x23456781 ||
 
  983       our_int64_array[2] != 0x34567812 ||
 
  984       our_int64_array[3] != -0x45678123)
 
  987   if (our_double_array_len != 3)
 
  996   v_DOUBLE = 9876.54321;
 
 1003   if (our_byte_array_len != 4)
 
 1006   if (our_byte_array[0] != 
'a' ||
 
 1007       our_byte_array[1] != 
'b' ||
 
 1008       our_byte_array[2] != 
'c' ||
 
 1009       our_byte_array[3] != 234)
 
 1012   if (our_boolean_array_len != 5)
 
 1015   if (our_boolean_array[0] != 
TRUE ||
 
 1016       our_boolean_array[1] != 
FALSE ||
 
 1017       our_boolean_array[2] != 
TRUE ||
 
 1018       our_boolean_array[3] != 
TRUE ||
 
 1019       our_boolean_array[4] != 
FALSE)
 
 1022   if (our_string_array_len != 4)
 
 1025   if (strcmp (our_string_array[0], 
"Foo") != 0 ||
 
 1026       strcmp (our_string_array[1], 
"bar") != 0 ||
 
 1027       strcmp (our_string_array[2], 
"") != 0 ||
 
 1028       strcmp (our_string_array[3], 
"woo woo woo woo") != 0)
 
 1038 verify_test_message_args_ignored (
DBusMessage *message)
 
 1043   DBusInitialFDs *initial_fds;
 
 1045   initial_fds = _dbus_check_fdleaks_enter ();
 
 1049   if (!dbus_message_iter_get_args (&iter, &error,
 
 1058       _dbus_verbose (
"arguments ignored.\n");
 
 1063   if (!dbus_message_iter_get_args (&iter, &error,
 
 1073       _dbus_verbose (
"arguments ignored.\n");
 
 1076   _dbus_check_fdleaks_leave (initial_fds);
 
 1080 verify_test_message_memleak (
DBusMessage *message)
 
 1087   char **our_string_array1;
 
 1088   int our_string_array_len1;
 
 1089   char **our_string_array2;
 
 1090   int our_string_array_len2;
 
 1091 #ifdef HAVE_UNIX_FD_PASSING 
 1095   DBusInitialFDs *initial_fds;
 
 1097   initial_fds = _dbus_check_fdleaks_enter ();
 
 1102   if (!dbus_message_iter_get_args (&iter, &error,
 
 1105                                    &our_string_array1, &our_string_array_len1,
 
 1106 #ifdef HAVE_UNIX_FD_PASSING
 
 1113       _dbus_verbose (
"expected error: %s - %s\n", error.
name,
 
 1117 #ifdef HAVE_UNIX_FD_PASSING 
 1123       _dbus_warn (
"error: parse with wrong signature: 'uashuu'.");
 
 1129   if (!dbus_message_iter_get_args (&iter, &error,
 
 1132                                    &our_string_array1, &our_string_array_len1,
 
 1133 #ifdef HAVE_UNIX_FD_PASSING
 
 1138                                    &our_string_array2, &our_string_array_len2,
 
 1139 #ifdef HAVE_UNIX_FD_PASSING
 
 1145       _dbus_verbose (
"expected error: %s - %s\n", error.
name,
 
 1150 #ifdef HAVE_UNIX_FD_PASSING 
 1157       _dbus_warn (
"error: parse with wrong signature: 'uashuashu'.");
 
 1163   if (!dbus_message_iter_get_args (&iter, &error,
 
 1166                                    &our_string_array1, &our_string_array_len1,
 
 1167 #ifdef HAVE_UNIX_FD_PASSING
 
 1172                                    &our_string_array2, &our_string_array_len2,
 
 1173 #ifdef HAVE_UNIX_FD_PASSING
 
 1186 #ifdef HAVE_UNIX_FD_PASSING 
 1191   _dbus_check_fdleaks_leave (initial_fds);
 
 1201 _dbus_message_test (
const char *test_data_dir)
 
 1211     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
 
 1213     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
 
 1217     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
 
 1219     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
 
 1222   const char *our_string_array[] = { 
"Foo", 
"bar", 
"", 
"woo woo woo woo" };
 
 1223   const char *our_string_array1[] = { 
"foo", 
"Bar", 
"", 
"Woo woo Woo woo" };
 
 1224   const char **v_ARRAY_STRING = our_string_array;
 
 1225   const char **v1_ARRAY_STRING = our_string_array1;
 
 1226   const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
 
 1227   const double *v_ARRAY_DOUBLE = our_double_array;
 
 1228   const unsigned char our_byte_array[] = { 
'a', 
'b', 
'c', 234 };
 
 1229   const unsigned char *v_ARRAY_BYTE = our_byte_array;
 
 1231   const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
 
 1234   const char *v_STRING;
 
 1243   unsigned char v_BYTE;
 
 1244   unsigned char v2_BYTE;
 
 1247 #ifdef HAVE_UNIX_FD_PASSING 
 1252   DBusInitialFDs *initial_fds;
 
 1265   initial_fds = _dbus_check_fdleaks_enter ();
 
 1268                                           "/org/freedesktop/TestPath",
 
 1269                                           "Foo.TestInterface",
 
 1275                         "/org/freedesktop/TestPath") == 0);
 
 1286                                  _dbus_string_get_length (&message->
header.
data));
 
 1288                                  _dbus_string_get_length (&message->
body));
 
 1295                                  _dbus_string_get_length (&message->
header.
data));
 
 1297                                  _dbus_string_get_length (&message->
body));
 
 1337                         "org.Foo.Bar") == 0);
 
 1393                                           "/org/freedesktop/TestPath",
 
 1394                                           "Foo.TestInterface",
 
 1401   v_INT32 = -0x12345678;
 
 1402   v_UINT32 = 0x12300042;
 
 1405   v_STRING = 
"Test string";
 
 1410 #ifdef HAVE_UNIX_FD_PASSING 
 1477 #ifdef HAVE_UNIX_FD_PASSING 
 1487   _dbus_verbose (
"HEADER\n");
 
 1489                                  _dbus_string_get_length (&message->
header.
data));
 
 1490   _dbus_verbose (
"BODY\n");
 
 1492                                  _dbus_string_get_length (&message->
body));
 
 1494   _dbus_verbose (
"Signature expected \"%s\" actual \"%s\"\n",
 
 1502   verify_test_message (message);
 
 1511                 _dbus_string_get_length (©->
header.
data));
 
 1514                 _dbus_string_get_length (©->
body));
 
 1516   verify_test_message (copy);
 
 1539   data = _dbus_string_get_const_data (&message->
header.
data);
 
 1540   for (i = 0; i < _dbus_string_get_length (&message->
header.
data); i++)
 
 1550   data = _dbus_string_get_const_data (&message->
body);
 
 1551   for (i = 0; i < _dbus_string_get_length (&message->
body); i++)
 
 1560 #ifdef HAVE_UNIX_FD_PASSING 
 1563     unsigned n_unix_fds;
 
 1565     _dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds);
 
 1570     _dbus_message_loader_return_unix_fds(loader, unix_fds, 1);
 
 1597   verify_test_message (message_without_unix_fds);
 
 1604       char *marshalled = 
NULL;
 
 1619       verify_test_message (message2);
 
 1651   _dbus_check_fdleaks_leave (initial_fds);
 
 1652   initial_fds = _dbus_check_fdleaks_enter ();
 
 1655   for (i = strlen (basic_types) - 1; i > 0; i--)
 
 1661       signature[0] = basic_types[i];
 
 1662       s = 
"SomeThingToSay";
 
 1663       memset (&val, 
'\0', 
sizeof (val));
 
 1666         "/de/ende/test", 
"de.ende.Test", 
"ArtistName");
 
 1670                                         signature, &array_iter);
 
 1671       for (some = 0; some < 3; some++)
 
 1686       "/de/ende/test", 
"de.ende.Test", 
"ArtistName");
 
 1694                                     NULL, &struct_iter);
 
 1706                                           "/org/freedesktop/TestPath",
 
 1707                                           "Foo.TestInterface",
 
 1720                           NULL, &struct_iter);
 
 1735                                           "/org/freedesktop/TestPath",
 
 1736                                           "Foo.TestInterface",
 
 1744 #ifdef HAVE_UNIX_FD_PASSING
 
 1750 #ifdef HAVE_UNIX_FD_PASSING
 
 1760 #ifdef HAVE_UNIX_FD_PASSING 
 1766 #ifdef HAVE_UNIX_FD_PASSING 
 1773   verify_test_message_args_ignored (message);
 
 1774   verify_test_message_memleak (message);
 
 1780     DBusMessageDataIter diter;
 
 1781     DBusMessageData mdata;
 
 1784     reset_validities_seen ();
 
 1787     _dbus_message_data_iter_init (&diter);
 
 1789     while (_dbus_message_data_iter_get_and_next (&diter,
 
 1792         if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
 
 1793                                                         mdata.expected_validity))
 
 1795             _dbus_warn (
"expected validity %d and did not get it",
 
 1796                         mdata.expected_validity);
 
 1800         _dbus_message_data_free (&mdata);
 
 1805     printf (
"%d sample messages tested\n", count);
 
 1807     print_validities_seen (
FALSE);
 
 1808     print_validities_seen (
TRUE);
 
 1812   _dbus_check_fdleaks_leave (initial_fds);
 
 1815   if (test_data_dir == 
NULL)
 
 1818   initial_fds = _dbus_check_fdleaks_enter ();
 
 1820   if (!dbus_internal_do_not_use_foreach_message_file (test_data_dir,
 
 1821                                                         (DBusForeachMessageFileFunc)
 
 1822                                                         dbus_internal_do_not_use_try_message_file,
 
 1826   _dbus_check_fdleaks_leave (initial_fds);