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

/* services.c  Service management

 *

 * Copyright (C) 2003  Red Hat, Inc.

 * Copyright (C) 2003  CodeFactory AB

 * 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

 *

 */

 #ifndef __SYMBIAN32__

#include <dbus/dbus-hash.h>

#include <dbus/dbus-list.h>

#include <dbus/dbus-mempool.h>

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

#else

#include "dbus-hash.h"

#include "dbus-list.h"

#include "dbus-mempool.h"

#include "dbus-marshal-validate.h"

#endif //__SYMBIAN32__

#include "driver.h"

#include "services.h"

#include "connection.h"

#include "utils.h"

#include "activation.h"

#include "policy.h"

#include "bus.h"

#include "selinux.h"

struct BusService

{

  int refcount;

  BusRegistry *registry;

  char *name;

  DBusList *owners;

};

struct BusOwner

{

  int refcount;

  BusService *service;

  DBusConnection *conn;

  unsigned int allow_replacement : 1;

  unsigned int do_not_queue : 1;

};

struct BusRegistry

{

  int refcount;

  BusContext *context;

  DBusHashTable *service_hash;

  DBusMemPool   *service_pool;

  DBusMemPool   *owner_pool;

  DBusHashTable *service_sid_table;

};

BusRegistry*

bus_registry_new (BusContext *context)

{

  BusRegistry *registry;

  registry = dbus_new0 (BusRegistry, 1);

  if (registry == NULL)

    return NULL;

  registry->refcount = 1;

  registry->context = context;

  registry->service_hash = _dbus_hash_table_new (DBUS_HASH_STRING,

                                                 NULL, NULL);

  if (registry->service_hash == NULL)

    goto failed;

  registry->service_pool = _dbus_mem_pool_new (sizeof (BusService),

                                               TRUE);

  if (registry->service_pool == NULL)

    goto failed;

  registry->owner_pool = _dbus_mem_pool_new (sizeof (BusOwner),

                                             TRUE);

  if (registry->owner_pool == NULL)

    goto failed;

  registry->service_sid_table = NULL;

  return registry;

 failed:

  bus_registry_unref (registry);

  return NULL;

}

BusRegistry *

bus_registry_ref (BusRegistry *registry)

{

  _dbus_assert (registry->refcount > 0);

  registry->refcount += 1;

  return registry;

}

void

bus_registry_unref  (BusRegistry *registry)

{

  _dbus_assert (registry->refcount > 0);

  registry->refcount -= 1;

  if (registry->refcount == 0)

    {

      if (registry->service_hash)

        _dbus_hash_table_unref (registry->service_hash);

      if (registry->service_pool)

        _dbus_mem_pool_free (registry->service_pool);

      if (registry->owner_pool)

        _dbus_mem_pool_free (registry->owner_pool);

      if (registry->service_sid_table)

        _dbus_hash_table_unref (registry->service_sid_table);

      dbus_free (registry);

    }

}

BusService*

bus_registry_lookup (BusRegistry      *registry,

                     const DBusString *service_name)

{

  BusService *service;

  service = _dbus_hash_table_lookup_string (registry->service_hash,

                                            _dbus_string_get_const_data (service_name));

  return service;

}

static DBusList *

_bus_service_find_owner_link (BusService *service,

                              DBusConnection *connection)

{

  DBusList *link;

  link = _dbus_list_get_first_link (&service->owners);

  while (link != NULL)

    {

      BusOwner *bus_owner;

      bus_owner = (BusOwner *) link->data;

      if (bus_owner->conn == connection) 

        break;

      link = _dbus_list_get_next_link (&service->owners, link);

    }

  return link;

}

static void

bus_owner_set_flags (BusOwner *owner,

                     dbus_uint32_t flags)

{

   owner->allow_replacement = 

        (flags & DBUS_NAME_FLAG_ALLOW_REPLACEMENT) != FALSE;

   owner->do_not_queue =

        (flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) != FALSE;

}

static BusOwner *

bus_owner_new (BusService *service, 

               DBusConnection *conn, 

	       dbus_uint32_t flags)

