/*
 * AT-SPI - Assistive Technology Service Provider Interface
 * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
 *
 * Copyright 2008, 2009 Codethink Ltd.
 * Copyright 2001, 2002, 2003 Sun Microsystems Inc.,
 * Copyright 2001, 2002, 2003 Ximian, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#define _GNU_SOURCE
#include "config.h"

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include<sys/stat.h>
#include <atk/atk.h>

#include <droute/droute.h>
#include <atspi/atspi.h>
#include <atk-bridge.h>

#include "bridge.h"
#include "event.h"
#include "adaptors.h"
#include "object.h"
#include "accessible-stateset.h"

#include "accessible-register.h"
#include "accessible-leasing.h"
#include "accessible-cache.h"

#include "spi-dbus.h"

/*---------------------------------------------------------------------------*/

static DBusHandlerResult
signal_filter (DBusConnection *bus, DBusMessage *message, void *user_data);

SpiBridge *spi_global_app_data = NULL;

static gboolean inited = FALSE;
static gboolean atexit_added = FALSE;

/*---------------------------------------------------------------------------*/

static event_data *
add_event (const char *bus_name, const char *event)
{
  event_data *evdata;
  gchar **data;

  spi_atk_add_client (bus_name);
  evdata = g_new0 (event_data, 1);
  data = g_strsplit (event, ":", 3);
  if (!data)
    {
      g_free (evdata);
      return NULL;
    }
  evdata->bus_name = g_strdup (bus_name);
  evdata->data = data;
  spi_global_app_data->events = g_list_append (spi_global_app_data->events, evdata);
  return evdata;
}

static GSList *clients = NULL;

static void
tally_event_reply ()
{
  static int replies_received = 0;

  if (!spi_global_app_data)
    return;

  replies_received++;
  if (replies_received == 3)
  {
    if (!clients)
      spi_atk_deregister_event_listeners ();
    spi_global_app_data->events_initialized = TRUE;
  }
}

GType
_atk_bridge_type_from_iface (const char *iface)
{
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_ACCESSIBLE))
    return ATK_TYPE_OBJECT;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_ACTION))
    return ATK_TYPE_ACTION;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_COMPONENT))
    return ATK_TYPE_COMPONENT;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_DOCUMENT))
    return ATK_TYPE_DOCUMENT;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_HYPERTEXT))
    return ATK_TYPE_HYPERTEXT;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_HYPERLINK))
    return ATK_TYPE_HYPERLINK;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_IMAGE))
    return ATK_TYPE_IMAGE;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_SELECTION))
    return ATK_TYPE_SELECTION;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_TABLE))
    return ATK_TYPE_TABLE;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_TEXT))
    return ATK_TYPE_TEXT;
  if (!strcmp (iface, ATSPI_DBUS_INTERFACE_VALUE))
    return ATK_TYPE_VALUE;
  return 0;
}

DRoutePropertyFunction
_atk_bridge_find_property_func (const char *property, GType *type)
{
  const char *iface;
  const char *member;
  DRouteProperty *dp;

  if (!strncasecmp (property, "action.", 7))
  {
    iface = ATSPI_DBUS_INTERFACE_ACTION;
    member = property + 7;
  }
  else if (!strncasecmp (property, "component.", 10))
  {
    iface = ATSPI_DBUS_INTERFACE_COMPONENT;
    member = property + 10;
  }
  else if (!strncasecmp (property, "selection.", 10))
  {
    iface = ATSPI_DBUS_INTERFACE_SELECTION;
    member = property + 10;
  }
  else if (!strncasecmp (property, "table.", 6))
  {
    iface = ATSPI_DBUS_INTERFACE_TABLE;
    member = property + 6;
  }
  else if (!strncasecmp (property, "text.", 5))
  {
    iface = ATSPI_DBUS_INTERFACE_TEXT;
    member = property + 5;
  }
  else if (!strncasecmp (property, "value.", 6))
  {
    iface = ATSPI_DBUS_INTERFACE_VALUE;
    member = property + 6;
  }
  else
  {
    iface = ATSPI_DBUS_INTERFACE_ACCESSIBLE;
    member = property;
  }

  *type = _atk_bridge_type_from_iface (iface);

  dp = g_hash_table_lookup (spi_global_app_data->property_hash, iface);

  if (!dp)
    return NULL;

  for (;dp->name; dp++)
  {
    if (!strcasecmp (dp->name, member))
    {
      return dp->get;
    }
  }
  return NULL;
}

