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

/* dbus-gproxy.c Proxy for remote objects

 *

 * Copyright (C) 2003, 2004, 2005 Red Hat, Inc.

 * Copyright (C) 2005 Nokia

 * 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 <dbus/dbus-glib.h>

#include <dbus/dbus-glib-lowlevel.h>

#include <dbus/dbus-signature.h>

#include "dbus-gutils.h"

#include "dbus-gsignature.h"

#include "dbus-gvalue.h"

#include "dbus-gvalue-utils.h"

#include "dbus-gobject.h"

#include <string.h>

#ifdef __SYMBIAN32__

#include<glib_global.h>

#include<glib-object.h>

#endif

#ifndef __SYMBIAN32__

#include <glib/gi18n.h>

#include <libintl.h>

#define _(x) dgettext (GETTEXT_PACKAGE, x)

#define N_(x) x

#else

#define _(x) x

#define N_(x) x

#endif

#include <gobject/gvaluecollector.h>

#ifdef __SYMBIAN32__

#include "libdbus_glib_wsd_solution.h"

#endif

#define DBUS_G_PROXY_CALL_TO_ID(x) (GPOINTER_TO_UINT(x))

#define DBUS_G_PROXY_ID_TO_CALL(x) (GUINT_TO_POINTER(x))

#define DBUS_G_PROXY_GET_PRIVATE(o)  \

       (G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TYPE_G_PROXY, DBusGProxyPrivate))

/**

 * @addtogroup DBusGLibInternals

 *

 * @{

 */

/**

 * DBusGProxyManager typedef

 */

typedef struct _DBusGProxyManager DBusGProxyManager;

typedef struct _DBusGProxyPrivate DBusGProxyPrivate;

/**

 * Internals of DBusGProxy

 */

struct _DBusGProxyPrivate

{

  DBusGProxyManager *manager; /**< Proxy manager */

  char *name;                 /**< Name messages go to or NULL */

  char *path;                 /**< Path messages go to or NULL */

  char *interface;            /**< Interface messages go to or NULL */

  DBusGProxyCall *name_call;  /**< Pending call id to retrieve name owner */

  guint for_owner : 1;        /**< Whether or not this proxy is for a name owner */

  guint associated : 1;       /**< Whether or not this proxy is associated (for name proxies) */

  /* FIXME: make threadsafe? */

  guint call_id_counter;      /**< Integer counter for pending calls */

  GData *signal_signatures;   /**< D-BUS signatures for each signal */

  GHashTable *pending_calls;  /**< Calls made on this proxy which have not yet returned */

};

static void dbus_g_proxy_init               (DBusGProxy      *proxy);

static void dbus_g_proxy_class_init         (DBusGProxyClass *klass);

static GObject *dbus_g_proxy_constructor    (GType                  type,

					     guint                  n_construct_properties,

					     GObjectConstructParam *construct_properties);

static void     dbus_g_proxy_set_property       (GObject               *object,

						 guint                  prop_id,

						 const GValue          *value,

						 GParamSpec            *pspec);

static void     dbus_g_proxy_get_property       (GObject               *object,

						 guint                  prop_id,

						 GValue                *value,

						 GParamSpec            *pspec);

static void dbus_g_proxy_finalize           (GObject         *object);

static void dbus_g_proxy_dispose            (GObject         *object);

static void dbus_g_proxy_destroy            (DBusGProxy      *proxy);

static void dbus_g_proxy_emit_remote_signal (DBusGProxy      *proxy,

                                             DBusMessage     *message);

static DBusGProxyCall *manager_begin_bus_call (DBusGProxyManager    *manager,

					       const char          *method,

					       DBusGProxyCallNotify notify,

					       gpointer             data,

					       GDestroyNotify       destroy,

					       GType                first_arg_type,

					       ...);

static guint dbus_g_proxy_begin_call_internal (DBusGProxy          *proxy,

					       const char          *method,

					       DBusGProxyCallNotify notify,

					       gpointer             data,

					       GDestroyNotify       destroy,

					       GValueArray         *args,

					       int timeout );

static gboolean dbus_g_proxy_end_call_internal (DBusGProxy        *proxy,

						guint              call_id,

						GError           **error,

						GType              first_arg_type,

						va_list            args);

/**

 * A list of proxies with a given name+path+interface, used to

 * route incoming signals.

 */

typedef struct

{

  GSList *proxies; /**< The list of proxies */

  char name[4]; /**< name (empty string for none), nul byte,

                 *   path, nul byte,

                 *   interface, nul byte

                 */

} DBusGProxyList;

/**

 * DBusGProxyManager's primary task is to route signals to the proxies

 * those signals are emitted on. In order to do this it also has to

 * track the owners of the names proxies are bound to.

 */

struct _DBusGProxyManager

{

  GStaticMutex lock; /**< Thread lock */

  int refcount;      /**< Reference count */

