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

/* dbus-gmain.c GLib main loop integration

 *

 * Copyright (C) 2002, 2003 CodeFactory AB

 * Copyright (C) 2005 Red Hat, Inc.

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

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

#include "dbus-gtest.h"

#include "dbus-gutils.h"

#include "dbus-gvalue.h"

#include "dbus-gobject.h"

#include "dbus-gvalue-utils.h"

#include "dbus-gsignature.h"

#include <string.h>

#ifndef __SYMBIAN32__

#include <libintl.h>

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

#define N_(x) x

#else

#define _(x) x

#define N_(x) x

#endif

#ifdef __SYMBIAN32__

#include "libdbus_glib_wsd_solution.h"

#endif

/**

 * @defgroup DBusGLibInternals GLib bindings implementation details

 * @ingroup  DBusInternals

 * @brief Implementation details of GLib bindings

 *

 * @{

 */

/**

 * DBusGMessageQueue:

 * A GSource subclass for dispatching DBusConnection messages.

 * We need this on top of the IO handlers, because sometimes

 * there are messages to dispatch queued up but no IO pending.

 */

typedef struct

{

  GSource source; /**< the parent GSource */

  DBusConnection *connection; /**< the connection to dispatch */

} DBusGMessageQueue;

static gboolean message_queue_prepare  (GSource     *source,

                                        gint        *timeout);

static gboolean message_queue_check    (GSource     *source);

static gboolean message_queue_dispatch (GSource     *source,

                                        GSourceFunc  callback,

                                        gpointer     user_data);

static const GSourceFuncs message_queue_funcs = {

  message_queue_prepare,

  message_queue_check,

  message_queue_dispatch,

  NULL

};

static gboolean

message_queue_prepare (GSource *source,

                       gint    *timeout)

{

  DBusConnection *connection = ((DBusGMessageQueue *)source)->connection;

  *timeout = -1;

  return (dbus_connection_get_dispatch_status (connection) == DBUS_DISPATCH_DATA_REMAINS);  

}

static gboolean

message_queue_check (GSource *source)

{

  return FALSE;

}

static gboolean

message_queue_dispatch (GSource     *source,

                        GSourceFunc  callback,

                        gpointer     user_data)

{

  DBusConnection *connection = ((DBusGMessageQueue *)source)->connection;

  dbus_connection_ref (connection);

  /* Only dispatch once - we don't want to starve other GSource */

  dbus_connection_dispatch (connection);

  dbus_connection_unref (connection);

  return TRUE;

}

typedef struct

{

  GMainContext *context;      /**< the main context */

  GSList *ios;                /**< all IOHandler */

  GSList *timeouts;           /**< all TimeoutHandler */

  DBusConnection *connection; /**< NULL if this is really for a server not a connection */

  GSource *message_queue_source; /**< DBusGMessageQueue */

} ConnectionSetup;

typedef struct

{

  ConnectionSetup *cs;

  GSource *source;

  DBusWatch *watch;

} IOHandler;

typedef struct

{

  ConnectionSetup *cs;

  GSource *source;

  DBusTimeout *timeout;

} TimeoutHandler;

#if EMULATOR

GET_GLOBAL_VAR_FROM_TLS(_dbus_gmain_connection_slot,dbus_gmain,dbus_int32_t)

#define _dbus_gmain_connection_slot (*GET_DBUS_WSD_VAR_NAME(_dbus_gmain_connection_slot,dbus_gmain,g)())

GET_STATIC_VAR_FROM_TLS(server_slot,dbus_gmain,dbus_int32_t)

#define server_slot (*GET_DBUS_WSD_VAR_NAME(server_slot,dbus_gmain,s)())

#else

dbus_int32_t _dbus_gmain_connection_slot = -1;

static dbus_int32_t server_slot = -1;

#endif

static ConnectionSetup*

connection_setup_new (GMainContext   *context,

                      DBusConnection *connection)

