-/* -*- mode: C; c-file-style: "gnu" -*- */
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* dispatch.c Message dispatcher
*
* Copyright (C) 2003 CodeFactory AB
* Copyright (C) 2003, 2004, 2005 Red Hat, Inc.
* Copyright (C) 2004 Imendio HB
+ * Copyright (C) 2013 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
- *
+ *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
+#include <config.h>
#include "dispatch.h"
#include "connection.h"
#include "driver.h"
#include "signals.h"
#include "test.h"
#include <dbus/dbus-internals.h>
+#include <dbus/dbus-misc.h>
#include <string.h>
+#ifdef ENABLE_KDBUS_TRANSPORT
+#include "kdbus-d.h"
+#endif
+
+#ifdef HAVE_UNIX_FD_PASSING
+#include <dbus/dbus-sysdeps-unix.h>
+#include <unistd.h>
+#endif
+
+/* This is hard-coded in the files in valid-config-files-*. We have to use
+ * the debug-pipe transport because the tests in this file require that
+ * dbus_connection_open_private() does not block. */
+#define TEST_DEBUG_PIPE "debug-pipe:name=test-server"
static dbus_bool_t
send_one_message (DBusConnection *connection,
message,
NULL))
return TRUE; /* silently don't send it */
-
+
+ if (dbus_message_contains_unix_fds(message) &&
+ !dbus_connection_can_send_type(connection, DBUS_TYPE_UNIX_FD))
+ return TRUE; /* silently don't send it */
+
if (!bus_transaction_send (transaction,
connection,
message))
_dbus_assert (sender == NULL || bus_connection_is_active (sender));
_dbus_assert (dbus_message_get_sender (message) != NULL);
+ context = bus_transaction_get_context (transaction);
+
+ /* First, send the message to the addressed_recipient, if there is one. */
+ if (addressed_recipient != NULL)
+ {
+ if (!bus_context_check_security_policy (context, transaction,
+ sender, addressed_recipient,
+ addressed_recipient,
+ message, error))
+ return FALSE;
+
+ if (dbus_message_contains_unix_fds (message) &&
+ !dbus_connection_can_send_type (addressed_recipient,
+ DBUS_TYPE_UNIX_FD))
+ {
+ dbus_set_error (error,
+ DBUS_ERROR_NOT_SUPPORTED,
+ "Tried to send message with Unix file descriptors"
+ "to a client that doesn't support that.");
+ return FALSE;
+ }
+
+ /* Dispatch the message */
+ if (!bus_transaction_send (transaction, addressed_recipient, message))
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+ }
+
+ /* Now dispatch to others who look interested in this message */
connections = bus_transaction_get_connections (transaction);
-
dbus_error_init (&tmp_error);
- context = bus_transaction_get_context (transaction);
matchmaker = bus_context_get_matchmaker (context);
recipients = NULL;
}
_dbus_list_clear (&recipients);
-
+
if (dbus_error_is_set (&tmp_error))
{
dbus_move_error (&tmp_error, error);
BusContext *context;
DBusHandlerResult result;
DBusConnection *addressed_recipient;
-
+
result = DBUS_HANDLER_RESULT_HANDLED;
-
+
transaction = NULL;
addressed_recipient = NULL;
dbus_error_init (&error);
-
+
context = bus_connection_get_context (connection);
_dbus_assert (context != NULL);
-
+
/* If we can't even allocate an OOM error, we just go to sleep
* until we can.
*/
while (!bus_connection_preallocate_oom_error (connection))
_dbus_wait_for_memory ();
-
+
/* Ref connection in case we disconnect it at some point in here */
dbus_connection_ref (connection);
-
+
service_name = dbus_message_get_destination (message);
#ifdef DBUS_ENABLE_VERBOSE_MODE
interface_name = dbus_message_get_interface (message);
member_name = dbus_message_get_member (message);
error_name = dbus_message_get_error_name (message);
-
+
_dbus_verbose ("DISPATCH: %s %s %s to %s\n",
interface_name ? interface_name : "(no interface)",
member_name ? member_name : "(no member)",
service_name ? service_name : "peer");
}
#endif /* DBUS_ENABLE_VERBOSE_MODE */
-
+
+ /* Create our transaction */
+ transaction = bus_transaction_new (context);
+ if (transaction == NULL)
+ {
+ BUS_SET_OOM (&error);
+ goto out;
+ }
+
/* If service_name is NULL, if it's a signal we send it to all
* connections with a match rule. If it's not a signal, there
* are some special cases here but mostly we just bail out.
if (service_name == NULL)
{
if (dbus_message_is_signal (message,
- DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL,
+ DBUS_INTERFACE_LOCAL,
"Disconnected"))
{
bus_connection_disconnected (connection);
result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto out;
}
+
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(bus_context_is_kdbus(context))
+ {
+ if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged"))
+ {
+ handleNameOwnerChanged(message, transaction, connection);
+ goto out;
+ }
+ }
+#endif
}
-
- /* Create our transaction */
- transaction = bus_transaction_new (context);
- if (transaction == NULL)
- {
- BUS_SET_OOM (&error);
- goto out;
- }
-
+
+#ifdef ENABLE_KDBUS_TRANSPORT
/* Assign a sender to the message */
- if (bus_connection_is_active (connection))
+ if(bus_context_is_kdbus(context) == FALSE) //if using kdbus, sender must be set on library side
+#endif
+ {
+ if (bus_connection_is_active (connection))
{
sender = bus_connection_get_name (connection);
_dbus_assert (sender != NULL);
*/
service_name = dbus_message_get_destination (message);
}
-
+ }
+
if (service_name &&
- strcmp (service_name, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS) == 0) /* to bus driver */
+ strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */
{
if (!bus_context_check_security_policy (context, transaction,
connection, NULL, NULL, message, &error))
goto out;
}
- _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
+ _dbus_verbose ("Giving message to %s\n", DBUS_SERVICE_DBUS);
if (!bus_driver_handle_message (connection, transaction, message, &error))
goto out;
}
else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */
{
_dbus_verbose ("Received message from non-registered client. Disconnecting.\n");
- dbus_connection_disconnect (connection);
+ dbus_connection_close (connection);
goto out;
}
else if (service_name != NULL) /* route to named service */
BusRegistry *registry;
_dbus_assert (service_name != NULL);
-
+
registry = bus_connection_get_registry (connection);
-
+
_dbus_string_init_const (&service_string, service_name);
service = bus_registry_lookup (registry, &service_string);
- if (service == NULL && dbus_message_get_auto_activation (message))
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if (dbus_message_get_auto_start (message) && (service == NULL || bus_service_get_is_kdbus_starter(service)))
+#else
+ if (service == NULL && dbus_message_get_auto_start (message))
+#endif
{
- BusActivation *activation;
+ BusActivation *activation;
+ /* We can't do the security policy check here, since the addressed
+ * recipient service doesn't exist yet. We do it before sending the
+ * message after the service has been created.
+ */
+ activation = bus_connection_get_activation (connection);
- /* We can't do the security policy check here, since the addressed
- * recipient service doesn't exist yet. We do it before sending the
- * message after the service has been created.
- */
- activation = bus_connection_get_activation (connection);
+ if (!bus_activation_activate_service (activation, connection, transaction, TRUE,
+ message, service_name, &error))
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (&error);
+ _dbus_verbose ("bus_activation_activate_service() failed: %s\n", error.name);
+ goto out;
+ }
- if (!bus_activation_activate_service (activation, connection, transaction, TRUE,
- message, service_name, &error))
- {
- _DBUS_ASSERT_ERROR_IS_SET (&error);
- _dbus_verbose ("bus_activation_activate_service() failed\n");
- goto out;
- }
-
- goto out;
- }
+ goto out;
+ }
else if (service == NULL)
{
dbus_set_error (&error,
- DBUS_ERROR_SERVICE_DOES_NOT_EXIST,
- "Service \"%s\" does not exist",
+ DBUS_ERROR_NAME_HAS_NO_OWNER,
+ "Name \"%s\" does not exist",
service_name);
goto out;
}
else
- {
- addressed_recipient = bus_service_get_primary_owner (service);
+ {
+ addressed_recipient = bus_service_get_primary_owners_connection (service);
_dbus_assert (addressed_recipient != NULL);
-
- if (!bus_context_check_security_policy (context, transaction,
- connection, addressed_recipient,
- addressed_recipient,
- message, &error))
- goto out;
-
- /* Dispatch the message */
- if (!bus_transaction_send (transaction, addressed_recipient, message))
- {
- BUS_SET_OOM (&error);
- goto out;
- }
}
}
- /* Now match the messages against any match rules, which will send
- * out signals and such. addressed_recipient may == NULL.
+ /* Now send the message to its destination (or not, if
+ * addressed_recipient == NULL), and match it against other connections'
+ * match rules.
*/
if (!bus_dispatch_matches (transaction, connection, addressed_recipient, message, &error))
goto out;
-
+
out:
if (dbus_error_is_set (&error))
{
* the OOM error
*/
_dbus_assert (transaction != NULL);
-
if (!bus_transaction_send_error_reply (transaction, connection,
&error, message))
{
bus_connection_send_oom_error (connection, message);
-
+
/* cancel transaction due to OOM */
if (transaction != NULL)
{
}
}
}
-
+
+
dbus_error_free (&error);
}
dbus_bool_t
bus_dispatch_add_connection (DBusConnection *connection)
-{
+{
if (!dbus_connection_add_filter (connection,
bus_dispatch_message_filter,
NULL, NULL))
return FALSE;
-
+
return TRUE;
}
NULL);
}
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
#include <stdio.h>
const char *what_is_expected)
{
_dbus_verbose ("expecting: %s\n", what_is_expected);
-
+
while (dbus_connection_get_dispatch_status (connection) ==
DBUS_DISPATCH_COMPLETE &&
dbus_connection_get_is_connected (connection))
static dbus_bool_t
check_service_owner_changed_foreach (DBusConnection *connection,
- void *data)
+ void *data)
{
CheckServiceOwnerChangedData *d = data;
DBusMessage *message;
DBusError error;
const char *service_name, *old_owner, *new_owner;
- if (d->expected_kind == SERVICE_CREATED
+ if (d->expected_kind == SERVICE_CREATED
&& connection == d->skip_connection)
return TRUE;
dbus_error_init (&error);
d->failed = TRUE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive a message on %p, expecting %s\n",
- connection, "ServiceOwnerChanged");
+ connection, "NameOwnerChanged");
goto out;
}
else if (!dbus_message_is_signal (message,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ServiceOwnerChanged"))
+ DBUS_INTERFACE_DBUS,
+ "NameOwnerChanged"))
{
- warn_unexpected (connection, message, "ServiceOwnerChanged");
+ warn_unexpected (connection, message, "NameOwnerChanged");
goto out;
}
DBUS_TYPE_INVALID);
if (dbus_error_is_set (&error))
- {
- if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
- {
+ {
+ if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
+ {
dbus_error_free (&error);
- _dbus_wait_for_memory ();
+ _dbus_wait_for_memory ();
goto reget_service_info_data;
- }
- else
- {
- _dbus_warn ("Did not get the expected arguments\n");
- goto out;
- }
- }
+ }
+ else
+ {
+ _dbus_warn ("Did not get the expected arguments\n");
+ goto out;
+ }
+ }
if ((d->expected_kind == SERVICE_CREATED && ( old_owner[0] || !new_owner[0]))
|| (d->expected_kind == OWNER_CHANGED && (!old_owner[0] || !new_owner[0]))
|| (d->expected_kind == SERVICE_DELETED && (!old_owner[0] || new_owner[0])))
{
- _dbus_warn ("inconsistent ServiceOwnerChanged arguments");
+ _dbus_warn ("inconsistent NameOwnerChanged arguments\n");
goto out;
}
goto out;
}
- if (*service_name == ':' && new_owner[0]
+ if (*service_name == ':' && new_owner[0]
&& strcmp (service_name, new_owner) != 0)
{
_dbus_warn ("inconsistent ServiceOwnedChanged message (\"%s\" [ %s -> %s ])\n",
}
d->failed = FALSE;
-
+
out:
dbus_error_free (&error);
-
+
if (message)
dbus_message_unref (message);
CheckServiceOwnerChangedData socd;
_dbus_verbose ("killing connection %p\n", connection);
-
- s = dbus_bus_get_base_service (connection);
+
+ s = dbus_bus_get_unique_name (connection);
_dbus_assert (s != NULL);
while ((base_service = _dbus_strdup (s)) == NULL)
_dbus_wait_for_memory ();
dbus_connection_ref (connection);
-
+
/* kick in the disconnect handler that unrefs the connection */
- dbus_connection_disconnect (connection);
+ dbus_connection_close (connection);
bus_test_run_everything (context);
-
+
_dbus_assert (bus_test_client_listed (connection));
-
+
/* Run disconnect handler in test.c */
if (bus_connection_dispatch_one_message (connection))
_dbus_assert_not_reached ("something received on connection being killed other than the disconnect");
-
+
_dbus_assert (!dbus_connection_get_is_connected (connection));
dbus_connection_unref (connection);
connection = NULL;
_dbus_assert (!bus_test_client_listed (connection));
-
+
socd.expected_kind = SERVICE_DELETED;
socd.expected_service_name = base_service;
socd.failed = FALSE;
socd.skip_connection = NULL;
-
+
bus_test_clients_foreach (check_service_owner_changed_foreach,
&socd);
dbus_free (base_service);
-
+
if (socd.failed)
- _dbus_assert_not_reached ("didn't get the expected ServiceOwnerChanged (deletion) messages");
-
+ _dbus_assert_not_reached ("didn't get the expected NameOwnerChanged (deletion) messages");
+
if (!check_no_leftovers (context))
_dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");
}
{
/* This kills the connection without expecting it to affect
* the rest of the bus.
- */
+ */
_dbus_verbose ("Unchecked kill of connection %p\n", connection);
dbus_connection_ref (connection);
- dbus_connection_disconnect (connection);
+ dbus_connection_close (connection);
/* dispatching disconnect handler will unref once */
if (bus_connection_dispatch_one_message (connection))
_dbus_assert_not_reached ("message other than disconnect dispatched after failure to register");
nmd.failed = FALSE;
bus_test_clients_foreach (check_no_messages_foreach,
&nmd);
-
+
if (nmd.failed)
{
- _dbus_verbose ("%s: leftover message found\n",
- _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("leftover message found\n");
return FALSE;
}
else
name_message = NULL;
_dbus_verbose ("check_hello_message for %p\n", connection);
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
"Hello");
if (message == NULL)
return TRUE;
dbus_connection_ref (connection); /* because we may get disconnected */
-
+
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
}
_dbus_assert (dbus_message_has_signature (message, ""));
-
+
dbus_message_unref (message);
message = NULL;
if (!dbus_connection_get_is_connected (connection))
{
_dbus_verbose ("connection was disconnected (presumably auth failed)\n");
-
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
-
+
/* send our message */
bus_test_run_clients_loop (SEND_PENDING (connection));
if (!dbus_connection_get_is_connected (connection))
{
_dbus_verbose ("connection was disconnected (presumably auth failed)\n");
-
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
-
+
block_connection_until_message_from_bus (context, connection, "reply to Hello");
if (!dbus_connection_get_is_connected (connection))
{
_dbus_verbose ("connection was disconnected (presumably auth failed)\n");
-
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
dbus_connection_unref (connection);
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
verbose_message_received (connection, message);
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
if (dbus_message_is_error (message,
else
{
CheckServiceOwnerChangedData socd;
-
+
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
{
; /* good, expected */
_dbus_verbose ("Got hello name: %s\n", name);
- while (!dbus_bus_set_base_service (connection, name))
+ while (!dbus_bus_set_unique_name (connection, name))
_dbus_wait_for_memory ();
-
+
socd.expected_kind = SERVICE_CREATED;
socd.expected_service_name = name;
socd.failed = FALSE;
socd.skip_connection = connection; /* we haven't done AddMatch so won't get it ourselves */
bus_test_clients_foreach (check_service_owner_changed_foreach,
&socd);
-
+
if (socd.failed)
goto out;
if (message == NULL)
{
_dbus_warn ("Expecting %s, got nothing\n",
- "ServiceAcquired");
+ "NameAcquired");
goto out;
}
- if (! dbus_message_is_signal (message, DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ServiceAcquired"))
+ if (! dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
+ "NameAcquired"))
{
_dbus_warn ("Expecting %s, got smthg else\n",
- "ServiceAcquired");
+ "NameAcquired");
goto out;
}
-
+
retry_get_acquired_name:
if (!dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &acquired,
if (!check_no_leftovers (context))
goto out;
-
+
retval = TRUE;
-
+
out:
- _dbus_verbose ("ending %s retval = %d\n", _DBUS_FUNCTION_NAME, retval);
-
+ _dbus_verbose ("ending - retval = %d\n", retval);
+
dbus_error_free (&error);
-
+
if (message)
dbus_message_unref (message);
if (name_message)
dbus_message_unref (name_message);
-
+
return retval;
}
message = NULL;
_dbus_verbose ("check_double_hello_message for %p\n", connection);
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
"Hello");
if (message == NULL)
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
-
+ _dbus_verbose ("connection was disconnected\n");
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
dbus_connection_unref (connection);
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
verbose_message_received (connection, message);
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
{
warn_unexpected (connection, message, "method return for Hello");
if (!check_no_leftovers (context))
goto out;
-
+
retval = TRUE;
-
+
out:
dbus_error_free (&error);
-
+
if (message)
dbus_message_unref (message);
-
+
return retval;
}
message = NULL;
_dbus_verbose ("check_get_connection_unix_user for %p\n", connection);
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
"GetConnectionUnixUser");
if (message == NULL)
return TRUE;
- base_service_name = dbus_bus_get_base_service (connection);
+ base_service_name = dbus_bus_get_unique_name (connection);
- if (!dbus_message_append_args (message,
+ if (!dbus_message_append_args (message,
DBUS_TYPE_STRING, &base_service_name,
DBUS_TYPE_INVALID))
{
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
-
+ _dbus_verbose ("connection was disconnected\n");
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
else
{
warn_unexpected (connection, message,
- "method_return for GetConnectionUnixUser");
+ "method_return for GetConnectionUnixUser");
goto out;
}
out:
dbus_error_free (&error);
-
+
if (message)
dbus_message_unref (message);
-
+
return retval;
}
*/
static dbus_bool_t
check_get_connection_unix_process_id (BusContext *context,
- DBusConnection *connection)
+ DBusConnection *connection)
{
DBusMessage *message;
dbus_uint32_t serial;
message = NULL;
_dbus_verbose ("check_get_connection_unix_process_id for %p\n", connection);
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
"GetConnectionUnixProcessID");
if (message == NULL)
return TRUE;
- base_service_name = dbus_bus_get_base_service (connection);
+ base_service_name = dbus_bus_get_unique_name (connection);
- if (!dbus_message_append_args (message,
+ if (!dbus_message_append_args (message,
DBUS_TYPE_STRING, &base_service_name,
DBUS_TYPE_INVALID))
{
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
-
+ _dbus_verbose ("connection was disconnected\n");
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
{
; /* good, this is a valid response */
}
+#ifdef DBUS_WIN
+ else if (dbus_message_is_error (message, DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN))
+ {
+ /* We are expecting this error, since we know in the test suite we aren't
+ * talking to a client running on UNIX
+ */
+ _dbus_verbose ("Windows correctly does not support GetConnectionUnixProcessID\n");
+ }
+#endif
else
{
warn_unexpected (connection, message, "not this error");
}
else
{
+#ifdef DBUS_WIN
+ warn_unexpected (connection, message, "GetConnectionUnixProcessID to fail on Windows");
+ goto out;
+#else
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
{
; /* good, expected */
else
{
warn_unexpected (connection, message,
- "method_return for GetConnectionUnixProcessID");
+ "method_return for GetConnectionUnixProcessID");
goto out;
}
_dbus_warn ("Did not get the expected DBUS_TYPE_UINT32 from GetConnectionUnixProcessID\n");
goto out;
}
- } else {
-
- /* test if returned pid is the same as our own pid
- *
- * @todo It would probably be good to restructure the tests
- * in a way so our parent is the bus that we're testing
- * cause then we can test that the pid returned matches
- * getppid()
- */
- if (pid != (dbus_uint32_t) _dbus_getpid ())
- {
+ }
+ else
+ {
+ /* test if returned pid is the same as our own pid
+ *
+ * @todo It would probably be good to restructure the tests
+ * in a way so our parent is the bus that we're testing
+ * cause then we can test that the pid returned matches
+ * getppid()
+ */
+ if (pid != (dbus_uint32_t) _dbus_getpid ())
+ {
_dbus_assert (dbus_error_is_set (&error));
_dbus_warn ("Result from GetConnectionUnixProcessID is not our own pid\n");
goto out;
- }
- }
+ }
+ }
+#endif /* !DBUS_WIN */
}
if (!check_no_leftovers (context))
out:
dbus_error_free (&error);
-
+
if (message)
dbus_message_unref (message);
-
+
return retval;
}
message = NULL;
_dbus_verbose ("check_add_match_all for %p\n", connection);
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
"AddMatch");
if (message == NULL)
dbus_message_unref (message);
return TRUE;
}
-
+
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
message = NULL;
dbus_connection_ref (connection); /* because we may get disconnected */
-
+
/* send our message */
bus_test_run_clients_loop (SEND_PENDING (connection));
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
-
+ _dbus_verbose ("connection was disconnected\n");
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
-
+
block_connection_until_message_from_bus (context, connection, "reply to AddMatch");
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
-
+ _dbus_verbose ("connection was disconnected\n");
+
dbus_connection_unref (connection);
-
+
return TRUE;
}
dbus_connection_unref (connection);
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
verbose_message_received (connection, message);
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
if (dbus_message_is_error (message,
if (!check_no_leftovers (context))
goto out;
-
+
retval = TRUE;
-
+
out:
dbus_error_free (&error);
-
+
if (message)
dbus_message_unref (message);
-
+
return retval;
}
dbus_error_init (&error);
- connection = dbus_connection_open ("debug-pipe:name=test-server", &error);
+ connection = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (connection == NULL)
{
_DBUS_ASSERT_ERROR_IS_SET (&error);
if (!bus_setup_debug_client (connection))
{
- dbus_connection_disconnect (connection);
+ dbus_connection_close (connection);
dbus_connection_unref (connection);
return TRUE;
}
spin_connection_until_authenticated (context, connection);
-
+
if (!check_hello_message (context, connection))
return FALSE;
-
- if (dbus_bus_get_base_service (connection) == NULL)
+
+ if (dbus_bus_get_unique_name (connection) == NULL)
{
/* We didn't successfully register, so we can't
* do the usual kill_client_connection() checks
{
if (!check_add_match_all (context, connection))
return FALSE;
-
+
kill_client_connection (context, connection);
}
* but the correct thing may include OOM errors.
*/
static dbus_bool_t
-check_nonexistent_service_activation (BusContext *context,
- DBusConnection *connection)
+check_nonexistent_service_no_auto_start (BusContext *context,
+ DBusConnection *connection)
{
DBusMessage *message;
dbus_uint32_t serial;
dbus_bool_t retval;
const char *nonexistent = NONEXISTENT_SERVICE_NAME;
dbus_uint32_t flags;
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ActivateService");
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "StartServiceByName");
if (message == NULL)
return TRUE;
+ dbus_message_set_auto_start (message, FALSE);
+
flags = 0;
if (!dbus_message_append_args (message,
DBUS_TYPE_STRING, &nonexistent,
dbus_message_unref (message);
return TRUE;
}
-
+
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
+ _dbus_verbose ("connection was disconnected\n");
return TRUE;
}
-
+
retval = FALSE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive a reply to %s %d on %p\n",
- "ActivateService", serial, connection);
+ "StartServiceByName", serial, connection);
goto out;
}
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_is_error (message,
DBUS_ERROR_NO_MEMORY))
{
; /* good, this is a valid response */
}
else if (dbus_message_is_error (message,
- DBUS_ERROR_ACTIVATE_SERVICE_NOT_FOUND))
+ DBUS_ERROR_SERVICE_UNKNOWN))
{
; /* good, this is expected also */
}
}
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
-
+
return retval;
}
* but the correct thing may include OOM errors.
*/
static dbus_bool_t
-check_nonexistent_service_auto_activation (BusContext *context,
- DBusConnection *connection)
+check_nonexistent_service_auto_start (BusContext *context,
+ DBusConnection *connection)
{
DBusMessage *message;
dbus_uint32_t serial;
dbus_bool_t retval;
-
+
message = dbus_message_new_method_call (NONEXISTENT_SERVICE_NAME,
"/org/freedesktop/TestSuite",
"org.freedesktop.TestSuite",
"Echo");
-
+
if (message == NULL)
return TRUE;
- dbus_message_set_auto_activation (message, TRUE);
-
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
+ _dbus_verbose ("connection was disconnected\n");
return TRUE;
}
-
+
retval = FALSE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_is_error (message,
DBUS_ERROR_NO_MEMORY))
{
; /* good, this is a valid response */
}
else if (dbus_message_is_error (message,
- DBUS_ERROR_ACTIVATE_SERVICE_NOT_FOUND))
+ DBUS_ERROR_SERVICE_UNKNOWN))
{
; /* good, this is expected also */
}
}
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
-
+
return retval;
}
dbus_bool_t retval;
DBusError error;
const char *base_service, *base_service_from_bus, *old_owner;
-
+
retval = FALSE;
-
+
dbus_error_init (&error);
base_service = NULL;
old_owner = NULL;
base_service_from_bus = NULL;
message = initial_message;
- dbus_message_ref (message);
+ dbus_message_ref (message);
if (dbus_message_is_signal (message,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ServiceOwnerChanged"))
+ DBUS_INTERFACE_DBUS,
+ "NameOwnerChanged"))
{
CheckServiceOwnerChangedData socd;
if (!dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &base_service,
- DBUS_TYPE_STRING, &old_owner,
+ DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &base_service_from_bus,
DBUS_TYPE_INVALID))
{
else
{
_dbus_warn ("Message %s doesn't have a service name: %s\n",
- "ServiceOwnerChanged (creation)",
+ "NameOwnerChanged (creation)",
error.message);
goto out;
}
base_service);
goto out;
}
-
+
if (strcmp (base_service, base_service_from_bus) != 0)
- {
+ {
_dbus_warn ("Expected base service activation, got \"%s\" instead with owner \"%s\"\n",
base_service, base_service_from_bus);
goto out;
old_owner);
goto out;
}
-
+
socd.expected_kind = SERVICE_CREATED;
socd.expected_service_name = base_service;
socd.failed = FALSE;
socd.skip_connection = connection;
bus_test_clients_foreach (check_service_owner_changed_foreach,
&socd);
-
+
if (socd.failed)
goto out;
}
else
{
- warn_unexpected (connection, message, "ServiceOwnerChanged (creation) for base service");
+ warn_unexpected (connection, message, "NameOwnerChanged (creation) for base service");
goto out;
}
*base_service_p = base_service;
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
dbus_bool_t retval;
DBusError error;
dbus_uint32_t activation_result;
-
+
retval = FALSE;
-
+
dbus_error_init (&error);
message = initial_message;
dbus_message_ref (message);
if (dbus_message_is_signal (message,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ServiceOwnerChanged"))
+ DBUS_INTERFACE_DBUS,
+ "NameOwnerChanged"))
{
CheckServiceOwnerChangedData socd;
const char *service_name, *base_service_from_bus, *old_owner;
if (!dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &service_name,
- DBUS_TYPE_STRING, &old_owner,
+ DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &base_service_from_bus,
DBUS_TYPE_INVALID))
{
else
{
_dbus_warn ("Message %s doesn't have a service name: %s\n",
- "ServiceOwnerChanged (creation)",
+ "NameOwnerChanged (creation)",
error.message);
goto out;
}
if (strcmp (base_service_name, base_service_from_bus) != 0)
{
- _dbus_warn ("ServiceOwnerChanged reports wrong base service: %s owner, expected %s instead\n",
+ _dbus_warn ("NameOwnerChanged reports wrong base service: %s owner, expected %s instead\n",
base_service_from_bus, base_service_name);
goto out;
}
if (old_owner[0])
{
_dbus_warn ("expected a %s, got a %s\n",
- "ServiceOwnerChanged (creation)",
- "ServiceOwnerChanged (change)");
+ "NameOwnerChanged (creation)",
+ "NameOwnerChanged (change)");
goto out;
}
socd.expected_service_name = service_name;
bus_test_clients_foreach (check_service_owner_changed_foreach,
&socd);
-
+
if (socd.failed)
goto out;
-
+
dbus_message_unref (message);
service_name = NULL;
old_owner = NULL;
base_service_from_bus = NULL;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Expected a reply to %s, got nothing\n",
- "ActivateService");
+ "StartServiceByName");
goto out;
}
}
else
{
- warn_unexpected (connection, message, "ServiceOwnerChanged for the activated name");
-
+ warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
+
goto out;
}
-
+
if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
{
- warn_unexpected (connection, message, "reply to ActivateService");
+ warn_unexpected (connection, message, "reply to StartServiceByName");
goto out;
}
if (!dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
{
_dbus_warn ("Did not have activation result first argument to %s: %s\n",
- "ActivateService", error.message);
+ "StartServiceByName", error.message);
goto out;
}
}
else
{
- if (activation_result == DBUS_ACTIVATION_REPLY_ACTIVATED)
+ if (activation_result == DBUS_START_REPLY_SUCCESS)
; /* Good */
- else if (activation_result == DBUS_ACTIVATION_REPLY_ALREADY_ACTIVE)
+ else if (activation_result == DBUS_START_REPLY_ALREADY_RUNNING)
; /* Good also */
else
{
- _dbus_warn ("Activation result was 0x%x, no good.\n",
+ _dbus_warn ("Activation result was %u, no good.\n",
activation_result);
goto out;
}
dbus_message_unref (message);
message = NULL;
-
+
if (!check_no_leftovers (context))
{
_dbus_warn ("Messages were left over after verifying existent activation results\n");
}
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
dbus_error_free (&error);
-
+
return retval;
}
static dbus_bool_t
check_service_auto_activated (BusContext *context,
- DBusConnection *connection,
- const char *activated_name,
- const char *base_service_name,
- DBusMessage *initial_message)
+ DBusConnection *connection,
+ const char *activated_name,
+ const char *base_service_name,
+ DBusMessage *initial_message)
{
DBusMessage *message;
dbus_bool_t retval;
DBusError error;
-
+
retval = FALSE;
-
+
dbus_error_init (&error);
message = initial_message;
dbus_message_ref (message);
if (dbus_message_is_signal (message,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ServiceOwnerChanged"))
+ DBUS_INTERFACE_DBUS,
+ "NameOwnerChanged"))
{
const char *service_name;
CheckServiceOwnerChangedData socd;
-
+
reget_service_name_arg:
if (!dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &service_name,
else
{
_dbus_warn ("Message %s doesn't have a service name: %s\n",
- "ServiceOwnerChanged",
+ "NameOwnerChanged",
error.message);
dbus_error_free (&error);
goto out;
}
}
-
+
if (strcmp (service_name, activated_name) != 0)
{
_dbus_warn ("Expected to see service %s created, saw %s instead\n",
activated_name, service_name);
goto out;
}
-
+
socd.expected_kind = SERVICE_CREATED;
socd.expected_service_name = service_name;
socd.failed = FALSE;
- socd.skip_connection = connection;
+ socd.skip_connection = connection;
bus_test_clients_foreach (check_service_owner_changed_foreach,
- &socd);
-
+ &socd);
+
if (socd.failed)
goto out;
-
+
/* Note that this differs from regular activation in that we don't get a
* reply to ActivateService here.
*/
-
+
dbus_message_unref (message);
message = NULL;
service_name = NULL;
}
else
{
- warn_unexpected (connection, message, "ServiceOwnerChanged for the activated name");
-
+ warn_unexpected (connection, message, "NameOwnerChanged for the activated name");
+
goto out;
}
-
+
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
-
+
return retval;
}
CheckServiceOwnerChangedData socd;
retval = FALSE;
-
+
/* Now we are expecting ServiceOwnerChanged (deletion) messages for the base
* service and the activated_name. The base service
* notification is required to come last.
socd.failed = FALSE;
socd.skip_connection = NULL;
bus_test_clients_foreach (check_service_owner_changed_foreach,
- &socd);
+ &socd);
if (socd.failed)
goto out;
-
+
socd.expected_kind = SERVICE_DELETED;
socd.expected_service_name = base_service;
socd.failed = FALSE;
goto out;
retval = TRUE;
-
+
out:
return retval;
}
DBusMessage *message;
dbus_uint32_t serial;
dbus_bool_t retval;
-
+
_dbus_verbose ("Sending exit message to the test service\n");
retval = FALSE;
-
+
/* Kill off the test service by sending it a quit message */
message = dbus_message_new_method_call (service_name,
"/org/freedesktop/TestSuite",
"org.freedesktop.TestSuite",
"Exit");
-
+
if (message == NULL)
{
/* Do this again; we still need the service to exit... */
if (!check_send_exit_to_service (context, connection,
service_name, base_service))
goto out;
-
+
return TRUE;
}
-
+
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
if (!check_send_exit_to_service (context, connection,
service_name, base_service))
goto out;
-
+
return TRUE;
}
dbus_connection_return_message (connection, message);
message = NULL;
}
-
+
if (!got_error)
{
/* If no error, wait for the test service to exit */
block_connection_until_message_from_bus (context, connection, "test service to exit");
-
+
bus_test_run_everything (context);
}
"error with the correct reply serial");
goto out;
}
-
+
if (!dbus_message_is_error (message,
DBUS_ERROR_NO_MEMORY))
{
* stuff.
*/
message = pop_message_waiting_for_memory (connection);
-
+
if (message == NULL)
{
warn_unexpected (connection, NULL,
"error with the correct reply serial");
goto out;
}
-
+
_dbus_verbose ("Got error %s after test service exited\n",
dbus_message_get_error_name (message));
-
+
if (!check_no_leftovers (context))
{
_dbus_warn ("Messages were left over after %s\n",
goto out;
}
}
-
+
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
-
+
return retval;
}
va_list ap;
dbus_bool_t error_found;
const char *error_name;
-
+
retval = FALSE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
}
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
-
+
return retval;
}
-
+
typedef enum
-{
+{
GOT_SERVICE_CREATED,
GOT_SERVICE_DELETED,
GOT_ERROR,
- GOT_SOMETHING_ELSE
+ GOT_SOMETHING_ELSE
} GotServiceInfo;
static GotServiceInfo
GotServiceInfo message_kind;
if (dbus_message_is_signal (message,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ServiceOwnerChanged"))
+ DBUS_INTERFACE_DBUS,
+ "NameOwnerChanged"))
{
DBusError error;
const char *service_name, *old_owner, *new_owner;
}
else
{
- _dbus_warn ("unexpected arguments for ServiceOwnerChanged message");
+ _dbus_warn ("unexpected arguments for NameOwnerChanged message\n");
message_kind = GOT_SOMETHING_ELSE;
}
}
* but the correct thing may include OOM errors.
*/
static dbus_bool_t
-check_existent_service_activation (BusContext *context,
- DBusConnection *connection)
+check_existent_service_no_auto_start (BusContext *context,
+ DBusConnection *connection)
{
DBusMessage *message;
DBusMessage *base_service_message;
dbus_uint32_t flags;
base_service_message = NULL;
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ActivateService");
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "StartServiceByName");
if (message == NULL)
return TRUE;
+ dbus_message_set_auto_start (message, FALSE);
+
flags = 0;
if (!dbus_message_append_args (message,
DBUS_TYPE_STRING, &existent,
dbus_message_unref (message);
return TRUE;
}
-
+
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
+ _dbus_verbose ("connection was disconnected\n");
return TRUE;
}
-
+
retval = FALSE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive any messages after %s %d on %p\n",
- "ActivateService", serial, connection);
+ "StartServiceByName", serial, connection);
goto out;
}
verbose_message_received (connection, message);
- _dbus_verbose (" (after sending %s)\n", "ActivateService");
+ _dbus_verbose (" (after sending %s)\n", "StartServiceByName");
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_is_error (message,
DBUS_ERROR_NO_MEMORY))
{
else if (dbus_message_is_error (message,
DBUS_ERROR_SPAWN_CHILD_EXITED) ||
dbus_message_is_error (message,
+ DBUS_ERROR_SPAWN_CHILD_SIGNALED) ||
+ dbus_message_is_error (message,
DBUS_ERROR_SPAWN_EXEC_FAILED))
{
; /* good, this is expected also */
else
{
GotServiceInfo message_kind;
-
+
if (!check_base_service_activated (context, connection,
message, &base_service))
goto out;
/* We may need to block here for the test service to exit or finish up */
block_connection_until_message_from_bus (context, connection, "test service to exit or finish up");
-
+
message = dbus_connection_borrow_message (connection);
if (message == NULL)
{
message = NULL;
switch (message_kind)
- {
- case GOT_SOMETHING_ELSE:
+ {
+ case GOT_SOMETHING_ELSE:
_dbus_warn ("Unexpected message after ActivateService "
"(should be an error or a service announcement");
- goto out;
+ goto out;
- case GOT_ERROR:
+ case GOT_ERROR:
if (!check_got_error (context, connection,
DBUS_ERROR_SPAWN_CHILD_EXITED,
DBUS_ERROR_NO_MEMORY,
* We can also get the error *after* the service deleted.
*/
- /* fall through */
+ /* fall through */
- case GOT_SERVICE_DELETED:
- {
- /* The service started up and got a base address, but then
- * failed to register under EXISTENT_SERVICE_NAME
- */
- CheckServiceOwnerChangedData socd;
-
- socd.expected_kind = SERVICE_DELETED;
- socd.expected_service_name = base_service;
- socd.failed = FALSE;
- socd.skip_connection = NULL;
-
- bus_test_clients_foreach (check_service_owner_changed_foreach,
- &socd);
-
- if (socd.failed)
- goto out;
+ case GOT_SERVICE_DELETED:
+ {
+ /* The service started up and got a base address, but then
+ * failed to register under EXISTENT_SERVICE_NAME
+ */
+ CheckServiceOwnerChangedData socd;
- /* Now we should get an error about the service exiting
- * if we didn't get it before.
- */
- if (message_kind != GOT_ERROR)
- {
- block_connection_until_message_from_bus (context, connection, "error about service exiting");
-
- /* and process everything again */
- bus_test_run_everything (context);
-
- if (!check_got_error (context, connection,
- DBUS_ERROR_SPAWN_CHILD_EXITED,
- NULL))
- goto out;
- }
- break;
- }
+ socd.expected_kind = SERVICE_DELETED;
+ socd.expected_service_name = base_service;
+ socd.failed = FALSE;
+ socd.skip_connection = NULL;
- case GOT_SERVICE_CREATED:
+ bus_test_clients_foreach (check_service_owner_changed_foreach,
+ &socd);
+
+ if (socd.failed)
+ goto out;
+
+ /* Now we should get an error about the service exiting
+ * if we didn't get it before.
+ */
+ if (message_kind != GOT_ERROR)
+ {
+ block_connection_until_message_from_bus (context, connection, "error about service exiting");
+
+ /* and process everything again */
+ bus_test_run_everything (context);
+
+ if (!check_got_error (context, connection,
+ DBUS_ERROR_SPAWN_CHILD_EXITED,
+ DBUS_ERROR_NO_MEMORY,
+ NULL))
+ goto out;
+ }
+ break;
+ }
+
+ case GOT_SERVICE_CREATED:
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Failed to pop message we just put back! "
- "should have been a ServiceOwnerChanged (creation)\n");
+ "should have been a NameOwnerChanged (creation)\n");
goto out;
}
-
+
if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
base_service, message))
goto out;
-
+
dbus_message_unref (message);
message = NULL;
goto out;
}
- if (!check_send_exit_to_service (context, connection,
+ if (!check_send_exit_to_service (context, connection,
EXISTENT_SERVICE_NAME, base_service))
- goto out;
+ goto out;
- break;
- }
+ break;
+ }
}
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
if (base_service_message)
dbus_message_unref (base_service_message);
-
+
return retval;
}
+#ifndef DBUS_WIN_FIXME
/* returns TRUE if the correct thing happens,
* but the correct thing may include OOM errors.
*/
static dbus_bool_t
-check_segfault_service_activation (BusContext *context,
- DBusConnection *connection)
+check_segfault_service_no_auto_start (BusContext *context,
+ DBusConnection *connection)
{
DBusMessage *message;
dbus_uint32_t serial;
dbus_bool_t retval;
const char *segv_service;
dbus_uint32_t flags;
-
- message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
- DBUS_PATH_ORG_FREEDESKTOP_DBUS,
- DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
- "ActivateService");
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "StartServiceByName");
if (message == NULL)
return TRUE;
+ dbus_message_set_auto_start (message, FALSE);
+
segv_service = "org.freedesktop.DBus.TestSuiteSegfaultService";
flags = 0;
if (!dbus_message_append_args (message,
dbus_message_unref (message);
return TRUE;
}
-
+
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
+ _dbus_verbose ("connection was disconnected\n");
return TRUE;
}
-
+
retval = FALSE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
_dbus_warn ("Did not receive a reply to %s %d on %p\n",
- "ActivateService", serial, connection);
+ "StartServiceByName", serial, connection);
goto out;
}
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_is_error (message,
DBUS_ERROR_NO_MEMORY))
{
; /* good, this is a valid response */
}
else if (dbus_message_is_error (message,
+ DBUS_ERROR_FAILED))
+ {
+ const char *servicehelper;
+ servicehelper = bus_context_get_servicehelper (context);
+ /* make sure this only happens with the launch helper */
+ _dbus_assert (servicehelper != NULL);
+ }
+ else if (dbus_message_is_error (message,
DBUS_ERROR_SPAWN_CHILD_SIGNALED))
{
; /* good, this is expected also */
}
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
-
+
return retval;
}
* but the correct thing may include OOM errors.
*/
static dbus_bool_t
-check_segfault_service_auto_activation (BusContext *context,
- DBusConnection *connection)
+check_segfault_service_auto_start (BusContext *context,
+ DBusConnection *connection)
{
DBusMessage *message;
dbus_uint32_t serial;
"/org/freedesktop/TestSuite",
"org.freedesktop.TestSuite",
"Echo");
-
+
if (message == NULL)
return TRUE;
- dbus_message_set_auto_activation (message, TRUE);
-
if (!dbus_connection_send (connection, message, &serial))
{
dbus_message_unref (message);
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
+ _dbus_verbose ("connection was disconnected\n");
return TRUE;
}
-
+
retval = FALSE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
- if (!dbus_message_has_sender (message, DBUS_SERVICE_ORG_FREEDESKTOP_DBUS))
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_warn ("Message has wrong sender %s\n",
dbus_message_get_sender (message) ?
dbus_message_get_sender (message) : "(none)");
goto out;
}
-
+
if (dbus_message_is_error (message,
DBUS_ERROR_NO_MEMORY))
{
}
retval = TRUE;
-
+
out:
if (message)
dbus_message_unref (message);
-
+
return retval;
}
+#endif
#define TEST_ECHO_MESSAGE "Test echo message"
+#define TEST_RUN_HELLO_FROM_SELF_MESSAGE "Test sending message to self"
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_existent_hello_from_self (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ const char *text;
+
+ message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.TestSuite",
+ "RunHelloFromSelf");
+
+ if (message == NULL)
+ return TRUE;
+
+ text = TEST_RUN_HELLO_FROM_SELF_MESSAGE;
+ if (!dbus_message_append_args (message,
+ DBUS_TYPE_STRING, &text,
+ DBUS_TYPE_INVALID))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+
+ /* Note: if this test is run in OOM mode, it will block when the bus
+ * doesn't send a reply due to OOM.
+ */
+ block_connection_until_message_from_bus (context, connection, "reply from running hello from self");
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message! Should have been reply from RunHelloFromSelf message\n");
+ return FALSE;
+ }
+
+ if (dbus_message_get_reply_serial (message) != serial)
+ {
+ _dbus_warn ("Wrong reply serial\n");
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ return TRUE;
+}
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_existent_ping (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.DBus.Peer",
+ "Ping");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+
+ /* Note: if this test is run in OOM mode, it will block when the bus
+ * doesn't send a reply due to OOM.
+ */
+ block_connection_until_message_from_bus (context, connection, "reply from running Ping");
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message! Should have been reply from Ping message\n");
+ return FALSE;
+ }
+
+ if (dbus_message_get_reply_serial (message) != serial)
+ {
+ _dbus_warn ("Wrong reply serial\n");
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+ {
+ _dbus_warn ("Unexpected message return during Ping\n");
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ return TRUE;
+}
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_existent_get_machine_id (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ const char *machine_id;
+
+ message = dbus_message_new_method_call (EXISTENT_SERVICE_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.DBus.Peer",
+ "GetMachineId");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+
+ /* Note: if this test is run in OOM mode, it will block when the bus
+ * doesn't send a reply due to OOM.
+ */
+ block_connection_until_message_from_bus (context, connection, "reply from running GetMachineId");
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message! Should have been reply from GetMachineId message\n");
+ return FALSE;
+ }
+
+ if (dbus_message_get_reply_serial (message) != serial)
+ {
+ _dbus_warn ("Wrong reply serial\n");
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+ {
+ _dbus_warn ("Unexpected message return during GetMachineId\n");
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ machine_id = NULL;
+ if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &machine_id, DBUS_TYPE_INVALID))
+ {
+ _dbus_warn ("Did not get a machine ID in reply to GetMachineId\n");
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ if (machine_id == NULL || strlen (machine_id) != 32)
+ {
+ _dbus_warn ("Machine id looks bogus: '%s'\n", machine_id ? machine_id : "null");
+ dbus_message_unref (message);
+ return FALSE;
+ }
+
+ /* We can't check that the machine id is correct because during make check it is
+ * just made up for each process separately
+ */
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ return TRUE;
+}
/* returns TRUE if the correct thing happens,
* but the correct thing may include OOM errors.
*/
static dbus_bool_t
-check_existent_service_auto_activation (BusContext *context,
- DBusConnection *connection)
+check_existent_service_auto_start (BusContext *context,
+ DBusConnection *connection)
{
DBusMessage *message;
DBusMessage *base_service_message;
"/org/freedesktop/TestSuite",
"org.freedesktop.TestSuite",
"Echo");
-
+
if (message == NULL)
return TRUE;
- dbus_message_set_auto_activation (message, TRUE);
-
text = TEST_ECHO_MESSAGE;
if (!dbus_message_append_args (message,
DBUS_TYPE_STRING, &text,
if (!dbus_connection_get_is_connected (connection))
{
- _dbus_verbose ("connection was disconnected: %s %d\n", _DBUS_FUNCTION_NAME, __LINE__);
+ _dbus_verbose ("connection was disconnected\n");
return TRUE;
}
retval = FALSE;
-
+
message = pop_message_waiting_for_memory (connection);
if (message == NULL)
{
- _dbus_warn ("Did not receive any messages after auto activation %d on %p\n",
+ _dbus_warn ("Did not receive any messages after auto start %d on %p\n",
serial, connection);
goto out;
}
verbose_message_received (connection, message);
- _dbus_verbose (" (after sending %s)\n", "auto activation");
+ _dbus_verbose (" (after sending %s)\n", "auto start");
/* we should get zero or two ServiceOwnerChanged signals */
if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL)
if (!check_base_service_activated (context, connection,
message, &base_service))
- goto out;
+ goto out;
base_service_message = message;
message = NULL;
message = dbus_connection_borrow_message (connection);
if (message == NULL)
{
- _dbus_warn ("No message after auto activation "
- "(should be a service announcement)");
- dbus_connection_return_message (connection, message);
- message = NULL;
+ _dbus_warn ("No message after auto activation "
+ "(should be a service announcement)\n");
+ dbus_connection_return_message (connection, message);
+ message = NULL;
goto out;
}
dbus_connection_return_message (connection, message);
message = NULL;
- switch (message_kind)
- {
- case GOT_SERVICE_CREATED:
- message = pop_message_waiting_for_memory (connection);
- if (message == NULL)
- {
- _dbus_warn ("Failed to pop message we just put back! "
- "should have been a ServiceOwnerChanged (creation)\n");
+ switch (message_kind)
+ {
+ case GOT_SERVICE_CREATED:
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message we just put back! "
+ "should have been a NameOwnerChanged (creation)\n");
+ goto out;
+ }
+
+ /* Check that ServiceOwnerChanged (creation) was correctly received */
+ if (!check_service_auto_activated (context, connection, EXISTENT_SERVICE_NAME,
+ base_service, message))
+ goto out;
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ break;
+
+ case GOT_SERVICE_DELETED:
+ {
+ /* The service started up and got a base address, but then
+ * failed to register under EXISTENT_SERVICE_NAME
+ */
+ CheckServiceOwnerChangedData socd;
+
+ socd.expected_kind = SERVICE_DELETED;
+ socd.expected_service_name = base_service;
+ socd.failed = FALSE;
+ socd.skip_connection = NULL;
+ bus_test_clients_foreach (check_service_owner_changed_foreach,
+ &socd);
+
+ if (socd.failed)
+ goto out;
+
+ break;
+ }
+
+ case GOT_ERROR:
+ case GOT_SOMETHING_ELSE:
+ _dbus_warn ("Unexpected message after auto activation\n");
+ goto out;
+ }
+ }
+
+ /* OK, now we've dealt with ServiceOwnerChanged signals, now should
+ * come the method reply (or error) from the initial method call
+ */
+
+ /* Note: if this test is run in OOM mode, it will block when the bus
+ * doesn't send a reply due to OOM.
+ */
+ block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message! Should have been reply from echo message\n");
+ goto out;
+ }
+
+ if (dbus_message_get_reply_serial (message) != serial)
+ {
+ _dbus_warn ("Wrong reply serial\n");
+ goto out;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ if (!check_existent_ping (context, connection))
+ goto out;
+
+ if (!check_existent_get_machine_id (context, connection))
+ goto out;
+
+ if (!check_existent_hello_from_self (context, connection))
+ goto out;
+
+ if (!check_send_exit_to_service (context, connection,
+ EXISTENT_SERVICE_NAME,
+ base_service))
+ goto out;
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ if (base_service_message)
+ dbus_message_unref (base_service_message);
+
+ return retval;
+}
+
+#define SERVICE_FILE_MISSING_NAME "org.freedesktop.DBus.TestSuiteEchoServiceDotServiceFileDoesNotExist"
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_launch_service_file_missing (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+
+ message = dbus_message_new_method_call (SERVICE_FILE_MISSING_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.TestSuite",
+ "Echo");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+ block_connection_until_message_from_bus (context, connection, "reply to service file missing should fail to auto-start");
+ bus_test_run_everything (context);
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_verbose ("connection was disconnected\n");
+ return TRUE;
+ }
+
+ retval = FALSE;
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive a reply to %s %d on %p\n",
+ "Echo message (auto activation)", serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
+ {
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+ {
+ _dbus_warn ("Message has wrong sender %s\n",
+ dbus_message_get_sender (message) ?
+ dbus_message_get_sender (message) : "(none)");
+ goto out;
+ }
+
+ if (dbus_message_is_error (message,
+ DBUS_ERROR_NO_MEMORY))
+ {
+ ; /* good, this is a valid response */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_SERVICE_UNKNOWN))
+ {
+ _dbus_verbose("got service unknown\n");
+ ; /* good, this is expected (only valid when using launch helper) */
+ }
+ else
+ {
+ warn_unexpected (connection, message, "not this error");
+
+ goto out;
+ }
+ }
+ else
+ {
+ _dbus_warn ("Did not expect to successfully auto-start missing service\n");
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ return retval;
+}
+
+#define SERVICE_USER_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoUser"
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_launch_service_user_missing (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+
+ message = dbus_message_new_method_call (SERVICE_USER_MISSING_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.TestSuite",
+ "Echo");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+ block_connection_until_message_from_bus (context, connection,
+ "reply to service which should fail to auto-start (missing User)");
+ bus_test_run_everything (context);
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_warn ("connection was disconnected\n");
+ return TRUE;
+ }
+
+ retval = FALSE;
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive a reply to %s %d on %p\n",
+ "Echo message (auto activation)", serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
+ {
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+ {
+ _dbus_warn ("Message has wrong sender %s\n",
+ dbus_message_get_sender (message) ?
+ dbus_message_get_sender (message) : "(none)");
+ goto out;
+ }
+
+ if (dbus_message_is_error (message,
+ DBUS_ERROR_NO_MEMORY))
+ {
+ ; /* good, this is a valid response */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_SPAWN_FILE_INVALID))
+ {
+ _dbus_verbose("got service file invalid\n");
+ ; /* good, this is expected (only valid when using launch helper) */
+ }
+ else
+ {
+ warn_unexpected (connection, message, "not this error");
+
+ goto out;
+ }
+ }
+ else
+ {
+ _dbus_warn ("Did not expect to successfully auto-start missing service\n");
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ return retval;
+}
+
+#define SERVICE_EXEC_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoExec"
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_launch_service_exec_missing (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+
+ message = dbus_message_new_method_call (SERVICE_EXEC_MISSING_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.TestSuite",
+ "Echo");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+ block_connection_until_message_from_bus (context, connection,
+ "reply to service which should fail to auto-start (missing Exec)");
+ bus_test_run_everything (context);
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_warn ("connection was disconnected\n");
+ return TRUE;
+ }
+
+ retval = FALSE;
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive a reply to %s %d on %p\n",
+ "Echo message (auto activation)", serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
+ {
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+ {
+ _dbus_warn ("Message has wrong sender %s\n",
+ dbus_message_get_sender (message) ?
+ dbus_message_get_sender (message) : "(none)");
+ goto out;
+ }
+
+ if (dbus_message_is_error (message,
+ DBUS_ERROR_NO_MEMORY))
+ {
+ ; /* good, this is a valid response */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_SERVICE_UNKNOWN))
+ {
+ _dbus_verbose("could not activate as invalid service file was not added\n");
+ ; /* good, this is expected as we shouldn't have been added to
+ * the activation list with a missing Exec key */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_SPAWN_FILE_INVALID))
+ {
+ _dbus_verbose("got service file invalid\n");
+ ; /* good, this is allowed, and is the message passed back from the
+ * launch helper */
+ }
+ else
+ {
+ warn_unexpected (connection, message, "not this error");
+
+ goto out;
+ }
+ }
+ else
+ {
+ _dbus_warn ("Did not expect to successfully auto-start missing service\n");
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ return retval;
+}
+
+#define SERVICE_SERVICE_MISSING_NAME "org.freedesktop.DBus.TestSuiteNoService"
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_launch_service_service_missing (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+
+ message = dbus_message_new_method_call (SERVICE_SERVICE_MISSING_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.TestSuite",
+ "Echo");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+ block_connection_until_message_from_bus (context, connection,
+ "reply to service which should fail to auto-start (missing Service)");
+ bus_test_run_everything (context);
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_warn ("connection was disconnected\n");
+ return TRUE;
+ }
+
+ retval = FALSE;
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive a reply to %s %d on %p\n",
+ "Echo message (auto activation)", serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
+ {
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+ {
+ _dbus_warn ("Message has wrong sender %s\n",
+ dbus_message_get_sender (message) ?
+ dbus_message_get_sender (message) : "(none)");
+ goto out;
+ }
+
+ if (dbus_message_is_error (message,
+ DBUS_ERROR_NO_MEMORY))
+ {
+ ; /* good, this is a valid response */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_SERVICE_UNKNOWN))
+ {
+ _dbus_verbose("could not activate as invalid service file was not added\n");
+ ; /* good, this is expected as we shouldn't have been added to
+ * the activation list with a missing Exec key */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_SPAWN_FILE_INVALID))
+ {
+ _dbus_verbose("got service file invalid\n");
+ ; /* good, this is allowed, and is the message passed back from the
+ * launch helper */
+ }
+ else
+ {
+ warn_unexpected (connection, message, "not this error");
+
+ goto out;
+ }
+ }
+ else
+ {
+ _dbus_warn ("Did not expect to successfully auto-start missing service\n");
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ return retval;
+}
+
+#define SHELL_FAIL_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceFail"
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_shell_fail_service_auto_start (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+
+ message = dbus_message_new_method_call (SHELL_FAIL_SERVICE_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.TestSuite",
+ "Echo");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+ block_connection_until_message_from_bus (context, connection, "reply to shell Echo on service which should fail to auto-start");
+ bus_test_run_everything (context);
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_verbose ("connection was disconnected\n");
+ return TRUE;
+ }
+
+ retval = FALSE;
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive a reply to %s %d on %p\n",
+ "Echo message (auto activation)", serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
+ {
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+ {
+ _dbus_warn ("Message has wrong sender %s\n",
+ dbus_message_get_sender (message) ?
+ dbus_message_get_sender (message) : "(none)");
+ goto out;
+ }
+
+ if (dbus_message_is_error (message,
+ DBUS_ERROR_NO_MEMORY))
+ {
+ ; /* good, this is a valid response */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_INVALID_ARGS))
+ {
+ _dbus_verbose("got invalid args\n");
+ ; /* good, this is expected also */
+ }
+ else
+ {
+ warn_unexpected (connection, message, "not this error");
+
+ goto out;
+ }
+ }
+ else
+ {
+ _dbus_warn ("Did not expect to successfully auto-start shell fail service\n");
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ return retval;
+}
+
+#define SHELL_SUCCESS_SERVICE_NAME "org.freedesktop.DBus.TestSuiteShellEchoServiceSuccess"
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_shell_service_success_auto_start (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ DBusMessage *base_service_message;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+ const char *base_service;
+ const char *argv[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
+
+ base_service_message = NULL;
+
+ message = dbus_message_new_method_call (SHELL_SUCCESS_SERVICE_NAME,
+ "/org/freedesktop/TestSuite",
+ "org.freedesktop.TestSuite",
+ "Echo");
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+
+ /* now wait for the message bus to hear back from the activated
+ * service.
+ */
+ block_connection_until_message_from_bus (context, connection, "reply to Echo on shell success service");
+ bus_test_run_everything (context);
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_verbose ("connection was disconnected\n");
+ return TRUE;
+ }
+
+ retval = FALSE;
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive any messages after auto start %d on %p\n",
+ serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+ _dbus_verbose (" (after sending %s)\n", "auto start");
+
+ /* we should get zero or two ServiceOwnerChanged signals */
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL)
+ {
+ GotServiceInfo message_kind;
+
+ if (!check_base_service_activated (context, connection,
+ message, &base_service))
+ goto out;
+
+ base_service_message = message;
+ message = NULL;
+
+ /* We may need to block here for the test service to exit or finish up */
+ block_connection_until_message_from_bus (context, connection, "service to exit");
+
+ /* Should get a service creation notification for the activated
+ * service name, or a service deletion on the base service name
+ */
+ message = dbus_connection_borrow_message (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("No message after auto activation "
+ "(should be a service announcement)\n");
+ dbus_connection_return_message (connection, message);
+ message = NULL;
+ goto out;
+ }
+
+ message_kind = check_got_service_info (message);
+
+ dbus_connection_return_message (connection, message);
+ message = NULL;
+
+ switch (message_kind)
+ {
+ case GOT_SERVICE_CREATED:
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message we just put back! "
+ "should have been a NameOwnerChanged (creation)\n");
+ goto out;
+ }
+
+ /* Check that ServiceOwnerChanged (creation) was correctly received */
+ if (!check_service_auto_activated (context, connection, SHELL_SUCCESS_SERVICE_NAME,
+ base_service, message))
+ goto out;
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ break;
+
+ case GOT_SERVICE_DELETED:
+ {
+ /* The service started up and got a base address, but then
+ * failed to register under SHELL_SUCCESS_SERVICE_NAME
+ */
+ CheckServiceOwnerChangedData socd;
+
+ socd.expected_kind = SERVICE_DELETED;
+ socd.expected_service_name = base_service;
+ socd.failed = FALSE;
+ socd.skip_connection = NULL;
+ bus_test_clients_foreach (check_service_owner_changed_foreach,
+ &socd);
+
+ if (socd.failed)
+ goto out;
+
+ break;
+ }
+
+ case GOT_ERROR:
+ case GOT_SOMETHING_ELSE:
+ _dbus_warn ("Unexpected message after auto activation\n");
+ goto out;
+ }
+ }
+
+ /* OK, now we've dealt with ServiceOwnerChanged signals, now should
+ * come the method reply (or error) from the initial method call
+ */
+
+ /* Note: if this test is run in OOM mode, it will block when the bus
+ * doesn't send a reply due to OOM.
+ */
+ block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message! Should have been reply from echo message\n");
+ goto out;
+ }
+
+ if (dbus_message_get_reply_serial (message) != serial)
+ {
+ _dbus_warn ("Wrong reply serial\n");
+ goto out;
+ }
+
+ if (!dbus_message_get_args (message, NULL,
+ DBUS_TYPE_STRING, &argv[0],
+ DBUS_TYPE_STRING, &argv[1],
+ DBUS_TYPE_STRING, &argv[2],
+ DBUS_TYPE_STRING, &argv[3],
+ DBUS_TYPE_STRING, &argv[4],
+ DBUS_TYPE_STRING, &argv[5],
+ DBUS_TYPE_STRING, &argv[6],
+ DBUS_TYPE_INVALID))
+ {
+ _dbus_warn ("Error getting arguments from return\n");
+ goto out;
+ }
+
+ /* don't worry about arg[0] as it may be different
+ depending on the path to the tests
+ */
+ if (strcmp("-test", argv[1]) != 0)
+ {
+ _dbus_warn ("Unexpected argv[1] in shell success service test (expected: %s, got: %s)\n",
+ "-test", argv[1]);
+ goto out;
+ }
+
+ if (strcmp("that", argv[2]) != 0)
+ {
+ _dbus_warn ("Unexpected argv[2] in shell success service test (expected: %s, got: %s)\n",
+ "that", argv[2]);
+ goto out;
+ }
+
+ if (strcmp("we get", argv[3]) != 0)
+ {
+ _dbus_warn ("Unexpected argv[3] in shell success service test (expected: %s, got: %s)\n",
+ "we get", argv[3]);
+ goto out;
+ }
+
+ if (strcmp("back", argv[4]) != 0)
+ {
+ _dbus_warn ("Unexpected argv[4] in shell success service test (expected: %s, got: %s)\n",
+ "back", argv[4]);
+ goto out;
+ }
+
+ if (strcmp("--what", argv[5]) != 0)
+ {
+ _dbus_warn ("Unexpected argv[5] in shell success service test (expected: %s, got: %s)\n",
+ "--what", argv[5]);
+ goto out;
+ }
+
+ if (strcmp("we put in", argv[6]) != 0)
+ {
+ _dbus_warn ("Unexpected argv[6] in shell success service test (expected: %s, got: %s)\n",
+ "we put in", argv[6]);
+ goto out;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ if (!check_send_exit_to_service (context, connection,
+ SHELL_SUCCESS_SERVICE_NAME,
+ base_service))
+ goto out;
+
+ retval = TRUE;
+
+ out:
+ if (message)
+ dbus_message_unref (message);
+
+ if (base_service_message)
+ dbus_message_unref (base_service_message);
+
+ return retval;
+}
+
+typedef struct
+{
+ Check1Func func;
+ BusContext *context;
+} Check1Data;
+
+static dbus_bool_t
+check_oom_check1_func (void *data)
+{
+ Check1Data *d = data;
+
+ if (! (* d->func) (d->context))
+ return FALSE;
+
+ if (!check_no_leftovers (d->context))
+ {
+ _dbus_warn ("Messages were left over, should be covered by test suite\n");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void
+check1_try_iterations (BusContext *context,
+ const char *description,
+ Check1Func func)
+{
+ Check1Data d;
+
+ d.func = func;
+ d.context = context;
+
+ if (!_dbus_test_oom_handling (description, check_oom_check1_func,
+ &d))
+ _dbus_assert_not_reached ("test failed");
+}
+
+static dbus_bool_t
+check_get_services (BusContext *context,
+ DBusConnection *connection,
+ const char *method,
+ char ***services,
+ int *len)
+{
+ DBusMessage *message;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+ DBusError error;
+ char **srvs;
+ int l;
+
+ retval = FALSE;
+ dbus_error_init (&error);
+ message = NULL;
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ method);
+
+ if (message == NULL)
+ return TRUE;
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ /* send our message */
+ bus_test_run_clients_loop (SEND_PENDING (connection));
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ dbus_connection_ref (connection); /* because we may get disconnected */
+ block_connection_until_message_from_bus (context, connection, "reply to ListActivatableNames/ListNames");
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_verbose ("connection was disconnected\n");
+
+ dbus_connection_unref (connection);
+
+ return TRUE;
+ }
+
+ dbus_connection_unref (connection);
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive a reply to %s %d on %p\n",
+ method, serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
+ {
+ if (dbus_message_is_error (message, DBUS_ERROR_NO_MEMORY))
+ {
+ ; /* good, this is a valid response */
+ }
+ else
+ {
+ warn_unexpected (connection, message, "not this error");
+
+ goto out;
+ }
+ }
+ else
+ {
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
+ {
+ ; /* good, expected */
+ }
+ else
+ {
+ warn_unexpected (connection, message,
+ "method_return for ListActivatableNames/ListNames");
+
+ goto out;
+ }
+
+ retry_get_property:
+
+ if (!dbus_message_get_args (message, &error,
+ DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING,
+ &srvs, &l,
+ DBUS_TYPE_INVALID))
+ {
+ if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
+ {
+ _dbus_verbose ("no memory to list services by %s\n", method);
+ dbus_error_free (&error);
+ _dbus_wait_for_memory ();
+ goto retry_get_property;
+ }
+ else
+ {
+ _dbus_assert (dbus_error_is_set (&error));
+ _dbus_warn ("Did not get the expected DBUS_TYPE_ARRAY from %s\n", method);
+ goto out;
+ }
+ } else {
+ *services = srvs;
+ *len = l;
+ }
+ }
+
+ if (!check_no_leftovers (context))
+ goto out;
+
+ retval = TRUE;
+
+ out:
+ dbus_error_free (&error);
+
+ if (message)
+ dbus_message_unref (message);
+
+ return retval;
+}
+
+/* returns TRUE if the correct thing happens,
+ * but the correct thing may include OOM errors.
+ */
+static dbus_bool_t
+check_list_services (BusContext *context,
+ DBusConnection *connection)
+{
+ DBusMessage *message;
+ DBusMessage *base_service_message;
+ const char *base_service;
+ dbus_uint32_t serial;
+ dbus_bool_t retval;
+ const char *existent = EXISTENT_SERVICE_NAME;
+ dbus_uint32_t flags;
+ char **services;
+ int len;
+
+ _dbus_verbose ("check_list_services for %p\n", connection);
+
+ if (!check_get_services (context, connection, "ListActivatableNames", &services, &len))
+ {
+ return TRUE;
+ }
+
+ if (!_dbus_string_array_contains ((const char **)services, existent))
+ {
+ _dbus_warn ("Did not get the expected %s from ListActivatableNames\n", existent);
+ dbus_free_string_array (services);
+ return FALSE;
+ }
+
+ dbus_free_string_array (services);
+
+ base_service_message = NULL;
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "StartServiceByName");
+
+ if (message == NULL)
+ return TRUE;
+
+ dbus_message_set_auto_start (message, FALSE);
+
+ flags = 0;
+ if (!dbus_message_append_args (message,
+ DBUS_TYPE_STRING, &existent,
+ DBUS_TYPE_UINT32, &flags,
+ DBUS_TYPE_INVALID))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ if (!dbus_connection_send (connection, message, &serial))
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
+
+ dbus_message_unref (message);
+ message = NULL;
+
+ bus_test_run_everything (context);
+
+ /* now wait for the message bus to hear back from the activated
+ * service.
+ */
+ block_connection_until_message_from_bus (context, connection, "activated service to connect");
+
+ bus_test_run_everything (context);
+
+ if (!dbus_connection_get_is_connected (connection))
+ {
+ _dbus_verbose ("connection was disconnected\n");
+ return TRUE;
+ }
+
+ retval = FALSE;
+
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive any messages after %s %d on %p\n",
+ "StartServiceByName", serial, connection);
+ goto out;
+ }
+
+ verbose_message_received (connection, message);
+ _dbus_verbose (" (after sending %s)\n", "StartServiceByName");
+
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
+ {
+ if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+ {
+ _dbus_warn ("Message has wrong sender %s\n",
+ dbus_message_get_sender (message) ?
+ dbus_message_get_sender (message) : "(none)");
+ goto out;
+ }
+
+ if (dbus_message_is_error (message,
+ DBUS_ERROR_NO_MEMORY))
+ {
+ ; /* good, this is a valid response */
+ }
+ else if (dbus_message_is_error (message,
+ DBUS_ERROR_SPAWN_CHILD_EXITED) ||
+ dbus_message_is_error (message,
+ DBUS_ERROR_SPAWN_CHILD_SIGNALED) ||
+ dbus_message_is_error (message,
+ DBUS_ERROR_SPAWN_EXEC_FAILED))
+ {
+ ; /* good, this is expected also */
+ }
+ else
+ {
+ _dbus_warn ("Did not expect error %s\n",
+ dbus_message_get_error_name (message));
+ goto out;
+ }
+ }
+ else
+ {
+ GotServiceInfo message_kind;
+
+ if (!check_base_service_activated (context, connection,
+ message, &base_service))
+ goto out;
+
+ base_service_message = message;
+ message = NULL;
+
+ /* We may need to block here for the test service to exit or finish up */
+ block_connection_until_message_from_bus (context, connection, "test service to exit or finish up");
+
+ message = dbus_connection_borrow_message (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Did not receive any messages after base service creation notification\n");
+ goto out;
+ }
+
+ message_kind = check_got_service_info (message);
+
+ dbus_connection_return_message (connection, message);
+ message = NULL;
+
+ switch (message_kind)
+ {
+ case GOT_SOMETHING_ELSE:
+ case GOT_ERROR:
+ case GOT_SERVICE_DELETED:
+ _dbus_warn ("Unexpected message after ActivateService "
+ "(should be an error or a service announcement)\n");
+ goto out;
+
+ case GOT_SERVICE_CREATED:
+ message = pop_message_waiting_for_memory (connection);
+ if (message == NULL)
+ {
+ _dbus_warn ("Failed to pop message we just put back! "
+ "should have been a NameOwnerChanged (creation)\n");
goto out;
}
-
- /* Check that ServiceOwnerChanged (creation) was correctly received */
- if (!check_service_auto_activated (context, connection, EXISTENT_SERVICE_NAME,
- base_service, message))
+
+ if (!check_service_activated (context, connection, EXISTENT_SERVICE_NAME,
+ base_service, message))
goto out;
-
+
dbus_message_unref (message);
message = NULL;
- break;
-
- case GOT_SERVICE_DELETED:
- {
- /* The service started up and got a base address, but then
- * failed to register under EXISTENT_SERVICE_NAME
- */
- CheckServiceOwnerChangedData socd;
-
- socd.expected_kind = SERVICE_DELETED;
- socd.expected_service_name = base_service;
- socd.failed = FALSE;
- socd.skip_connection = NULL;
- bus_test_clients_foreach (check_service_owner_changed_foreach,
- &socd);
-
- if (socd.failed)
+ if (!check_no_leftovers (context))
+ {
+ _dbus_warn ("Messages were left over after successful activation\n");
goto out;
+ }
- break;
- }
-
- case GOT_ERROR:
- case GOT_SOMETHING_ELSE:
- _dbus_warn ("Unexpected message after auto activation\n");
- goto out;
+ break;
}
}
- /* OK, now we've dealt with ServiceOwnerChanged signals, now should
- * come the method reply (or error) from the initial method call
- */
-
- /* Note: if this test is run in OOM mode, it will block when the bus
- * doesn't send a reply due to OOM.
- */
- block_connection_until_message_from_bus (context, connection, "reply from echo message after auto-activation");
-
- message = pop_message_waiting_for_memory (connection);
- if (message == NULL)
+ if (!check_get_services (context, connection, "ListNames", &services, &len))
{
- _dbus_warn ("Failed to pop message! Should have been reply from echo message\n");
- goto out;
+ return TRUE;
}
- if (dbus_message_get_reply_serial (message) != serial)
+ if (!_dbus_string_array_contains ((const char **)services, existent))
{
- _dbus_warn ("Wrong reply serial\n");
+ _dbus_warn ("Did not get the expected %s from ListNames\n", existent);
goto out;
}
- dbus_message_unref (message);
- message = NULL;
-
+ dbus_free_string_array (services);
+
if (!check_send_exit_to_service (context, connection,
- EXISTENT_SERVICE_NAME,
- base_service))
+ EXISTENT_SERVICE_NAME, base_service))
goto out;
-
+
retval = TRUE;
out:
typedef struct
{
- Check1Func func;
- BusContext *context;
-} Check1Data;
-
-static dbus_bool_t
-check_oom_check1_func (void *data)
-{
- Check1Data *d = data;
-
- if (! (* d->func) (d->context))
- return FALSE;
-
- if (!check_no_leftovers (d->context))
- {
- _dbus_warn ("Messages were left over, should be covered by test suite\n");
- return FALSE;
- }
-
- return TRUE;
-}
-
-static void
-check1_try_iterations (BusContext *context,
- const char *description,
- Check1Func func)
-{
- Check1Data d;
-
- d.func = func;
- d.context = context;
-
- if (!_dbus_test_oom_handling (description, check_oom_check1_func,
- &d))
- _dbus_assert_not_reached ("test failed");
-}
-
-typedef struct
-{
Check2Func func;
BusContext *context;
DBusConnection *connection;
if (! (* d->func) (d->context, d->connection))
return FALSE;
-
+
if (!check_no_leftovers (d->context))
{
- _dbus_warn ("Messages were left over, should be covered by test suite");
+ _dbus_warn ("Messages were left over, should be covered by test suite\n");
return FALSE;
}
d.func = func;
d.context = context;
d.connection = connection;
-
+
if (!_dbus_test_oom_handling (description, check_oom_check2_func,
&d))
{
}
}
-dbus_bool_t
-bus_dispatch_test (const DBusString *test_data_dir)
+static dbus_bool_t
+setenv_TEST_LAUNCH_HELPER_CONFIG(const DBusString *test_data_dir,
+ const char *filename)
+{
+ DBusString full;
+ DBusString file;
+
+ if (!_dbus_string_init (&full))
+ return FALSE;
+
+ if (!_dbus_string_copy (test_data_dir, 0, &full, 0))
+ {
+ _dbus_string_free (&full);
+ return FALSE;
+ }
+
+ _dbus_string_init_const (&file, filename);
+
+ if (!_dbus_concat_dir_and_file (&full, &file))
+ {
+ _dbus_string_free (&full);
+ return FALSE;
+ }
+
+ _dbus_verbose ("Setting TEST_LAUNCH_HELPER_CONFIG to '%s'\n",
+ _dbus_string_get_const_data (&full));
+
+ dbus_setenv ("TEST_LAUNCH_HELPER_CONFIG", _dbus_string_get_const_data (&full));
+
+ _dbus_string_free (&full);
+
+ return TRUE;
+}
+
+static dbus_bool_t
+bus_dispatch_test_conf (const DBusString *test_data_dir,
+ const char *filename,
+ dbus_bool_t use_launcher)
{
BusContext *context;
DBusConnection *foo;
DBusConnection *baz;
DBusError error;
+ /* save the config name for the activation helper */
+ if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename))
+ _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
+
dbus_error_init (&error);
-
- context = bus_context_new_test (test_data_dir,
- "valid-config-files/debug-allow-all.conf");
+
+ context = bus_context_new_test (test_data_dir, filename);
if (context == NULL)
return FALSE;
-
- foo = dbus_connection_open ("debug-pipe:name=test-server", &error);
+
+ foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (foo == NULL)
_dbus_assert_not_reached ("could not alloc connection");
_dbus_assert_not_reached ("could not set up connection");
spin_connection_until_authenticated (context, foo);
-
+
if (!check_hello_message (context, foo))
_dbus_assert_not_reached ("hello message failed");
if (!check_add_match_all (context, foo))
_dbus_assert_not_reached ("AddMatch message failed");
-
- bar = dbus_connection_open ("debug-pipe:name=test-server", &error);
+
+ bar = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (bar == NULL)
_dbus_assert_not_reached ("could not alloc connection");
_dbus_assert_not_reached ("could not set up connection");
spin_connection_until_authenticated (context, bar);
-
+
if (!check_hello_message (context, bar))
_dbus_assert_not_reached ("hello message failed");
if (!check_add_match_all (context, bar))
_dbus_assert_not_reached ("AddMatch message failed");
-
- baz = dbus_connection_open ("debug-pipe:name=test-server", &error);
+
+ baz = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (baz == NULL)
_dbus_assert_not_reached ("could not alloc connection");
_dbus_assert_not_reached ("could not set up connection");
spin_connection_until_authenticated (context, baz);
-
+
if (!check_hello_message (context, baz))
_dbus_assert_not_reached ("hello message failed");
if (!check_add_match_all (context, baz))
_dbus_assert_not_reached ("AddMatch message failed");
+#ifdef DBUS_WIN_FIXME
+ _dbus_warn("TODO: testing of GetConnectionUnixUser message skipped for now\n");
+ _dbus_warn("TODO: testing of GetConnectionUnixProcessID message skipped for now\n");
+#else
if (!check_get_connection_unix_user (context, baz))
_dbus_assert_not_reached ("GetConnectionUnixUser message failed");
if (!check_get_connection_unix_process_id (context, baz))
_dbus_assert_not_reached ("GetConnectionUnixProcessID message failed");
-
+#endif
+
+ if (!check_list_services (context, baz))
+ _dbus_assert_not_reached ("ListActivatableNames message failed");
+
if (!check_no_leftovers (context))
{
- _dbus_warn ("Messages were left over after setting up initial connections");
+ _dbus_warn ("Messages were left over after setting up initial connections\n");
_dbus_assert_not_reached ("initial connection setup failed");
}
-
+
check1_try_iterations (context, "create_and_hello",
check_hello_connection);
-
- check2_try_iterations (context, foo, "nonexistent_service_activation",
- check_nonexistent_service_activation);
-
- check2_try_iterations (context, foo, "segfault_service_activation",
- check_segfault_service_activation);
-
- check2_try_iterations (context, foo, "existent_service_activation",
- check_existent_service_activation);
-
- check2_try_iterations (context, foo, "nonexistent_service_auto_activation",
- check_nonexistent_service_auto_activation);
-
- check2_try_iterations (context, foo, "segfault_service_auto_activation",
- check_segfault_service_auto_activation);
+
+ check2_try_iterations (context, foo, "nonexistent_service_no_auto_start",
+ check_nonexistent_service_no_auto_start);
+
+#ifdef DBUS_WIN_FIXME
+ _dbus_warn("TODO: dispatch.c segfault_service_no_auto_start test\n");
+#else
+ check2_try_iterations (context, foo, "segfault_service_no_auto_start",
+ check_segfault_service_no_auto_start);
+#endif
+
+ check2_try_iterations (context, foo, "existent_service_no_auto_start",
+ check_existent_service_no_auto_start);
+
+ check2_try_iterations (context, foo, "nonexistent_service_auto_start",
+ check_nonexistent_service_auto_start);
+
+
+#ifdef DBUS_WIN_FIXME
+ _dbus_warn("TODO: dispatch.c segfault_service_auto_start test\n");
+#else
+ /* only do the segfault test if we are not using the launcher */
+ check2_try_iterations (context, foo, "segfault_service_auto_start",
+ check_segfault_service_auto_start);
+#endif
+
+ /* only do the shell fail test if we are not using the launcher */
+ check2_try_iterations (context, foo, "shell_fail_service_auto_start",
+ check_shell_fail_service_auto_start);
+
+ /* specific to launcher */
+ if (use_launcher)
+ if (!check_launch_service_file_missing (context, foo))
+ _dbus_assert_not_reached ("did not get service file not found error");
#if 0
/* Note: need to resolve some issues with the testing code in order to run
* this in oom (handle that we sometimes don't get replies back from the bus
* when oom happens, without blocking the test).
*/
- check2_try_iterations (context, foo, "existent_service_auto_activation",
- check_existent_service_auto_activation);
+ check2_try_iterations (context, foo, "existent_service_auto_auto_start",
+ check_existent_service_auto_start);
#endif
-
- if (!check_existent_service_auto_activation (context, foo))
- _dbus_assert_not_reached ("existent service auto activation failed");
+
+ if (!check_existent_service_auto_start (context, foo))
+ _dbus_assert_not_reached ("existent service auto start failed");
+
+ if (!check_shell_service_success_auto_start (context, foo))
+ _dbus_assert_not_reached ("shell success service auto start failed");
_dbus_verbose ("Disconnecting foo, bar, and baz\n");
kill_client_connection_unchecked (baz);
bus_context_unref (context);
-
+
+ return TRUE;
+}
+
+static dbus_bool_t
+bus_dispatch_test_conf_fail (const DBusString *test_data_dir,
+ const char *filename)
+{
+ BusContext *context;
+ DBusConnection *foo;
+ DBusError error;
+
+ /* save the config name for the activation helper */
+ if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename))
+ _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
+
+ dbus_error_init (&error);
+
+ context = bus_context_new_test (test_data_dir, filename);
+ if (context == NULL)
+ return FALSE;
+
+ foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
+ if (foo == NULL)
+ _dbus_assert_not_reached ("could not alloc connection");
+
+ if (!bus_setup_debug_client (foo))
+ _dbus_assert_not_reached ("could not set up connection");
+
+ spin_connection_until_authenticated (context, foo);
+
+ if (!check_hello_message (context, foo))
+ _dbus_assert_not_reached ("hello message failed");
+
+ if (!check_double_hello_message (context, foo))
+ _dbus_assert_not_reached ("double hello message failed");
+
+ if (!check_add_match_all (context, foo))
+ _dbus_assert_not_reached ("AddMatch message failed");
+
+ /* this only tests the activation.c user check */
+ if (!check_launch_service_user_missing (context, foo))
+ _dbus_assert_not_reached ("user missing did not trigger error");
+
+ /* this only tests the desktop.c exec check */
+ if (!check_launch_service_exec_missing (context, foo))
+ _dbus_assert_not_reached ("exec missing did not trigger error");
+
+ /* this only tests the desktop.c service check */
+ if (!check_launch_service_service_missing (context, foo))
+ _dbus_assert_not_reached ("service missing did not trigger error");
+
+ _dbus_verbose ("Disconnecting foo\n");
+
+ kill_client_connection_unchecked (foo);
+
+ bus_context_unref (context);
+
+ return TRUE;
+}
+
+dbus_bool_t
+bus_dispatch_test (const DBusString *test_data_dir)
+{
+ /* run normal activation tests */
+ _dbus_verbose ("Normal activation tests\n");
+ if (!bus_dispatch_test_conf (test_data_dir,
+ "valid-config-files/debug-allow-all.conf", FALSE))
+ return FALSE;
+
+#ifdef DBUS_WIN
+ _dbus_warn("Info: Launch helper activation tests skipped because launch-helper is not supported yet\n");
+#else
+ /* run launch-helper activation tests */
+ _dbus_verbose ("Launch helper activation tests\n");
+ if (!bus_dispatch_test_conf (test_data_dir,
+ "valid-config-files-system/debug-allow-all-pass.conf", TRUE))
+ return FALSE;
+
+ /* run select launch-helper activation tests on broken service files */
+ if (!bus_dispatch_test_conf_fail (test_data_dir,
+ "valid-config-files-system/debug-allow-all-fail.conf"))
+ return FALSE;
+#endif
+
return TRUE;
}
DBusError error;
dbus_error_init (&error);
-
+
/* Test SHA1 authentication */
_dbus_verbose ("Testing SHA1 context\n");
-
+
context = bus_context_new_test (test_data_dir,
"valid-config-files/debug-allow-all-sha1.conf");
if (context == NULL)
return FALSE;
- foo = dbus_connection_open ("debug-pipe:name=test-server", &error);
+ foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (foo == NULL)
_dbus_assert_not_reached ("could not alloc connection");
_dbus_assert_not_reached ("could not set up connection");
spin_connection_until_authenticated (context, foo);
-
+
if (!check_hello_message (context, foo))
_dbus_assert_not_reached ("hello message failed");
if (!check_add_match_all (context, foo))
_dbus_assert_not_reached ("addmatch message failed");
-
+
if (!check_no_leftovers (context))
{
_dbus_warn ("Messages were left over after setting up initial SHA-1 connection\n");
_dbus_assert_not_reached ("initial connection setup failed");
}
-
+
check1_try_iterations (context, "create_and_hello_sha1",
check_hello_connection);
return TRUE;
}
-#endif /* DBUS_BUILD_TESTS */
+#ifdef HAVE_UNIX_FD_PASSING
+
+dbus_bool_t
+bus_unix_fds_passing_test(const DBusString *test_data_dir)
+{
+ BusContext *context;
+ DBusConnection *foo, *bar;
+ DBusError error;
+ DBusMessage *m;
+ int one[2], two[2], x, y, z;
+ char r;
+
+ dbus_error_init (&error);
+
+ context = bus_context_new_test (test_data_dir, "valid-config-files/debug-allow-all.conf");
+ if (context == NULL)
+ _dbus_assert_not_reached ("could not alloc context");
+
+ foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
+ if (foo == NULL)
+ _dbus_assert_not_reached ("could not alloc connection");
+
+ if (!bus_setup_debug_client (foo))
+ _dbus_assert_not_reached ("could not set up connection");
+
+ spin_connection_until_authenticated (context, foo);
+
+ if (!check_hello_message (context, foo))
+ _dbus_assert_not_reached ("hello message failed");
+
+ if (!check_add_match_all (context, foo))
+ _dbus_assert_not_reached ("AddMatch message failed");
+
+ bar = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
+ if (bar == NULL)
+ _dbus_assert_not_reached ("could not alloc connection");
+
+ if (!bus_setup_debug_client (bar))
+ _dbus_assert_not_reached ("could not set up connection");
+
+ spin_connection_until_authenticated (context, bar);
+
+ if (!check_hello_message (context, bar))
+ _dbus_assert_not_reached ("hello message failed");
+
+ if (!check_add_match_all (context, bar))
+ _dbus_assert_not_reached ("AddMatch message failed");
+
+ if (!(m = dbus_message_new_signal("/", "a.b.c", "d")))
+ _dbus_assert_not_reached ("could not alloc message");
+
+ if (!(_dbus_full_duplex_pipe(one, one+1, TRUE, &error)))
+ _dbus_assert_not_reached("Failed to allocate pipe #1");
+
+ if (!(_dbus_full_duplex_pipe(two, two+1, TRUE, &error)))
+ _dbus_assert_not_reached("Failed to allocate pipe #2");
+
+ if (!dbus_message_append_args(m,
+ DBUS_TYPE_UNIX_FD, one,
+ DBUS_TYPE_UNIX_FD, two,
+ DBUS_TYPE_UNIX_FD, two,
+ DBUS_TYPE_INVALID))
+ _dbus_assert_not_reached("Failed to attach fds.");
+
+ if (!_dbus_close(one[0], &error))
+ _dbus_assert_not_reached("Failed to close pipe #1 ");
+ if (!_dbus_close(two[0], &error))
+ _dbus_assert_not_reached("Failed to close pipe #2 ");
+
+ if (!(dbus_connection_can_send_type(foo, DBUS_TYPE_UNIX_FD)))
+ _dbus_assert_not_reached("Connection cannot do fd passing");
+
+ if (!(dbus_connection_can_send_type(bar, DBUS_TYPE_UNIX_FD)))
+ _dbus_assert_not_reached("Connection cannot do fd passing");
+
+ if (!dbus_connection_send (foo, m, NULL))
+ _dbus_assert_not_reached("Failed to send fds");
+
+ dbus_message_unref(m);
+
+ bus_test_run_clients_loop (SEND_PENDING (foo));
+
+ bus_test_run_everything (context);
+
+ block_connection_until_message_from_bus (context, foo, "unix fd reception on foo");
+
+ if (!(m = pop_message_waiting_for_memory (foo)))
+ _dbus_assert_not_reached("Failed to receive msg");
+
+ if (!dbus_message_is_signal(m, "a.b.c", "d"))
+ _dbus_assert_not_reached("bogus message received");
+
+ dbus_message_unref(m);
+
+ block_connection_until_message_from_bus (context, bar, "unix fd reception on bar");
+
+ if (!(m = pop_message_waiting_for_memory (bar)))
+ _dbus_assert_not_reached("Failed to receive msg");
+
+ if (!dbus_message_is_signal(m, "a.b.c", "d"))
+ _dbus_assert_not_reached("bogus message received");
+
+ if (!dbus_message_get_args(m,
+ &error,
+ DBUS_TYPE_UNIX_FD, &x,
+ DBUS_TYPE_UNIX_FD, &y,
+ DBUS_TYPE_UNIX_FD, &z,
+ DBUS_TYPE_INVALID))
+ _dbus_assert_not_reached("Failed to parse fds.");
+
+ dbus_message_unref(m);
+
+ if (write(x, "X", 1) != 1)
+ _dbus_assert_not_reached("Failed to write to pipe #1");
+ if (write(y, "Y", 1) != 1)
+ _dbus_assert_not_reached("Failed to write to pipe #2");
+ if (write(z, "Z", 1) != 1)
+ _dbus_assert_not_reached("Failed to write to pipe #2/2nd fd");
+
+ if (!_dbus_close(x, &error))
+ _dbus_assert_not_reached("Failed to close pipe #1/other side ");
+ if (!_dbus_close(y, &error))
+ _dbus_assert_not_reached("Failed to close pipe #2/other side ");
+ if (!_dbus_close(z, &error))
+ _dbus_assert_not_reached("Failed to close pipe #2/other size 2nd fd ");
+
+ if (read(one[1], &r, 1) != 1 || r != 'X')
+ _dbus_assert_not_reached("Failed to read value from pipe.");
+ if (read(two[1], &r, 1) != 1 || r != 'Y')
+ _dbus_assert_not_reached("Failed to read value from pipe.");
+ if (read(two[1], &r, 1) != 1 || r != 'Z')
+ _dbus_assert_not_reached("Failed to read value from pipe.");
+
+ if (!_dbus_close(one[1], &error))
+ _dbus_assert_not_reached("Failed to close pipe #1 ");
+ if (!_dbus_close(two[1], &error))
+ _dbus_assert_not_reached("Failed to close pipe #2 ");
+
+ _dbus_verbose ("Disconnecting foo\n");
+ kill_client_connection_unchecked (foo);
+
+ _dbus_verbose ("Disconnecting bar\n");
+ kill_client_connection_unchecked (bar);
+
+ bus_context_unref (context);
+
+ return TRUE;
+}
+#endif
+
+#endif /* DBUS_ENABLE_EMBEDDED_TESTS */
projects / platform / upstream / dbus.git / blobdiff