/*

 * handles.c - mechanism to store and retrieve handles on a connection

 * Copyright (C) 2005 Collabora Ltd.

 * 

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <glib.h>

#include <dbus/dbus-glib.h>

#include <string.h>

#include "gheap.h"

#include "handles.h"

#include "handle-set.h"

#include "telepathy-errors.h"

#include "telepathy-helpers.h"

#include "util.h"

#include "config.h"

#ifdef ENABLE_HANDLE_LEAK_DEBUG

#include <stdlib.h>

#include <stdio.h>

#include <execinfo.h>

typedef struct _HandleLeakTrace HandleLeakTrace;

struct _HandleLeakTrace

{

  char **trace;

  int len;

};

static void

handle_leak_trace_free (HandleLeakTrace *hltrace)

{

  free (hltrace->trace);

  g_free (hltrace);

}

static void

handle_leak_trace_free_gfunc (gpointer data, gpointer user_data)

{

  return handle_leak_trace_free ((HandleLeakTrace *) data);

}

#endif /* ENABLE_HANDLE_LEAK_DEBUG */

/*#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	gchar** _s_handles_list_handle_strings() { return (gchar**)((libgabble_ImpurePtr()->_s_handles_list_handle_strings)); }

	#define list_handle_strings (GET_WSD_VAR_NAME(list_handle_strings,handles, s)())	

#endif*/

typedef struct _GabbleHandlePriv GabbleHandlePriv;

struct _GabbleHandlePriv

{

  guint refcount;

  gchar *string;

#ifdef ENABLE_HANDLE_LEAK_DEBUG

  GSList *traces;

#endif /* ENABLE_HANDLE_LEAK_DEBUG */

  GData *datalist;

};

struct _GabbleHandleRepo

{

  GHashTable *contact_handles;

  GHashTable *room_handles;

  GData *list_handles;

  GHashTable *contact_strings;

  GHashTable *room_strings;

  GHeap *free_contact_handles;

  GHeap *free_room_handles;

  guint contact_serial;

  guint room_serial;

  GData *client_contact_handle_sets;

  GData *client_room_handle_sets;

  DBusGProxy *bus_service_proxy;

};

//#ifndef EMULATOR

static const char *list_handle_strings[GABBLE_LIST_HANDLE_DENY] =

{

    "publish",      /* GABBLE_LIST_HANDLE_PUBLISH */

    "subscribe",    /* GABBLE_LIST_HANDLE_SUBSCRIBE */

    "known",        /* GABBLE_LIST_HANDLE_KNOWN */

    "deny"          /* GABBLE_LIST_HANDLE_DENY */

};

//#endif

/* private functions */

static GabbleHandlePriv *

handle_priv_new ()

{

  GabbleHandlePriv *priv;

  priv = g_new0 (GabbleHandlePriv, 1);

  g_datalist_init (&(priv->datalist));

  return priv;

}

static void

handle_priv_free (GabbleHandlePriv *priv)

{

  g_assert (priv != NULL);

  g_free(priv->string);

  g_datalist_clear (&(priv->datalist));

#ifdef ENABLE_HANDLE_LEAK_DEBUG

  g_slist_foreach (priv->traces, handle_leak_trace_free_gfunc, NULL);

  g_slist_free (priv->traces);

#endif /* ENABLE_HANDLE_LEAK_DEBUG */

  g_free (priv);

}

static GabbleHandlePriv *

handle_priv_lookup (GabbleHandleRepo *repo,

                    TpHandleType type,

                    GabbleHandle handle)

{

  GabbleHandlePriv *priv = NULL;

  g_assert (repo != NULL);

  g_assert (gabble_handle_type_is_valid (type, NULL));

  g_assert (handle != 0);

  switch (type) {

    case TP_HANDLE_TYPE_CONTACT:

      priv = g_hash_table_lookup (repo->contact_handles, GINT_TO_POINTER (handle));

      break;

    case TP_HANDLE_TYPE_ROOM:

      priv = g_hash_table_lookup (repo->room_handles, GINT_TO_POINTER (handle));

      break;

    case TP_HANDLE_TYPE_LIST:

      priv = g_datalist_id_get_data (&repo->list_handles, handle);

      break;

    default:

      g_assert_not_reached();

    }

  return priv;

}

