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

/* activation.c  Activation of services

 *

 * Copyright (C) 2003  CodeFactory AB

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

#include "desktop-file.h" 

#include "services.h"

#include "test.h"

#include "utils.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-internals.h>

#include <dbus/dbus-hash.h>

#include <dbus/dbus-list.h>

#include <dbus/dbus-shell.h>

#include <dbus/dbus-spawn.h>

#include <dbus/dbus-timeout.h>

#include <dbus/dbus-sysdeps.h>

#else

#include "dbus-internals.h"

#include "dbus-hash.h"

#include "dbus-list.h"

#include "dbus-shell.h"

#include "dbus-spawn.h"

#include "dbus-timeout.h"

#include "dbus-sysdeps.h"

#endif //__SYMBIAN32__

#include <dirent.h>

#include <errno.h>

#define DBUS_SERVICE_SECTION "D-BUS Service"

#define DBUS_SERVICE_NAME "Name"

#define DBUS_SERVICE_EXEC "Exec"

struct BusActivation

{

  int refcount;

  DBusHashTable *entries;

  DBusHashTable *pending_activations;

  char *server_address;

  BusContext *context;

  int n_pending_activations; /**< This is in fact the number of BusPendingActivationEntry,

                              * i.e. number of pending activation requests, not pending

                              * activations per se

                              */

  DBusHashTable *directories;

};

typedef struct

{

  int refcount;

  char *dir_c;

  DBusHashTable *entries;

} BusServiceDirectory;

typedef struct

{

  int refcount;

  char *name;

  char *exec;

  unsigned long mtime;

  BusServiceDirectory *s_dir;

  char *filename;

} BusActivationEntry;

typedef struct BusPendingActivationEntry BusPendingActivationEntry;

struct BusPendingActivationEntry

{

  DBusMessage *activation_message;

  DBusConnection *connection;

  dbus_bool_t auto_activation;

};

typedef struct

{

  int refcount;

  BusActivation *activation;

  char *service_name;

  char *exec;

  DBusList *entries;

  int n_entries;

  DBusBabysitter *babysitter;

  DBusTimeout *timeout;

  unsigned int timeout_added : 1;

} BusPendingActivation;

#if 0

static BusServiceDirectory *

bus_service_directory_ref (BusServiceDirectory *dir)

{

  _dbus_assert (dir->refcount);

  dir->refcount++;

  return dir;

}

#endif

static void

bus_service_directory_unref (BusServiceDirectory *dir)

{

  if (dir == NULL) 

    return; 

  _dbus_assert (dir->refcount > 0);

  dir->refcount--;

  if (dir->refcount > 0)

    return;

  if (dir->entries)

    _dbus_hash_table_unref (dir->entries);

  dbus_free (dir->dir_c);

  dbus_free (dir);

}

static void

bus_pending_activation_entry_free (BusPendingActivationEntry *entry)

{

  if (entry->activation_message)

    dbus_message_unref (entry->activation_message);

  if (entry->connection)

    dbus_connection_unref (entry->connection);

  dbus_free (entry);

}

static void

handle_timeout_callback (DBusTimeout   *timeout,

                         void          *data)

{

  BusPendingActivation *pending_activation = data;

  while (!dbus_timeout_handle (pending_activation->timeout))

    _dbus_wait_for_memory ();

}

static BusPendingActivation * 

bus_pending_activation_ref (BusPendingActivation *pending_activation)

{

  _dbus_assert (pending_activation->refcount > 0);

  pending_activation->refcount += 1;

  return pending_activation;

}

static void

bus_pending_activation_unref (BusPendingActivation *pending_activation)

