/* -*- mode: C; c-file-style: "gnu" -*- */

/* dispatch.c  Message dispatcher

 *

 * Copyright (C) 2003  CodeFactory AB

 * Copyright (C) 2003, 2004, 2005  Red Hat, Inc.

 * Copyright (C) 2004  Imendio HB

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * 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

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * 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

 *

 */

#include "dispatch.h"

#include "connection.h"

#include "driver.h"

#include "services.h"

#include "activation.h"

#include "utils.h"

#include "bus.h"

#include "signals.h"

#include "test.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-internals.h>

#else

#include "dbus-internals.h"

#endif //__SYMBIAN32__

#include <string.h>

#ifdef __SYMBIAN32__

#include "config.h"

#endif //__SYMBIAN32__

static dbus_bool_t

send_one_message (DBusConnection *connection,

                  BusContext     *context,

                  DBusConnection *sender,

                  DBusConnection *addressed_recipient,

                  DBusMessage    *message,

                  BusTransaction *transaction,

                  DBusError      *error)

{

  if (!bus_context_check_security_policy (context, transaction,

                                          sender,

                                          addressed_recipient,

                                          connection,

                                          message,

                                          NULL))

    return TRUE; /* silently don't send it */

  if (!bus_transaction_send (transaction,

                             connection,

                             message))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  return TRUE;

}

dbus_bool_t

bus_dispatch_matches (BusTransaction *transaction,

                      DBusConnection *sender,

                      DBusConnection *addressed_recipient,

                      DBusMessage    *message,

                      DBusError      *error)

{

  DBusError tmp_error;

  BusConnections *connections;

  DBusList *recipients;

  BusMatchmaker *matchmaker;

  DBusList *link;

  BusContext *context;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  /* sender and recipient can both be NULL for the bus driver,

   * or for signals with no particular recipient

   */

  _dbus_assert (sender == NULL || bus_connection_is_active (sender));

  _dbus_assert (dbus_message_get_sender (message) != NULL);

  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;

  if (!bus_matchmaker_get_recipients (matchmaker, connections,

                                      sender, addressed_recipient, message,

                                      &recipients))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  link = _dbus_list_get_first_link (&recipients);

  while (link != NULL)

    {

      DBusConnection *dest;

      dest = link->data;

      if (!send_one_message (dest, context, sender, addressed_recipient,

                             message, transaction, &tmp_error))

        break;

      link = _dbus_list_get_next_link (&recipients, link);

    }

  _dbus_list_clear (&recipients);

  if (dbus_error_is_set (&tmp_error))

    {

      dbus_move_error (&tmp_error, error);

      return FALSE;

    }

  else

    return TRUE;

}

static DBusHandlerResult

bus_dispatch (DBusConnection *connection,

              DBusMessage    *message)

{

  const char *sender, *service_name;

  DBusError error;

  BusTransaction *transaction;

  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

  {

    const char *interface_name, *member_name, *error_name;

    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)",

                   error_name ? error_name : "(no error name)",

                   service_name ? service_name : "peer");

  }