{

  BusOwner *result;

  result = _dbus_mem_pool_alloc (service->registry->owner_pool);

  if (result != NULL)

    {

      result->refcount = 1;

      /* don't ref the connection because we don't want

         to block the connection from going away.

         transactions take care of reffing the connection

         but we need to use refcounting on the owner

         so that the owner does not get freed before

         we can deref the connection in the transaction

       */

      result->conn = conn;

      result->service = service;

      if (!bus_connection_add_owned_service (conn, service))

        {

          _dbus_mem_pool_dealloc (service->registry->owner_pool, result);

          return NULL;

        }

      bus_owner_set_flags (result, flags);

    }

  return result;

}

static BusOwner *

bus_owner_ref (BusOwner *owner)

{

  _dbus_assert (owner->refcount > 0);

  owner->refcount += 1;

  return owner;

}

static void

bus_owner_unref  (BusOwner *owner)

{

  _dbus_assert (owner->refcount > 0);

  owner->refcount -= 1;

  if (owner->refcount == 0)

    {

      bus_connection_remove_owned_service (owner->conn, owner->service);

      _dbus_mem_pool_dealloc (owner->service->registry->owner_pool, owner);

    }

}

BusService*

bus_registry_ensure (BusRegistry               *registry,

                     const DBusString          *service_name,

                     DBusConnection            *owner_connection_if_created,

                     dbus_uint32_t              flags,

                     BusTransaction            *transaction,

                     DBusError                 *error)

{

  BusService *service;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  _dbus_assert (owner_connection_if_created != NULL);

  _dbus_assert (transaction != NULL);

  service = _dbus_hash_table_lookup_string (registry->service_hash,

                                            _dbus_string_get_const_data (service_name));

  if (service != NULL)

    return service;

  service = _dbus_mem_pool_alloc (registry->service_pool);

  if (service == NULL)

    {

      BUS_SET_OOM (error);

      return NULL;

    }

  service->registry = registry;  

  service->refcount = 1;

  _dbus_verbose ("copying string %p '%s' to service->name\n",

                 service_name, _dbus_string_get_const_data (service_name));

  if (!_dbus_string_copy_data (service_name, &service->name))

    {

      _dbus_mem_pool_dealloc (registry->service_pool, service);

      BUS_SET_OOM (error);

      return NULL;

    }

  _dbus_verbose ("copied string %p '%s' to '%s'\n",

                 service_name, _dbus_string_get_const_data (service_name),

                 service->name);

  if (!bus_driver_send_service_owner_changed (service->name, 

					      NULL,

					      bus_connection_get_name (owner_connection_if_created),

					      transaction, error))

    {

      bus_service_unref (service);

      return NULL;

    }

  if (!bus_activation_service_created (bus_context_get_activation (registry->context),

				       service->name, transaction, error))

    {

      bus_service_unref (service);

      return NULL;

    }

  if (!bus_service_add_owner (service, owner_connection_if_created, flags,

                                              transaction, error))

    {

      bus_service_unref (service);

      return NULL;

    }

  if (!_dbus_hash_table_insert_string (registry->service_hash,

                                       service->name,

                                       service))

    {

      /* The add_owner gets reverted on transaction cancel */

      BUS_SET_OOM (error);

      return NULL;

    }

  return service;

}

void

bus_registry_foreach (BusRegistry               *registry,

                      BusServiceForeachFunction  function,

                      void                      *data)

{

  DBusHashIter iter;

  _dbus_hash_iter_init (registry->service_hash, &iter);

  while (_dbus_hash_iter_next (&iter))

    {

      BusService *service = _dbus_hash_iter_get_value (&iter);

      (* function) (service, data);

    }

}

dbus_bool_t

bus_registry_list_services (BusRegistry *registry,

                            char      ***listp,

                            int         *array_len)

{

  int i, j, len;

  char **retval;

  DBusHashIter iter;

  len = _dbus_hash_table_get_n_entries (registry->service_hash);

  retval = dbus_new (char *, len + 1);

  if (retval == NULL)

    return FALSE;

  _dbus_hash_iter_init (registry->service_hash, &iter);

  i = 0;

  while (_dbus_hash_iter_next (&iter))

    {

      BusService *service = _dbus_hash_iter_get_value (&iter);

      retval[i] = _dbus_strdup (service->name);

      if (retval[i] == NULL)

	goto error;

      i++;

    }

  retval[i] = NULL;

  if (array_len)

    *array_len = len;

  *listp = retval;

  return TRUE;

 error:

  for (j = 0; j < i; j++)

    dbus_free (retval[i]);

  dbus_free (retval);

  return FALSE;

}

