static DBusHandlerResult
filter_func(DBusConnection *conn, DBusMessage *bus_msg, void *data)
{
const char *method = dbus_message_get_member(bus_msg);
const char *iface = dbus_message_get_interface(bus_msg);
const char *sender = dbus_message_get_sender(bus_msg);
const char *path = dbus_message_get_path(bus_msg);
PyObject *py_args = pydbus_import(bus_msg);
if (!dbus_message_has_destination(bus_msg, config_unique_address)
&& strncmp(dbus_message_get_destination(bus_msg), DBUS_SERVICE_NAME, strlen(DBUS_SERVICE_NAME))) {
return DBUS_HANDLER_RESULT_HANDLED;
}
switch (dbus_message_get_type(bus_msg)) {
case DBUS_MESSAGE_TYPE_METHOD_CALL:
if (my_proc.nr_children > MAX_PROC) {
// Busy
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
else {
log_debug("Got message '%s.%s' from '%s'\n", iface, method, sender);
if (strcmp(config_interface, iface) == 0 && strcmp(path, "/") == 0) {
// "setLocale" and "cancel" methods are handled in main process
if (strcmp(method, "setLocale") == 0 || strcmp(method, "cancel") == 0 || strcmp(method, "listRunning") == 0) {
handle_core_message(bus_msg, path, iface, method, sender, py_args);
}
else {
// Else, handle in child process
proc_fork(handle_message, bus_msg);
}
}
else {
// Else, handle in child process
proc_fork(handle_message, bus_msg);
}
break;
}
case DBUS_MESSAGE_TYPE_SIGNAL:
log_debug("Got signal '%s.%s' from '%s'\n", iface, method, sender);
break;
}
return DBUS_HANDLER_RESULT_HANDLED;
}
/**
* @ingroup DBusMessageInternals
* Unit test for DBusMessage.
*
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_message_test (const char *test_data_dir)
{
DBusMessage *message, *message_without_unix_fds;
DBusMessageLoader *loader;
int i;
const char *data;
DBusMessage *copy;
const char *name1;
const char *name2;
const dbus_uint32_t our_uint32_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int32_t our_int32_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
#ifdef DBUS_HAVE_INT64
const dbus_uint64_t our_uint64_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int64_t our_int64_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
#endif
const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
const char **v_ARRAY_STRING = our_string_array;
const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
const double *v_ARRAY_DOUBLE = our_double_array;
const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
const unsigned char *v_ARRAY_BYTE = our_byte_array;
const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
char sig[64];
const char *s;
const char *v_STRING;
double v_DOUBLE;
dbus_int16_t v_INT16;
dbus_uint16_t v_UINT16;
dbus_int32_t v_INT32;
dbus_uint32_t v_UINT32;
#ifdef DBUS_HAVE_INT64
dbus_int64_t v_INT64;
dbus_uint64_t v_UINT64;
#endif
unsigned char v_BYTE;
unsigned char v2_BYTE;
dbus_bool_t v_BOOLEAN;
DBusMessageIter iter, array_iter, struct_iter;
#ifdef HAVE_UNIX_FD_PASSING
int v_UNIX_FD;
#endif
char **decomposed;
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
"TestMethod"));
_dbus_assert (strcmp (dbus_message_get_path (message),
"/org/freedesktop/TestPath") == 0);
dbus_message_set_serial (message, 1234);
/* string length including nul byte not a multiple of 4 */
if (!dbus_message_set_sender (message, "org.foo.bar1"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
dbus_message_set_reply_serial (message, 5678);
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
if (!dbus_message_set_sender (message, NULL))
_dbus_assert_not_reached ("out of memory");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
_dbus_assert (dbus_message_get_serial (message) == 1234);
_dbus_assert (dbus_message_get_reply_serial (message) == 5678);
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
dbus_message_set_no_reply (message, TRUE);
_dbus_assert (dbus_message_get_no_reply (message) == TRUE);
dbus_message_set_no_reply (message, FALSE);
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
/* Set/get some header fields */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Set/get them with longer values */
if (!dbus_message_set_path (message, "/foo/bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo/bar") == 0);
if (!dbus_message_set_interface (message, "org.Foo.Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo.Bar") == 0);
if (!dbus_message_set_member (message, "BarFoo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"BarFoo") == 0);
/* Realloc shorter again */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Path decomposing */
dbus_message_set_path (message, NULL);
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (decomposed[0] == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/a/b");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (strcmp (decomposed[0], "a") == 0);
_dbus_assert (strcmp (decomposed[1], "b") == 0);
_dbus_assert (decomposed[2] == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/spam/eggs");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (strcmp (decomposed[0], "spam") == 0);
_dbus_assert (strcmp (decomposed[1], "eggs") == 0);
_dbus_assert (decomposed[2] == NULL);
dbus_free_string_array (decomposed);
dbus_message_unref (message);
/* Test the vararg functions */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
dbus_message_set_serial (message, 1);
dbus_message_set_reply_serial (message, 5678);
v_INT16 = -0x123;
v_UINT16 = 0x123;
v_INT32 = -0x12345678;
v_UINT32 = 0x12300042;
#ifdef DBUS_HAVE_INT64
v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
#endif
v_STRING = "Test string";
v_DOUBLE = 3.14159;
v_BOOLEAN = TRUE;
v_BYTE = 42;
v2_BYTE = 24;
#ifdef HAVE_UNIX_FD_PASSING
v_UNIX_FD = 1;
#endif
dbus_message_append_args (message,
DBUS_TYPE_INT16, &v_INT16,
DBUS_TYPE_UINT16, &v_UINT16,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_UINT32, &v_UINT32,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_INT64, &v_INT64,
DBUS_TYPE_UINT64, &v_UINT64,
#endif
DBUS_TYPE_STRING, &v_STRING,
DBUS_TYPE_DOUBLE, &v_DOUBLE,
DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
DBUS_TYPE_BYTE, &v_BYTE,
DBUS_TYPE_BYTE, &v2_BYTE,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
_DBUS_N_ELEMENTS (our_uint32_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
_DBUS_N_ELEMENTS (our_int32_array),
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
_DBUS_N_ELEMENTS (our_uint64_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
_DBUS_N_ELEMENTS (our_int64_array),
#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
_DBUS_N_ELEMENTS (our_double_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
_DBUS_N_ELEMENTS (our_byte_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
_DBUS_N_ELEMENTS (our_boolean_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
_DBUS_N_ELEMENTS (our_string_array),
DBUS_TYPE_INVALID);
i = 0;
sig[i++] = DBUS_TYPE_INT16;
sig[i++] = DBUS_TYPE_UINT16;
sig[i++] = DBUS_TYPE_INT32;
sig[i++] = DBUS_TYPE_UINT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_INT64;
sig[i++] = DBUS_TYPE_UINT64;
#endif
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT32;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT64;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT64;
#endif
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_STRING;
message_without_unix_fds = dbus_message_copy(message);
_dbus_assert(message_without_unix_fds);
#ifdef HAVE_UNIX_FD_PASSING
dbus_message_append_args (message,
DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
DBUS_TYPE_INVALID);
sig[i++] = DBUS_TYPE_UNIX_FD;
#endif
sig[i++] = DBUS_TYPE_INVALID;
_dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
_dbus_verbose ("HEADER\n");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose ("BODY\n");
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
sig, dbus_message_get_signature (message));
s = dbus_message_get_signature (message);
_dbus_assert (dbus_message_has_signature (message, sig));
_dbus_assert (strcmp (s, sig) == 0);
verify_test_message (message);
copy = dbus_message_copy (message);
_dbus_assert (dbus_message_get_reply_serial (message) ==
dbus_message_get_reply_serial (copy));
_dbus_assert (message->header.padding == copy->header.padding);
_dbus_assert (_dbus_string_get_length (&message->header.data) ==
_dbus_string_get_length (©->header.data));
_dbus_assert (_dbus_string_get_length (&message->body) ==
_dbus_string_get_length (©->body));
verify_test_message (copy);
name1 = dbus_message_get_interface (message);
name2 = dbus_message_get_interface (copy);
_dbus_assert (strcmp (name1, name2) == 0);
name1 = dbus_message_get_member (message);
name2 = dbus_message_get_member (copy);
_dbus_assert (strcmp (name1, name2) == 0);
dbus_message_unref (copy);
/* Message loader test */
dbus_message_lock (message);
loader = _dbus_message_loader_new ();
/* check ref/unref */
_dbus_message_loader_ref (loader);
_dbus_message_loader_unref (loader);
/* Write the header data one byte at a time */
data = _dbus_string_get_const_data (&message->header.data);
for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
/* Write the body data one byte at a time */
data = _dbus_string_get_const_data (&message->body);
for (i = 0; i < _dbus_string_get_length (&message->body); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
#ifdef HAVE_UNIX_FD_PASSING
{
int *unix_fds;
unsigned n_unix_fds;
/* Write unix fd */
_dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds);
_dbus_assert(n_unix_fds > 0);
_dbus_assert(message->n_unix_fds == 1);
unix_fds[0] = _dbus_dup(message->unix_fds[0], NULL);
_dbus_assert(unix_fds[0] >= 0);
_dbus_message_loader_return_unix_fds(loader, unix_fds, 1);
}
#endif
dbus_message_unref (message);
/* Now pop back the message */
if (!_dbus_message_loader_queue_messages (loader))
_dbus_assert_not_reached ("no memory to queue messages");
if (_dbus_message_loader_get_is_corrupted (loader))
_dbus_assert_not_reached ("message loader corrupted");
message = _dbus_message_loader_pop_message (loader);
if (!message)
_dbus_assert_not_reached ("received a NULL message");
if (dbus_message_get_reply_serial (message) != 5678)
_dbus_assert_not_reached ("reply serial fields differ");
dbus_message_unref (message);
/* ovveride the serial, since it was reset by dbus_message_copy() */
dbus_message_set_serial(message_without_unix_fds, 8901);
dbus_message_lock (message_without_unix_fds);
verify_test_message (message_without_unix_fds);
{
/* Marshal and demarshal the message. */
DBusMessage *message2;
DBusError error = DBUS_ERROR_INIT;
char *marshalled = NULL;
int len = 0;
char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx";
if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len))
_dbus_assert_not_reached ("failed to marshal message");
_dbus_assert (len != 0);
_dbus_assert (marshalled != NULL);
_dbus_assert (dbus_message_demarshal_bytes_needed (marshalled, len) == len);
message2 = dbus_message_demarshal (marshalled, len, &error);
_dbus_assert (message2 != NULL);
_dbus_assert (!dbus_error_is_set (&error));
verify_test_message (message2);
dbus_message_unref (message2);
dbus_free (marshalled);
/* Demarshal invalid message. */
message2 = dbus_message_demarshal ("invalid", 7, &error);
_dbus_assert (message2 == NULL);
_dbus_assert (dbus_error_is_set (&error));
dbus_error_free (&error);
/* Demarshal invalid (empty) message. */
message2 = dbus_message_demarshal ("", 0, &error);
_dbus_assert (message2 == NULL);
_dbus_assert (dbus_error_is_set (&error));
dbus_error_free (&error);
/* Bytes needed to demarshal empty message: 0 (more) */
_dbus_assert (dbus_message_demarshal_bytes_needed ("", 0) == 0);
/* Bytes needed to demarshal invalid message: -1 (error). */
_dbus_assert (dbus_message_demarshal_bytes_needed (garbage_header, DBUS_MINIMUM_HEADER_SIZE) == -1);
}
dbus_message_unref (message_without_unix_fds);
_dbus_message_loader_unref (loader);
check_memleaks ();
_dbus_check_fdleaks();
/* Check that we can abandon a container */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"Method");
dbus_message_iter_init_append (message, &iter);
_dbus_assert (dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
(DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING),
&array_iter));
_dbus_assert (dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT,
NULL, &struct_iter));
s = "peaches";
_dbus_assert (dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING,
&s));
/* uh-oh, error, try and unwind */
dbus_message_iter_abandon_container (&array_iter, &struct_iter);
dbus_message_iter_abandon_container (&array_iter, &iter);
dbus_message_unref (message);
/* Load all the sample messages from the message factory */
{
DBusMessageDataIter diter;
DBusMessageData mdata;
int count;
reset_validities_seen ();
count = 0;
_dbus_message_data_iter_init (&diter);
while (_dbus_message_data_iter_get_and_next (&diter,
&mdata))
{
if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
mdata.expected_validity))
{
_dbus_warn ("expected validity %d and did not get it\n",
mdata.expected_validity);
_dbus_assert_not_reached ("message data failed");
}
_dbus_message_data_free (&mdata);
count += 1;
}
printf ("%d sample messages tested\n", count);
print_validities_seen (FALSE);
print_validities_seen (TRUE);
}
check_memleaks ();
_dbus_check_fdleaks();
/* Now load every message in test_data_dir if we have one */
if (test_data_dir == NULL)
return TRUE;
return dbus_internal_do_not_use_foreach_message_file (test_data_dir,
(DBusForeachMessageFileFunc)
dbus_internal_do_not_use_try_message_file,
NULL);
}
/**
* @ingroup DBusMessageInternals
* Unit test for DBusMessage.
*
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_message_test (const char *test_data_dir)
{
DBusMessage *message;
DBusMessageLoader *loader;
int i;
const char *data;
DBusMessage *copy;
const char *name1;
const char *name2;
const dbus_uint32_t our_uint32_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int32_t our_int32_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
#ifdef DBUS_HAVE_INT64
const dbus_uint64_t our_uint64_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int64_t our_int64_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
#endif
const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
const char **v_ARRAY_STRING = our_string_array;
const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
const double *v_ARRAY_DOUBLE = our_double_array;
const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
const unsigned char *v_ARRAY_BYTE = our_byte_array;
const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
char sig[64];
const char *s;
const char *v_STRING;
double v_DOUBLE;
dbus_int16_t v_INT16;
dbus_uint16_t v_UINT16;
dbus_int32_t v_INT32;
dbus_uint32_t v_UINT32;
#ifdef DBUS_HAVE_INT64
dbus_int64_t v_INT64;
dbus_uint64_t v_UINT64;
#endif
unsigned char v_BYTE;
unsigned char v2_BYTE;
dbus_bool_t v_BOOLEAN;
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
"TestMethod"));
_dbus_assert (strcmp (dbus_message_get_path (message),
"/org/freedesktop/TestPath") == 0);
_dbus_message_set_serial (message, 1234);
/* string length including nul byte not a multiple of 4 */
if (!dbus_message_set_sender (message, "org.foo.bar1"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
dbus_message_set_reply_serial (message, 5678);
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
if (!dbus_message_set_sender (message, NULL))
_dbus_assert_not_reached ("out of memory");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
_dbus_assert (dbus_message_get_serial (message) == 1234);
_dbus_assert (dbus_message_get_reply_serial (message) == 5678);
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
dbus_message_set_no_reply (message, TRUE);
_dbus_assert (dbus_message_get_no_reply (message) == TRUE);
dbus_message_set_no_reply (message, FALSE);
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
/* Set/get some header fields */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Set/get them with longer values */
if (!dbus_message_set_path (message, "/foo/bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo/bar") == 0);
if (!dbus_message_set_interface (message, "org.Foo.Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo.Bar") == 0);
if (!dbus_message_set_member (message, "BarFoo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"BarFoo") == 0);
/* Realloc shorter again */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
dbus_message_unref (message);
/* Test the vararg functions */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
_dbus_message_set_serial (message, 1);
dbus_message_set_reply_serial (message, 5678);
v_INT16 = -0x123;
v_UINT16 = 0x123;
v_INT32 = -0x12345678;
v_UINT32 = 0x12300042;
#ifdef DBUS_HAVE_INT64
v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
#endif
v_STRING = "Test string";
v_DOUBLE = 3.14159;
v_BOOLEAN = TRUE;
v_BYTE = 42;
v2_BYTE = 24;
dbus_message_append_args (message,
DBUS_TYPE_INT16, &v_INT16,
DBUS_TYPE_UINT16, &v_UINT16,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_UINT32, &v_UINT32,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_INT64, &v_INT64,
DBUS_TYPE_UINT64, &v_UINT64,
#endif
DBUS_TYPE_STRING, &v_STRING,
DBUS_TYPE_DOUBLE, &v_DOUBLE,
DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
DBUS_TYPE_BYTE, &v_BYTE,
DBUS_TYPE_BYTE, &v2_BYTE,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
_DBUS_N_ELEMENTS (our_uint32_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
_DBUS_N_ELEMENTS (our_int32_array),
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
_DBUS_N_ELEMENTS (our_uint64_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
_DBUS_N_ELEMENTS (our_int64_array),
#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
_DBUS_N_ELEMENTS (our_double_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
_DBUS_N_ELEMENTS (our_byte_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
_DBUS_N_ELEMENTS (our_boolean_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
_DBUS_N_ELEMENTS (our_string_array),
DBUS_TYPE_INVALID);
i = 0;
sig[i++] = DBUS_TYPE_INT16;
sig[i++] = DBUS_TYPE_UINT16;
sig[i++] = DBUS_TYPE_INT32;
sig[i++] = DBUS_TYPE_UINT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_INT64;
sig[i++] = DBUS_TYPE_UINT64;
#endif
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT32;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT64;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT64;
#endif
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_INVALID;
_dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
_dbus_verbose ("HEADER\n");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose ("BODY\n");
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
sig, dbus_message_get_signature (message));
s = dbus_message_get_signature (message);
_dbus_assert (dbus_message_has_signature (message, sig));
_dbus_assert (strcmp (s, sig) == 0);
verify_test_message (message);
copy = dbus_message_copy (message);
_dbus_assert (dbus_message_get_reply_serial (message) ==
dbus_message_get_reply_serial (copy));
_dbus_assert (message->header.padding == copy->header.padding);
_dbus_assert (_dbus_string_get_length (&message->header.data) ==
_dbus_string_get_length (©->header.data));
_dbus_assert (_dbus_string_get_length (&message->body) ==
_dbus_string_get_length (©->body));
verify_test_message (copy);
name1 = dbus_message_get_interface (message);
name2 = dbus_message_get_interface (copy);
_dbus_assert (strcmp (name1, name2) == 0);
name1 = dbus_message_get_member (message);
name2 = dbus_message_get_member (copy);
_dbus_assert (strcmp (name1, name2) == 0);
dbus_message_unref (copy);
/* Message loader test */
_dbus_message_lock (message);
loader = _dbus_message_loader_new ();
/* check ref/unref */
_dbus_message_loader_ref (loader);
_dbus_message_loader_unref (loader);
/* Write the header data one byte at a time */
data = _dbus_string_get_const_data (&message->header.data);
for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
/* Write the body data one byte at a time */
data = _dbus_string_get_const_data (&message->body);
for (i = 0; i < _dbus_string_get_length (&message->body); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
dbus_message_unref (message);
/* Now pop back the message */
if (!_dbus_message_loader_queue_messages (loader))
_dbus_assert_not_reached ("no memory to queue messages");
if (_dbus_message_loader_get_is_corrupted (loader))
_dbus_assert_not_reached ("message loader corrupted");
message = _dbus_message_loader_pop_message (loader);
if (!message)
_dbus_assert_not_reached ("received a NULL message");
if (dbus_message_get_reply_serial (message) != 5678)
_dbus_assert_not_reached ("reply serial fields differ");
verify_test_message (message);
dbus_message_unref (message);
_dbus_message_loader_unref (loader);
check_memleaks ();
/* Load all the sample messages from the message factory */
{
DBusMessageDataIter diter;
DBusMessageData mdata;
int count;
reset_validities_seen ();
count = 0;
_dbus_message_data_iter_init (&diter);
while (_dbus_message_data_iter_get_and_next (&diter,
&mdata))
{
if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
mdata.expected_validity))
{
_dbus_warn ("expected validity %d and did not get it\n",
mdata.expected_validity);
_dbus_assert_not_reached ("message data failed");
}
_dbus_message_data_free (&mdata);
count += 1;
}
printf ("%d sample messages tested\n", count);
print_validities_seen (FALSE);
print_validities_seen (TRUE);
}
check_memleaks ();
/* Now load every message in test_data_dir if we have one */
if (test_data_dir == NULL)
return TRUE;
return dbus_internal_do_not_use_foreach_message_file (test_data_dir,
(DBusForeachMessageFileFunc)
dbus_internal_do_not_use_try_message_file,
NULL);
}