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

/* driver.c  Bus client (driver)

 *

 * Copyright (C) 2003 CodeFactory AB

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

 * 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 "activation.h"

#include "connection.h"

#include "driver.h"

#include "dispatch.h"

#include "services.h"

#include "selinux.h"

#include "signals.h"

#include "utils.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-string.h>

#include <dbus/dbus-internals.h>

#include <dbus/dbus-marshal-recursive.h>

#else

#include "dbus-string.h"

#include "dbus-internals.h"

#include "dbus-marshal-recursive.h"

#endif //__SYMBIAN32__

#include <string.h>

static dbus_bool_t bus_driver_send_welcome_message (DBusConnection *connection,

                                                    DBusMessage    *hello_message,

                                                    BusTransaction *transaction,

                                                    DBusError      *error);

dbus_bool_t

bus_driver_send_service_owner_changed (const char     *service_name,

				       const char     *old_owner,

				       const char     *new_owner,

				       BusTransaction *transaction,

				       DBusError      *error)

{

  DBusMessage *message;

  dbus_bool_t retval;

  const char *null_service;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  null_service = "";

  _dbus_verbose ("sending name owner changed: %s [%s -> %s]\n",

                 service_name, 

                 old_owner ? old_owner : null_service, 

                 new_owner ? new_owner : null_service);

  message = dbus_message_new_signal (DBUS_PATH_DBUS,

                                     DBUS_INTERFACE_DBUS,

                                     "NameOwnerChanged");

  if (message == NULL)

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS))

    goto oom;

  if (!dbus_message_append_args (message,

                                 DBUS_TYPE_STRING, &service_name,

                                 DBUS_TYPE_STRING, old_owner ? &old_owner : &null_service,

                                 DBUS_TYPE_STRING, new_owner ? &new_owner : &null_service,

                                 DBUS_TYPE_INVALID))

    goto oom;

  _dbus_assert (dbus_message_has_signature (message, "sss"));

  retval = bus_dispatch_matches (transaction, NULL, NULL, message, error);

  dbus_message_unref (message);

  return retval;

 oom:

  dbus_message_unref (message);

  BUS_SET_OOM (error);

  return FALSE;

}

dbus_bool_t

bus_driver_send_service_lost (DBusConnection *connection,

			      const char     *service_name,

                              BusTransaction *transaction,

                              DBusError      *error)

{

  DBusMessage *message;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  message = dbus_message_new_signal (DBUS_PATH_DBUS,

                                     DBUS_INTERFACE_DBUS,

                                     "NameLost");

  if (message == NULL)

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!dbus_message_set_destination (message, bus_connection_get_name (connection)) ||

      !dbus_message_append_args (message,

                                 DBUS_TYPE_STRING, &service_name,

                                 DBUS_TYPE_INVALID))

    {

      dbus_message_unref (message);

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!bus_transaction_send_from_driver (transaction, connection, message))

    {

      dbus_message_unref (message);

      BUS_SET_OOM (error);

      return FALSE;

    }

  else

    {

      dbus_message_unref (message);

      return TRUE;

    }

}

dbus_bool_t

bus_driver_send_service_acquired (DBusConnection *connection,

                                  const char     *service_name,

                                  BusTransaction *transaction,

                                  DBusError      *error)

{

  DBusMessage *message;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  message = dbus_message_new_signal (DBUS_PATH_DBUS,

                                     DBUS_INTERFACE_DBUS,

                                     "NameAcquired");

  if (message == NULL)

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!dbus_message_set_destination (message, bus_connection_get_name (connection)) ||

      !dbus_message_append_args (message,

                                 DBUS_TYPE_STRING, &service_name,

                                 DBUS_TYPE_INVALID))

    {

      dbus_message_unref (message);

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!bus_transaction_send_from_driver (transaction, connection, message))

    {

      dbus_message_unref (message);

      BUS_SET_OOM (error);

      return FALSE;

    }

  else

    {

      dbus_message_unref (message);

      return TRUE;

    }

}

static dbus_bool_t

create_unique_client_name (BusRegistry *registry,

                           DBusString  *str)

{

  /* We never want to use the same unique client name twice, because

   * we want to guarantee that if you send a message to a given unique

   * name, you always get the same application. So we use two numbers

   * for INT_MAX * INT_MAX combinations, should be pretty safe against

   * wraparound.

   */

  /* FIXME these should be in BusRegistry rather than static vars */

  static int next_major_number = 0;

  static int next_minor_number = 0;

  int len;

  len = _dbus_string_get_length (str);

  while (TRUE)

    {

      /* start out with 1-0, go to 1-1, 1-2, 1-3,

       * up to 1-MAXINT, then 2-0, 2-1, etc.

       */

      if (next_minor_number <= 0)

        {

          next_major_number += 1;

          next_minor_number = 0;

          if (next_major_number <= 0)

            _dbus_assert_not_reached ("INT_MAX * INT_MAX clients were added");

        }

      _dbus_assert (next_major_number > 0);

      _dbus_assert (next_minor_number >= 0);

      /* appname:MAJOR-MINOR */

      if (!_dbus_string_append (str, ":"))

        return FALSE;

      if (!_dbus_string_append_int (str, next_major_number))

        return FALSE;

      if (!_dbus_string_append (str, "."))

        return FALSE;

      if (!_dbus_string_append_int (str, next_minor_number))

        return FALSE;

      next_minor_number += 1;

      /* Check if a client with the name exists */

      if (bus_registry_lookup (registry, str) == NULL)

	break;

      /* drop the number again, try the next one. */

      _dbus_string_set_length (str, len);

    }

  return TRUE;

}