static void
add_property_to_event (event_data *evdata, const char *property)
{
  AtspiPropertyDefinition *prop = g_new0 (AtspiPropertyDefinition, 1);
  prop->func = _atk_bridge_find_property_func (property, &prop->type);
  if (!prop->func)
  {
    g_warning ("atk-bridge: Request for unknown property '%s'", property);
    g_free (prop);
    return;
  }

  prop->name = g_strdup (property);
  evdata->properties = g_slist_append (evdata->properties, prop);
}

static void
add_event_from_iter (DBusMessageIter *iter)
{
  const char *bus_name, *event;
  event_data *evdata;

  dbus_message_iter_get_basic (iter, &bus_name);
  dbus_message_iter_next (iter);
  dbus_message_iter_get_basic (iter, &event);
  dbus_message_iter_next (iter);
  evdata = add_event (bus_name, event);
  if (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_ARRAY)
  {
    DBusMessageIter iter_sub_array;
    dbus_message_iter_recurse (iter, &iter_sub_array);
    while (dbus_message_iter_get_arg_type (&iter_sub_array) != DBUS_TYPE_INVALID)
    {
      const char *property;
      dbus_message_iter_get_basic (&iter_sub_array, &property);
      add_property_to_event (evdata, property);
       dbus_message_iter_next (&iter_sub_array);
    }
  }
}

static void
get_events_reply (DBusPendingCall *pending, void *user_data)
{
  DBusMessage *reply = dbus_pending_call_steal_reply (pending);
  DBusMessageIter iter, iter_array, iter_struct;

  if (!reply || !spi_global_app_data)
    goto done;

  if (strcmp (dbus_message_get_signature (reply), "a(ss)") != 0 &&
      strcmp (dbus_message_get_signature (reply), "a(ssas)") != 0)
    {
      g_warning ("atk-bridge: GetRegisteredEvents returned message with unknown signature");
      goto done;
    }

  dbus_message_iter_init (reply, &iter);
  dbus_message_iter_recurse (&iter, &iter_array);
  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
    {
      dbus_message_iter_recurse (&iter_array, &iter_struct);
      add_event_from_iter (&iter_struct);
      dbus_message_iter_next (&iter_array);
    }

done:
  if (reply)
    dbus_message_unref (reply);
  if (pending)
    dbus_pending_call_unref (pending);

  tally_event_reply ();
}

static void
get_device_events_reply (DBusPendingCall *pending, void *user_data)
{
  DBusMessage *reply = dbus_pending_call_steal_reply (pending);
  DBusMessageIter iter, iter_array, iter_struct;

  if (!reply)
    goto done;

  if (strncmp (dbus_message_get_signature (reply), "a(s", 3) != 0)
    {
      g_warning ("atk-bridge: get_device_events_reply: unknown signature");
      goto done;
    }

  dbus_message_iter_init (reply, &iter);
  dbus_message_iter_recurse (&iter, &iter_array);
  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
    {
      char *bus_name;
      dbus_message_iter_recurse (&iter_array, &iter_struct);
      dbus_message_iter_get_basic (&iter_struct, &bus_name);
      spi_atk_add_client (bus_name);
      dbus_message_iter_next (&iter_array);
    }

done:
  if (reply)
    dbus_message_unref (reply);
  if (pending)
    dbus_pending_call_unref (pending);

  tally_event_reply ();
}

static void
get_registered_event_listeners (SpiBridge *app)
{
  DBusMessage *message;
  DBusPendingCall *pending = NULL;

  message = dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
                                         ATSPI_DBUS_PATH_REGISTRY,
                                         ATSPI_DBUS_INTERFACE_REGISTRY,
                                         "GetRegisteredEvents");
  if (!message)
    return;

  dbus_connection_send_with_reply (app->bus, message, &pending, -1);
  dbus_message_unref (message);
  if (!pending)
    {
      spi_global_app_data->events_initialized = TRUE;
      return;
    }
  dbus_pending_call_set_notify (pending, get_events_reply, NULL, NULL);

  message = dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
                                         ATSPI_DBUS_PATH_DEC,
                                         ATSPI_DBUS_INTERFACE_DEC,
                                         "GetKeystrokeListeners");
  if (!message)
    return;
  pending = NULL;
  dbus_connection_send_with_reply (app->bus, message, &pending, -1);
  dbus_message_unref (message);
  if (!pending)
    {
      spi_global_app_data->events_initialized = TRUE;
      return;
    }
  dbus_pending_call_set_notify (pending, get_device_events_reply, NULL, NULL);

  message = dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
                                         ATSPI_DBUS_PATH_DEC,
                                         ATSPI_DBUS_INTERFACE_DEC,
                                         "GetDeviceEventListeners");
  if (!message)
    return;
  pending = NULL;
  dbus_connection_send_with_reply (app->bus, message, &pending, -1);
  dbus_message_unref (message);
  if (!pending)
    {
      spi_global_app_data->events_initialized = TRUE;
      return;
    }
  dbus_pending_call_set_notify (pending, get_device_events_reply, NULL, NULL);
}