#endif /* DBUS_ENABLE_VERBOSE_MODE */

  /* 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_LOCAL,

                                  "Disconnected"))

        {

          bus_connection_disconnected (connection);

          goto out;

        }

      if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL)

        {

          /* DBusConnection also handles some of these automatically, we leave

           * it to do so.

           */

          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

          goto out;

        }

    }

  /* Create our transaction */

  transaction = bus_transaction_new (context);

  if (transaction == NULL)

    {

      BUS_SET_OOM (&error);

      goto out;

    }

  /* Assign a sender to the message */

  if (bus_connection_is_active (connection))

    {

      sender = bus_connection_get_name (connection);

      _dbus_assert (sender != NULL);

      if (!dbus_message_set_sender (message, sender))

        {

          BUS_SET_OOM (&error);

          goto out;

        }

      /* We need to refetch the service name here, because

       * dbus_message_set_sender can cause the header to be

       * reallocated, and thus the service_name pointer will become

       * invalid.

       */

      service_name = dbus_message_get_destination (message);

    }

  if (service_name &&

      strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */

    {

      if (!bus_context_check_security_policy (context, transaction,

                                              connection, NULL, NULL, message, &error))

        {

          _dbus_verbose ("Security policy rejected message\n");

          goto out;

        }

      _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_close (connection);

      goto out;

    }

  else if (service_name != NULL) /* route to named service */

    {

      DBusString service_string;

      BusService *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_start (message))

        {

          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);

          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;

            }

          goto out;

        }

      else if (service == NULL)

        {

          dbus_set_error (&error,

                          DBUS_ERROR_NAME_HAS_NO_OWNER,

                          "Name \"%s\" does not exist",

                          service_name);

          goto out;

        }

      else

        {

          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.

   */

  if (!bus_dispatch_matches (transaction, connection, addressed_recipient, message, &error))

    goto out;

 out:

  if (dbus_error_is_set (&error))

    {

      if (!dbus_connection_get_is_connected (connection))

        {

          /* If we disconnected it, we won't bother to send it any error

           * messages.

           */

          _dbus_verbose ("Not sending error to connection we disconnected\n");

        }

      else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

        {

          bus_connection_send_oom_error (connection, message);

          /* cancel transaction due to OOM */

          if (transaction != NULL)

            {

              bus_transaction_cancel_and_free (transaction);

              transaction = NULL;

            }

        }

      else

        {

          /* Try to send the real error, if no mem to do that, send

           * 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)

                {

                  bus_transaction_cancel_and_free (transaction);

                  transaction = NULL;

                }

            }

        }

      dbus_error_free (&error);

    }

  if (transaction != NULL)

    {

      bus_transaction_execute_and_free (transaction);

    }

  dbus_connection_unref (connection);

  return result;

}

static DBusHandlerResult

bus_dispatch_message_filter (DBusConnection     *connection,

                             DBusMessage        *message,

                             void               *user_data)

{

  return bus_dispatch (connection, message);

}

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;

}

void

bus_dispatch_remove_connection (DBusConnection *connection)

{

  /* Here we tell the bus driver that we want to get off. */

  bus_driver_remove_connection (connection);

  dbus_connection_remove_filter (connection,

                                 bus_dispatch_message_filter,

                                 NULL);

}

#ifdef DBUS_BUILD_TESTS

#include <stdio.h>

/* This is used to know whether we need to block in order to finish

 * sending a message, or whether the initial dbus_connection_send()

 * already flushed the queue.

 */

#define SEND_PENDING(connection) (dbus_connection_has_messages_to_send (connection))

typedef dbus_bool_t (* Check1Func) (BusContext     *context);

typedef dbus_bool_t (* Check2Func) (BusContext     *context,

                                    DBusConnection *connection);

static dbus_bool_t check_no_leftovers (BusContext *context);

static void

block_connection_until_message_from_bus (BusContext     *context,

                                         DBusConnection *connection,

                                         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))

    {

      #ifndef __SYMBIAN32__

      bus_test_run_bus_loop (context, TRUE);

      #else										//_dbus_loop_iterate() blocks indefinitly on setting argument to TRUE on Symbian,it must be investigated 

      	bus_test_run_bus_loop (context, FALSE);

      #endif

      bus_test_run_clients_loop (FALSE);

    }

}

static void

spin_connection_until_authenticated (BusContext     *context,

                                     DBusConnection *connection)

{

  _dbus_verbose ("Spinning to auth connection %p\n", connection);

  while (!dbus_connection_get_is_authenticated (connection) &&

         dbus_connection_get_is_connected (connection))

    {

      bus_test_run_bus_loop (context, FALSE);

      bus_test_run_clients_loop (FALSE);

    }

  _dbus_verbose (" ... done spinning to auth connection %p\n", connection);

}

/* compensate for fact that pop_message() can return #NULL due to OOM */

static DBusMessage*

pop_message_waiting_for_memory (DBusConnection *connection)

{

  while (dbus_connection_get_dispatch_status (connection) ==

         DBUS_DISPATCH_NEED_MEMORY)

    _dbus_wait_for_memory ();

  return dbus_connection_pop_message (connection);

}

static DBusMessage*

borrow_message_waiting_for_memory (DBusConnection *connection)

{

  while (dbus_connection_get_dispatch_status (connection) ==

         DBUS_DISPATCH_NEED_MEMORY)

    _dbus_wait_for_memory ();

  return dbus_connection_borrow_message (connection);

}

static void

warn_unexpected_real (DBusConnection *connection,

                      DBusMessage    *message,

                      const char     *expected,

                      const char     *function,

                      int             line)