{

  ConnectionSetup *cs;

  cs = g_new0 (ConnectionSetup, 1);

  g_assert (context != NULL);

  cs->context = context;

  g_main_context_ref (cs->context);  

  if (connection)

    {

      cs->connection = connection;

      cs->message_queue_source = g_source_new ((GSourceFuncs *) &message_queue_funcs,

                                               sizeof (DBusGMessageQueue));

      ((DBusGMessageQueue*)cs->message_queue_source)->connection = connection;

      g_source_attach (cs->message_queue_source, cs->context);

    }

  return cs;

}

static void

io_handler_source_finalized (gpointer data)

{

  IOHandler *handler;

  handler = data;

  if (handler->watch)

    dbus_watch_set_data (handler->watch, NULL, NULL);

  g_free (handler);

}

static void

io_handler_destroy_source (void *data)

{

  IOHandler *handler;

  handler = data;

  if (handler->source)

    {

      GSource *source = handler->source;

      handler->source = NULL;

      handler->cs->ios = g_slist_remove (handler->cs->ios, handler);

      g_source_destroy (source);

      g_source_unref (source);

    }

}

static void

io_handler_watch_freed (void *data)

{

  IOHandler *handler;

  handler = data;

  handler->watch = NULL;

  io_handler_destroy_source (handler);

}

static gboolean

io_handler_dispatch (GIOChannel   *source,

                     GIOCondition  condition,

                     gpointer      data)

{

  IOHandler *handler;

  guint dbus_condition = 0;

  DBusConnection *connection;

  handler = data;

  connection = handler->cs->connection;

  if (connection)

    dbus_connection_ref (connection);

  if (condition & G_IO_IN)

    dbus_condition |= DBUS_WATCH_READABLE;

  if (condition & G_IO_OUT)

    dbus_condition |= DBUS_WATCH_WRITABLE;

  if (condition & G_IO_ERR)

    dbus_condition |= DBUS_WATCH_ERROR;

  if (condition & G_IO_HUP)

    dbus_condition |= DBUS_WATCH_HANGUP;

  /* Note that we don't touch the handler after this, because

   * dbus may have disabled the watch and thus killed the

   * handler.

   */

  dbus_watch_handle (handler->watch, dbus_condition);

  handler = NULL;

  if (connection)

    dbus_connection_unref (connection);

  return TRUE;

}

static void

connection_setup_add_watch (ConnectionSetup *cs,

                            DBusWatch       *watch)

{

  guint flags;

  GIOCondition condition;

  GIOChannel *channel;

  IOHandler *handler;

  if (!dbus_watch_get_enabled (watch))

    return;

  g_assert (dbus_watch_get_data (watch) == NULL);

  flags = dbus_watch_get_flags (watch);

  condition = G_IO_ERR | G_IO_HUP;

  if (flags & DBUS_WATCH_READABLE)

    condition |= G_IO_IN;

  if (flags & DBUS_WATCH_WRITABLE)

    condition |= G_IO_OUT;

  handler = g_new0 (IOHandler, 1);

  handler->cs = cs;

  handler->watch = watch;

  channel = g_io_channel_unix_new (dbus_watch_get_fd (watch));

  handler->source = g_io_create_watch (channel, condition);

  g_source_set_callback (handler->source, (GSourceFunc) io_handler_dispatch, handler,

                         io_handler_source_finalized);

  g_source_attach (handler->source, cs->context);

  cs->ios = g_slist_prepend (cs->ios, handler);

  dbus_watch_set_data (watch, handler, io_handler_watch_freed);

  g_io_channel_unref (channel);

}

static void

connection_setup_remove_watch (ConnectionSetup *cs,

                               DBusWatch       *watch)

{

  IOHandler *handler;

  handler = dbus_watch_get_data (watch);

  if (handler == NULL)

    return;

  io_handler_destroy_source (handler);

}

static void

timeout_handler_source_finalized (gpointer data)

{

  TimeoutHandler *handler;

  handler = data;

  if (handler->timeout)

    dbus_timeout_set_data (handler->timeout, NULL, NULL);

  g_free (handler);

}

static void

timeout_handler_destroy_source (void *data)

{

  TimeoutHandler *handler;

  handler = data;

  if (handler->source)

    {

      GSource *source = handler->source;

      handler->source = NULL;

      handler->cs->timeouts = g_slist_remove (handler->cs->timeouts, handler);

      g_source_destroy (source);

      g_source_unref (source);

    }

}

