/* -*- 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;