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

/* dbus-gobject.c Exporting a GObject remotely

 *

 * 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

 *

 */

#ifndef __SYMBIAN32__

#include <config.h>

#else

#include "config.h"

#endif //__SYMBIAN32__

#include <gobject/gvaluecollector.h>

#include <dbus/dbus-glib.h>

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

#include "dbus-gtest.h"

#include "dbus-gutils.h"

#include "dbus-gobject.h"

#include "dbus-gsignature.h"

#include "dbus-gvalue.h"

#include "dbus-gmarshal.h"

#include "dbus-gvalue-utils.h"

#include <string.h>

#ifdef __SYMBIAN32__

#include "libdbus_glib_wsd_solution.h"

#endif

typedef struct

{

  char *default_iface;

  GType code_enum;

} DBusGErrorInfo;

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(marshal_table,dbus_gobject,GHashTable *)

#define marshal_table (*GET_DBUS_WSD_VAR_NAME(marshal_table,dbus_gobject,s)())

GET_STATIC_VAR_FROM_TLS(error_metadata,dbus_gobject,GData *)

#define error_metadata (*GET_DBUS_WSD_VAR_NAME(error_metadata,dbus_gobject,s)())

GET_STATIC_VAR_FROM_TLS(globals_lock,dbus_gobject,GStaticRWLock )

#define globals_lock (*GET_DBUS_WSD_VAR_NAME(globals_lock,dbus_gobject,s)())

#else

static GStaticRWLock globals_lock = G_STATIC_RW_LOCK_INIT;

static GHashTable *marshal_table = NULL;

static GData *error_metadata = NULL;

#endif

static char*

uscore_to_wincaps (const char *uscore)

{

  const char *p;

  GString *str;

  gboolean last_was_uscore;

  last_was_uscore = TRUE;

  str = g_string_new (NULL);

  p = uscore;

  while (p && *p)

    {

      if (*p == '-' || *p == '_')

        {

          last_was_uscore = TRUE;

        }

      else

        {

          if (last_was_uscore)

            {

              g_string_append_c (str, g_ascii_toupper (*p));

              last_was_uscore = FALSE;

            }

          else

            g_string_append_c (str, *p);

        }

      ++p;

    }

  return g_string_free (str, FALSE);

}

static const char *

string_table_next (const char *table)

{

  return (table + (strlen (table) + 1));

}

static const char *

string_table_lookup (const char *table, int index)

{

  const char *ret;

  ret = table;

  while (index--)

    ret = string_table_next (ret);

  return ret;

}

static const char *

get_method_data (const DBusGObjectInfo *object,

		 const DBusGMethodInfo *method)

{

  return object->data + method->data_offset;

}

static char *

object_error_domain_prefix_from_object_info (const DBusGObjectInfo *info)

{

  /* FIXME */

  return NULL;

}

static char *

object_error_code_from_object_info (const DBusGObjectInfo *info, GQuark domain, gint code)

{

  /* FIXME */

  return NULL;

}

static const char *

method_interface_from_object_info (const DBusGObjectInfo *object,

			      const DBusGMethodInfo *method)

{

  return string_table_lookup (get_method_data (object, method), 0);

}

static const char *

method_name_from_object_info (const DBusGObjectInfo *object,

			      const DBusGMethodInfo *method)

{

  return string_table_lookup (get_method_data (object, method), 1);

}

static const char *

method_arg_info_from_object_info (const DBusGObjectInfo *object,

				  const DBusGMethodInfo *method)

{

  return string_table_lookup (get_method_data (object, method), 3);/*RB was 2*/

}

typedef enum

{

  RETVAL_NONE,    

  RETVAL_NOERROR,    

  RETVAL_ERROR

} RetvalType;

static const char *

arg_iterate (const char    *data,

	     const char   **name,

	     gboolean      *in,

	     gboolean      *constval,

	     RetvalType    *retval,

	     const char   **type)

