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

/* bus.c  message bus context object

 *

 * Copyright (C) 2003, 2004 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 "bus.h"

#include "activation.h"

#include "connection.h"

#include "services.h"

#include "utils.h"

#include "policy.h"

#include "config-parser.h"

#include "signals.h"

#include "selinux.h"

#include "dir-watch.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-list.h>

#include <dbus/dbus-hash.h>

#include <dbus/dbus-internals.h>

#else

#include "dbus-list.h"

#include "dbus-hash.h"

#include "dbus-internals.h"

#endif

struct BusContext

{

  int refcount;

  char *config_file;

  char *type;

  char *address;

  char *pidfile;

  char *user;

  DBusLoop *loop;

  DBusList *servers;

  BusConnections *connections;

  BusActivation *activation;

  BusRegistry *registry;

  BusPolicy *policy;

  BusMatchmaker *matchmaker;

  DBusUserDatabase *user_database;

  BusLimits limits;

  unsigned int fork : 1;

};

static dbus_int32_t server_data_slot = -1;

typedef struct

{

  BusContext *context;

} BusServerData;

#define BUS_SERVER_DATA(server) (dbus_server_get_data ((server), server_data_slot))

static BusContext*

server_get_context (DBusServer *server)

{

  BusContext *context;

  BusServerData *bd;

  if (!dbus_server_allocate_data_slot (&server_data_slot))

    return NULL;

  bd = BUS_SERVER_DATA (server);

  if (bd == NULL)

    {

      dbus_server_free_data_slot (&server_data_slot);

      return NULL;

    }

  context = bd->context;

  dbus_server_free_data_slot (&server_data_slot);

  return context;

}

static dbus_bool_t

server_watch_callback (DBusWatch     *watch,

                       unsigned int   condition,

                       void          *data)

{

  /* FIXME this can be done in dbus-mainloop.c

   * if the code in activation.c for the babysitter

   * watch handler is fixed.

   */

  return dbus_watch_handle (watch, condition);

}

static dbus_bool_t

add_server_watch (DBusWatch  *watch,

                  void       *data)

{

  DBusServer *server = data;

  BusContext *context;

  context = server_get_context (server);

  return _dbus_loop_add_watch (context->loop,

                               watch, server_watch_callback, server,

                               NULL);

}

static void

remove_server_watch (DBusWatch  *watch,

                     void       *data)

{

  DBusServer *server = data;

  BusContext *context;

  context = server_get_context (server);

  _dbus_loop_remove_watch (context->loop,

                           watch, server_watch_callback, server);

}

static void

server_timeout_callback (DBusTimeout   *timeout,

                         void          *data)

{

  /* can return FALSE on OOM but we just let it fire again later */

  dbus_timeout_handle (timeout);

}

static dbus_bool_t

add_server_timeout (DBusTimeout *timeout,

                    void        *data)

{

  DBusServer *server = data;

  BusContext *context;

  context = server_get_context (server);

  return _dbus_loop_add_timeout (context->loop,

                                 timeout, server_timeout_callback, server, NULL);

}

static void

remove_server_timeout (DBusTimeout *timeout,

                       void        *data)

{

  DBusServer *server = data;

  BusContext *context;

  context = server_get_context (server);

  _dbus_loop_remove_timeout (context->loop,

                             timeout, server_timeout_callback, server);

}

static void

new_connection_callback (DBusServer     *server,

                         DBusConnection *new_connection,

                         void           *data)

{

  BusContext *context = data;

  if (!bus_connections_setup_connection (context->connections, new_connection))

    {

      _dbus_verbose ("No memory to setup new connection\n");

      /* if we don't do this, it will get unref'd without

       * being disconnected... kind of strange really

       * that we have to do this, people won't get it right

       * in general.

       */

      dbus_connection_close (new_connection);

    }

  dbus_connection_set_max_received_size (new_connection,

                                         context->limits.max_incoming_bytes);

  dbus_connection_set_max_message_size (new_connection,

                                        context->limits.max_message_size);

  /* on OOM, we won't have ref'd the connection so it will die. */

}

static void

free_server_data (void *data)

{

  BusServerData *bd = data;  

  dbus_free (bd);

}

static dbus_bool_t

setup_server (BusContext *context,

              DBusServer *server,

              char      **auth_mechanisms,

              DBusError  *error)

{

  BusServerData *bd;

  bd = dbus_new0 (BusServerData, 1);

  if (!dbus_server_set_data (server,

                             server_data_slot,

                             bd, free_server_data))

    {

      dbus_free (bd);

      BUS_SET_OOM (error);

      return FALSE;

    }

  bd->context = context;

  if (!dbus_server_set_auth_mechanisms (server, (const char**) auth_mechanisms))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  dbus_server_set_new_connection_function (server,

                                           new_connection_callback,

                                           context, NULL);

  if (!dbus_server_set_watch_functions (server,

                                        add_server_watch,

                                        remove_server_watch,

                                        NULL,

                                        server,

                                        NULL))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!dbus_server_set_timeout_functions (server,

                                          add_server_timeout,

                                          remove_server_timeout,

                                          NULL,

                                          server, NULL))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  return TRUE;

}

/* This code only gets executed the first time the

   config files are parsed.  It is not executed

   when config files are reloaded.*/

static dbus_bool_t

process_config_first_time_only (BusContext      *context,

				BusConfigParser *parser,

				DBusError       *error)