  DBusConnection *connection; /**< Connection we're associated with. */

  DBusGProxy *bus_proxy; /**< Special internal proxy used to talk to the bus */

  GHashTable *proxy_lists; /**< Hash used to route incoming signals

                            *   and iterate over proxies

                            */

  GHashTable *owner_names; /**< Hash to keep track of mapping from

			    *   base name -> [name,name,...] for proxies which

			    *   are for names.

			    */

  GSList *unassociated_proxies;     /**< List of name proxies for which

				     *   there was no result for

				     *   GetNameOwner

				     */

};

static DBusGProxyManager *dbus_g_proxy_manager_ref    (DBusGProxyManager *manager);

static DBusHandlerResult  dbus_g_proxy_manager_filter (DBusConnection    *connection,

                                                       DBusMessage       *message,

                                                       void              *user_data);

/** Lock the DBusGProxyManager */

#define LOCK_MANAGER(mgr)   (g_static_mutex_lock (&(mgr)->lock))

/** Unlock the DBusGProxyManager */

#define UNLOCK_MANAGER(mgr) (g_static_mutex_unlock (&(mgr)->lock))

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(g_proxy_manager_slot,dbus_gproxy,int )

#define g_proxy_manager_slot (*GET_DBUS_WSD_VAR_NAME(g_proxy_manager_slot,dbus_gproxy,s)())

GET_STATIC_VAR_FROM_TLS(connection_g_proxy_lock,dbus_gproxy,GStaticMutex )

#define connection_g_proxy_lock (*GET_DBUS_WSD_VAR_NAME(connection_g_proxy_lock,dbus_gproxy,s)())

#else

static int g_proxy_manager_slot = -1;

/* Lock controlling get/set manager as data on each connection */

static GStaticMutex connection_g_proxy_lock = G_STATIC_MUTEX_INIT;

#endif

static DBusGProxyManager*

dbus_g_proxy_manager_get (DBusConnection *connection)

{

  DBusGProxyManager *manager;

  dbus_connection_allocate_data_slot (&g_proxy_manager_slot);

  if (g_proxy_manager_slot < 0)

    g_error ("out of memory");

  g_static_mutex_lock (&connection_g_proxy_lock);

  manager = dbus_connection_get_data (connection, g_proxy_manager_slot);

  if (manager != NULL)

    {

      dbus_connection_free_data_slot (&g_proxy_manager_slot);

      dbus_g_proxy_manager_ref (manager);

      g_static_mutex_unlock (&connection_g_proxy_lock);

      return manager;

    }

  manager = g_new0 (DBusGProxyManager, 1);

  manager->refcount = 1;

  manager->connection = connection;

  g_static_mutex_init (&manager->lock);

  /* Proxy managers keep the connection alive, which means that

   * DBusGProxy indirectly does. To free a connection you have to free

   * all the proxies referring to it.

   */

  dbus_connection_ref (manager->connection);

  dbus_connection_set_data (connection, g_proxy_manager_slot,

                            manager, NULL);

  dbus_connection_add_filter (connection, dbus_g_proxy_manager_filter,

                              manager, NULL);

  g_static_mutex_unlock (&connection_g_proxy_lock);

  return manager;

}

static DBusGProxyManager * 

dbus_g_proxy_manager_ref (DBusGProxyManager *manager)

{

  g_assert (manager != NULL);

  g_assert (manager->refcount > 0);

  LOCK_MANAGER (manager);

  manager->refcount += 1;

  UNLOCK_MANAGER (manager);

  return manager;

}

static void

dbus_g_proxy_manager_unref (DBusGProxyManager *manager)

{

  g_assert (manager != NULL);

  g_assert (manager->refcount > 0);

  LOCK_MANAGER (manager);

  manager->refcount -= 1;

  if (manager->refcount == 0)

    {

      UNLOCK_MANAGER (manager);

      if (manager->bus_proxy)

	g_object_unref (manager->bus_proxy);

      if (manager->proxy_lists)

        {

          /* can't have any proxies left since they hold

           * a reference to the proxy manager.

           */

          g_assert (g_hash_table_size (manager->proxy_lists) == 0);

          g_hash_table_destroy (manager->proxy_lists);

          manager->proxy_lists = NULL;

        }

      if (manager->owner_names)

	{

	  /* Since we destroyed all proxies, none can be tracking

	   * name owners

	   */

          g_assert (g_hash_table_size (manager->owner_names) == 0);

	  g_hash_table_destroy (manager->owner_names);

	  manager->owner_names = NULL;

	}

      g_assert (manager->unassociated_proxies == NULL);

      g_static_mutex_free (&manager->lock);

      g_static_mutex_lock (&connection_g_proxy_lock);

      dbus_connection_remove_filter (manager->connection, dbus_g_proxy_manager_filter,

                                     manager);

      dbus_connection_set_data (manager->connection,

                                g_proxy_manager_slot,

                                NULL, NULL);

      g_static_mutex_unlock (&connection_g_proxy_lock);

      dbus_connection_unref (manager->connection);

      g_free (manager);

      dbus_connection_free_data_slot (&g_proxy_manager_slot);

    }

  else

    {

      UNLOCK_MANAGER (manager);

    }

}