static void
register_reply (DBusPendingCall *pending, void *user_data)
{
  DBusMessage *reply;
  SpiBridge *app = user_data;

  reply = dbus_pending_call_steal_reply (pending);
  dbus_pending_call_unref (pending);

  if (!spi_global_app_data)
    {
      if (reply)
         dbus_message_unref (reply);
      return;
    }

  if (reply)
    {
      gchar *app_name, *obj_path;

      if (strcmp (dbus_message_get_signature (reply), "(so)") != 0)
        {
          g_warning ("AT-SPI: Could not obtain desktop path or name\n");
        }
      else
        {
          DBusMessageIter iter, iter_struct;
          dbus_message_iter_init (reply, &iter);
          dbus_message_iter_recurse (&iter, &iter_struct);
          dbus_message_iter_get_basic (&iter_struct, &app_name);
          dbus_message_iter_next (&iter_struct);
          dbus_message_iter_get_basic (&iter_struct, &obj_path);

          g_free (app->desktop_name);
          app->desktop_name = g_strdup (app_name);
          g_free (app->desktop_path);
          app->desktop_path = g_strdup (obj_path);
        }
    }
  else
    {
      g_warning ("AT-SPI: Could not embed inside desktop");
      return;
    }
  dbus_message_unref (reply);

  if (!spi_global_app_data->events_initialized)
    get_registered_event_listeners (spi_global_app_data);
}

static gboolean
register_application (SpiBridge * app)
{
  DBusMessage *message;
  DBusMessageIter iter;
  DBusPendingCall *pending;

  g_free (app->desktop_name);
  g_free (app->desktop_path);

  /* These will be overridden when we get a reply, but in practice these
     defaults should always be correct */
  app->desktop_name = g_strdup (ATSPI_DBUS_NAME_REGISTRY);
  app->desktop_path = g_strdup (ATSPI_DBUS_PATH_ROOT);

  message = dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
                                          ATSPI_DBUS_PATH_ROOT,
                                          ATSPI_DBUS_INTERFACE_SOCKET,
                                          "Embed");

  dbus_message_iter_init_append (message, &iter);
  spi_object_append_reference (&iter, app->root);
  
    if (!dbus_connection_send_with_reply (app->bus, message, &pending, -1)
        || !pending)
    {
        if (pending)
          dbus_pending_call_unref (pending);

        dbus_message_unref (message);
        return FALSE;
    }

    dbus_pending_call_set_notify (pending, register_reply, app, NULL);

  if (message)
    dbus_message_unref (message);

  return TRUE;
}

/*---------------------------------------------------------------------------*/

static void
remove_socket ()
{
  if (!spi_global_app_data)
    return;

  if (spi_global_app_data->app_bus_addr &&
      !strncmp (spi_global_app_data->app_bus_addr, "unix:path=", 10))
  {
    unlink (spi_global_app_data->app_bus_addr + 10);
    g_free (spi_global_app_data->app_bus_addr);
    spi_global_app_data->app_bus_addr = NULL;
  }

  if (spi_global_app_data->app_tmp_dir)
  {
    rmdir (spi_global_app_data->app_tmp_dir);
    g_free (spi_global_app_data->app_tmp_dir);
    spi_global_app_data->app_tmp_dir = NULL;
  }
}

static void
deregister_application (SpiBridge * app)
{
  DBusMessage *message;
  DBusMessageIter iter;
  const char *uname;

  message = dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
                                          ATSPI_DBUS_PATH_REGISTRY,
                                          ATSPI_DBUS_INTERFACE_REGISTRY,
                                          "DeregisterApplication");
  dbus_message_set_no_reply (message, TRUE);

  uname = dbus_bus_get_unique_name (app->bus);

  dbus_message_iter_init_append (message, &iter);
  dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &uname);
  dbus_connection_send (app->bus, message, NULL);
  if (message)
    dbus_message_unref (message);

  remove_socket ();

  g_free (app->desktop_name);
  app->desktop_name = NULL;
  g_free (app->desktop_path);
  app->desktop_path = NULL;
}

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

