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

  return strcmp (info->name, name);

}

typedef struct

{

  const char *name;

  const char *owner;

  DBusGProxyNameOwnerInfo *info;

} DBusGProxyNameOwnerForeachData;

static void

name_owner_foreach (gpointer key, gpointer val, gpointer data)

{

  const char *owner;

  DBusGProxyNameOwnerForeachData *foreach_data;

  GSList *names;

  GSList *link;

  owner = key;

  names = val;

  foreach_data = data;

  if (foreach_data->owner != NULL)

    return;

  g_assert (foreach_data->info == NULL);

  link = g_slist_find_custom (names, foreach_data->name, find_name_in_info);

  if (link)

    {

      foreach_data->owner = owner;

      foreach_data->info = link->data;

    }

}

static gboolean

dbus_g_proxy_manager_lookup_name_owner (DBusGProxyManager        *manager,

					const char               *name,

					DBusGProxyNameOwnerInfo **info,

					const char              **owner)

{

  DBusGProxyNameOwnerForeachData foreach_data;

  foreach_data.name = name;

  foreach_data.owner = NULL;

  foreach_data.info = NULL;

  g_hash_table_foreach (manager->owner_names, name_owner_foreach, &foreach_data);

  *info = foreach_data.info;

  *owner = foreach_data.owner;

  return *info != NULL;

}

static void

insert_nameinfo (DBusGProxyManager       *manager,

		 const char              *owner,

		 DBusGProxyNameOwnerInfo *info)

{

  GSList *names;

  gboolean insert;

  names = g_hash_table_lookup (manager->owner_names, owner);

  /* Only need to g_hash_table_insert the first time */

  insert = (names == NULL);

  names = g_slist_append (names, info); 

  if (insert)

    g_hash_table_insert (manager->owner_names, g_strdup (owner), names);

}

static void

dbus_g_proxy_manager_monitor_name_owner (DBusGProxyManager  *manager,

					 const char         *owner,

					 const char         *name)

{

  GSList *names;

  GSList *link;

  DBusGProxyNameOwnerInfo *nameinfo;

  names = g_hash_table_lookup (manager->owner_names, owner);

  link = g_slist_find_custom (names, name, find_name_in_info);

  if (!link)

    {

      nameinfo = g_new0 (DBusGProxyNameOwnerInfo, 1);

      nameinfo->name = g_strdup (name);

      nameinfo->refcount = 1;

      insert_nameinfo (manager, owner, nameinfo);

    }

  else

    {

      nameinfo = link->data;

      nameinfo->refcount++;

    }

}

static void

dbus_g_proxy_manager_unmonitor_name_owner (DBusGProxyManager  *manager,

					   const char         *name)

{

  DBusGProxyNameOwnerInfo *info;

  const char *owner;

  gboolean ret;

  ret = dbus_g_proxy_manager_lookup_name_owner (manager, name, &info, &owner);

  g_assert (ret);

  g_assert (info != NULL);

  g_assert (owner != NULL);

  info->refcount--;

  if (info->refcount == 0)

    {

      GSList *names;

      GSList *link;

      names = g_hash_table_lookup (manager->owner_names, owner);

      link = g_slist_find_custom (names, name, find_name_in_info);

      names = g_slist_delete_link (names, link);

      if (names != NULL)

	g_hash_table_insert (manager->owner_names, g_strdup (owner), names);

      else

	g_hash_table_remove (manager->owner_names, owner);

      g_free (info->name);

      g_free (info);

    }

}

typedef struct

{

  const char *name;

  GSList *destroyed;

} DBusGProxyUnassociateData;

static void

unassociate_proxies (gpointer key, gpointer val, gpointer user_data)

{

  DBusGProxyList *list;

  const char *name;

  GSList *tmp;

  DBusGProxyUnassociateData *data;

  list = val;

  data = user_data;

  name = data->name;

  for (tmp = list->proxies; tmp; tmp = tmp->next)

    {

      DBusGProxy *proxy = DBUS_G_PROXY (tmp->data);

      DBusGProxyPrivate *priv = DBUS_G_PROXY_GET_PRIVATE(proxy);

      DBusGProxyManager *manager;

      manager = priv->manager;

      if (!strcmp (priv->name, name))

	{

	  if (!priv->for_owner)

	    {

	      g_assert (priv->associated);

	      g_assert (priv->name_call == NULL);

	      priv->associated = FALSE;

	      manager->unassociated_proxies = g_slist_prepend (manager->unassociated_proxies, proxy);

	    }

	  else

	    {

	      data->destroyed = g_slist_prepend (data->destroyed, proxy);

              /* make contents of list into weak pointers in case the objects

               * unref each other when disposing */

              g_object_add_weak_pointer (G_OBJECT (proxy),

                  &(data->destroyed->data));

	    }

	}

    }

}