{

  DBusList *link;

  if (pending_activation == NULL) /* hash table requires this */

    return;

  _dbus_assert (pending_activation->refcount > 0);

  pending_activation->refcount -= 1;

  if (pending_activation->refcount > 0)

    return;

  if (pending_activation->timeout_added)

    {

      _dbus_loop_remove_timeout (bus_context_get_loop (pending_activation->activation->context),

                                 pending_activation->timeout,

                                 handle_timeout_callback, pending_activation);

      pending_activation->timeout_added = FALSE;

    }

  if (pending_activation->timeout)

    _dbus_timeout_unref (pending_activation->timeout);

  if (pending_activation->babysitter)

    {

      if (!_dbus_babysitter_set_watch_functions (pending_activation->babysitter,

                                                 NULL, NULL, NULL,

                                                 pending_activation->babysitter,

                                                 NULL))

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

      _dbus_babysitter_unref (pending_activation->babysitter);

    }

  dbus_free (pending_activation->service_name);

  dbus_free (pending_activation->exec);

  link = _dbus_list_get_first_link (&pending_activation->entries);

  while (link != NULL)

    {

      BusPendingActivationEntry *entry = link->data;

      bus_pending_activation_entry_free (entry);

      link = _dbus_list_get_next_link (&pending_activation->entries, link);

    }

  _dbus_list_clear (&pending_activation->entries);

  pending_activation->activation->n_pending_activations -=

    pending_activation->n_entries;

  _dbus_assert (pending_activation->activation->n_pending_activations >= 0);

  dbus_free (pending_activation);

}

static BusActivationEntry *

bus_activation_entry_ref (BusActivationEntry *entry)

{

  _dbus_assert (entry->refcount > 0);

  entry->refcount++;

  return entry;

}

static void

bus_activation_entry_unref (BusActivationEntry *entry)

{

  if (entry == NULL) /* hash table requires this */

    return;

  _dbus_assert (entry->refcount > 0);

  entry->refcount--;

  if (entry->refcount > 0) 

    return;

  dbus_free (entry->name);

  dbus_free (entry->exec);

  dbus_free (entry->filename);

  dbus_free (entry);

}

static dbus_bool_t

update_desktop_file_entry (BusActivation       *activation,

                           BusServiceDirectory *s_dir,

                           DBusString          *filename,

                           BusDesktopFile      *desktop_file,

                           DBusError           *error)

{

  char *name, *exec;

  BusActivationEntry *entry;

  DBusStat stat_buf;

  DBusString file_path;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  name = NULL;

  exec = NULL;

  entry = NULL;

  if (!_dbus_string_init (&file_path))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!_dbus_string_append (&file_path, s_dir->dir_c) ||

      !_dbus_concat_dir_and_file (&file_path, filename))

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  if (!_dbus_stat (&file_path, &stat_buf, NULL)) 

    {

      dbus_set_error (error, DBUS_ERROR_FAILED,

                      "Can't stat the service file\n");

      goto failed;

    }

  if (!bus_desktop_file_get_string (desktop_file,

                                    DBUS_SERVICE_SECTION,

                                    DBUS_SERVICE_NAME,

                                    &name,

                                    error))

    goto failed;

  if (!bus_desktop_file_get_string (desktop_file,

                                    DBUS_SERVICE_SECTION,

                                    DBUS_SERVICE_EXEC,

                                    &exec,

                                    error))

    goto failed;

  entry = _dbus_hash_table_lookup_string (s_dir->entries, 

                                          _dbus_string_get_const_data (filename));

  if (entry == NULL) /* New file */

    { 

      /* FIXME we need a better-defined algorithm for which service file to

       * pick than "whichever one is first in the directory listing"

       */

      if (_dbus_hash_table_lookup_string (activation->entries, name))

        {

          dbus_set_error (error, DBUS_ERROR_FAILED,

                          "Service %s already exists in activation entry list\n", name);

          goto failed;

        }

      entry = dbus_new0 (BusActivationEntry, 1);

      if (entry == NULL)

        {

          BUS_SET_OOM (error);

          goto failed;

        }

      entry->name = name;

      entry->exec = exec;

      entry->refcount = 1;

      entry->s_dir = s_dir;

      entry->filename = _dbus_strdup (_dbus_string_get_const_data (filename));

      if (!entry->filename)

        {

          BUS_SET_OOM (error);

          goto failed;

        }

      if (!_dbus_hash_table_insert_string (activation->entries, entry->name, bus_activation_entry_ref (entry)))

        {

          BUS_SET_OOM (error);

          goto failed;

        }

      if (!_dbus_hash_table_insert_string (s_dir->entries, entry->filename, bus_activation_entry_ref (entry)))

        {

          /* Revert the insertion in the entries table */

          _dbus_hash_table_remove_string (activation->entries, entry->name);

          BUS_SET_OOM (error);

          goto failed;

        }

      _dbus_verbose ("Added \"%s\" to list of services\n", entry->name);

    }

  else /* Just update the entry */

    {

      bus_activation_entry_ref (entry);

      _dbus_hash_table_remove_string (activation->entries, entry->name);

      if (_dbus_hash_table_lookup_string (activation->entries, name))

        {

          _dbus_verbose ("The new service name \"%s\" of service file \"%s\" already in cache, ignoring\n",

                         name, _dbus_string_get_const_data (&file_path));

          goto failed;

        }

      dbus_free (entry->name);

      dbus_free (entry->exec);

      entry->name = name;

      entry->exec = exec;

      if (!_dbus_hash_table_insert_string (activation->entries,

                                           entry->name, bus_activation_entry_ref(entry)))

        {

          BUS_SET_OOM (error);

          /* Also remove path to entries hash since we want this in sync with

           * the entries hash table */

          _dbus_hash_table_remove_string (entry->s_dir->entries, 

                                          entry->filename);

          bus_activation_entry_unref (entry);

          return FALSE;

        }

    }

  entry->mtime = stat_buf.mtime;

  _dbus_string_free (&file_path);

  bus_activation_entry_unref (entry);

  return TRUE;