static GabbleHandle

gabble_handle_alloc (GabbleHandleRepo *repo, TpHandleType type)

{

  GabbleHandle ret = 0;

  g_assert (repo != NULL);

  g_assert (gabble_handle_type_is_valid (type, NULL));

  switch (type) {

    case TP_HANDLE_TYPE_CONTACT:

      if (g_heap_size (repo->free_contact_handles))

        ret = GPOINTER_TO_UINT (g_heap_extract_first (repo->free_contact_handles));

      else

        ret = repo->contact_serial++;

      break;

    case TP_HANDLE_TYPE_ROOM:

      if (g_heap_size (repo->free_room_handles))

        ret = GPOINTER_TO_UINT (g_heap_extract_first (repo->free_room_handles));

      else

        ret = repo->room_serial++;

      break;

    default:

      g_assert_not_reached();

    }

  return ret;

}

static gint

handle_compare_func (gconstpointer a, gconstpointer b)

{

  GabbleHandle first = GPOINTER_TO_UINT (a);

  GabbleHandle second = GPOINTER_TO_UINT (b);

  return (first == second) ? 0 : ((first < second) ? -1 : 1);

}

static void

handle_priv_remove (GabbleHandleRepo *repo,

                    TpHandleType type,

                    GabbleHandle handle)

{

  GabbleHandlePriv *priv;

  const gchar *string;

  g_assert (gabble_handle_type_is_valid (type, NULL));

  g_assert (handle != 0);

  g_assert (repo != NULL);

  priv = handle_priv_lookup (repo, type, handle);

  g_assert (priv != NULL);

  string = priv->string;

  switch (type) {

    case TP_HANDLE_TYPE_CONTACT:

      g_hash_table_remove (repo->contact_strings, string);

      g_hash_table_remove (repo->contact_handles, GINT_TO_POINTER (handle));

      if (handle == repo->contact_serial-1)

        repo->contact_serial--;

      else

        g_heap_add (repo->free_contact_handles, GUINT_TO_POINTER (handle));

      break;

    case TP_HANDLE_TYPE_ROOM:

      g_hash_table_remove (repo->room_strings, string);

      g_hash_table_remove (repo->room_handles, GINT_TO_POINTER (handle));

      if (handle == repo->room_serial-1)

        repo->room_serial--;

      else

        g_heap_add (repo->free_room_handles, GUINT_TO_POINTER (handle));

      break;

    case TP_HANDLE_TYPE_LIST:

      g_dataset_id_remove_data (&repo->list_handles, handle);

      break;

    default:

      g_assert_not_reached ();

    }

}

static void

handles_name_owner_changed_cb (DBusGProxy *proxy,

                               const gchar *name,

                               const gchar *old_owner,

                               const gchar *new_owner,

                               gpointer data)

{

  GabbleHandleRepo *repo = (GabbleHandleRepo *) data;

  if (old_owner && strlen (old_owner))

    {

      if (!new_owner || !strlen (new_owner))

        {

          g_datalist_remove_data (&repo->client_contact_handle_sets, old_owner);

          g_datalist_remove_data (&repo->client_room_handle_sets, old_owner);

        }

    }

}

/* public API */

/**

 * gabble_handle_jid_is_valid

 *

 * Validates a jid for given handle type and returns TRUE/FALSE

 * on success/failure. In the latter case further information is

 * provided through error if set.

 */

gboolean

gabble_handle_jid_is_valid (TpHandleType type, const gchar *jid, GError **error)