static void

timeout_handler_timeout_freed (void *data)

{

  TimeoutHandler *handler;

  handler = data;

  handler->timeout = NULL;

  timeout_handler_destroy_source (handler);

}

static gboolean

timeout_handler_dispatch (gpointer      data)

{

  TimeoutHandler *handler;

  handler = data;

  dbus_timeout_handle (handler->timeout);

  return TRUE;

}

static void

connection_setup_add_timeout (ConnectionSetup *cs,

                              DBusTimeout     *timeout)

{

  TimeoutHandler *handler;

  if (!dbus_timeout_get_enabled (timeout))

    return;

  g_assert (dbus_timeout_get_data (timeout) == NULL);

  handler = g_new0 (TimeoutHandler, 1);

  handler->cs = cs;

  handler->timeout = timeout;

  handler->source = g_timeout_source_new (dbus_timeout_get_interval (timeout));

  g_source_set_callback (handler->source, timeout_handler_dispatch, handler,

                         timeout_handler_source_finalized);

  g_source_attach (handler->source, handler->cs->context);

  cs->timeouts = g_slist_prepend (cs->timeouts, handler);

  dbus_timeout_set_data (timeout, handler, timeout_handler_timeout_freed);

}

static void

connection_setup_remove_timeout (ConnectionSetup *cs,

                                 DBusTimeout       *timeout)

{

  TimeoutHandler *handler;

  handler = dbus_timeout_get_data (timeout);

  if (handler == NULL)

    return;

  timeout_handler_destroy_source (handler);

}

static void

connection_setup_free (ConnectionSetup *cs)

{

  while (cs->ios)

    io_handler_destroy_source (cs->ios->data);

  while (cs->timeouts)

    timeout_handler_destroy_source (cs->timeouts->data);

  if (cs->message_queue_source)

    {

      GSource *source;

      source = cs->message_queue_source;

      cs->message_queue_source = NULL;

      g_source_destroy (source);

      g_source_unref (source);

    }

  g_main_context_unref (cs->context);

  g_free (cs);

}

static dbus_bool_t

add_watch (DBusWatch *watch,

	   gpointer   data)

{

  ConnectionSetup *cs;

  cs = data;

  connection_setup_add_watch (cs, watch);

  return TRUE;

}

static void

remove_watch (DBusWatch *watch,

	      gpointer   data)

{

  ConnectionSetup *cs;

  cs = data;

  connection_setup_remove_watch (cs, watch);

}

static void

watch_toggled (DBusWatch *watch,

               void      *data)

{

  /* Because we just exit on OOM, enable/disable is

   * no different from add/remove

   */

  if (dbus_watch_get_enabled (watch))

    add_watch (watch, data);

  else

    remove_watch (watch, data);

}

static dbus_bool_t

add_timeout (DBusTimeout *timeout,

	     void        *data)

{

  ConnectionSetup *cs;

  cs = data;

  if (!dbus_timeout_get_enabled (timeout))

    return TRUE;

  connection_setup_add_timeout (cs, timeout);

  return TRUE;

}

static void

remove_timeout (DBusTimeout *timeout,

		void        *data)

{

  ConnectionSetup *cs;

  cs = data;

  connection_setup_remove_timeout (cs, timeout);

}

static void

timeout_toggled (DBusTimeout *timeout,

                 void        *data)

{

  /* Because we just exit on OOM, enable/disable is

   * no different from add/remove

   */

  if (dbus_timeout_get_enabled (timeout))

    add_timeout (timeout, data);

  else

    remove_timeout (timeout, data);

}

static void

wakeup_main (void *data)

{

  ConnectionSetup *cs = data;

  g_main_context_wakeup (cs->context);

}

/* Move to a new context */

static ConnectionSetup*

connection_setup_new_from_old (GMainContext    *context,

                               ConnectionSetup *old)