static void

dbus_g_proxy_manager_replace_name_owner (DBusGProxyManager  *manager,

					 const char         *name,

					 const char         *prev_owner,

					 const char         *new_owner)

{

  GSList *names;

  if (prev_owner[0] == '\0')

    {

      GSList *tmp;

      GSList *removed;

      /* We have a new service, look at unassociated proxies */

      removed = NULL;

      for (tmp = manager->unassociated_proxies; tmp ; tmp = tmp->next)

	{

	  DBusGProxy *proxy = tmp->data;

	  DBusGProxyPrivate *priv = DBUS_G_PROXY_GET_PRIVATE(proxy);

	  if (!strcmp (priv->name, name))

	    {

	      removed = g_slist_prepend (removed, tmp);

	      dbus_g_proxy_manager_monitor_name_owner (manager, new_owner, name);

	      priv->associated = TRUE;

	    }

	}

      for (tmp = removed; tmp; tmp = tmp->next)

	manager->unassociated_proxies = g_slist_delete_link (manager->unassociated_proxies, tmp->data);

      g_slist_free (removed);

    }

  else

    {

      DBusGProxyNameOwnerInfo *info;

      GSList *link;

      /* Name owner changed or deleted */ 

      names = g_hash_table_lookup (manager->owner_names, prev_owner);

      info = NULL;

      if (names != NULL)

        {

	  link = g_slist_find_custom (names, name, find_name_in_info);

	  if (link != NULL)

	    {

	      info = link->data;

	      names = g_slist_delete_link (names, link);

	      if (names == NULL)

	        g_hash_table_remove (manager->owner_names, prev_owner);

	    }

        }

      if (new_owner[0] == '\0')

	{

	  DBusGProxyUnassociateData data;

	  GSList *tmp;

	  data.name = name;

	  data.destroyed = NULL;

	  /* A service went away, we need to unassociate proxies */

	  g_hash_table_foreach (manager->proxy_lists,

				unassociate_proxies, &data);

	  UNLOCK_MANAGER (manager);

          /* the destroyed list's data pointers are weak pointers, so that we

           * don't end up calling destroy on proxies which have already been

           * freed up as a result of other ones being destroyed */

	  for (tmp = data.destroyed; tmp; tmp = tmp->next)

            if (tmp->data != NULL)

              {

                g_object_remove_weak_pointer (G_OBJECT (tmp->data),

                    &(tmp->data));

                dbus_g_proxy_destroy (tmp->data);

              }

	  g_slist_free (data.destroyed);

	  LOCK_MANAGER (manager);

	  if (info)

	    {

	      g_free (info->name);

	      g_free (info);

	    }

	}

      else if (info)

	{

	  insert_nameinfo (manager, new_owner, info);

	}

    }

}

static void

got_name_owner_cb (DBusGProxy       *bus_proxy,

		   DBusGProxyCall   *call,

		   void             *user_data)

{

  DBusGProxy *proxy = user_data;

  DBusGProxyPrivate *priv = DBUS_G_PROXY_GET_PRIVATE(proxy);

  GError *error;

  char *owner;

  error = NULL;

  owner = NULL;

  LOCK_MANAGER (priv->manager);

  if (!dbus_g_proxy_end_call (bus_proxy, call, &error,

			      G_TYPE_STRING, &owner,

			      G_TYPE_INVALID))

    {

      if (error->domain == DBUS_GERROR && error->code == DBUS_GERROR_NAME_HAS_NO_OWNER)

	{

	  priv->manager->unassociated_proxies = g_slist_prepend (priv->manager->unassociated_proxies, proxy);

	}

      else if (error->domain == DBUS_GERROR && error->code == DBUS_GERROR_REMOTE_EXCEPTION)

	g_warning ("Couldn't get name owner (%s): %s",

		   dbus_g_error_get_name (error),

		   error->message);

      else

	g_warning ("Couldn't get name owner (code %d): %s",

                   error->code, error->message);

      g_clear_error (&error);

      goto out;

    }

  else

    {

      dbus_g_proxy_manager_monitor_name_owner (priv->manager, owner, priv->name);

      priv->associated = TRUE;

    }

 out:

  priv->name_call = NULL;

  UNLOCK_MANAGER (priv->manager);

  g_free (owner);

}

