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

}

BusContext*

bus_context_new (const DBusString *config_file,

                 ForceForkSetting  force_fork,

                 int               print_addr_fd,

                 int               print_pid_fd,

                 DBusError        *error)

{

  BusContext *context;

  BusConfigParser *parser;

  DBusCredentials creds;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  context = NULL;

  parser = NULL;

  if (!dbus_server_allocate_data_slot (&server_data_slot))

    {

      BUS_SET_OOM (error);

      return NULL;

    }

  context = dbus_new0 (BusContext, 1);

  if (context == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  context->refcount = 1;

  if (!_dbus_string_copy_data (config_file, &context->config_file))

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  context->loop = _dbus_loop_new ();

  if (context->loop == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  context->registry = bus_registry_new (context);

  if (context->registry == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  parser = bus_config_load (config_file, TRUE, NULL, error);

  if (parser == NULL)

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  if (!process_config_first_time_only (context, parser, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  if (!process_config_every_time (context, parser, FALSE, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  /* we need another ref of the server data slot for the context

   * to own

   */

  if (!dbus_server_allocate_data_slot (&server_data_slot))

    _dbus_assert_not_reached ("second ref of server data slot failed");

  context->user_database = _dbus_user_database_new ();

  if (context->user_database == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  /* Note that we don't know whether the print_addr_fd is

   * one of the sockets we're using to listen on, or some

   * other random thing. But I think the answer is "don't do

   * that then"

   */

  if (print_addr_fd >= 0)

    {

      DBusString addr;

      const char *a = bus_context_get_address (context);

      int bytes;

      _dbus_assert (a != NULL);

      if (!_dbus_string_init (&addr))

        {

          BUS_SET_OOM (error);

          goto failed;

        }

        #ifndef __SYMBIAN32__

         if (!_dbus_string_append (&addr, a) ||

          !_dbus_string_append (&addr, "\n")) 

      #else

      if (!_dbus_string_append (&addr, a) )

       #endif 

        {

          _dbus_string_free (&addr);

          BUS_SET_OOM (error);

          goto failed;

        }

      bytes = _dbus_string_get_length (&addr);

      if (_dbus_write_socket (print_addr_fd, &addr, 0, bytes) != bytes)

        {

          dbus_set_error (error, DBUS_ERROR_FAILED,

                          "Printing message bus address: %s\n",

                          _dbus_strerror (errno));

          _dbus_string_free (&addr);

          goto failed;

        }

      if (print_addr_fd > 2)

        _dbus_close_socket (print_addr_fd, NULL);

      _dbus_string_free (&addr);

    }

  context->connections = bus_connections_new (context);

  if (context->connections == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  context->matchmaker = bus_matchmaker_new ();

  if (context->matchmaker == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  /* check user before we fork */

  if (context->user != NULL)

    {

      DBusString u;

      _dbus_string_init_const (&u, context->user);

      if (!_dbus_credentials_from_username (&u, &creds) ||

          creds.uid < 0 ||

          creds.gid < 0)

        {

          dbus_set_error (error, DBUS_ERROR_FAILED,

                          "Could not get UID and GID for username \"%s\"",

                          context->user);

          goto failed;

        }

    }

  /* Now become a daemon if appropriate */

  if ((force_fork != FORK_NEVER && context->fork) || force_fork == FORK_ALWAYS)

    {

      DBusString u;

      if (context->pidfile)

        _dbus_string_init_const (&u, context->pidfile);

      if (!_dbus_become_daemon (context->pidfile ? &u : NULL, 

				print_pid_fd,

				error))

	{

	  _DBUS_ASSERT_ERROR_IS_SET (error);

	  goto failed;

	}

    }

  else

    {

      /* Need to write PID file for ourselves, not for the child process */

      if (context->pidfile != NULL)

        {

          DBusString u;

          _dbus_string_init_const (&u, context->pidfile);

          if (!_dbus_write_pid_file (&u, _dbus_getpid (), error))

	    {

	      _DBUS_ASSERT_ERROR_IS_SET (error);

	      goto failed;

	    }

        }

    }

  /* Write PID if requested */

  if (print_pid_fd >= 0)

    {

      DBusString pid;

      int bytes;

      if (!_dbus_string_init (&pid))

        {

          BUS_SET_OOM (error);

          goto failed;

        }

      if (!_dbus_string_append_int (&pid, _dbus_getpid ()) ||

          !_dbus_string_append (&pid, "\n"))

        {

          _dbus_string_free (&pid);

          BUS_SET_OOM (error);

          goto failed;

        }

      bytes = _dbus_string_get_length (&pid);

      if (_dbus_write_socket (print_pid_fd, &pid, 0, bytes) != bytes)

        {

          dbus_set_error (error, DBUS_ERROR_FAILED,

                          "Printing message bus PID: %s\n",

                          _dbus_strerror (errno));

          _dbus_string_free (&pid);

          goto failed;

        }

      if (print_pid_fd > 2)

        _dbus_close_socket (print_pid_fd, NULL);

      _dbus_string_free (&pid);

    }

  if (!bus_selinux_full_init ())

    {

      _dbus_warn ("SELinux initialization failed\n");

    }

  if (!process_config_postinit (context, parser, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  if (parser != NULL)

    {

      bus_config_parser_unref (parser);

      parser = NULL;

    }

  /* Here we change our credentials if required,

   * as soon as we've set up our sockets and pidfile

   */

  if (context->user != NULL)

    {

      if (!_dbus_change_identity (creds.uid, creds.gid, error))

	{

	  _DBUS_ASSERT_ERROR_IS_SET (error);

	  goto failed;

	}

    }

  dbus_server_free_data_slot (&server_data_slot);

  return context;

 failed:  

  if (parser != NULL)

    bus_config_parser_unref (parser);

  if (context != NULL)

    bus_context_unref (context);

  if (server_data_slot >= 0)

    dbus_server_free_data_slot (&server_data_slot);

  return NULL;

}

dbus_bool_t

bus_context_reload_config (BusContext *context,

			   DBusError  *error)

{

  BusConfigParser *parser;

  DBusString config_file;

  dbus_bool_t ret;

  /* Flush the user database cache */

  _dbus_user_database_flush(context->user_database);

  ret = FALSE;

  _dbus_string_init_const (&config_file, context->config_file);

  parser = bus_config_load (&config_file, TRUE, NULL, error);

  if (parser == NULL)

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  if (!process_config_every_time (context, parser, TRUE, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  if (!process_config_postinit (context, parser, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto failed;

    }

  ret = TRUE;

 failed:  

  if (parser != NULL)

    bus_config_parser_unref (parser);

  return ret;

}

static void

shutdown_server (BusContext *context,

                 DBusServer *server)

{

  if (server == NULL ||

      !dbus_server_get_is_connected (server))

    return;

  if (!dbus_server_set_watch_functions (server,

                                        NULL, NULL, NULL,

                                        context,

                                        NULL))

    _dbus_assert_not_reached ("setting watch functions to NULL failed");

  if (!dbus_server_set_timeout_functions (server,

                                          NULL, NULL, NULL,

                                          context,

                                          NULL))

    _dbus_assert_not_reached ("setting timeout functions to NULL failed");

  dbus_server_disconnect (server);

}

void

bus_context_shutdown (BusContext  *context)

{

  DBusList *link;

  link = _dbus_list_get_first_link (&context->servers);

  while (link != NULL)

    {

      shutdown_server (context, link->data);

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

    }

}

BusContext *

bus_context_ref (BusContext *context)

{

  _dbus_assert (context->refcount > 0);

  context->refcount += 1;

  return context;

}

void

bus_context_unref (BusContext *context)

{

  _dbus_assert (context->refcount > 0);

  context->refcount -= 1;

  if (context->refcount == 0)

    {

      DBusList *link;

      _dbus_verbose ("Finalizing bus context %p\n", context);

      bus_context_shutdown (context);

      if (context->connections)

        {

          bus_connections_unref (context->connections);

          context->connections = NULL;

        }

      if (context->registry)

        {

          bus_registry_unref (context->registry);

          context->registry = NULL;

        }

      if (context->activation)

        {

          bus_activation_unref (context->activation);

          context->activation = NULL;

        }

      link = _dbus_list_get_first_link (&context->servers);

      while (link != NULL)

        {

          dbus_server_unref (link->data);

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

        }

      _dbus_list_clear (&context->servers);

      if (context->policy)

        {

          bus_policy_unref (context->policy);

          context->policy = NULL;

        }

      if (context->loop)

        {

          _dbus_loop_unref (context->loop);

          context->loop = NULL;

        }

      if (context->matchmaker)

        {

          bus_matchmaker_unref (context->matchmaker);

          context->matchmaker = NULL;

        }

      dbus_free (context->config_file);

      dbus_free (context->type);

      dbus_free (context->address);

      dbus_free (context->user);

      if (context->pidfile)

	{

          DBusString u;

          _dbus_string_init_const (&u, context->pidfile);

          /* Deliberately ignore errors here, since there's not much

	   * we can do about it, and we're exiting anyways.

	   */

	  _dbus_delete_file (&u, NULL);

          dbus_free (context->pidfile); 

	}

      if (context->user_database != NULL)

	_dbus_user_database_unref (context->user_database);

      dbus_free (context);

      dbus_server_free_data_slot (&server_data_slot);

    }

}

/* type may be NULL */

const char*

bus_context_get_type (BusContext *context)

{

  return context->type;

}

const char*

bus_context_get_address (BusContext *context)

{

  return context->address;

}

BusRegistry*

bus_context_get_registry (BusContext  *context)

{

  return context->registry;