dbus_bool_t

bus_registry_acquire_service (BusRegistry      *registry,

                              DBusConnection   *connection,

                              const DBusString *service_name,

                              dbus_uint32_t     flags,

                              dbus_uint32_t    *result,

                              BusTransaction   *transaction,

                              DBusError        *error)

{

  dbus_bool_t retval;

  DBusConnection *old_owner_conn;

  DBusConnection *current_owner_conn;

  BusClientPolicy *policy;

  BusService *service;

  BusActivation  *activation;

  BusSELinuxID *sid;

  BusOwner *primary_owner;

  retval = FALSE;

  if (!_dbus_validate_bus_name (service_name, 0,

                                _dbus_string_get_length (service_name)))

    {

      dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,

                      "Requested bus name \"%s\" is not valid",

                      _dbus_string_get_const_data (service_name));

      _dbus_verbose ("Attempt to acquire invalid service name\n");

      goto out;

    }

  if (_dbus_string_get_byte (service_name, 0) == ':')

    {

      /* Not allowed; only base services can start with ':' */

      dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,

                      "Cannot acquire a service starting with ':' such as \"%s\"",

                      _dbus_string_get_const_data (service_name));

      _dbus_verbose ("Attempt to acquire invalid base service name \"%s\"",

                     _dbus_string_get_const_data (service_name));

      goto out;

    }

  if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))

    {

      dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,

                      "Connection \"%s\" is not allowed to own the service \"%s\"because "

                      "it is reserved for D-Bus' use only",

                      bus_connection_is_active (connection) ?

                      bus_connection_get_name (connection) :

                      "(inactive)",

                      DBUS_SERVICE_DBUS);

      goto out;

    }

  policy = bus_connection_get_policy (connection);

  _dbus_assert (policy != NULL);

  /* Note that if sid is #NULL then the bus's own context gets used

   * in bus_connection_selinux_allows_acquire_service()

   */

  sid = bus_selinux_id_table_lookup (registry->service_sid_table,

                                     service_name);

  if (!bus_selinux_allows_acquire_service (connection, sid,

					   _dbus_string_get_const_data (service_name), error))

    {

      if (dbus_error_is_set (error) &&

	  dbus_error_has_name (error, DBUS_ERROR_NO_MEMORY))

	{

	  goto out;

	}

      dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,

                      "Connection \"%s\" is not allowed to own the service \"%s\" due "

                      "to SELinux policy",

                      bus_connection_is_active (connection) ?

                      bus_connection_get_name (connection) :

                      "(inactive)",

                      _dbus_string_get_const_data (service_name));

      goto out;

    }

  if (!bus_client_policy_check_can_own (policy, connection,

                                        service_name))

    {

      dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,

                      "Connection \"%s\" is not allowed to own the service \"%s\" due "

                      "to security policies in the configuration file",

                      bus_connection_is_active (connection) ?

                      bus_connection_get_name (connection) :

                      "(inactive)",

                      _dbus_string_get_const_data (service_name));

      goto out;

    }

  if (bus_connection_get_n_services_owned (connection) >=

      bus_context_get_max_services_per_connection (registry->context))

    {

      dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,

                      "Connection \"%s\" is not allowed to own more services "

                      "(increase limits in configuration file if required)",

                      bus_connection_is_active (connection) ?

                      bus_connection_get_name (connection) :

                      "(inactive)");

      goto out;

    }

  service = bus_registry_lookup (registry, service_name);

  if (service != NULL)

    {

      primary_owner = bus_service_get_primary_owner (service);

      if (primary_owner != NULL)

        old_owner_conn = primary_owner->conn;

      else

        old_owner_conn = NULL;

    }

  else

    old_owner_conn = NULL;

  if (service == NULL)

    {

      service = bus_registry_ensure (registry,

                                     service_name, connection, flags,

                                     transaction, error);

      if (service == NULL)

        goto out;

    }

  primary_owner = bus_service_get_primary_owner (service);

  if (primary_owner == NULL)

    goto out;

  current_owner_conn = primary_owner->conn;

  if (old_owner_conn == NULL)

    {

      _dbus_assert (current_owner_conn == connection);

      *result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;      

    }

  else if (old_owner_conn == connection)

    {