static AtkPlugClass *plug_class;
static AtkSocketClass *socket_class;

static gchar *
get_plug_id (AtkPlug * plug)
{
  const char *uname = dbus_bus_get_unique_name (spi_global_app_data->bus);
  gchar *path;
  GString *str = g_string_new (NULL);

  path = spi_register_object_to_path (spi_global_register, G_OBJECT (plug));
  g_string_printf (str, "%s:%s", uname, path);
  g_free (path);
  return g_string_free (str, FALSE);
}

AtkStateSet *
socket_ref_state_set (AtkObject *accessible)
{
  char *child_name, *child_path;
  AtkSocket *socket = ATK_SOCKET (accessible);
  int count = 0;
  int j;
  int v;
  DBusMessage *message, *reply;
  DBusMessageIter iter, iter_array;
  AtkStateSet *set;

  set = atk_state_set_new ();

  if (!socket->embedded_plug_id)
    return set;

  child_name = g_strdup (socket->embedded_plug_id);
  if (!child_name)
    return set;
  child_path = g_utf8_strchr (child_name + 1, -1, ':');
  if (!child_path)
    {
      g_free (child_name);
      return set;
    }
  *(child_path++) = '\0';
  message = dbus_message_new_method_call (child_name, child_path, ATSPI_DBUS_INTERFACE_ACCESSIBLE, "GetState");
  g_free (child_name);
  reply = dbus_connection_send_with_reply_and_block (spi_global_app_data->bus, message, 1, NULL);
  dbus_message_unref (message);
  if (reply == NULL)
    return set;
  if (strcmp (dbus_message_get_signature (reply), "au") != 0)
    {
      dbus_message_unref (reply);
      return set;
    }

  dbus_message_iter_init (reply, &iter);
  dbus_message_iter_recurse (&iter, &iter_array);
  do
    {
      dbus_message_iter_get_basic (&iter_array, &v);
      for (j = 0; j < 32; j++)
        {
          if (v & (1 << j))
            {
              AtkState state = spi_atk_state_from_spi_state ((count << 5) + j);
              atk_state_set_add_state (set, state);
            }
        }
      count++;
    }
  while (dbus_message_iter_next (&iter_array));
  dbus_message_unref (reply);
  return set;
}

static void
socket_embed_hook (AtkSocket * socket, gchar * plug_id)
{
  g_return_if_fail (spi_global_register != NULL);

  AtkObject *accessible = ATK_OBJECT(socket);
  gchar *plug_name, *plug_path;
  AtkObjectClass *klass;

  /* Force registration */
  gchar *path = spi_register_object_to_path (spi_global_register, G_OBJECT (accessible));
  /* Let the plug know that it has been embedded */
  plug_name = g_strdup (plug_id);
  if (!plug_name)
    {
      g_free (path);
      return;
    }
  plug_path = g_utf8_strchr (plug_name + 1, -1, ':');
  if (plug_path)
    {
      DBusMessage *message;
      *(plug_path++) = '\0';
      message = dbus_message_new_method_call (plug_name, plug_path, ATSPI_DBUS_INTERFACE_SOCKET, "Embedded");
      dbus_message_append_args (message, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID);
      dbus_connection_send (spi_global_app_data->bus, message, NULL);
    }
  g_free (plug_name);
  g_free (path);

  klass = ATK_OBJECT_GET_CLASS (accessible);
  klass->ref_state_set = socket_ref_state_set;
}

static void
install_plug_hooks ()
{
  gpointer data;

  data = g_type_class_ref (ATK_TYPE_PLUG);
  plug_class = ATK_PLUG_CLASS (data);
  data = g_type_class_ref (ATK_TYPE_SOCKET);
  socket_class = ATK_SOCKET_CLASS (data);
  plug_class->get_object_id = get_plug_id;
  socket_class->embed = socket_embed_hook;
}

static guint
get_ancestral_uid (guint pid)
{
  FILE *fp;
  char buf [80];
  int ppid = 0;
  int uid = 0;
  gboolean got_ppid = 0;
  gboolean got_uid = 0;

  sprintf (buf, "/proc/%d/status", pid);
  fp = fopen (buf, "r");
  if (!fp)
    return 0;
  while ((!got_ppid || !got_uid) && fgets (buf, sizeof (buf), fp))
  {
    if (sscanf (buf, "PPid:\t%d", &ppid) == 1)
      got_ppid = TRUE;
    else if (sscanf (buf, "Uid:\t%d", &uid) == 1)
      got_uid = TRUE;
  }
  fclose (fp);

  if (!got_ppid || !got_uid)
    return 0;
  if (uid != 0)
    return uid;
  if (ppid == 0 || ppid == 1)
    return 0;
  return get_ancestral_uid (ppid);
}