static dbus_bool_t

bus_driver_handle_hello (DBusConnection *connection,

                         BusTransaction *transaction,

                         DBusMessage    *message,

                         DBusError      *error)

{

  DBusString unique_name;

  BusService *service;

  dbus_bool_t retval;

  BusRegistry *registry;

  BusConnections *connections;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  if (bus_connection_is_active (connection))

    {

      /* We already handled an Hello message for this connection. */

      dbus_set_error (error, DBUS_ERROR_FAILED,

                      "Already handled an Hello message");

      return FALSE;

    }

  /* Note that when these limits are exceeded we don't disconnect the

   * connection; we just sort of leave it hanging there until it times

   * out or disconnects itself or is dropped due to the max number of

   * incomplete connections. It's even OK if the connection wants to

   * retry the hello message, we support that.

   */

  connections = bus_connection_get_connections (connection);

  if (!bus_connections_check_limits (connections, connection,

                                     error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      return FALSE;

    }

  if (!_dbus_string_init (&unique_name))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  retval = FALSE;

  registry = bus_connection_get_registry (connection);

  if (!create_unique_client_name (registry, &unique_name))

    {

      BUS_SET_OOM (error);

      goto out_0;

    }

  if (!bus_connection_complete (connection, &unique_name, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto out_0;

    }

  if (!dbus_message_set_sender (message,

                                bus_connection_get_name (connection)))

    {

      BUS_SET_OOM (error);

      goto out_0;

    }

  if (!bus_driver_send_welcome_message (connection, message, transaction, error))

    goto out_0;

  /* Create the service */

  service = bus_registry_ensure (registry,

                                 &unique_name, connection, 0, transaction, error);

  if (service == NULL)

    goto out_0;

  _dbus_assert (bus_connection_is_active (connection));

  retval = TRUE;

 out_0:

  _dbus_string_free (&unique_name);

  return retval;

}

static dbus_bool_t

bus_driver_send_welcome_message (DBusConnection *connection,

                                 DBusMessage    *hello_message,

                                 BusTransaction *transaction,

                                 DBusError      *error)

{

  DBusMessage *welcome;

  const char *name;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  name = bus_connection_get_name (connection);

  _dbus_assert (name != NULL);

  welcome = dbus_message_new_method_return (hello_message);

  if (welcome == NULL)

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!dbus_message_append_args (welcome,

                                 DBUS_TYPE_STRING, &name,

                                 DBUS_TYPE_INVALID))

    {

      dbus_message_unref (welcome);

      BUS_SET_OOM (error);

      return FALSE;

    }

  _dbus_assert (dbus_message_has_signature (welcome, DBUS_TYPE_STRING_AS_STRING));

  if (!bus_transaction_send_from_driver (transaction, connection, welcome))

    {

      dbus_message_unref (welcome);

      BUS_SET_OOM (error);

      return FALSE;

    }

  else

    {

      dbus_message_unref (welcome);

      return TRUE;

    }

}

static dbus_bool_t

bus_driver_handle_list_services (DBusConnection *connection,

                                 BusTransaction *transaction,

                                 DBusMessage    *message,

                                 DBusError      *error)

{

  DBusMessage *reply;

  int len;

  char **services;

  BusRegistry *registry;

  int i;

  DBusMessageIter iter;

  DBusMessageIter sub;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  registry = bus_connection_get_registry (connection);

  reply = dbus_message_new_method_return (message);

  if (reply == NULL)

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!bus_registry_list_services (registry, &services, &len))

    {

      dbus_message_unref (reply);

      BUS_SET_OOM (error);

      return FALSE;

    }

  dbus_message_iter_init_append (reply, &iter);

  if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,

                                         DBUS_TYPE_STRING_AS_STRING,

                                         &sub))

    {

      dbus_free_string_array (services);

      dbus_message_unref (reply);

      BUS_SET_OOM (error);

      return FALSE;

    }

  {

    /* Include the bus driver in the list */

    const char *v_STRING = DBUS_SERVICE_DBUS;

    if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,

                                         &v_STRING))

      {

        dbus_free_string_array (services);

        dbus_message_unref (reply);

        BUS_SET_OOM (error);

        return FALSE;

      }

  }

  i = 0;

  while (i < len)

    {

      if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,

                                           &services[i]))

        {

          dbus_free_string_array (services);

          dbus_message_unref (reply);

          BUS_SET_OOM (error);

          return FALSE;

        }

      ++i;

    }

  dbus_free_string_array (services);

  if (!dbus_message_iter_close_container (&iter, &sub))

    {

      dbus_message_unref (reply);

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!bus_transaction_send_from_driver (transaction, connection, reply))

    {

      dbus_message_unref (reply);

      BUS_SET_OOM (error);

      return FALSE;

    }

  else

    {

      dbus_message_unref (reply);

      return TRUE;

    }

}