{

  GSList *tmp;

  ConnectionSetup *cs;

  g_assert (old->context != context);

  cs = connection_setup_new (context, old->connection);

  tmp = old->ios;

  while (tmp != NULL)

    {

      IOHandler *handler = tmp->data;

      connection_setup_add_watch (cs, handler->watch);

      tmp = tmp->next;

    }

  tmp = old->timeouts;

  while (tmp != NULL)

    {

      TimeoutHandler *handler = tmp->data;

      connection_setup_add_timeout (cs, handler->timeout);

      tmp = tmp->next;

    }

  return cs;

}

/** @} */ /* End of GLib bindings internals */

/** @addtogroup DBusGLib

 * @{

 */

/**

 * dbus_connection_setup_with_g_main:

 * @connection: the connection

 * @context: the #GMainContext or #NULL for default context

 *

 * Sets the watch and timeout functions of a #DBusConnection

 * to integrate the connection with the GLib main loop.

 * Pass in #NULL for the #GMainContext unless you're

 * doing something specialized.

 *

 * If called twice for the same context, does nothing the second

 * time. If called once with context A and once with context B,

 * context B replaces context A as the context monitoring the

 * connection.

 */

 #ifdef __SYMBIAN32__

EXPORT_C

#endif

void

dbus_connection_setup_with_g_main (DBusConnection *connection,

				   GMainContext   *context)

{

  ConnectionSetup *old_setup;

  ConnectionSetup *cs;

  /* FIXME we never free the slot, so its refcount just keeps growing,

   * which is kind of broken.

   */

  dbus_connection_allocate_data_slot (&_dbus_gmain_connection_slot);

  if (_dbus_gmain_connection_slot < 0)

    goto nomem;

  if (context == NULL)

    context = g_main_context_default ();

  cs = NULL;

  old_setup = dbus_connection_get_data (connection, _dbus_gmain_connection_slot);

  if (old_setup != NULL)

    {

      if (old_setup->context == context)

        return; /* nothing to do */

      cs = connection_setup_new_from_old (context, old_setup);

      /* Nuke the old setup */

      dbus_connection_set_data (connection, _dbus_gmain_connection_slot, NULL, NULL);

      old_setup = NULL;

    }

  if (cs == NULL)

    cs = connection_setup_new (context, connection);

  if (!dbus_connection_set_data (connection, _dbus_gmain_connection_slot, cs,

                                 (DBusFreeFunction)connection_setup_free))

    goto nomem;

  if (!dbus_connection_set_watch_functions (connection,

                                            add_watch,

                                            remove_watch,

                                            watch_toggled,

                                            cs, NULL))

    goto nomem;

  if (!dbus_connection_set_timeout_functions (connection,

                                              add_timeout,

                                              remove_timeout,

                                              timeout_toggled,

                                              cs, NULL))

    goto nomem;

  dbus_connection_set_wakeup_main_function (connection,

					    wakeup_main,

					    cs, NULL);

  return;

 nomem:

  g_error ("Not enough memory to set up DBusConnection for use with GLib");

}

/**

 * dbus_server_setup_with_g_main:

 * @server: the server

 * @context: the #GMainContext or #NULL for default

 *

 * Sets the watch and timeout functions of a #DBusServer

 * to integrate the server with the GLib main loop.

 * In most cases the context argument should be #NULL.

 *

 * If called twice for the same context, does nothing the second

 * time. If called once with context A and once with context B,

 * context B replaces context A as the context monitoring the

 * connection.

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

void

dbus_server_setup_with_g_main (DBusServer   *server,

                               GMainContext *context)

{

  ConnectionSetup *old_setup;

  ConnectionSetup *cs;

  /* FIXME we never free the slot, so its refcount just keeps growing,

   * which is kind of broken.

   */

  dbus_server_allocate_data_slot (&server_slot);

  if (server_slot < 0)

    goto nomem;

  if (context == NULL)

    context = g_main_context_default ();

  cs = NULL;

  old_setup = dbus_server_get_data (server, server_slot);

  if (old_setup != NULL)

    {

      if (old_setup->context == context)

        return; /* nothing to do */

      cs = connection_setup_new_from_old (context, old_setup);

      /* Nuke the old setup */

      dbus_server_set_data (server, server_slot, NULL, NULL);

      old_setup = NULL;

    }

  if (cs == NULL)

    cs = connection_setup_new (context, NULL);

  if (!dbus_server_set_data (server, server_slot, cs,

                             (DBusFreeFunction)connection_setup_free))

    goto nomem;

  if (!dbus_server_set_watch_functions (server,

                                        add_watch,

                                        remove_watch,

                                        watch_toggled,

                                        cs, NULL))

    goto nomem;

  if (!dbus_server_set_timeout_functions (server,

                                          add_timeout,

                                          remove_timeout,

                                          timeout_toggled,

                                          cs, NULL))

    goto nomem;

  return;

 nomem:

  g_error ("Not enough memory to set up DBusServer for use with GLib");

}