static dbus_bool_t
user_check (DBusConnection *bus, unsigned long uid, void *data)
{
  if (uid == getuid () || uid == geteuid ())
    return TRUE;
  if (getuid () == 0)
  {
    guint ancestor = get_ancestral_uid (getpid ());
    return (ancestor == uid || ancestor == 1 || ancestor == 0);
  }
  return FALSE;
}

static void
new_connection_cb (DBusServer *server, DBusConnection *con, void *data)
{
  dbus_connection_set_unix_user_function (con, user_check, NULL, NULL);
  dbus_connection_ref(con);
  atspi_dbus_connection_setup_with_g_main(con, NULL);
  droute_intercept_dbus (con);
  droute_context_register (spi_global_app_data->droute, con);

  spi_global_app_data->direct_connections = g_list_append (spi_global_app_data->direct_connections, con);
}


gchar *atspi_dbus_name = NULL;
static gboolean atspi_no_register = FALSE;

static GOptionEntry atspi_option_entries[] = {
  {"atspi-dbus-name", 0, 0, G_OPTION_ARG_STRING, &atspi_dbus_name,
   "D-Bus bus name to register as", NULL},
  {"atspi-no-register", 0, 0, G_OPTION_ARG_NONE, &atspi_no_register,
   "Do not register with Registry Daemon", NULL},
  {NULL}
};

static gchar *
introspect_children_cb (const char *path, void *data)
{
  if (!strcmp (path, "/org/a11y/atspi/accessible"))
    {
      return g_strdup ("<node name=\"root\"/>\n");
      /* TODO: Should we place the whole hierarchy here? */
    }
  return NULL;
}

static void
handle_event_listener_registered (DBusConnection *bus, DBusMessage *message,
                                  void *user_data)
{
  DBusMessageIter iter;
  const char *signature = dbus_message_get_signature (message);

  if (strcmp (signature, "ssas") != 0 &&
      strcmp (signature, "ss") != 0)
  {
    g_warning ("got RegisterEvent with invalid signature '%s'", signature);
    return;
  }

  dbus_message_iter_init (message, &iter);
  add_event_from_iter (&iter);
}

static void
free_property_definition (void *data)
{
  AtspiPropertyDefinition *pd = data;

  g_free (pd->name);
  g_free (pd);
}

static void
remove_events (const char *bus_name, const char *event)
{
  gchar **remove_data;
  GList *list;

  remove_data = g_strsplit (event, ":", 3);
  if (!remove_data)
    {
      return;
    }

  for (list = spi_global_app_data->events; list;)
    {
      event_data *evdata = list->data;
      if (!g_strcmp0 (evdata->bus_name, bus_name) &&
          spi_event_is_subtype (evdata->data, remove_data))
        {
          GList *next;
          GList *events = spi_global_app_data->events;

          g_strfreev (evdata->data);
          g_free (evdata->bus_name);
          g_slist_free_full (evdata->properties, free_property_definition);
          g_free (evdata);

          next = list->next;
          spi_global_app_data->events = g_list_delete_link (events, list);
          list = next;
        }
      else
        {
          list = list->next;
        }
    }

  g_strfreev (remove_data);
}

static void
handle_event_listener_deregistered (DBusConnection *bus, DBusMessage *message,
                                    void *user_data)
{
  gchar *name;
  char *sender;

  if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &sender,
                              DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
    return;

  remove_events (sender, name);
}

static void
handle_device_listener_registered (DBusConnection *bus, DBusMessage *message,
                                    void *user_data)
{
  char *sender;
  DBusMessageIter iter, iter_struct;

  if (strncmp (dbus_message_get_signature (message), "(s", 2) != 0)
    {
      g_warning ("atk-bridge: handle_device_listener_register: unknown signature");
      return;
    }

  dbus_message_iter_init (message, &iter);
  dbus_message_iter_recurse (&iter, &iter_struct);
  dbus_message_iter_get_basic (&iter_struct, &sender);
  spi_atk_add_client (sender);
}