{

  gboolean inarg;

  if (name)

    *name = data;

  data = string_table_next (data);

  switch (*data)

    {

    case 'I':

      inarg = TRUE;

      break;

    case 'O':

      inarg = FALSE;

      break;

    default:

      g_warning ("invalid arg direction '%c'", *data);

      inarg = FALSE;

      break;

    }

  if (in)

    *in = inarg;

  if (!inarg)

    {

      data = string_table_next (data);

      switch (*data)

	{

	case 'F':

	  if (constval)

	    *constval = FALSE;

	  break;

	case 'C':

	  if (constval)

	    *constval = TRUE;

	  break;

	default:

	  g_warning ("invalid arg const value '%c'", *data);

	  break;

	}

      data = string_table_next (data);

      switch (*data)

	{

	case 'N':

	  if (retval)

	    *retval = RETVAL_NONE;

	  break;

	case 'E':

	  if (retval)

	    *retval = RETVAL_ERROR;

	  break;

	case 'R':

	  if (retval)

	    *retval = RETVAL_NOERROR;

	  break;

	default:

	  g_warning ("invalid arg ret value '%c'", *data);

	  break;

	}

    }

  else

    {

      if (constval)

	*constval = FALSE;

      if (retval)

      #ifndef __SYMBIAN32__

      	*retval = FALSE;

      #else

	*retval = (RetvalType)FALSE;

	 #endif

    }

  data = string_table_next (data);

  if (type)

    *type = data;

  return string_table_next (data);

}

static char *

method_dir_signature_from_object_info (const DBusGObjectInfo *object,

				       const DBusGMethodInfo *method,

				       gboolean               in)

{

  const char *arg;

  GString *ret;

  arg = method_arg_info_from_object_info (object, method);

  ret = g_string_new (NULL);

  while (*arg)

    {

      const char *name;

      gboolean arg_in;

      const char *type;

      arg = arg_iterate (arg, &name, &arg_in, NULL, NULL, &type);

      if (arg_in == in)

	g_string_append (ret, type);

    }

  return g_string_free (ret, FALSE);

}

static char *

method_input_signature_from_object_info (const DBusGObjectInfo *object,

					 const DBusGMethodInfo *method)

{

  return method_dir_signature_from_object_info (object, method, TRUE);

}

static char *

method_output_signature_from_object_info (const DBusGObjectInfo *object,

					  const DBusGMethodInfo *method)

{

  return method_dir_signature_from_object_info (object, method, FALSE);

}

static const char *

propsig_iterate (const char *data, const char **iface, const char **name)

{

  *iface = data;

  data = string_table_next (data);

  *name = data;

  return string_table_next (data);

}

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(quark,dbus_gobject,GQuark )

#define quark (*GET_DBUS_WSD_VAR_NAME(quark,dbus_gobject,s)())

#endif

static GQuark

dbus_g_object_type_dbus_metadata_quark (void)

{

#ifndef EMULATOR

  static GQuark quark;

#endif

  if (!quark)

    quark = g_quark_from_static_string ("DBusGObjectTypeDBusMetadataQuark");

  return quark;

}

static GList *

lookup_object_info (GObject *object)

{

  GType *interfaces, *p;

  GList *info_list = NULL;

  const DBusGObjectInfo *info;

  GType classtype;

  interfaces = g_type_interfaces (G_TYPE_FROM_INSTANCE (object), NULL);

  for (p = interfaces; *p != 0; p++)

    {

      info = g_type_get_qdata (*p, dbus_g_object_type_dbus_metadata_quark ());

      if (info != NULL && info->format_version >= 0)

          info_list = g_list_prepend (info_list, (gpointer) info);

    }

  g_free (interfaces);

  for (classtype = G_TYPE_FROM_INSTANCE (object); classtype != 0; classtype = g_type_parent (classtype))

    {

      info = g_type_get_qdata (classtype, dbus_g_object_type_dbus_metadata_quark ());

      if (info != NULL && info->format_version >= 0)

          info_list = g_list_prepend (info_list, (gpointer) info);

    }

  /* if needed only:

  return g_list_reverse (info_list);

  */

  return info_list;

}

static void

gobject_unregister_function (DBusConnection  *connection,

                             void            *user_data)

{

#ifdef WINSCW

  GObject *object;

  object = G_OBJECT (user_data);

#endif

  /* FIXME */

}

typedef struct

{

  GString *xml;

  GType gtype;

  const DBusGObjectInfo *object_info;

} DBusGLibWriteIterfaceData;

typedef struct

{

  GSList *methods;

  GSList *signals;

  GSList *properties;

} DBusGLibWriteInterfaceValues;

static void

write_interface (gpointer key, gpointer val, gpointer user_data)