{

  if (message)

    _dbus_warn ("%s:%d received message interface \"%s\" member \"%s\" error name \"%s\" on %p, expecting %s\n",

                function, line,

                dbus_message_get_interface (message) ?

                dbus_message_get_interface (message) : "(unset)",

                dbus_message_get_member (message) ?

                dbus_message_get_member (message) : "(unset)",

                dbus_message_get_error_name (message) ?

                dbus_message_get_error_name (message) : "(unset)",

                connection,

                expected);

  else

    _dbus_warn ("%s:%d received no message on %p, expecting %s\n",

                function, line, connection, expected);

}

#define warn_unexpected(connection, message, expected) \

  warn_unexpected_real (connection, message, expected, _DBUS_FUNCTION_NAME, __LINE__)

static void

verbose_message_received (DBusConnection *connection,

                          DBusMessage    *message)

{

  _dbus_verbose ("Received message interface \"%s\" member \"%s\" error name \"%s\" on %p\n",

                 dbus_message_get_interface (message) ?

                 dbus_message_get_interface (message) : "(unset)",

                 dbus_message_get_member (message) ?

                 dbus_message_get_member (message) : "(unset)",

                 dbus_message_get_error_name (message) ?

                 dbus_message_get_error_name (message) : "(unset)",

                 connection);

}

typedef enum

{

  SERVICE_CREATED,

  OWNER_CHANGED,

  SERVICE_DELETED

} ServiceInfoKind;

typedef struct

{

  ServiceInfoKind expected_kind;

  const char *expected_service_name;

  dbus_bool_t failed;

  DBusConnection *skip_connection;

} CheckServiceOwnerChangedData;

static dbus_bool_t

check_service_owner_changed_foreach (DBusConnection *connection,

                                     void           *data)

{

  CheckServiceOwnerChangedData *d = data;

  DBusMessage *message;

  DBusError error;

  const char *service_name, *old_owner, *new_owner;

  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, "NameOwnerChanged");

      goto out;

    }

  else if (!dbus_message_is_signal (message,

                                    DBUS_INTERFACE_DBUS,

                                    "NameOwnerChanged"))

    {

      warn_unexpected (connection, message, "NameOwnerChanged");

      goto out;

    }

  else

    {

    reget_service_info_data:

      service_name = NULL;

      old_owner = NULL;

      new_owner = NULL;

      dbus_message_get_args (message, &error,

                             DBUS_TYPE_STRING, &service_name,

                             DBUS_TYPE_STRING, &old_owner,

                             DBUS_TYPE_STRING, &new_owner,

                             DBUS_TYPE_INVALID);

      if (dbus_error_is_set (&error))

        {

          if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

            {

              dbus_error_free (&error);

              _dbus_wait_for_memory ();              

              goto reget_service_info_data;

            }

          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 NameOwnerChanged arguments\n");

          goto out;

        }

      if (strcmp (service_name, d->expected_service_name) != 0)

        {

          _dbus_warn ("expected info on service %s, got info on %s\n",

                      d->expected_service_name,

                      service_name);

          goto out;

        }

      if (*service_name == ':' && new_owner[0] 

          && strcmp (service_name, new_owner) != 0)

        {

          _dbus_warn ("inconsistent ServiceOwnedChanged message (\"%s\" [ %s -> %s ])\n",

                      service_name, old_owner, new_owner);

          goto out;

        }

    }

  d->failed = FALSE;

 out:

  dbus_error_free (&error);

  if (message)

    dbus_message_unref (message);

  return !d->failed;

}

static void

kill_client_connection (BusContext     *context,

                        DBusConnection *connection)

