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>    48 #ifdef DBUS_ENABLE_EMBEDDED_TESTS    70   _dbus_return_val_if_fail (iter != 
NULL, 
FALSE);
    71   _dbus_return_val_if_error_is_set (error, 
FALSE);
    73   va_start (var_args, first_arg_type);
    83 #ifdef DBUS_ENABLE_EMBEDDED_TESTS    84 #include "dbus-test.h"    85 #include "dbus-message-factory.h"    89 static int validities_seen[DBUS_VALIDITY_LAST + _DBUS_NEGATIVE_VALIDITY_COUNT];
    92 reset_validities_seen (
void)
    98       validities_seen[i] = 0;
   106   validities_seen[validity + _DBUS_NEGATIVE_VALIDITY_COUNT] += 1;
   116       if ((i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_VALIDITY_UNKNOWN ||
   117           (i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_INVALID_FOR_UNKNOWN_REASON)
   119       else if ((not_seen && validities_seen[i] == 0) ||
   120                (!not_seen && validities_seen[i] > 0))
   121         printf (
"validity %3d seen %d times\n",
   122                 i - _DBUS_NEGATIVE_VALIDITY_COUNT,
   129 check_memleaks (
void)
   133   if (_dbus_get_malloc_blocks_outstanding () != 0)
   135       _dbus_warn (
"%d dbus_malloc blocks were not freed in %s\n",
   136                   _dbus_get_malloc_blocks_outstanding (), __FILE__);
   142 struct DBusInitialFDs {
   148 _dbus_check_fdleaks_enter (
void)
   155   fds = malloc (
sizeof (DBusInitialFDs));
   160   if ((d = opendir (
"/proc/self/fd")))
   164       while ((de = readdir(d)))
   170           if (de->d_name[0] == 
'.')
   174           l = strtol (de->d_name, &e, 10);
   185           FD_SET (fd, &fds->set);
   198 _dbus_check_fdleaks_leave (DBusInitialFDs *fds)
   205   if ((d = opendir (
"/proc/self/fd")))
   209       while ((de = readdir(d)))
   215           if (de->d_name[0] == 
'.')
   219           l = strtol (de->d_name, &e, 10);
   230           if (FD_ISSET (fd, &fds->set))
   233           _dbus_warn (
"file descriptor %i leaked in %s.\n", fd, __FILE__);
   257       _dbus_warn (
"loader corrupted on message that was expected to be valid; invalid reason %d\n",
   265       _dbus_warn (
"didn't load message that was expected to be valid (message not popped)\n");
   269   if (_dbus_string_get_length (&loader->
data) > 0)
   271       _dbus_warn (
"had leftover bytes from expected-to-be-valid single message\n");
   281   if (!check_message_handling (message))
   306       _dbus_warn (
"loader not corrupted on message that was expected to be invalid\n");
   312   if (expected_validity != DBUS_INVALID_FOR_UNKNOWN_REASON &&
   315       _dbus_warn (
"expected message to be corrupted for reason %d and was corrupted for %d instead\n",
   337       _dbus_warn (
"loader corrupted on message that was expected to be valid (but incomplete), corruption reason %d\n",
   345       _dbus_warn (
"loaded message that was expected to be incomplete\n");
   349   record_validity_seen (DBUS_VALID_BUT_INCOMPLETE);
   366     return check_have_valid_message (loader);
   367   else if (expected_validity == DBUS_VALID_BUT_INCOMPLETE)
   368     return check_incomplete_message (loader);
   369   else if (expected_validity == DBUS_VALIDITY_UNKNOWN)
   381     return check_invalid_message (loader, expected_validity);
   392 dbus_internal_do_not_use_load_message_file (
const DBusString    *filename,
   400   _dbus_verbose (
"Loading raw %s\n", _dbus_string_get_const_data (filename));
   403       _dbus_warn (
"Could not load message file %s: %s\n",
   404                   _dbus_string_get_const_data (filename),
   426 dbus_internal_do_not_use_try_message_file (
const DBusString    *filename,
   437   if (!dbus_internal_do_not_use_load_message_file (filename, &data))
   440   retval = dbus_internal_do_not_use_try_message_data (&data, expected_validity);
   446       if (_dbus_string_get_length (&data) > 0)
   448                                        _dbus_string_get_length (&data));
   450       _dbus_warn (
"Failed message loader test on %s\n",
   451                   _dbus_string_get_const_data (filename));
   468 dbus_internal_do_not_use_try_message_data (
const DBusString    *data,
   488   len = _dbus_string_get_length (data);
   489   for (i = 0; i < len; i++)
   495                                 _dbus_string_get_byte (data, i));
   499   if (!check_loader_results (loader, expected_validity))
   514                        _dbus_string_get_length (buffer));
   518   if (!check_loader_results (loader, expected_validity))
   528   len = _dbus_string_get_length (data);
   529   for (i = 0; i < len; i += 2)
   535                                 _dbus_string_get_byte (data, i));
   538                                   _dbus_string_get_byte (data, i+1));
   542   if (!check_loader_results (loader, expected_validity))
   559 process_test_subdir (
const DBusString          *test_base_dir,
   562                      DBusForeachMessageFileFunc 
function,
   594                   _dbus_string_get_const_data (&test_directory),
   600   printf (
"Testing %s:\n", subdir);
   622               printf (
"SKIP: Could not load %s, message builder language no longer supported\n",
   623                       _dbus_string_get_const_data (&filename));
   626           _dbus_verbose (
"Skipping non-.message file %s\n",
   627                          _dbus_string_get_const_data (&filename));
   633               _dbus_string_get_const_data (&filename));
   635       if (! (*
function) (&full_path,
   636                          expected_validity, user_data))
   647       _dbus_warn (
"Could not get next file in %s: %s\n",
   648                   _dbus_string_get_const_data (&test_directory),
   676 dbus_internal_do_not_use_foreach_message_file (
const char                *test_data_dir,
   677                                                DBusForeachMessageFileFunc func,
   687   if (!process_test_subdir (&test_directory, 
"valid-messages",
   693   if (!process_test_subdir (&test_directory, 
"invalid-messages",
   694                             DBUS_INVALID_FOR_UNKNOWN_REASON, func, user_data))
   699   if (!process_test_subdir (&test_directory, 
"incomplete-messages",
   700                             DBUS_VALID_BUT_INCOMPLETE, func, user_data))
   715 #define GET_AND_CHECK(iter, typename, literal)                                  \   717     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \   718       _dbus_assert_not_reached ("got wrong argument type from message iter");   \   719     dbus_message_iter_get_basic (&iter, &v_##typename);                         \   720     if (v_##typename != literal)                                                \   721       _dbus_assert_not_reached ("got wrong value from message iter");           \   724 #define GET_AND_CHECK_STRCMP(iter, typename, literal)                           \   726     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \   727       _dbus_assert_not_reached ("got wrong argument type from message iter");   \   728     dbus_message_iter_get_basic (&iter, &v_##typename);                         \   729     if (strcmp (v_##typename, literal) != 0)                                    \   730       _dbus_assert_not_reached ("got wrong value from message iter");           \   733 #define GET_AND_CHECK_AND_NEXT(iter, typename, literal)         \   735     GET_AND_CHECK(iter, typename, literal);                     \   736     if (!dbus_message_iter_next (&iter))                        \   737       _dbus_assert_not_reached ("failed to move iter to next"); \   740 #define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal)  \   742     GET_AND_CHECK_STRCMP(iter, typename, literal);              \   743     if (!dbus_message_iter_next (&iter))                        \   744       _dbus_assert_not_reached ("failed to move iter to next"); \   751   const char *v_STRING;
   753   dbus_int16_t v_INT16;
   754   dbus_uint16_t v_UINT16;
   755   dbus_int32_t v_INT32;
   756   dbus_uint32_t v_UINT32;
   757   dbus_int64_t v_INT64;
   758   dbus_uint64_t v_UINT64;
   759   unsigned char v_BYTE;
   762   const dbus_int32_t *our_int_array;
   767   GET_AND_CHECK_STRCMP_AND_NEXT (iter, STRING, 
"Test string");
   768   GET_AND_CHECK_AND_NEXT (iter, INT32, -0x12345678);
   769   GET_AND_CHECK_AND_NEXT (iter, UINT32, 0xedd1e);
   770   GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
   780   GET_AND_CHECK_AND_NEXT (array, DOUBLE, 1.5);
   781   GET_AND_CHECK (array, DOUBLE, 2.5);
   789   GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
   806   GET_AND_CHECK (iter, BYTE, 0xF0);
   818   dbus_int16_t our_int16;
   819   dbus_uint16_t our_uint16;
   820   dbus_int32_t our_int;
   821   dbus_uint32_t our_uint;
   826   unsigned char our_byte_1, our_byte_2;
   827   const dbus_uint32_t *our_uint32_array = (
void*)0xdeadbeef;
   828   int our_uint32_array_len;
   829   dbus_int32_t *our_int32_array = (
void*)0xdeadbeef;
   830   int our_int32_array_len;
   831   dbus_int64_t our_int64;
   832   dbus_uint64_t our_uint64;
   833   dbus_int64_t *our_uint64_array = (
void*)0xdeadbeef;
   834   int our_uint64_array_len;
   835   const dbus_int64_t *our_int64_array = (
void*)0xdeadbeef;
   836   int our_int64_array_len;
   837   const double *our_double_array = (
void*)0xdeadbeef;
   838   int our_double_array_len;
   839   const unsigned char *our_byte_array = (
void*)0xdeadbeef;
   840   int our_byte_array_len;
   841   const dbus_bool_t *our_boolean_array = (
void*)0xdeadbeef;
   842   int our_boolean_array_len;
   843   char **our_string_array;
   844   int our_string_array_len;
   848   if (!dbus_message_iter_get_args (&iter, &error,
   861                                    &our_uint32_array, &our_uint32_array_len,
   863                                    &our_int32_array, &our_int32_array_len,
   865                                    &our_uint64_array, &our_uint64_array_len,
   867                                    &our_int64_array, &our_int64_array_len,
   869                                    &our_double_array, &our_double_array_len,
   871                                    &our_byte_array, &our_byte_array_len,
   873                                    &our_boolean_array, &our_boolean_array_len,
   875                                    &our_string_array, &our_string_array_len,
   883   if (our_int16 != -0x123)
   886   if (our_uint16 != 0x123)
   889   if (our_int != -0x12345678)
   892   if (our_uint != 0x12300042)
   895   if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
   897   if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
   904   if (strcmp (our_str, 
"Test string") != 0)
   910   if (our_byte_1 != 42)
   913   if (our_byte_2 != 24)
   916   if (our_uint32_array_len != 4 ||
   917       our_uint32_array[0] != 0x12345678 ||
   918       our_uint32_array[1] != 0x23456781 ||
   919       our_uint32_array[2] != 0x34567812 ||
   920       our_uint32_array[3] != 0x45678123)
   923   if (our_int32_array_len != 4 ||
   924       our_int32_array[0] != 0x12345678 ||
   925       our_int32_array[1] != -0x23456781 ||
   926       our_int32_array[2] != 0x34567812 ||
   927       our_int32_array[3] != -0x45678123)
   930   if (our_uint64_array_len != 4 ||
   931       our_uint64_array[0] != 0x12345678 ||
   932       our_uint64_array[1] != 0x23456781 ||
   933       our_uint64_array[2] != 0x34567812 ||
   934       our_uint64_array[3] != 0x45678123)
   937   if (our_int64_array_len != 4 ||
   938       our_int64_array[0] != 0x12345678 ||
   939       our_int64_array[1] != -0x23456781 ||
   940       our_int64_array[2] != 0x34567812 ||
   941       our_int64_array[3] != -0x45678123)
   944   if (our_double_array_len != 3)
   953   v_DOUBLE = 9876.54321;
   960   if (our_byte_array_len != 4)
   963   if (our_byte_array[0] != 
'a' ||
   964       our_byte_array[1] != 
'b' ||
   965       our_byte_array[2] != 
'c' ||
   966       our_byte_array[3] != 234)
   969   if (our_boolean_array_len != 5)
   972   if (our_boolean_array[0] != 
TRUE ||
   973       our_boolean_array[1] != 
FALSE ||
   974       our_boolean_array[2] != 
TRUE ||
   975       our_boolean_array[3] != 
TRUE ||
   976       our_boolean_array[4] != 
FALSE)
   979   if (our_string_array_len != 4)
   982   if (strcmp (our_string_array[0], 
"Foo") != 0 ||
   983       strcmp (our_string_array[1], 
"bar") != 0 ||
   984       strcmp (our_string_array[2], 
"") != 0 ||
   985       strcmp (our_string_array[3], 
"woo woo woo woo") != 0)
   995 verify_test_message_args_ignored (
DBusMessage *message)
   999   dbus_uint32_t our_uint;
  1000   DBusInitialFDs *initial_fds;
  1002   initial_fds = _dbus_check_fdleaks_enter ();
  1006   if (!dbus_message_iter_get_args (&iter, &error,
  1015       _dbus_verbose (
"arguments ignored.\n");
  1020   if (!dbus_message_iter_get_args (&iter, &error,
  1030       _dbus_verbose (
"arguments ignored.\n");
  1033   _dbus_check_fdleaks_leave (initial_fds);
  1037 verify_test_message_memleak (
DBusMessage *message)
  1041   dbus_uint32_t our_uint1;
  1042   dbus_uint32_t our_uint2;
  1043   dbus_uint32_t our_uint3;
  1044   char **our_string_array1;
  1045   int our_string_array_len1;
  1046   char **our_string_array2;
  1047   int our_string_array_len2;
  1048 #ifdef HAVE_UNIX_FD_PASSING  1052   DBusInitialFDs *initial_fds;
  1054   initial_fds = _dbus_check_fdleaks_enter ();
  1059   if (!dbus_message_iter_get_args (&iter, &error,
  1062                                    &our_string_array1, &our_string_array_len1,
  1063 #ifdef HAVE_UNIX_FD_PASSING
  1067                                    DBUS_TYPE_UINT32, &our_uint3,
  1070       _dbus_verbose (
"expected error: %s - %s\n", error.
name,
  1074 #ifdef HAVE_UNIX_FD_PASSING  1080       _dbus_warn (
"error: parse with wrong signature: 'uashuu'.\n");
  1086   if (!dbus_message_iter_get_args (&iter, &error,
  1087                                    DBUS_TYPE_UINT32, &our_uint1,
  1089                                    &our_string_array1, &our_string_array_len1,
  1090 #ifdef HAVE_UNIX_FD_PASSING
  1091                                    DBUS_TYPE_UNIX_FD, &our_unix_fd1,
  1093                                    DBUS_TYPE_UINT32, &our_uint2,
  1095                                    &our_string_array2, &our_string_array_len2,
  1096 #ifdef HAVE_UNIX_FD_PASSING
  1097                                    DBUS_TYPE_UNIX_FD, &our_unix_fd2,
  1099                                    DBUS_TYPE_UINT32, &our_uint3,
  1102       _dbus_verbose (
"expected error: %s - %s\n", error.
name,
  1107 #ifdef HAVE_UNIX_FD_PASSING  1114       _dbus_warn (
"error: parse with wrong signature: 'uashuashu'.\n");
  1120   if (!dbus_message_iter_get_args (&iter, &error,
  1121                                    DBUS_TYPE_UINT32, &our_uint1,
  1123                                    &our_string_array1, &our_string_array_len1,
  1124 #ifdef HAVE_UNIX_FD_PASSING
  1125                                    DBUS_TYPE_UNIX_FD, &our_unix_fd1,
  1127                                    DBUS_TYPE_UINT32, &our_uint2,
  1129                                    &our_string_array2, &our_string_array_len2,
  1130 #ifdef HAVE_UNIX_FD_PASSING
  1131                                    DBUS_TYPE_UNIX_FD, &our_unix_fd2,
  1143 #ifdef HAVE_UNIX_FD_PASSING  1148   _dbus_check_fdleaks_leave (initial_fds);
  1158 _dbus_message_test (
const char *test_data_dir)
  1167   const dbus_uint32_t our_uint32_array[] =
  1168     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
  1169   const dbus_int32_t our_int32_array[] =
  1170     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
  1171   const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
  1172   const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
  1173   const dbus_uint64_t our_uint64_array[] =
  1174     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
  1175   const dbus_int64_t our_int64_array[] =
  1176     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
  1177   const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
  1178   const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
  1179   const char *our_string_array[] = { 
"Foo", 
"bar", 
"", 
"woo woo woo woo" };
  1180   const char *our_string_array1[] = { 
"foo", 
"Bar", 
"", 
"Woo woo Woo woo" };
  1181   const char **v_ARRAY_STRING = our_string_array;
  1182   const char **v1_ARRAY_STRING = our_string_array1;
  1183   const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
  1184   const double *v_ARRAY_DOUBLE = our_double_array;
  1185   const unsigned char our_byte_array[] = { 
'a', 
'b', 
'c', 234 };
  1186   const unsigned char *v_ARRAY_BYTE = our_byte_array;
  1188   const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
  1191   const char *v_STRING;
  1193   dbus_int16_t v_INT16;
  1194   dbus_uint16_t v_UINT16;
  1195   dbus_int32_t v_INT32;
  1196   dbus_uint32_t v_UINT32;
  1197   dbus_uint32_t v1_UINT32;
  1198   dbus_int64_t v_INT64;
  1199   dbus_uint64_t v_UINT64;
  1200   unsigned char v_BYTE;
  1201   unsigned char v2_BYTE;
  1204 #ifdef HAVE_UNIX_FD_PASSING  1209   DBusInitialFDs *initial_fds;
  1222   initial_fds = _dbus_check_fdleaks_enter ();
  1225                                           "/org/freedesktop/TestPath",
  1226                                           "Foo.TestInterface",
  1232                         "/org/freedesktop/TestPath") == 0);
  1243                                  _dbus_string_get_length (&message->
header.
data));
  1245                                  _dbus_string_get_length (&message->
body));
  1252                                  _dbus_string_get_length (&message->
header.
data));
  1254                                  _dbus_string_get_length (&message->
body));
  1294                         "org.Foo.Bar") == 0);
  1350                                           "/org/freedesktop/TestPath",
  1351                                           "Foo.TestInterface",
  1358   v_INT32 = -0x12345678;
  1359   v_UINT32 = 0x12300042;
  1360   v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
  1361   v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
  1362   v_STRING = 
"Test string";
  1367 #ifdef HAVE_UNIX_FD_PASSING  1376                             DBUS_TYPE_UINT32, &v_UINT32,
  1434 #ifdef HAVE_UNIX_FD_PASSING  1436                             DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
  1444   _dbus_verbose (
"HEADER\n");
  1446                                  _dbus_string_get_length (&message->
header.
data));
  1447   _dbus_verbose (
"BODY\n");
  1449                                  _dbus_string_get_length (&message->
body));
  1451   _dbus_verbose (
"Signature expected \"%s\" actual \"%s\"\n",
  1459   verify_test_message (message);
  1468                 _dbus_string_get_length (©->
header.
data));
  1471                 _dbus_string_get_length (©->
body));
  1473   verify_test_message (copy);
  1496   data = _dbus_string_get_const_data (&message->
header.
data);
  1497   for (i = 0; i < _dbus_string_get_length (&message->
header.
data); i++)
  1507   data = _dbus_string_get_const_data (&message->
body);
  1508   for (i = 0; i < _dbus_string_get_length (&message->
body); i++)
  1517 #ifdef HAVE_UNIX_FD_PASSING  1520     unsigned n_unix_fds;
  1554   verify_test_message (message_without_unix_fds);
  1561       char *marshalled = 
NULL;
  1576       verify_test_message (message2);
  1608   _dbus_check_fdleaks_leave (initial_fds);
  1609   initial_fds = _dbus_check_fdleaks_enter ();
  1612   for (i = strlen (basic_types) - 1; i > 0; i--)
  1618       signature[0] = basic_types[i];
  1619       s = 
"SomeThingToSay";
  1620       memset (&val, 
'\0', 
sizeof (val));
  1623         "/de/ende/test", 
"de.ende.Test", 
"ArtistName");
  1627                                         signature, &array_iter);
  1628       for (some = 0; some < 3; some++)
  1643       "/de/ende/test", 
"de.ende.Test", 
"ArtistName");
  1651                                     NULL, &struct_iter);
  1663                                           "/org/freedesktop/TestPath",
  1664                                           "Foo.TestInterface",
  1677                           NULL, &struct_iter);
  1692                                           "/org/freedesktop/TestPath",
  1693                                           "Foo.TestInterface",
  1698                             DBUS_TYPE_UINT32, &v_UINT32,
  1701 #ifdef HAVE_UNIX_FD_PASSING
  1702                             DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
  1704                             DBUS_TYPE_UINT32, &v1_UINT32,
  1707 #ifdef HAVE_UNIX_FD_PASSING
  1708                             DBUS_TYPE_UNIX_FD, &v1_UNIX_FD,
  1717 #ifdef HAVE_UNIX_FD_PASSING  1723 #ifdef HAVE_UNIX_FD_PASSING  1730   verify_test_message_args_ignored (message);
  1731   verify_test_message_memleak (message);
  1737     DBusMessageDataIter diter;
  1738     DBusMessageData mdata;
  1741     reset_validities_seen ();
  1744     _dbus_message_data_iter_init (&diter);
  1746     while (_dbus_message_data_iter_get_and_next (&diter,
  1749         if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
  1750                                                         mdata.expected_validity))
  1752             _dbus_warn (
"expected validity %d and did not get it\n",
  1753                         mdata.expected_validity);
  1757         _dbus_message_data_free (&mdata);
  1762     printf (
"%d sample messages tested\n", count);
  1764     print_validities_seen (FALSE);
  1765     print_validities_seen (
TRUE);
  1769   _dbus_check_fdleaks_leave (initial_fds);
  1772   if (test_data_dir == 
NULL)
  1775   initial_fds = _dbus_check_fdleaks_enter ();
  1777   if (!dbus_internal_do_not_use_foreach_message_file (test_data_dir,
  1778                                                         (DBusForeachMessageFileFunc)
  1779                                                         dbus_internal_do_not_use_try_message_file,
  1783   _dbus_check_fdleaks_leave (initial_fds);
 #define DBUS_TYPE_UINT16
Type code marking a 16-bit unsigned integer. 
void dbus_message_lock(DBusMessage *message)
Locks a message. 
const char * message
public error message field 
#define NULL
A null pointer, defined appropriately for C or C++. 
dbus_bool_t dbus_message_is_method_call(DBusMessage *message, const char *iface, const char *method)
Checks whether the message is a method call with the given interface and member fields. 
DBUS_PRIVATE_EXPORT long _dbus_message_loader_get_max_message_size(DBusMessageLoader *loader)
Gets the maximum allowed message size in bytes. 
void dbus_message_set_no_reply(DBusMessage *message, dbus_bool_t no_reply)
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. 
int dbus_message_iter_get_arg_type(DBusMessageIter *iter)
Returns the argument type of the argument that the message iterator points to. 
DBUS_PRIVATE_EXPORT void _dbus_message_loader_return_buffer(DBusMessageLoader *loader, DBusString *buffer)
Returns a buffer obtained from _dbus_message_loader_get_buffer(), indicating to the loader how many b...
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0(). 
DBUS_PRIVATE_EXPORT void _dbus_message_loader_return_unix_fds(DBusMessageLoader *loader, int *fds, unsigned n_fds)
Returns a buffer obtained from _dbus_message_loader_get_unix_fds(). 
dbus_uint32_t dbus_message_get_serial(DBusMessage *message)
Returns the serial of a message or 0 if none has been specified. 
#define DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_STRUCT_BEGIN_CHAR as a string literal instead of a int literal 
void dbus_message_iter_recurse(DBusMessageIter *iter, DBusMessageIter *sub)
Recurses into a container value when reading values from a message, initializing a sub-iterator to us...
DBUS_PRIVATE_EXPORT DBusMessage * _dbus_message_loader_pop_message(DBusMessageLoader *loader)
Pops a loaded message (passing ownership of the message to the caller). 
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...
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_TYPE_STRUCT
STRUCT and DICT_ENTRY are sort of special since their codes can't appear in a type string...
void _dbus_directory_close(DBusDirIter *iter)
Closes a directory iteration. 
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_message_iter_get_args_valist(DBusMessageIter *iter, DBusError *error, int first_arg_type, va_list var_args)
Implementation of the varargs arg-getting functions. 
#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. 
dbus_bool_t _dbus_directory_get_next_file(DBusDirIter *iter, DBusString *filename, DBusError *error)
Get next file in the directory. 
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack. 
const char * dbus_message_get_signature(DBusMessage *message)
Gets the type signature of the message, i.e. 
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message. 
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
#define DBUS_TYPE_BYTE
Type code marking an 8-bit unsigned integer. 
dbus_bool_t _dbus_file_get_contents(DBusString *str, const DBusString *filename, DBusError *error)
Appends the contents of the given file to the string, returning error code. 
DBUS_PRIVATE_EXPORT void _dbus_message_loader_unref(DBusMessageLoader *loader)
Decrements the reference count of the loader and finalizes the loader when the count reaches zero...
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory. 
const char * dbus_message_get_path(DBusMessage *message)
Gets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitt...
DBusDirIter * _dbus_directory_open(const DBusString *filename, DBusError *error)
Open a directory to iterate over. 
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string. 
int _dbus_dup(int fd, DBusError *error)
Duplicates a file descriptor. 
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...
DBusValidity
This is primarily used in unit testing, so we can verify that each invalid message is invalid for the...
DBusMessageIter struct; contains no public fields. 
#define DBUS_TYPE_DOUBLE
Type code marking an 8-byte double in IEEE 754 format. 
dbus_bool_t dbus_message_iter_init(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for reading the arguments of the message passed in. ...
dbus_bool_t _dbus_string_ends_with_c_str(const DBusString *a, const char *c_str)
Returns whether a string ends with the given suffix. 
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type. 
#define DBUS_TYPE_INT64
Type code marking a 64-bit signed integer. 
Internals of directory iterator. 
const char * dbus_message_get_member(DBusMessage *message)
Gets the interface member being invoked (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted (DBUS_MESSAGE_TYPE...
Internals of DBusMessage. 
#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. 
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string. 
DBusHeader header
Header network data and associated cache. 
dbus_bool_t dbus_message_set_sender(DBusMessage *message, const char *sender)
Sets the message sender. 
DBusString data
Buffered data. 
DBUS_PRIVATE_EXPORT DBusMessageLoader * _dbus_message_loader_ref(DBusMessageLoader *loader)
Increments the reference count of the loader. 
dbus_bool_t dbus_message_get_path_decomposed(DBusMessage *message, char ***path)
Gets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitt...
void _dbus_warn(const char *format,...)
Prints a warning message to stderr. 
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. 
DBUS_PRIVATE_EXPORT DBusMessageLoader * _dbus_message_loader_new(void)
Creates a new message loader. 
Object representing an exception. 
int dbus_message_iter_get_element_count(DBusMessageIter *iter)
Returns the number of elements in the array-typed value pointed to by the iterator. 
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. 
dbus_uint32_t dbus_message_get_reply_serial(DBusMessage *message)
Returns the serial that the message is a reply to or 0 if none. 
dbus_bool_t dbus_message_has_signature(DBusMessage *message, const char *signature)
Checks whether the message has the given signature; see dbus_message_get_signature() for more details...
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_message_loader_get_is_corrupted(DBusMessageLoader *loader)
Checks whether the loader is confused due to bad data. 
#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_message_has_destination(DBusMessage *message, const char *name)
Checks whether the message was sent to the given name. 
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory. 
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(). 
#define TRUE
Expands to "1". 
dbus_bool_t dbus_message_marshal(DBusMessage *msg, char **marshalled_data_p, int *len_p)
Turn a DBusMessage into the marshalled form as described in the D-Bus specification. 
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called. 
DBusMessage * dbus_message_copy(const DBusMessage *message)
Creates a new message that is an exact replica of the message specified, except that its refcount is ...
int dbus_message_iter_get_element_type(DBusMessageIter *iter)
Returns the element type of the array that the message iterator points to. 
const char * name
public error name field 
DBusMessage * dbus_message_demarshal(const char *str, int len, DBusError *error)
Demarshal a D-Bus message from the format described in the D-Bus specification. 
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor. 
const char * dbus_message_get_interface(DBusMessage *message)
Gets the interface this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitted...
#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). 
dbus_bool_t dbus_message_has_sender(DBusMessage *message, const char *name)
Checks whether the message has the given unique name as its sender. 
dbus_bool_t dbus_message_iter_next(DBusMessageIter *iter)
Moves the iterator to the next field, if any. 
dbus_bool_t dbus_message_get_no_reply(DBusMessage *message)
Returns TRUE if the message does not expect a reply. 
#define DBUS_TYPE_INT16
Type code marking a 16-bit signed integer. 
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_message_loader_get_unix_fds(DBusMessageLoader *loader, int **fds, unsigned *max_n_fds)
Gets the buffer to use for reading unix fds from the network. 
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings. 
#define DBUS_TYPE_BOOLEAN
Type code marking a boolean. 
DBUS_PRIVATE_EXPORT void _dbus_message_loader_get_buffer(DBusMessageLoader *loader, DBusString **buffer)
Gets the buffer to use for reading data from the network. 
#define DBUS_STRUCT_END_CHAR_AS_STRING
DBUS_STRUCT_END_CHAR a string literal instead of a int literal 
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; you are required to append the contents of the contai...
A simple value union that lets you access bytes as if they were various types; useful when dealing wi...
#define DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_STRING as a string literal instead of a int literal 
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message. 
dbus_bool_t _dbus_close(int fd, DBusError *error)
Closes a file descriptor. 
void dbus_shutdown(void)
Frees all memory allocated internally by libdbus and reverses the effects of dbus_threads_init(). 
#define FALSE
Expands to "0". 
int dbus_message_demarshal_bytes_needed(const char *buf, int len)
Returns the number of bytes required to be in the buffer to demarshal a D-Bus message. 
void dbus_message_iter_abandon_container(DBusMessageIter *iter, DBusMessageIter *sub)
Abandons creation of a contained-typed value and frees resources created by dbus_message_iter_open_co...
DBUS_PRIVATE_EXPORT void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log. 
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_message_loader_queue_messages(DBusMessageLoader *loader)
Converts buffered data into messages, if we have enough data. 
char * _dbus_strdup(const char *str)
Duplicates a string. 
DBusValidity corruption_reason
why we were corrupted 
dbus_bool_t dbus_message_set_member(DBusMessage *message, const char *member)
Sets the interface member being invoked (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted (DBUS_MESSAGE_TYPE...
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0...
Implementation details of DBusMessageLoader. 
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set). 
#define _DBUS_DOUBLES_BITWISE_EQUAL(a, b)
On x86 there is an 80-bit FPU, and if you do "a == b" it may have a or b in an 80-bit register...
void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
Sets the serial number of a message.