{

  DBusList *link;

  DBusList **addresses;

  const char *user, *pidfile;

  char **auth_mechanisms;

  DBusList **auth_mechanisms_list;

  int len;

  dbus_bool_t retval;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  retval = FALSE;

  auth_mechanisms = NULL;

  /* Check for an existing pid file. Of course this is a race;

   * we'd have to use fcntl() locks on the pid file to

   * avoid that. But we want to check for the pid file

   * before overwriting any existing sockets, etc.

   */

  pidfile = bus_config_parser_get_pidfile (parser);

  if (pidfile != NULL)

    {

      DBusString u;

      DBusStat stbuf;

      _dbus_string_init_const (&u, pidfile);

      if (_dbus_stat (&u, &stbuf, NULL))

	{

	  dbus_set_error (error, DBUS_ERROR_FAILED,

			  "The pid file \"%s\" exists, if the message bus is not running, remove this file",

			  pidfile);

	  goto failed;

	}

    }

  /* keep around the pid filename so we can delete it later */

  context->pidfile = _dbus_strdup (pidfile);

  /* Build an array of auth mechanisms */

  auth_mechanisms_list = bus_config_parser_get_mechanisms (parser);

  len = _dbus_list_get_length (auth_mechanisms_list);

  if (len > 0)

    {

      int i;

      auth_mechanisms = dbus_new0 (char*, len + 1);

      if (auth_mechanisms == NULL)

	{

	  BUS_SET_OOM (error);

	  goto failed;

	}

      i = 0;

      link = _dbus_list_get_first_link (auth_mechanisms_list);

      while (link != NULL)

        {

          auth_mechanisms[i] = _dbus_strdup (link->data);

          if (auth_mechanisms[i] == NULL)

	    {

	      BUS_SET_OOM (error);

	      goto failed;

	    }

          link = _dbus_list_get_next_link (auth_mechanisms_list, link);

        }

    }

  else

    {

      auth_mechanisms = NULL;

    }

  /* Listen on our addresses */

  addresses = bus_config_parser_get_addresses (parser);  

  link = _dbus_list_get_first_link (addresses);

  while (link != NULL)

    {

      DBusServer *server;

      server = dbus_server_listen (link->data, error);

      if (server == NULL)

	{

	  _DBUS_ASSERT_ERROR_IS_SET (error);

	  goto failed;

	}

      else if (!setup_server (context, server, auth_mechanisms, error))

	{

	  _DBUS_ASSERT_ERROR_IS_SET (error);

	  goto failed;

	}

      if (!_dbus_list_append (&context->servers, server))

        {

          BUS_SET_OOM (error);

          goto failed;

        }          

      link = _dbus_list_get_next_link (addresses, link);

    }

  /* note that type may be NULL */

  context->type = _dbus_strdup (bus_config_parser_get_type (parser));

  if (bus_config_parser_get_type (parser) != NULL && context->type == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  user = bus_config_parser_get_user (parser);

  if (user != NULL)

    {

      context->user = _dbus_strdup (user);

      if (context->user == NULL)

	{

	  BUS_SET_OOM (error);

	  goto failed;

	}

    }

  context->fork = bus_config_parser_get_fork (parser);

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  retval = TRUE;

 failed:

  dbus_free_string_array (auth_mechanisms);

  return retval;

}

/* This code gets executed every time the config files

   are parsed: both during BusContext construction

   and on reloads. */

static dbus_bool_t

process_config_every_time (BusContext      *context,

			   BusConfigParser *parser,

			   dbus_bool_t      is_reload,

			   DBusError       *error)

{

  DBusString full_address;

  DBusList *link;

  char *addr;

  dbus_bool_t retval;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  addr = NULL;

  retval = FALSE;

  if (!_dbus_string_init (&full_address))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  /* get our limits and timeout lengths */

  bus_config_parser_get_limits (parser, &context->limits);

  context->policy = bus_config_parser_steal_policy (parser);

  _dbus_assert (context->policy != NULL);

  /* We have to build the address backward, so that

   * <listen> later in the config file have priority

   */

  link = _dbus_list_get_last_link (&context->servers);

  while (link != NULL)

    {

      addr = dbus_server_get_address (link->data);

      if (addr == NULL)

        {

          BUS_SET_OOM (error);

          goto failed;

        }

      if (_dbus_string_get_length (&full_address) > 0)

        {

          if (!_dbus_string_append (&full_address, ";"))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

        }

      if (!_dbus_string_append (&full_address, addr))

        {

          BUS_SET_OOM (error);

          goto failed;

        }

      dbus_free (addr);

      addr = NULL;

      link = _dbus_list_get_prev_link (&context->servers, link);

    }

  if (is_reload)

    dbus_free (context->address);

  if (!_dbus_string_copy_data (&full_address, &context->address))

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  /* Create activation subsystem */

  if (is_reload)

    bus_activation_unref (context->activation);

  context->activation = bus_activation_new (context, &full_address,

                                            bus_config_parser_get_service_dirs (parser),

                                            error);

  if (context->activation == NULL)

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  /* Drop existing conf-dir watches (if applicable) */

  if (is_reload)

    bus_drop_all_directory_watches ();

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  retval = TRUE;

 failed:

  _dbus_string_free (&full_address);

  if (addr)

    dbus_free (addr);

  return retval;

}

static dbus_bool_t

process_config_postinit (BusContext      *context,

			 BusConfigParser *parser,

			 DBusError       *error)

{

  DBusHashTable *service_context_table;

  service_context_table = bus_config_parser_steal_service_context_table (parser);

  if (!bus_registry_set_service_context_table (context->registry,

					       service_context_table))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  _dbus_hash_table_unref (service_context_table);

  /* Watch all conf directories */

  _dbus_list_foreach (bus_config_parser_get_conf_dirs (parser),

		      (DBusForeachFunction) bus_watch_directory,

		      context);

  return TRUE;