static char *

get_name_owner (DBusConnection     *connection,

		const char         *name,

		GError            **error)

{

  DBusError derror;

  DBusMessage *request, *reply;

  char *base_name;

  dbus_error_init (&derror);

  base_name = NULL;

  reply = NULL;

  request = dbus_message_new_method_call (DBUS_SERVICE_DBUS,

					  DBUS_PATH_DBUS,

					  DBUS_INTERFACE_DBUS,

					  "GetNameOwner");

  if (request == NULL)

    g_error ("Out of memory");

  if (!dbus_message_append_args (request, 

				 DBUS_TYPE_STRING, &name, 

				 DBUS_TYPE_INVALID))

    g_error ("Out of memory");

  reply =

    dbus_connection_send_with_reply_and_block (connection,

                                               request,

                                               2000, &derror);

  if (reply == NULL)

    goto error;

  if (dbus_set_error_from_message (&derror, reply))

    goto error;

  if (!dbus_message_get_args (reply, &derror, 

			      DBUS_TYPE_STRING, &base_name, 

			      DBUS_TYPE_INVALID))

    goto error;

  base_name = g_strdup (base_name);

  goto out;

 error:

  g_assert (dbus_error_is_set (&derror));

  dbus_set_g_error (error, &derror);

  dbus_error_free (&derror);

 out:

  if (request)

    dbus_message_unref (request);

  if (reply)

    dbus_message_unref (reply);

  return base_name;

}

static void

dbus_g_proxy_manager_register (DBusGProxyManager *manager,

                               DBusGProxy        *proxy)

{

  DBusGProxyList *list;

  DBusGProxyPrivate *priv = DBUS_G_PROXY_GET_PRIVATE(proxy);

  LOCK_MANAGER (manager);

  if (manager->proxy_lists == NULL)

    {

      g_assert (manager->owner_names == NULL);

      list = NULL;

      manager->proxy_lists = g_hash_table_new_full (tristring_hash,

                                                    tristring_equal,

                                                    NULL,

                                                    (GFreeFunc) g_proxy_list_free);

      manager->owner_names = g_hash_table_new_full (g_str_hash,

                                                    g_str_equal,

                                                    g_free,

                                                    NULL);

      /* FIXME - for now we listen for all NameOwnerChanged; once

       * Anders' detail patch lands we should add individual rules

       */

      dbus_bus_add_match (manager->connection,

                          "type='signal',sender='" DBUS_SERVICE_DBUS

			  "',path='" DBUS_PATH_DBUS

			  "',interface='" DBUS_INTERFACE_DBUS

			  "',member='NameOwnerChanged'",

			  NULL);

    }

  else

    {

      char *tri;

      tri = tristring_from_proxy (proxy);

      list = g_hash_table_lookup (manager->proxy_lists, tri);

      g_free (tri);

    }

  if (list == NULL)

    {

      list = g_proxy_list_new (proxy);

      g_hash_table_replace (manager->proxy_lists,

                            list->name, list);

    }

  if (list->proxies == NULL && priv->name)

    {

      /* We have to add the match rule to the server,

       * but only if the server is a message bus,

       * not if it's a peer.

       */

       char *rule;

       rule = g_proxy_get_match_rule (proxy);

       /* We don't check for errors; it's not like anyone would handle them, and

        * we don't want a round trip here.

        */

       dbus_bus_add_match (manager->connection,

			   rule, NULL);

       g_free (rule);

    }

  g_assert (g_slist_find (list->proxies, proxy) == NULL);

  list->proxies = g_slist_prepend (list->proxies, proxy);

  if (!priv->for_owner)

    {

      const char *owner;

      DBusGProxyNameOwnerInfo *info;

      if (!dbus_g_proxy_manager_lookup_name_owner (manager, priv->name, &info, &owner))