/**

 * dbus_g_connection_open:

 * @address: address of the connection to open

 * @error: address where an error can be returned.

 *

 * Returns a connection to the given address.

 *

 * (Internally, calls dbus_connection_open() then calls

 * dbus_connection_setup_with_g_main() on the result.)

 *

 * Returns: a DBusConnection

 */

 	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

DBusGConnection*

dbus_g_connection_open (const gchar  *address,

                        GError      **error)

{

  DBusConnection *connection;

  DBusError derror;

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  _dbus_g_value_types_init ();

  dbus_error_init (&derror);

  connection = dbus_connection_open (address, &derror);

  if (connection == NULL)

    {

      dbus_set_g_error (error, &derror);

      dbus_error_free (&derror);

      return NULL;

    }

  /* does nothing if it's already been done */

  dbus_connection_setup_with_g_main (connection, NULL);

  return DBUS_G_CONNECTION_FROM_CONNECTION (connection);

}

/**

 * dbus_g_bus_get:

 * @type: bus type

 * @error: address where an error can be returned.

 *

 * Returns a connection to the given bus. The connection is a global variable

 * shared with other callers of this function.

 * 

 * (Internally, calls dbus_bus_get() then calls

 * dbus_connection_setup_with_g_main() on the result.)

 *

 * Returns: a DBusConnection

 */

 #ifdef __SYMBIAN32__

EXPORT_C

#endif

DBusGConnection*

dbus_g_bus_get (DBusBusType     type,

                GError        **error)

{

  DBusConnection *connection;

  DBusError derror;

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  _dbus_g_value_types_init ();

  dbus_error_init (&derror);

  connection = dbus_bus_get (type, &derror);

  if (connection == NULL)

    {

      dbus_set_g_error (error, &derror);

      dbus_error_free (&derror);

      return NULL;

    }

  /* does nothing if it's already been done */

  dbus_connection_setup_with_g_main (connection, NULL);

  return DBUS_G_CONNECTION_FROM_CONNECTION (connection);

}

/** @} */ /* end of public API */

#ifdef DBUS_BUILD_TESTS

/**

 * @ingroup DBusGLibInternals

 * Unit test for GLib main loop integration

 * Returns: #TRUE on success.

 */

  	#ifdef __SYMBIAN32__

	EXPORT_C

	#endif

gboolean

_dbus_gmain_test (const char *test_data_dir)

{

  GType type;

  GType rectype;

  g_type_init ();

  _dbus_g_value_types_init ();

  rectype = dbus_g_type_get_collection ("GArray", G_TYPE_UINT);

  g_assert (rectype != G_TYPE_INVALID);

  g_assert (!strcmp (g_type_name (rectype), "GArray_guint_"));

  type = _dbus_gtype_from_signature ("au", TRUE);

  g_assert (type == rectype);

  rectype = dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING);

  g_assert (rectype != G_TYPE_INVALID);

  g_assert (!strcmp (g_type_name (rectype), "GHashTable_gchararray+gchararray_"));

  type = _dbus_gtype_from_signature ("a{ss}", TRUE);

  g_assert (type == rectype);

  type = _dbus_gtype_from_signature ("o", FALSE);

  g_assert (type == DBUS_TYPE_G_OBJECT_PATH);

  type = _dbus_gtype_from_signature ("o", TRUE);

  g_assert (type == DBUS_TYPE_G_OBJECT_PATH);

  return TRUE;

}

#endif /* DBUS_BUILD_TESTS */