{

  if (type == TP_HANDLE_TYPE_CONTACT || type == TP_HANDLE_TYPE_ROOM)

    {

      if (!strchr (jid, '@'))

        {

          g_debug ("%s: jid %s has no @", G_STRFUNC, jid);

          g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,

              "jid %s has no @", jid);

          return FALSE;

        }

      /* FIXME: do more extensive checking */

    }

  else

    {

      g_assert_not_reached ();

      /* FIXME: add checking for other types here */

    }

  return TRUE;

}

gboolean

gabble_handle_type_is_valid (TpHandleType type, GError **error)

{

  gboolean ret;

  if (type > TP_HANDLE_TYPE_NONE && type <= TP_HANDLE_TYPE_LIST)

    {

      ret = TRUE;

    }

  else

    {

      g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,

          "invalid handle type %u", type);

      ret = FALSE;

    }

  return ret;

}

GabbleHandleRepo *

gabble_handle_repo_new ()

{

  GabbleHandleRepo *repo;

  GabbleHandle publish, subscribe, known, deny;

  repo = g_new0 (GabbleHandleRepo, 1);

  repo->contact_handles = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) handle_priv_free);

  repo->room_handles = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) handle_priv_free);

  repo->contact_strings = g_hash_table_new (g_str_hash, g_str_equal);

  repo->room_strings = g_hash_table_new (g_str_hash, g_str_equal);

  repo->free_contact_handles = g_heap_new (handle_compare_func);

  repo->free_room_handles = g_heap_new (handle_compare_func);

  repo->contact_serial = 1;

  repo->room_serial = 1;

  g_datalist_init (&repo->list_handles);

  publish = GABBLE_LIST_HANDLE_PUBLISH;

  g_datalist_id_set_data_full (&repo->list_handles, (GQuark) publish,

      handle_priv_new(), (GDestroyNotify) handle_priv_free);

  subscribe = GABBLE_LIST_HANDLE_SUBSCRIBE;

  g_datalist_id_set_data_full (&repo->list_handles, (GQuark) subscribe,

      handle_priv_new(), (GDestroyNotify) handle_priv_free);

  known = GABBLE_LIST_HANDLE_KNOWN;

  g_datalist_id_set_data_full (&repo->list_handles, (GQuark) known,

      handle_priv_new(), (GDestroyNotify) handle_priv_free);

  deny = GABBLE_LIST_HANDLE_DENY;

  g_datalist_id_set_data_full (&repo->list_handles, (GQuark) deny,

      handle_priv_new(), (GDestroyNotify) handle_priv_free);

  g_datalist_init (&repo->client_contact_handle_sets);

  g_datalist_init (&repo->client_room_handle_sets);

  repo->bus_service_proxy = dbus_g_proxy_new_for_name (tp_get_bus(),

                                                       DBUS_SERVICE_DBUS,

                                                       DBUS_PATH_DBUS,

                                                       DBUS_INTERFACE_DBUS);

  dbus_g_proxy_add_signal (repo->bus_service_proxy,

                           "NameOwnerChanged",

                           G_TYPE_STRING,

                           G_TYPE_STRING,

                           G_TYPE_STRING,

                           G_TYPE_INVALID);

  dbus_g_proxy_connect_signal (repo->bus_service_proxy,

                               "NameOwnerChanged",

                               G_CALLBACK (handles_name_owner_changed_cb),

                               repo,

                               NULL);

  return repo;

}

#ifdef ENABLE_HANDLE_LEAK_DEBUG

static void

handle_leak_debug_printbt_foreach (gpointer data, gpointer user_data)

{

  HandleLeakTrace *hltrace = (HandleLeakTrace *) data;

  int i;

  for (i = 1; i < hltrace->len; i++)

    {

      g_message ("\t\t%s\n", hltrace->trace[i]);

    }

  g_message ("\n");

}

static void

handle_leak_debug_printhandles_foreach (gpointer key, gpointer value, gpointer ignore)

{

  GabbleHandle handle = GPOINTER_TO_UINT (key);

  GabbleHandlePriv *priv = (GabbleHandlePriv *) value;

  g_message ("\t%5u: %s (%u refs), traces:\n", handle, priv->string, priv->refcount);

  g_slist_foreach (priv->traces, handle_leak_debug_printbt_foreach, NULL);

}

