mirror of
https://gitlab.freedesktop.org/dbus/dbus.git
synced 2025-12-24 22:50:08 +01:00
c1091cbbd2
* bus/services.c (bus_service_list_queued_owners):
Add a pointer cast to fix compiler warning
* dbus/dbus-dataslot.c (_dbus_data_slot_list_get):
return a NULL instead of FALSE since the return type
is not expecting a boolean
* dbus/dbus-marshal-basic.c (_dbus_marshal_test):
Remove unused variable
* dbus/dbus-marshal-recursive-util.c (node_new):
return a NULL instead of FALSE since the return type
is not expecting a boolean
* dbus/dbus-server-debug-pipe.c (_dbus_transport_debug_pipe_new):
Send a NULL into _dbus_transport_new_for_fd instead of a FALSE
because we are expecting a pointer not a boolean
* dbus/dbus-sysdeps-util.c (_dbus_get_tmpdir):
add void as the parameter so some compilers
don't complain
* dbus/dbus-transport-unix.c (_dbus_transport_new_for_domain_socket,
_dbus_transport_new_for_tcp_socket):
Send a NULL into _dbus_transport_new_for_fd instead of a FALSE
because we are expecting a pointer not a boolean
* test/shell-test.c (test_command_line):
cast the second argument to _dbus_list_append to avoid compiler
warnings
* test/test-names.c (main): remove unused variable
* test/test-service.c (check_hello_from_self_reply):
Initialize echo_message and echo_reply to NULL
* test/test-shell-service.c (handle_echo):
Remove unused variable and cast the third parameter passed to
dbus_connection_get_object_path_data to avoid compiler warrnings
* test/name-test/test-names.c (clear_message_queue):
Remove unused function
* test/name-test/test-pending-call-dispatch.c:
Fix format string in printf
401 lines
11 KiB
C
401 lines
11 KiB
C
|
|
#include "test-utils.h"
|
|
|
|
static DBusLoop *loop;
|
|
static dbus_bool_t already_quit = FALSE;
|
|
static dbus_bool_t hello_from_self_reply_recived = FALSE;
|
|
|
|
static void
|
|
quit (void)
|
|
{
|
|
if (!already_quit)
|
|
{
|
|
_dbus_loop_quit (loop);
|
|
already_quit = TRUE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
die (const char *message)
|
|
{
|
|
fprintf (stderr, "*** test-service: %s", message);
|
|
exit (1);
|
|
}
|
|
|
|
static void
|
|
check_hello_from_self_reply (DBusPendingCall *pcall,
|
|
void *user_data)
|
|
{
|
|
DBusMessage *reply;
|
|
DBusMessage *echo_message, *echo_reply = NULL;
|
|
DBusError error;
|
|
DBusConnection *connection;
|
|
|
|
int type;
|
|
|
|
dbus_error_init (&error);
|
|
|
|
connection = dbus_bus_get (DBUS_BUS_STARTER, &error);
|
|
if (connection == NULL)
|
|
{
|
|
fprintf (stderr, "*** Failed to open connection to activating message bus: %s\n",
|
|
error.message);
|
|
dbus_error_free (&error);
|
|
die("no memory");
|
|
}
|
|
|
|
|
|
echo_message = (DBusMessage *)user_data;
|
|
|
|
reply = dbus_pending_call_steal_reply (pcall);
|
|
|
|
type = dbus_message_get_type (reply);
|
|
|
|
if (type == DBUS_MESSAGE_TYPE_METHOD_RETURN)
|
|
{
|
|
const char *s;
|
|
printf ("Reply from HelloFromSelf recived\n");
|
|
|
|
if (!dbus_message_get_args (echo_message,
|
|
&error,
|
|
DBUS_TYPE_STRING, &s,
|
|
DBUS_TYPE_INVALID))
|
|
{
|
|
echo_reply = dbus_message_new_error (echo_message,
|
|
error.name,
|
|
error.message);
|
|
|
|
if (echo_reply == NULL)
|
|
die ("No memory\n");
|
|
|
|
}
|
|
else
|
|
{
|
|
echo_reply = dbus_message_new_method_return (echo_message);
|
|
if (echo_reply == NULL)
|
|
die ("No memory\n");
|
|
|
|
if (!dbus_message_append_args (echo_reply,
|
|
DBUS_TYPE_STRING, &s,
|
|
DBUS_TYPE_INVALID))
|
|
die ("No memory");
|
|
}
|
|
|
|
if (!dbus_connection_send (connection, echo_reply, NULL))
|
|
die ("No memory\n");
|
|
|
|
dbus_message_unref (echo_reply);
|
|
}
|
|
else if (type == DBUS_MESSAGE_TYPE_ERROR)
|
|
{
|
|
dbus_set_error_from_message (&error, reply);
|
|
printf ("Error type in reply: %s\n", error.message);
|
|
|
|
if (strcmp (error.name, DBUS_ERROR_NO_MEMORY) != 0)
|
|
{
|
|
echo_reply = dbus_message_new_error (echo_reply,
|
|
error.name,
|
|
error.message);
|
|
|
|
if (echo_reply == NULL)
|
|
die ("No memory\n");
|
|
|
|
if (!dbus_connection_send (connection, echo_reply, NULL))
|
|
die ("No memory\n");
|
|
|
|
dbus_message_unref (echo_reply);
|
|
}
|
|
dbus_error_free (&error);
|
|
}
|
|
else
|
|
_dbus_assert_not_reached ("Unexpected message recived\n");
|
|
|
|
hello_from_self_reply_recived = TRUE;
|
|
|
|
dbus_message_unref (reply);
|
|
dbus_message_unref (echo_message);
|
|
dbus_pending_call_unref (pcall);
|
|
}
|
|
|
|
static DBusHandlerResult
|
|
handle_run_hello_from_self (DBusConnection *connection,
|
|
DBusMessage *message)
|
|
{
|
|
DBusError error;
|
|
DBusMessage *reply, *self_message;
|
|
DBusPendingCall *pcall;
|
|
char *s;
|
|
|
|
_dbus_verbose ("sending reply to Echo method\n");
|
|
|
|
dbus_error_init (&error);
|
|
|
|
if (!dbus_message_get_args (message,
|
|
&error,
|
|
DBUS_TYPE_STRING, &s,
|
|
DBUS_TYPE_INVALID))
|
|
{
|
|
reply = dbus_message_new_error (message,
|
|
error.name,
|
|
error.message);
|
|
|
|
if (reply == NULL)
|
|
die ("No memory\n");
|
|
|
|
if (!dbus_connection_send (connection, reply, NULL))
|
|
die ("No memory\n");
|
|
|
|
dbus_message_unref (reply);
|
|
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
printf ("Sending HelloFromSelf\n");
|
|
|
|
_dbus_verbose ("*** Sending message to self\n");
|
|
self_message = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteEchoService",
|
|
"/org/freedesktop/TestSuite",
|
|
"org.freedesktop.TestSuite",
|
|
"HelloFromSelf");
|
|
|
|
if (self_message == NULL)
|
|
die ("No memory");
|
|
|
|
if (!dbus_connection_send_with_reply (connection, self_message, &pcall, -1))
|
|
die("No memory");
|
|
|
|
dbus_message_ref (message);
|
|
if (!dbus_pending_call_set_notify (pcall, check_hello_from_self_reply, (void *)message, NULL))
|
|
die("No memory");
|
|
|
|
printf ("Sent HelloFromSelf\n");
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
|
|
static DBusHandlerResult
|
|
handle_echo (DBusConnection *connection,
|
|
DBusMessage *message)
|
|
{
|
|
DBusError error;
|
|
DBusMessage *reply;
|
|
char *s;
|
|
|
|
_dbus_verbose ("sending reply to Echo method\n");
|
|
|
|
dbus_error_init (&error);
|
|
|
|
if (!dbus_message_get_args (message,
|
|
&error,
|
|
DBUS_TYPE_STRING, &s,
|
|
DBUS_TYPE_INVALID))
|
|
{
|
|
reply = dbus_message_new_error (message,
|
|
error.name,
|
|
error.message);
|
|
|
|
if (reply == NULL)
|
|
die ("No memory\n");
|
|
|
|
if (!dbus_connection_send (connection, reply, NULL))
|
|
die ("No memory\n");
|
|
|
|
dbus_message_unref (reply);
|
|
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
reply = dbus_message_new_method_return (message);
|
|
if (reply == NULL)
|
|
die ("No memory\n");
|
|
|
|
if (!dbus_message_append_args (reply,
|
|
DBUS_TYPE_STRING, &s,
|
|
DBUS_TYPE_INVALID))
|
|
die ("No memory");
|
|
|
|
if (!dbus_connection_send (connection, reply, NULL))
|
|
die ("No memory\n");
|
|
|
|
fprintf (stderr, "Echo service echoed string: \"%s\"\n", s);
|
|
|
|
dbus_message_unref (reply);
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
|
|
static void
|
|
path_unregistered_func (DBusConnection *connection,
|
|
void *user_data)
|
|
{
|
|
/* connection was finalized */
|
|
}
|
|
|
|
static DBusHandlerResult
|
|
path_message_func (DBusConnection *connection,
|
|
DBusMessage *message,
|
|
void *user_data)
|
|
{
|
|
if (dbus_message_is_method_call (message,
|
|
"org.freedesktop.TestSuite",
|
|
"Echo"))
|
|
return handle_echo (connection, message);
|
|
else if (dbus_message_is_method_call (message,
|
|
"org.freedesktop.TestSuite",
|
|
"Exit"))
|
|
{
|
|
dbus_connection_close (connection);
|
|
quit ();
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
else if (dbus_message_is_method_call (message,
|
|
"org.freedesktop.TestSuite",
|
|
"EmitFoo"))
|
|
{
|
|
/* Emit the Foo signal */
|
|
DBusMessage *signal;
|
|
double v_DOUBLE;
|
|
|
|
_dbus_verbose ("emitting signal Foo\n");
|
|
|
|
signal = dbus_message_new_signal ("/org/freedesktop/TestSuite",
|
|
"org.freedesktop.TestSuite",
|
|
"Foo");
|
|
if (signal == NULL)
|
|
die ("No memory\n");
|
|
|
|
v_DOUBLE = 42.6;
|
|
if (!dbus_message_append_args (signal,
|
|
DBUS_TYPE_DOUBLE, &v_DOUBLE,
|
|
DBUS_TYPE_INVALID))
|
|
die ("No memory");
|
|
|
|
if (!dbus_connection_send (connection, signal, NULL))
|
|
die ("No memory\n");
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
|
|
else if (dbus_message_is_method_call (message,
|
|
"org.freedesktop.TestSuite",
|
|
"RunHelloFromSelf"))
|
|
{
|
|
return handle_run_hello_from_self (connection, message);
|
|
}
|
|
else if (dbus_message_is_method_call (message,
|
|
"org.freedesktop.TestSuite",
|
|
"HelloFromSelf"))
|
|
{
|
|
DBusMessage *reply;
|
|
printf ("Recived the HelloFromSelf message\n");
|
|
|
|
reply = dbus_message_new_method_return (message);
|
|
if (reply == NULL)
|
|
die ("No memory");
|
|
|
|
if (!dbus_connection_send (connection, reply, NULL))
|
|
die ("No memory");
|
|
}
|
|
else
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
static DBusObjectPathVTable
|
|
echo_vtable = {
|
|
path_unregistered_func,
|
|
path_message_func,
|
|
NULL,
|
|
};
|
|
|
|
|
|
static const char* echo_path = "/org/freedesktop/TestSuite" ;
|
|
|
|
static DBusHandlerResult
|
|
filter_func (DBusConnection *connection,
|
|
DBusMessage *message,
|
|
void *user_data)
|
|
{
|
|
if (dbus_message_is_signal (message,
|
|
DBUS_INTERFACE_LOCAL,
|
|
"Disconnected"))
|
|
{
|
|
dbus_connection_close (connection);
|
|
quit ();
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
else
|
|
{
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
}
|
|
|
|
int
|
|
main (int argc,
|
|
char **argv)
|
|
{
|
|
DBusError error;
|
|
int result;
|
|
DBusConnection *connection;
|
|
|
|
dbus_error_init (&error);
|
|
connection = dbus_bus_get (DBUS_BUS_STARTER, &error);
|
|
if (connection == NULL)
|
|
{
|
|
fprintf (stderr, "*** Failed to open connection to activating message bus: %s\n",
|
|
error.message);
|
|
dbus_error_free (&error);
|
|
return 1;
|
|
}
|
|
|
|
loop = _dbus_loop_new ();
|
|
if (loop == NULL)
|
|
die ("No memory\n");
|
|
|
|
if (!test_connection_setup (loop, connection))
|
|
die ("No memory\n");
|
|
|
|
if (!dbus_connection_add_filter (connection,
|
|
filter_func, NULL, NULL))
|
|
die ("No memory");
|
|
|
|
if (!dbus_connection_register_object_path (connection,
|
|
echo_path,
|
|
&echo_vtable,
|
|
(void*) 0xdeadbeef))
|
|
die ("No memory");
|
|
|
|
{
|
|
void *d;
|
|
if (!dbus_connection_get_object_path_data (connection, echo_path, &d))
|
|
die ("No memory");
|
|
if (d != (void*) 0xdeadbeef)
|
|
die ("dbus_connection_get_object_path_data() doesn't seem to work right\n");
|
|
}
|
|
|
|
result = dbus_bus_request_name (connection, "org.freedesktop.DBus.TestSuiteEchoService",
|
|
0, &error);
|
|
if (dbus_error_is_set (&error))
|
|
{
|
|
fprintf (stderr, "Error %s\n", error.message);
|
|
_dbus_verbose ("*** Failed to acquire service: %s\n",
|
|
error.message);
|
|
dbus_error_free (&error);
|
|
exit (1);
|
|
}
|
|
|
|
_dbus_verbose ("*** Test service entering main loop\n");
|
|
_dbus_loop_run (loop);
|
|
|
|
test_connection_shutdown (loop, connection);
|
|
|
|
dbus_connection_remove_filter (connection, filter_func, NULL);
|
|
|
|
dbus_connection_unref (connection);
|
|
|
|
_dbus_loop_unref (loop);
|
|
loop = NULL;
|
|
|
|
dbus_shutdown ();
|
|
|
|
_dbus_verbose ("*** Test service exiting\n");
|
|
|
|
return 0;
|
|
}
|