static DBusHandlerResult
signal_filter (DBusConnection *bus, DBusMessage *message, void *user_data)
{
  const char *interface = dbus_message_get_interface (message);
  const char *member = dbus_message_get_member (message);
  DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  static gboolean registry_lost = FALSE;

  if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL)
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

  if (!strcmp (interface, ATSPI_DBUS_INTERFACE_REGISTRY))
    {
      result = DBUS_HANDLER_RESULT_HANDLED;
      if (!strcmp (member, "EventListenerRegistered"))
        handle_event_listener_registered (bus, message, user_data);
      else if (!strcmp (member, "EventListenerDeregistered"))
        handle_event_listener_deregistered (bus, message, user_data);
      else
        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    }
  else if (!strcmp (interface, ATSPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER))
    {
      result = DBUS_HANDLER_RESULT_HANDLED;
      if (!strcmp (member, "KeystrokeListenerRegistered"))
        handle_device_listener_registered (bus, message, user_data);
      else if (!strcmp (member, "DeviceListenerRegistered"))
        handle_device_listener_registered (bus, message, user_data);
      else
        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    }

  if (!g_strcmp0(interface, DBUS_INTERFACE_DBUS) &&
      !g_strcmp0(member, "NameOwnerChanged"))
    {
      char *name, *old, *new;
      if (dbus_message_get_args (message, NULL,
                                 DBUS_TYPE_STRING, &name,
                                 DBUS_TYPE_STRING, &old,
                                 DBUS_TYPE_STRING, &new,
                                 DBUS_TYPE_INVALID))
        {
          if (!strcmp (name, "org.a11y.atspi.Registry"))
            {
              if (registry_lost && !old[0])
                {
                  register_application (spi_global_app_data);
                  registry_lost = FALSE;
                }
              else if (!new[0])
                registry_lost = TRUE;
            }
          else if (*old != '\0' && *new == '\0')
              spi_atk_remove_client (old);
        }
    }

  return result;
}

int
spi_atk_create_socket (SpiBridge *app)
{
#ifndef DISABLE_P2P
  DBusServer *server;
  DBusError error;
  const gchar *user_runtime_dir = g_get_user_runtime_dir ();

  if (g_mkdir_with_parents (user_runtime_dir, 0700) != 0)
    return -1;

  if (getuid () != 0)
  {
    app->app_tmp_dir = g_build_filename (user_runtime_dir,
                                         "at-spi2-XXXXXX", NULL);
    if (!g_mkdtemp (app->app_tmp_dir))
    {
      g_free (app->app_tmp_dir);
      app->app_tmp_dir = NULL;
      return -1;
    }
  }

  if (app->app_tmp_dir)
    app->app_bus_addr = g_strdup_printf ("unix:path=%s/socket", app->app_tmp_dir);
  else
    app->app_bus_addr = g_strdup_printf ("unix:path=%s/at-spi2-socket-%d",
                                         user_runtime_dir, getpid ());

  if (!spi_global_app_data->app_bus_addr)
    return -1;

  dbus_error_init(&error);
  server = dbus_server_listen(spi_global_app_data->app_bus_addr, &error);
  if (server == NULL)
  {
    g_warning ("atk-bridge: Couldn't listen on dbus server: %s", error.message);
    dbus_error_free (&error);
    spi_global_app_data->app_bus_addr [0] = '\0';
    return -1;
  }

  atspi_dbus_server_setup_with_g_main(server, NULL);
  dbus_server_set_new_connection_function(server, new_connection_cb, NULL, NULL);

  spi_global_app_data->server = server;
#endif

  return 0;
}

/*
 * Checks the status of the environment variables
 *
 * At this moment it only checks NO_AT_BRIDGE
 *
 * Returns TRUE if there isn't anything on the environment preventing
 * you to load the bridge, FALSE otherwise
 */
static gboolean
check_envvar (void)
{
  const gchar *envvar;

  envvar = g_getenv ("NO_AT_BRIDGE");

  if (envvar && atoi (envvar) == 1)
    return FALSE;
  else
    return TRUE;
}

void
spi_atk_activate ()
{
  DRoutePath *treepath;

  spi_atk_register_event_listeners ();
  if (!spi_global_cache)
    {
      spi_global_cache    = g_object_new (SPI_CACHE_TYPE, NULL);
      treepath = droute_add_one (spi_global_app_data->droute,
                                 "/org/a11y/atspi/cache", spi_global_cache);

      if (!treepath)
        {
          g_warning ("atk-bridge: Error in droute_add_one().  Already running?");
          return;
        }
      spi_initialize_cache (treepath);
      if (spi_global_app_data->bus)
        droute_path_register (treepath, spi_global_app_data->bus);
    }
}