{

  char *base_service;

  const char *s;

  CheckServiceOwnerChangedData socd;

  _dbus_verbose ("killing connection %p\n", 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_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 NameOwnerChanged (deletion) messages");

  if (!check_no_leftovers (context))

    _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");

}

static void

kill_client_connection_unchecked (DBusConnection *connection)

{

  /* 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_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");

  _dbus_assert (!bus_test_client_listed (connection));

  dbus_connection_unref (connection);

}

typedef struct

{

  dbus_bool_t failed;

} CheckNoMessagesData;

static dbus_bool_t

check_no_messages_foreach (DBusConnection *connection,

                           void           *data)

{

  CheckNoMessagesData *d = data;

  DBusMessage *message;

  message = pop_message_waiting_for_memory (connection);

  if (message != NULL)

    {

      warn_unexpected (connection, message, "no messages");

      d->failed = TRUE;

    }

  if (message)

    dbus_message_unref (message);

  return !d->failed;

}

static dbus_bool_t

check_no_leftovers (BusContext *context)

{

  CheckNoMessagesData nmd;

  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);

      return FALSE;

    }

  else

    return TRUE;

}

/* returns TRUE if the correct thing happens,

 * but the correct thing may include OOM errors.

 */

static dbus_bool_t

check_hello_message (BusContext     *context,

                     DBusConnection *connection)

{

  DBusMessage *message;

  DBusMessage *name_message;

  dbus_uint32_t serial;

  dbus_bool_t retval;

  DBusError error;

  const char *name;

  const char *acquired;

  retval = FALSE;

  dbus_error_init (&error);

  name = NULL;

  acquired = NULL;

  message = NULL;

  name_message = NULL;

  _dbus_verbose ("check_hello_message for %p\n", connection);

  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_connection_unref (connection);

      return TRUE;

    }

  _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)

    {

      _dbus_warn ("Did not receive a reply to %s %d on %p\n",

                  "Hello", serial, connection);

      goto out;

    }

  verbose_message_received (connection, message);

  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,

                                 DBUS_ERROR_NO_MEMORY))

        {

          ; /* good, this is a valid response */

        }

      else

        {

          warn_unexpected (connection, message, "not this error");

          goto out;

        }

    }

  else

    {

      CheckServiceOwnerChangedData socd;

      if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)

        {

          ; /* good, expected */

        }

      else

        {

          warn_unexpected (connection, message, "method return for Hello");

          goto out;

        }

    retry_get_hello_name:

      if (!dbus_message_get_args (message, &error,

                                  DBUS_TYPE_STRING, &name,

                                  DBUS_TYPE_INVALID))

        {

          if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

            {

              _dbus_verbose ("no memory to get service name arg from hello\n");

              dbus_error_free (&error);

              _dbus_wait_for_memory ();

              goto retry_get_hello_name;

            }

          else

            {

              _dbus_assert (dbus_error_is_set (&error));

              _dbus_warn ("Did not get the expected single string argument to hello\n");

              goto out;

            }

        }

      _dbus_verbose ("Got hello name: %s\n", 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;

      name_message = message;

      /* Client should also have gotten ServiceAcquired */

      message = pop_message_waiting_for_memory (connection);

      if (message == NULL)

        {

          _dbus_warn ("Expecting %s, got nothing\n",

                      "NameAcquired");

          goto out;

        }

      if (! dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,

                                    "NameAcquired"))

        {

          _dbus_warn ("Expecting %s, got smthg else\n",

                      "NameAcquired");

          goto out;

        }

    retry_get_acquired_name:

      if (!dbus_message_get_args (message, &error,

                                  DBUS_TYPE_STRING, &acquired,

                                  DBUS_TYPE_INVALID))

        {

          if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

            {

              _dbus_verbose ("no memory to get service name arg from acquired\n");

              dbus_error_free (&error);

              _dbus_wait_for_memory ();

              goto retry_get_acquired_name;

            }

          else

            {

              _dbus_assert (dbus_error_is_set (&error));

              _dbus_warn ("Did not get the expected single string argument to ServiceAcquired\n");

              goto out;

            }

        }

      _dbus_verbose ("Got acquired name: %s\n", acquired);

      if (strcmp (acquired, name) != 0)

        {

          _dbus_warn ("Acquired name is %s but expected %s\n",

                      acquired, name);

          goto out;

        }

      acquired = NULL;

    }

  if (!check_no_leftovers (context))

    goto out;

  retval = TRUE;

 out:

  _dbus_verbose ("ending %s retval = %d\n", _DBUS_FUNCTION_NAME, retval);

  dbus_error_free (&error);

  if (message)

    dbus_message_unref (message);

  if (name_message)

    dbus_message_unref (name_message);

  return retval;

}

/* returns TRUE if the correct thing happens,

 * but the correct thing may include OOM errors.

 */

static dbus_bool_t

check_double_hello_message (BusContext     *context,

                            DBusConnection *connection)

{

  DBusMessage *message;

  dbus_uint32_t serial;

  dbus_bool_t retval;

  DBusError error;

  retval = FALSE;

  dbus_error_init (&error);

  message = NULL;

  _dbus_verbose ("check_double_hello_message for %p\n", connection);

  message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,

                                          DBUS_PATH_DBUS,

                                          DBUS_INTERFACE_DBUS,

                                          "Hello");