static guint

tristring_hash (gconstpointer key)

{

  const char *p = key;

  guint h = *p;

  if (h)

    {

      for (p += 1; *p != '\0'; p++)

        h = (h << 5) - h + *p;

    }

  /* skip nul and do the next substring */

  for (p += 1; *p != '\0'; p++)

    h = (h << 5) - h + *p;

  /* skip nul again and another substring */

  for (p += 1; *p != '\0'; p++)

    h = (h << 5) - h + *p;

  return h;

}

static gboolean

strequal_len (const char *a,

              const char *b,

              size_t     *lenp)

{

  size_t a_len;

  size_t b_len;

  a_len = strlen (a);

  b_len = strlen (b);

  if (a_len != b_len)

    return FALSE;

  if (memcmp (a, b, a_len) != 0)

    return FALSE;

  *lenp = a_len;

  return TRUE;

}

static gboolean

tristring_equal (gconstpointer  a,

                 gconstpointer  b)

{

  const char *ap = a;

  const char *bp = b;

  size_t len;

  if (!strequal_len (ap, bp, &len))

    return FALSE;

  ap += len + 1;

  bp += len + 1;

  if (!strequal_len (ap, bp, &len))

    return FALSE;

  ap += len + 1;

  bp += len + 1;

  if (strcmp (ap, bp) != 0)

    return FALSE;

  return TRUE;

}

static char*

tristring_alloc_from_strings (size_t      padding_before,

                              const char *name,

                              const char *path,

                              const char *interface)

{

  size_t name_len, iface_len, path_len, len;

  char *tri;

  if (name)

    name_len = strlen (name);

  else

    name_len = 0;

  path_len = strlen (path);

  iface_len = strlen (interface);

  tri = g_malloc (padding_before + name_len + path_len + iface_len + 3);

  len = padding_before;

  if (name)

    memcpy (&tri[len], name, name_len);

  len += name_len;

  tri[len] = '\0';

  len += 1;

  g_assert (len == (padding_before + name_len + 1));

  memcpy (&tri[len], path, path_len);

  len += path_len;

  tri[len] = '\0';

  len += 1;

  g_assert (len == (padding_before + name_len + path_len + 2));

  memcpy (&tri[len], interface, iface_len);

  len += iface_len;

  tri[len] = '\0';

  len += 1;

  g_assert (len == (padding_before + name_len + path_len + iface_len + 3));

  return tri;

}

static char*

tristring_from_proxy (DBusGProxy *proxy)

{

  DBusGProxyPrivate *priv = DBUS_G_PROXY_GET_PRIVATE(proxy);

  return tristring_alloc_from_strings (0,

                                       priv->name,

                                       priv->path,

                                       priv->interface);

}

static char*

tristring_from_message (DBusMessage *message)

{

  const char *path;

  const char *interface;

  path = dbus_message_get_path (message);

  interface = dbus_message_get_interface (message);

  g_assert (path);

  g_assert (interface);

  return tristring_alloc_from_strings (0,

                                       dbus_message_get_sender (message),

                                       path, interface);

}

static DBusGProxyList*

g_proxy_list_new (DBusGProxy *first_proxy)

{

  DBusGProxyList *list;

  DBusGProxyPrivate *priv = DBUS_G_PROXY_GET_PRIVATE(first_proxy);

  list = (void*) tristring_alloc_from_strings (G_STRUCT_OFFSET (DBusGProxyList, name),

                                               priv->name,

                                               priv->path,

                                               priv->interface);

  list->proxies = NULL;

  return list;

}

static void

g_proxy_list_free (DBusGProxyList *list)

{

  /* we don't hold a reference to the proxies in the list,

   * as they ref the GProxyManager

   */

  g_slist_free (list->proxies);  

  g_free (list);

}

static char*

g_proxy_get_match_rule (DBusGProxy *proxy)

{

  DBusGProxyPrivate *priv = DBUS_G_PROXY_GET_PRIVATE(proxy);

  /* FIXME Escaping is required here */

  if (priv->name)

    return g_strdup_printf ("type='signal',sender='%s',path='%s',interface='%s'",

                            priv->name, priv->path, priv->interface);

  else

    return g_strdup_printf ("type='signal',path='%s',interface='%s'",

                            priv->path, priv->interface);

}

typedef struct

{

  char *name;

  guint refcount;

} DBusGProxyNameOwnerInfo;

static gint

find_name_in_info (gconstpointer a, gconstpointer b)

{

  const DBusGProxyNameOwnerInfo *info = a;

  const char *name = b;