static void

handle_leak_debug_print_report (GabbleHandleRepo *repo)

{

  g_assert (repo != NULL);

  g_message ("The following contact handles were not freed:\n");

  g_hash_table_foreach (repo->contact_handles, handle_leak_debug_printhandles_foreach, NULL);

  g_message ("The following room handles were not freed:\n");

  g_hash_table_foreach (repo->room_handles, handle_leak_debug_printhandles_foreach, NULL);

}

static HandleLeakTrace *

handle_leak_debug_bt ()

{

  void *bt_addresses[16];

  HandleLeakTrace *ret = g_new0 (HandleLeakTrace, 1);

  ret->len = backtrace (bt_addresses, 16);

  ret->trace = backtrace_symbols (bt_addresses, ret->len);

  return ret;

}

#define HANDLE_LEAK_DEBUG_DO(traces_slist) \

  { (traces_slist) =  g_slist_append ((traces_slist), handle_leak_debug_bt ()); }

#else /* !ENABLE_HANDLE_LEAK_DEBUG */

#define HANDLE_LEAK_DEBUG_DO(traces_slist) {}

#endif /* ENABLE_HANDLE_LEAK_DEBUG */

void

gabble_handle_repo_destroy (GabbleHandleRepo *repo)

{

  g_assert (repo != NULL);

  g_assert (repo->contact_handles);

  g_assert (repo->room_handles);

  g_assert (repo->contact_strings);

  g_assert (repo->room_strings);

  g_datalist_clear (&repo->client_contact_handle_sets);

  g_datalist_clear (&repo->client_room_handle_sets);

#ifdef ENABLE_HANDLE_LEAK_DEBUG

  handle_leak_debug_print_report (repo);

#endif /* ENABLE_HANDLE_LEAK_DEBUG */

  g_hash_table_destroy (repo->contact_handles);

  g_hash_table_destroy (repo->room_handles);

  g_hash_table_destroy (repo->contact_strings);

  g_hash_table_destroy (repo->room_strings);

  g_heap_destroy (repo->free_contact_handles);

  g_heap_destroy (repo->free_room_handles);

  g_datalist_clear (&repo->list_handles);

  dbus_g_proxy_disconnect_signal (repo->bus_service_proxy,

                                  "NameOwnerChanged",

                                  G_CALLBACK (handles_name_owner_changed_cb),

                                  repo);

  g_object_unref (G_OBJECT (repo->bus_service_proxy));

  g_free (repo);

}

gboolean

gabble_handle_is_valid (GabbleHandleRepo *repo, TpHandleType type, GabbleHandle handle, GError **error)

{

  GArray *arr;

  gboolean ret;

  arr = g_array_new (FALSE, FALSE, sizeof (GabbleHandle));

  g_array_insert_val (arr, 0, handle);

  ret = gabble_handles_are_valid (repo, type, arr, FALSE, error);

  g_array_free (arr, TRUE);

  return ret;

}

gboolean

gabble_handles_are_valid (GabbleHandleRepo *repo,

                          TpHandleType type,

                          const GArray *array,

                          gboolean allow_zero,

                          GError **error)

{

  guint i;

  g_return_val_if_fail (repo != NULL, FALSE);

  g_return_val_if_fail (array != NULL, FALSE);

  if (!gabble_handle_type_is_valid (type, error))

    return FALSE;

  for (i = 0; i < array->len; i++)

    {

      GabbleHandle handle = g_array_index (array, GabbleHandle, i);

      if (handle == 0)

        {

          if (allow_zero)

              continue;

          g_debug ("someone tried to validate handle zero");

          g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,

              "invalid handle %u", handle);

          return FALSE;

        }

      if (handle_priv_lookup (repo, type, handle) == NULL)

        {

          g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,

              "invalid handle %u", handle);

          return FALSE;

        }

    }