/*
 * spi_app_init
 *
 * The following needs to be initialized.
 *
 * - DRoute for routing message to their accessible objects.
 * - Event handlers for emmitting signals on specific ATK events.
 * - setup the bus for p2p communication
 * - Application registration with the AT-SPI registry.
 *
 */
int
atk_bridge_adaptor_init (gint * argc, gchar ** argv[])
{
  GOptionContext *opt;
  GError *err = NULL;
  DBusError error;
  AtkObject *root;
  gboolean load_bridge;
  DRoutePath *accpath;

  load_bridge = check_envvar ();
  if (inited && !load_bridge)
    g_warning ("ATK Bridge is disabled but a11y has already been enabled.");

  if (inited)
    return 0;
  if (!load_bridge)
    return -1;

  inited = TRUE;

  root = atk_get_root ();
  g_warn_if_fail (root);
  if (!root)
    {
      inited = FALSE;
      return -1;
    }

  /* Parse command line options */
  opt = g_option_context_new (NULL);
  g_option_context_add_main_entries (opt, atspi_option_entries, NULL);
  g_option_context_set_ignore_unknown_options (opt, TRUE);
  if (!g_option_context_parse (opt, argc, argv, &err))
    {
      g_warning ("AT-SPI Option parsing failed: %s\n", err->message);
      g_error_free (err);
    }
  g_option_context_free (opt);

  /* Allocate global data and do ATK initializations */
  spi_global_app_data = g_new0 (SpiBridge, 1);
  spi_global_app_data->root = g_object_ref (root);

  /* Set up D-Bus connection and register bus name */
  dbus_error_init (&error);
  spi_global_app_data->bus = atspi_get_a11y_bus ();
  if (!spi_global_app_data->bus)
    {
      g_free (spi_global_app_data);
      spi_global_app_data = NULL;
      inited = FALSE;
      return -1;
    }

  if (atspi_dbus_name != NULL)
    {
      if (dbus_bus_request_name
          (spi_global_app_data->bus, atspi_dbus_name, 0, &error))
        {
          g_print ("AT-SPI Recieved D-Bus name - %s\n", atspi_dbus_name);
        }
      else
        {
          g_print
            ("AT-SPI D-Bus name requested but could not be allocated - %s\n",
             atspi_dbus_name);
        }
    }

  spi_global_app_data->main_context = g_main_context_new ();

  atspi_dbus_connection_setup_with_g_main (spi_global_app_data->bus, NULL);

  /* Hook our plug-and socket functions */
  install_plug_hooks ();

  /* 
   * Create the leasing, register and cache objects.
   * The order is important here, the cache depends on the
   * register object.
   */
  spi_global_register = g_object_new (SPI_REGISTER_TYPE, NULL);
  spi_global_leasing  = g_object_new (SPI_LEASING_TYPE, NULL);

  /* Register droute for routing AT-SPI messages */
  spi_global_app_data->droute =
    droute_new ();

  accpath = droute_add_many (spi_global_app_data->droute,
                             "/org/a11y/atspi/accessible",
                             NULL,
                             introspect_children_cb,
                             NULL,
                             (DRouteGetDatumFunction)
                             spi_global_register_path_to_object);


  /* Register all interfaces with droute and set up application accessible db */
  spi_initialize_accessible (accpath);
  spi_initialize_application (accpath);
  spi_initialize_action (accpath);
  spi_initialize_collection (accpath);
  spi_initialize_component (accpath);
  spi_initialize_document (accpath);
  spi_initialize_editabletext (accpath);
  spi_initialize_hyperlink (accpath);
  spi_initialize_hypertext (accpath);
  spi_initialize_image (accpath);
  spi_initialize_selection (accpath);
  spi_initialize_socket (accpath);
  spi_initialize_table (accpath);
  spi_initialize_table_cell (accpath);
  spi_initialize_text (accpath);
  spi_initialize_value (accpath);

  droute_context_register (spi_global_app_data->droute,
                           spi_global_app_data->bus);

  /* Register methods to send D-Bus signals on certain ATK events */
  if (clients)
    spi_atk_activate ();

  /* Set up filter and match rules to catch signals */
  dbus_bus_add_match (spi_global_app_data->bus, "type='signal', interface='org.a11y.atspi.Registry', sender='org.a11y.atspi.Registry'", NULL);
  dbus_bus_add_match (spi_global_app_data->bus, "type='signal', interface='org.a11y.atspi.DeviceEventListener', sender='org.a11y.atspi.Registry'", NULL);
  dbus_bus_add_match (spi_global_app_data->bus, "type='signal', arg0='org.a11y.atspi.Registry', interface='org.freedesktop.DBus', member='NameOwnerChanged'", NULL);
  dbus_connection_add_filter (spi_global_app_data->bus, signal_filter, NULL,
                              NULL);

  /* Register this app by sending a signal out to AT-SPI registry daemon */
  if (!atspi_no_register && (!root || !ATK_IS_PLUG (root)))
    register_application (spi_global_app_data);
  else
    get_registered_event_listeners (spi_global_app_data);

  if (!atexit_added)
    atexit (remove_socket);
  atexit_added = TRUE;

  dbus_error_free (&error);
  return 0;
}