{

  const char *name;

  GSList *methods;

  GSList *signals;

  GSList *properties;

  GString *xml;

  const DBusGObjectInfo *object_info;

  DBusGLibWriteIterfaceData *data;

  DBusGLibWriteInterfaceValues *values;

  name = key;

  values = val;

  methods = values->methods;

  signals = values->signals;

  properties = values->properties;

  data = user_data;

  xml = data->xml;

  object_info = data->object_info;

  g_string_append_printf (xml, "  <interface name=\"%s\">\n", name);

  /* FIXME: recurse to parent types ? */

  for (; methods; methods = methods->next)

    {

      DBusGMethodInfo *method;

      const char *args;

      method = methods->data;

      g_string_append_printf (xml, "    <method name=\"%s\">\n",

			      method_name_from_object_info (object_info, method));

      args = method_arg_info_from_object_info (object_info, method);

      while (*args)

	{

	  const char *name;

	  gboolean arg_in;

	  const char *type;

	  args = arg_iterate (args, &name, &arg_in, NULL, NULL, &type);

	  /* FIXME - handle container types */

	  g_string_append_printf (xml, "      <arg name=\"%s\" type=\"%s\" direction=\"%s\"/>\n",

				  name, type, arg_in ? "in" : "out");

	}

      g_string_append (xml, "    </method>\n");

    }

  g_slist_free (values->methods);

  for (; signals; signals = signals->next)

    {

      guint id;

      guint arg;

      const char *signame;

      GSignalQuery query;

      char *s;

      signame = signals->data;

      s = _dbus_gutils_wincaps_to_uscore (signame);

      id = g_signal_lookup (s, data->gtype);

      g_assert (id != 0);

      g_signal_query (id, &query);

      g_assert (query.return_type == G_TYPE_NONE);

      g_string_append_printf (xml, "    <signal name=\"%s\">\n", signame);

      for (arg = 0; arg < query.n_params; arg++)

	{

	  char *dbus_type = _dbus_gtype_to_signature (query.param_types[arg]);

	  g_assert (dbus_type != NULL);

          g_string_append (xml, "      <arg type=\"");

          g_string_append (xml, dbus_type);

          g_string_append (xml, "\"/>\n");

	  g_free (dbus_type);

	}

      g_string_append (xml, "    </signal>\n");

      g_free (s);

    }

  g_slist_free (values->signals);

  for (; properties; properties = properties->next)

    {

      const char *propname;

      GParamSpec *spec;

      char *dbus_type;

      gboolean can_set;

      gboolean can_get;

      char *s;

      propname = properties->data;

      spec = NULL;

      s = _dbus_gutils_wincaps_to_uscore (propname);

      spec = g_object_class_find_property (g_type_class_peek (data->gtype), s);

      g_assert (spec != NULL);

      g_free (s);

      dbus_type = _dbus_gtype_to_signature (G_PARAM_SPEC_VALUE_TYPE (spec));

      g_assert (dbus_type != NULL);

      can_set = ((spec->flags & G_PARAM_WRITABLE) != 0 &&

		 (spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);

      can_get = (spec->flags & G_PARAM_READABLE) != 0;

      if (can_set || can_get)

	{

	  g_string_append_printf (xml, "    <property name=\"%s\" ", propname);

	  g_string_append (xml, "type=\"");

	  g_string_append (xml, dbus_type);

	  g_string_append (xml, "\" access=\"");

	  if (can_set && can_get)

	    g_string_append (xml, "readwrite");

	  else if (can_get)

	    g_string_append (xml, "read");

	  else

	    {

	      g_assert (can_set);

	      g_string_append (xml, "write");

	    }

	  g_string_append (xml, "\"/>\n");

	}

      g_free (dbus_type);

      g_string_append (xml, "    </property>\n");

    }

  g_slist_free (values->properties);

  g_free (values);

  g_string_append (xml, "  </interface>\n");

}

static DBusGLibWriteInterfaceValues *

lookup_values (GHashTable *interfaces, const char *method_interface)

{

  DBusGLibWriteInterfaceValues *values;

  if ((values = g_hash_table_lookup (interfaces, (gpointer) method_interface)) == NULL)

    {

      values = g_new0 (DBusGLibWriteInterfaceValues, 1);

      g_hash_table_insert (interfaces, (gpointer) method_interface, values);

    }

  return values;

}

static void

introspect_interfaces (GObject *object, GString *xml)

{

  GList *info_list;

  const GList *info_list_walk;

  const DBusGObjectInfo *info;

  DBusGLibWriteIterfaceData data;

  int i;

  GHashTable *interfaces;

  DBusGLibWriteInterfaceValues *values;

  const char *propsig;

  info_list = lookup_object_info (object);

  g_assert (info_list != NULL);

  /* Gather a list of all interfaces, indexed into their methods */

  for (info_list_walk = info_list; info_list_walk != NULL; info_list_walk = g_list_next (info_list_walk))

    {

      info = (DBusGObjectInfo *) info_list_walk->data;

      interfaces = g_hash_table_new (g_str_hash, g_str_equal);

      g_assert (info != NULL);

      for (i = 0; i < info->n_method_infos; i++)

        {

          #ifdef WINSCW

          const char *method_name;

           const char *method_args;

          #endif

          const char *method_interface;

          const DBusGMethodInfo *method;

          method = &(info->method_infos[i]);

          method_interface = method_interface_from_object_info (info, method);

          #ifdef WINSCW

          method_name = method_name_from_object_info (info, method);

          method_args = method_arg_info_from_object_info (info, method);

          #endif

          values = lookup_values (interfaces, method_interface);

          values->methods = g_slist_prepend (values->methods, (gpointer) method);

        }

      propsig = info->exported_signals;

      while (*propsig)

        {

          const char *iface;

          const char *signame;

          propsig = propsig_iterate (propsig, &iface, &signame);

          values = lookup_values (interfaces, iface);

          values->signals = g_slist_prepend (values->signals, (gpointer) signame);

        }

      propsig = info->exported_properties;

      while (*propsig)

        {

          const char *iface;

          const char *propname;

          propsig = propsig_iterate (propsig, &iface, &propname);

          values = lookup_values (interfaces, iface);

          values->properties = g_slist_prepend (values->properties, (gpointer) propname);

        }

      memset (&data, 0, sizeof (data));

      data.xml = xml;

      data.gtype = G_TYPE_FROM_INSTANCE (object);

      data.object_info = info;

      g_hash_table_foreach (interfaces, write_interface, &data);

      g_hash_table_destroy (interfaces);

    }

  g_list_free (info_list);

}

static DBusHandlerResult

handle_introspect (DBusConnection *connection,

                   DBusMessage    *message,

                   GObject        *object)

{

  GString *xml;

  unsigned int i;

  DBusMessage *ret;

  char **children;

  if (!dbus_connection_list_registered (connection, 

                                        dbus_message_get_path (message),

                                        &children))

    g_error ("Out of memory");

  xml = g_string_new (NULL);

  g_string_append (xml, DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE);

  g_string_append (xml, "<node>\n");

  /* We are introspectable, though I guess that was pretty obvious */

  g_string_append_printf (xml, "  <interface name=\"%s\">\n", DBUS_INTERFACE_INTROSPECTABLE);

  g_string_append (xml, "    <method name=\"Introspect\">\n");

  g_string_append_printf (xml, "      <arg name=\"data\" direction=\"out\" type=\"%s\"/>\n", DBUS_TYPE_STRING_AS_STRING);

  g_string_append (xml, "    </method>\n");

  g_string_append (xml, "  </interface>\n");

  /* We support get/set properties */

  g_string_append_printf (xml, "  <interface name=\"%s\">\n", DBUS_INTERFACE_PROPERTIES);

  g_string_append (xml, "    <method name=\"Get\">\n");

  g_string_append_printf (xml, "      <arg name=\"interface\" direction=\"in\" type=\"%s\"/>\n", DBUS_TYPE_STRING_AS_STRING);

  g_string_append_printf (xml, "      <arg name=\"propname\" direction=\"in\" type=\"%s\"/>\n", DBUS_TYPE_STRING_AS_STRING);

  g_string_append_printf (xml, "      <arg name=\"value\" direction=\"out\" type=\"%s\"/>\n", DBUS_TYPE_VARIANT_AS_STRING);

  g_string_append (xml, "    </method>\n");

  g_string_append (xml, "    <method name=\"Set\">\n");

  g_string_append_printf (xml, "      <arg name=\"interface\" direction=\"in\" type=\"%s\"/>\n", DBUS_TYPE_STRING_AS_STRING);

  g_string_append_printf (xml, "      <arg name=\"propname\" direction=\"in\" type=\"%s\"/>\n", DBUS_TYPE_STRING_AS_STRING);

  g_string_append_printf (xml, "      <arg name=\"value\" direction=\"in\" type=\"%s\"/>\n", DBUS_TYPE_VARIANT_AS_STRING);

  g_string_append (xml, "    </method>\n");

  g_string_append (xml, "  </interface>\n");

  introspect_interfaces (object, xml);

  /* Append child nodes */

  for (i = 0; children[i]; i++)

      g_string_append_printf (xml, "  <node name=\"%s\"/>\n",

                              children[i]);

  /* Close the XML, and send it to the requesting app */

  g_string_append (xml, "</node>\n");

  ret = dbus_message_new_method_return (message);

  if (ret == NULL)

    g_error ("Out of memory");

  dbus_message_append_args (ret,

                            DBUS_TYPE_STRING, &xml->str,

                            DBUS_TYPE_INVALID);

  dbus_connection_send (connection, ret, NULL);

  dbus_message_unref (ret);

  g_string_free (xml, TRUE);

  dbus_free_string_array (children);

  return DBUS_HANDLER_RESULT_HANDLED;

}

static DBusMessage*

set_object_property (DBusConnection  *connection,

                     DBusMessage     *message,

                     DBusMessageIter *iter,

                     GObject         *object,

                     GParamSpec      *pspec)

{

  GValue value = { 0, };

  DBusMessage *ret;

  DBusMessageIter sub;

  DBusGValueMarshalCtx context;

  dbus_message_iter_recurse (iter, &sub);

  context.gconnection = DBUS_G_CONNECTION_FROM_CONNECTION (connection);

  context.proxy = NULL;

  g_value_init (&value, pspec->value_type);

  if (_dbus_gvalue_demarshal (&context, &sub, &value, NULL))

    {

      g_object_set_property (object,

                             pspec->name,

                             &value);

      g_value_unset (&value);

      ret = dbus_message_new_method_return (message);

      if (ret == NULL)

        g_error ("out of memory");

    }

  else

    {

      ret = dbus_message_new_error (message,

                                    DBUS_ERROR_INVALID_ARGS,

                                    "Argument's D-BUS type can't be converted to a GType");

      if (ret == NULL)

        g_error ("out of memory");

    }

  return ret;

}

static DBusMessage*

get_object_property (DBusConnection *connection,

                     DBusMessage    *message,

                     GObject        *object,

                     GParamSpec     *pspec)

{

  GType value_gtype;

  GValue value = {0, };

  gchar *variant_sig;

  DBusMessage *ret;

  DBusMessageIter iter, subiter;

  ret = dbus_message_new_method_return (message);

  if (ret == NULL)

    g_error ("out of memory");

  g_value_init (&value, pspec->value_type);

  g_object_get_property (object, pspec->name, &value);

  variant_sig = _dbus_gvalue_to_signature (&value);

  if (variant_sig == NULL)

    {

      value_gtype = G_VALUE_TYPE (&value);

      g_warning ("Cannot marshal type \"%s\" in variant", g_type_name (value_gtype));

      g_value_unset (&value);

      return ret;

    }

  dbus_message_iter_init_append (ret, &iter);

  if (!dbus_message_iter_open_container (&iter,

					 DBUS_TYPE_VARIANT,

					 variant_sig,

					 &subiter))

    {

      g_free (variant_sig);

      g_value_unset (&value);

      return ret;

    }

  if (!_dbus_gvalue_marshal (&subiter, &value))

    {

      dbus_message_unref (ret);

      ret = dbus_message_new_error (message,

                                    DBUS_ERROR_UNKNOWN_METHOD,

                                    "Can't convert GType of object property to a D-BUS type");

    }

  dbus_message_iter_close_container (&iter, &subiter);

  g_value_unset (&value);

  g_free (variant_sig);

  return ret;

}

static gboolean

lookup_object_and_method (GObject      *object,

			  DBusMessage  *message,

			  const DBusGObjectInfo **object_ret,

			  const DBusGMethodInfo **method_ret)

{

  const char *interface;

  const char *member;

  const char *signature;

  GList *info_list;

  const GList *info_list_walk;

  const DBusGObjectInfo *info;

  int i;

  interface = dbus_message_get_interface (message);

  member = dbus_message_get_member (message);

  signature = dbus_message_get_signature (message);

  info_list = lookup_object_info (object);

  for (info_list_walk = info_list; info_list_walk != NULL; info_list_walk = g_list_next (info_list_walk))

    {

      info = (DBusGObjectInfo *) info_list_walk->data;

      *object_ret = info;

      for (i = 0; i < info->n_method_infos; i++)

        {

          const char *expected_member;

          const char *expected_interface;

          char *expected_signature;

          const DBusGMethodInfo *method;

          method = &(info->method_infos[i]);

          /* Check method interface/name and input signature */ 

          expected_interface = method_interface_from_object_info (*object_ret, method);

          expected_member = method_name_from_object_info (*object_ret, method);

          expected_signature = method_input_signature_from_object_info (*object_ret, method);

          if ((interface == NULL

              || strcmp (expected_interface, interface) == 0)

              && strcmp (expected_member, member) == 0

              && strcmp (expected_signature, signature) == 0)

            {

              g_free (expected_signature);

              *method_ret = method;

              g_list_free (info_list);

              return TRUE;

            }

            g_free (expected_signature);

        }

    }

  if (info_list)

    g_list_free (info_list);

  return FALSE;

}

static char *

gerror_domaincode_to_dbus_error_name (const DBusGObjectInfo *object_info,

				      const char *msg_interface,

				      GQuark domain, gint code)

{

  const char *domain_str;

  const char *code_str;

  GString *dbus_error_name;

  domain_str = object_error_domain_prefix_from_object_info (object_info);

  code_str = object_error_code_from_object_info (object_info, domain, code);

  if (!domain_str || !code_str)

    {

      DBusGErrorInfo *info;

      g_static_rw_lock_reader_lock (&globals_lock);

      if (error_metadata != NULL)

	info = g_datalist_id_get_data (&error_metadata, domain);

      else

	info = NULL;

      g_static_rw_lock_reader_unlock (&globals_lock);

      if (info)

	{

	  GEnumValue *value;

	  GEnumClass *klass;

	  klass = g_type_class_ref (info->code_enum);

	  value = g_enum_get_value (klass, code);

	  g_type_class_unref (klass);

	  domain_str = info->default_iface;

	  code_str = value->value_nick;

	}

    }

  if (!domain_str)

    domain_str = msg_interface;

  if (!domain_str || !code_str)

    {

      /* If we can't map it sensibly, make up an error name */

      char *domain_from_quark;

      dbus_error_name = g_string_new ("org.freedesktop.DBus.GLib.UnmappedError.");

      domain_from_quark = uscore_to_wincaps (g_quark_to_string (domain));

      g_string_append (dbus_error_name, domain_from_quark);

      g_free (domain_from_quark);

      g_string_append_printf (dbus_error_name, ".Code%d", code);

    }

  else

    {

      dbus_error_name = g_string_new (domain_str);

      g_string_append_c (dbus_error_name, '.');

      g_string_append (dbus_error_name, code_str);

    }

  return g_string_free (dbus_error_name, FALSE);

}

static DBusMessage *

gerror_to_dbus_error_message (const DBusGObjectInfo *object_info,

			      DBusMessage     *message,

			      GError          *error)

{

  DBusMessage *reply;

  if (!error)

    {

      char *error_msg;

      error_msg = g_strdup_printf ("Method invoked for %s returned FALSE but did not set error", dbus_message_get_member (message));

      reply = dbus_message_new_error (message, "org.freedesktop.DBus.GLib.ErrorError", error_msg);

      g_free (error_msg);

    }

  else

    {

      if (error->domain == DBUS_GERROR)

	reply = dbus_message_new_error (message,

					dbus_g_error_get_name (error),

					error->message);

      else

	{

	  char *error_name;

	  error_name = gerror_domaincode_to_dbus_error_name (object_info,

							     dbus_message_get_interface (message),

							     error->domain, error->code);

	  reply = dbus_message_new_error (message, error_name, error->message);

	  g_free (error_name); 

	}

    }

  return reply;

}

/**

 * SECTION:dbus-gmethod

 * @short_description: GMethod Info & Invocation

 * @see_also: #DBusGMessage

 * @stability: Stable

 *

 * These types are used to call methods on #GObject objects.

 */

/**

 * The context of an asynchronous method call.  See dbus_g_method_return() and

 * dbus_g_method_return_error().

 */

struct _DBusGMethodInvocation {

  DBusGConnection *connection; /**< The connection */

  DBusGMessage *message; /**< The message which generated the method call */

  const DBusGObjectInfo *object; /**< The object the method was called on */

  const DBusGMethodInfo *method; /**< The method called */

};

static DBusHandlerResult

invoke_object_method (GObject         *object,

		      const DBusGObjectInfo *object_info,

		      const DBusGMethodInfo *method,

		      DBusConnection  *connection,

		      DBusMessage     *message)

{

  gboolean had_error, call_only;

  GError *gerror;

  GValueArray *value_array;

  GValue return_value = {0,};

  GClosure closure;

  char *in_signature;