failed:

  dbus_free (name);

  dbus_free (exec);

  _dbus_string_free (&file_path);

  if (entry)

    bus_activation_entry_unref (entry);

  return FALSE;

}

static dbus_bool_t

check_service_file (BusActivation       *activation,

                    BusActivationEntry  *entry,

                    BusActivationEntry **updated_entry,

                    DBusError           *error)

{

  DBusStat stat_buf;

  dbus_bool_t retval;

  BusActivationEntry *tmp_entry;

  DBusString file_path;

  DBusString filename;

  retval = TRUE;

  tmp_entry = entry;

  _dbus_string_init_const (&filename, entry->filename);

  if (!_dbus_string_init (&file_path))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!_dbus_string_append (&file_path, entry->s_dir->dir_c) ||

      !_dbus_concat_dir_and_file (&file_path, &filename))

    {

      BUS_SET_OOM (error);

      retval = FALSE;

      goto out;

    }

  if (!_dbus_stat (&file_path, &stat_buf, NULL))

    {

      _dbus_verbose ("****** Can't stat file \"%s\", removing from cache\n",

                     _dbus_string_get_const_data (&file_path));

      _dbus_hash_table_remove_string (activation->entries, entry->name);

      _dbus_hash_table_remove_string (entry->s_dir->entries, entry->filename);

      tmp_entry = NULL;

      retval = TRUE;

      goto out;

    }

  else 

    {

      if (stat_buf.mtime > entry->mtime) 

        {

          BusDesktopFile *desktop_file;

          DBusError tmp_error;

          dbus_error_init (&tmp_error);

          desktop_file = bus_desktop_file_load (&file_path, &tmp_error);

          if (desktop_file == NULL)

            {

              _dbus_verbose ("Could not load %s: %s\n",

                             _dbus_string_get_const_data (&file_path), 

                             tmp_error.message);

              if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))

                {

                  dbus_move_error (&tmp_error, error);

                  retval = FALSE;

                  goto out;

                }

              dbus_error_free (&tmp_error);

              retval = TRUE;

              goto out;

            }

          /* @todo We can return OOM or a DBUS_ERROR_FAILED error 

           *       Handle these both better

           */ 

          if (!update_desktop_file_entry (activation, entry->s_dir, &filename, desktop_file, &tmp_error))

            {

              bus_desktop_file_free (desktop_file);

              if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))

                {

                  dbus_move_error (&tmp_error, error);

                  retval = FALSE;

                  goto out;

                }

              dbus_error_free (&tmp_error);

              retval = TRUE;

              goto out;

            }

          bus_desktop_file_free (desktop_file);

          retval = TRUE;

        }

    }

out:

  _dbus_string_free (&file_path);

  if (updated_entry != NULL)

    *updated_entry = tmp_entry;

  return retval;

}

/* warning: this doesn't fully "undo" itself on failure, i.e. doesn't strip

 * hash entries it already added.

 */

static dbus_bool_t

update_directory (BusActivation       *activation,

                  BusServiceDirectory *s_dir,

                  DBusError           *error)

{

  DBusDirIter *iter;

  DBusString dir, filename;

  BusDesktopFile *desktop_file;

  DBusError tmp_error;

  dbus_bool_t retval;

  BusActivationEntry *entry;

  DBusString full_path;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  iter = NULL;

  desktop_file = NULL;

  _dbus_string_init_const (&dir, s_dir->dir_c);