void
atk_bridge_adaptor_cleanup (void)
{
  GList *l;
  GSList *ls;

  if (!inited)
    return;

  if (!spi_global_app_data)
      return;

  spi_atk_tidy_windows ();
  spi_atk_deregister_event_listeners ();

  deregister_application (spi_global_app_data);

  if (spi_global_app_data->bus)
    {
      dbus_connection_remove_filter (spi_global_app_data->bus, signal_filter, NULL);
      droute_context_unregister (spi_global_app_data->droute, spi_global_app_data->bus);
      dbus_connection_close (spi_global_app_data->bus);
      dbus_connection_unref (spi_global_app_data->bus);
      spi_global_app_data->bus = NULL;
    }

  for (l = spi_global_app_data->direct_connections; l; l = l->next)
    {
      DBusConnection *connection;

      connection = l->data;

      droute_context_unregister (spi_global_app_data->droute, connection);
      droute_unintercept_dbus (connection);
      dbus_connection_close (connection);
      dbus_connection_unref (connection);
    }
  g_list_free (spi_global_app_data->direct_connections);
  spi_global_app_data->direct_connections = NULL;

  for (ls = clients; ls; ls = ls->next)
    g_free (ls->data);
  g_slist_free (clients);
  clients = NULL;

  g_clear_object (&spi_global_cache);
  g_clear_object (&spi_global_leasing);
  g_clear_object (&spi_global_register);

  if (spi_global_app_data->main_context)
    g_main_context_unref (spi_global_app_data->main_context);

  droute_free (spi_global_app_data->droute);

  g_free (spi_global_app_data);
  spi_global_app_data = NULL;

  inited = FALSE;
}

/*---------------------------------------------------------------------------*/

static gchar *name_match_tmpl =
       "type='signal', interface='org.freedesktop.DBus', member='NameOwnerChanged', arg0='%s'";

void
spi_atk_add_client (const char *bus_name)
{
  GSList *l;
  gchar *match;

  for (l = clients; l; l = l->next)
  {
    if (!g_strcmp0 (l->data, bus_name))
      return;
  }
  if (!clients)
    spi_atk_activate ();
  clients = g_slist_append (clients, g_strdup (bus_name));
  match = g_strdup_printf (name_match_tmpl, bus_name);
  dbus_bus_add_match (spi_global_app_data->bus, match, NULL);
  g_free (match);
}

void
spi_atk_remove_client (const char *bus_name)
{
  GSList *l;
  GSList *next_node;

  l = clients;
  while (l)
  {
    next_node = l->next;

    if (!g_strcmp0 (l->data, bus_name))
    {
      gchar *match = g_strdup_printf (name_match_tmpl, l->data);
      dbus_bus_remove_match (spi_global_app_data->bus, match, NULL);
  g_free (match);
      g_free (l->data);
      clients = g_slist_delete_link (clients, l);
      if (!clients)
        spi_atk_deregister_event_listeners ();
      return;
    }

    l = next_node;
  }
}

void
spi_atk_add_interface (DRoutePath *path,
                       const char *name,
                       const char *introspect,
                       const DRouteMethod   *methods,
                       const DRouteProperty *properties)
{
  droute_path_add_interface (path, name, introspect, methods, properties);

  if (properties)
  {
    if (!spi_global_app_data->property_hash)
      spi_global_app_data->property_hash = g_hash_table_new_full (g_str_hash,
                                                                  g_str_equal,
                                                                  g_free, NULL);
    g_hash_table_insert (spi_global_app_data->property_hash, g_strdup (name),
                         (gpointer) properties);
  }
}
/*END------------------------------------------------------------------------*/