static dbus_bool_t

bus_driver_handle_list_activatable_services (DBusConnection *connection,

					     BusTransaction *transaction,

					     DBusMessage    *message,

					     DBusError      *error)

{

  DBusMessage *reply;

  int len;

  char **services;

  BusActivation *activation;

  int i;

  DBusMessageIter iter;

  DBusMessageIter sub;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  activation = bus_connection_get_activation (connection);

  reply = dbus_message_new_method_return (message);

  if (reply == NULL)

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!bus_activation_list_services (activation, &services, &len))

    {

      dbus_message_unref (reply);

      BUS_SET_OOM (error);

      return FALSE;

    }

  dbus_message_iter_init_append (reply, &iter);

  if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,

					 DBUS_TYPE_STRING_AS_STRING,

					 &sub))

    {

      dbus_free_string_array (services);

      dbus_message_unref (reply);

      BUS_SET_OOM (error);

      return FALSE;

    }

  {

    /* Include the bus driver in the list */

    const char *v_STRING = DBUS_SERVICE_DBUS;

    if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,

					 &v_STRING))

      {

	dbus_free_string_array (services);

	dbus_message_unref (reply);

	BUS_SET_OOM (error);

	return FALSE;

      }

  }

  i = 0;

  while (i < len)

    {

      if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING,

					   &services[i]))