/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
/* vim:set et sts=4: */
/* ibus - The Input Bus
 * Copyright (C) 2008-2013 Peng Huang <shawn.p.huang@gmail.com>
 * Copyright (C) 2015-2025 Takao Fujiwara <takao.fujiwara1@gmail.com>
 * Copyright (C) 2008-2024 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#include "dbusimpl.h"

#include <string.h>

#include "global.h"
#include "ibusimpl.h"
#include "marshalers.h"
#include "matchrule.h"
#include "types.h"

enum {
    NAME_OWNER_CHANGED,
    NAME_LOST,
    NAME_ACQUIRED,
    LAST_SIGNAL,
};

enum {
    PROP_0,
};

static guint dbus_signals[LAST_SIGNAL] = { 0 };

struct _BusDBusImpl {
    IBusService parent;

    /* instance members */
    /* a map from a unique bus name (e.g. ":1.0") to a BusConnection. */
    GHashTable *unique_names;
    /* a map from a requested well-known name (e.g.
     * "org.freedesktop.IBus.Panel") to a BusNameService. */
    GHashTable *names;
    /* a list of IBusService objects. */
    GList *objects;
    /* a list of active BusConnections. */
    GList *connections;
    /* a list of BusMatchRules requested by the connections above. */
    GList *rules;
    /* a serial number used to generate a unique name of a bus. */
    guint id;

    GMutex dispatch_lock;
    GList *dispatch_queue;

    GMutex forward_lock;
    GList *forward_queue;

    /* a list of BusMethodCall to be used to reply when services are
       really available */
    GList *start_service_calls;
};

struct _BusDBusImplClass {
    IBusServiceClass parent;

    /* class members */
    void    (* name_owner_changed) (BusDBusImpl     *dbus,
                                    BusConnection   *connection,
                                    gchar           *name,
                                    gchar           *old_name,
                                    gchar           *new_name);

    void    (* name_lost)          (BusDBusImpl     *dbus,
                                    BusConnection   *connection,
                                    gchar           *name);

    void    (* name_acquired)      (BusDBusImpl     *dbus,
                                    BusConnection   *connection,
                                    gchar           *name);
};

typedef struct _BusDispatchData BusDispatchData;
struct _BusDispatchData {
    GDBusMessage *message;
    BusConnection *skip_connection;
};

typedef struct _BusNameService BusNameService;
struct _BusNameService {
    gchar *name;
    GSList *owners;
};

typedef struct _BusConnectionOwner BusConnectionOwner;
struct _BusConnectionOwner {
    BusConnection *conn;

    guint allow_replacement : 1;
    guint do_not_queue : 1;
};

typedef struct _BusMethodCall BusMethodCall;
struct _BusMethodCall {
    BusDBusImpl *dbus;
    BusConnection *connection;
    GVariant *parameters;
    GDBusMethodInvocation *invocation;
    guint timeout_id;
};

/* functions prototype */
static void     bus_dbus_impl_destroy           (BusDBusImpl        *dbus);
static void     bus_dbus_impl_service_method_call
                                                (IBusService        *service,
                                                 GDBusConnection    *dbus_connection,
                                                 const gchar        *sender,
                                                 const gchar        *object_path,
                                                 const gchar        *interface_name,
                                                 const gchar        *method_name,
                                                 GVariant           *parameters,
                                                 GDBusMethodInvocation
                                                                    *invocation);
static GVariant *bus_dbus_impl_service_get_property
                                                (IBusService        *service,
                                                 GDBusConnection    *connection,
                                                 const gchar        *sender,
                                                 const gchar        *object_path,
                                                 const gchar        *interface_name,
                                                 const gchar        *property_name,
                                                 GError            **error);
static gboolean  bus_dbus_impl_service_set_property
                                                (IBusService        *service,
                                                 GDBusConnection    *connection,
                                                 const gchar        *sender,
                                                 const gchar        *object_path,
                                                 const gchar        *interface_name,
                                                 const gchar        *property_name,
                                                 GVariant           *value,
                                                 GError            **error);
static void      bus_dbus_impl_name_owner_changed
                                                (BusDBusImpl        *dbus,
                                                 BusConnection      *connection,
                                                 gchar              *name,
                                                 gchar              *old_name,
                                                 gchar              *new_name);
static void      bus_dbus_impl_name_lost
                                                (BusDBusImpl        *dbus,
                                                 BusConnection      *connection,
                                                 gchar              *name);
static void      bus_dbus_impl_name_acquired
                                                (BusDBusImpl        *dbus,
                                                 BusConnection      *connection,
                                                 gchar              *name);
static void      bus_dbus_impl_connection_destroy_cb
                                                (BusConnection      *connection,
                                                 BusDBusImpl        *dbus);
static void      bus_dbus_impl_rule_destroy_cb  (BusMatchRule       *rule,
                                                 BusDBusImpl        *dbus);
static void      bus_dbus_impl_object_destroy_cb(IBusService        *object,
                                                 BusDBusImpl        *dbus);

G_DEFINE_TYPE(BusDBusImpl, bus_dbus_impl, IBUS_TYPE_SERVICE)

/* The D-Bus interfaces available in this class, which consists of a list of
 * methods this class implements and a list of signals this class may emit.
 * See bus_dbus_impl_new_connection and ibusservice.c for more details.
 */
static const gchar introspection_xml[] =
    "<node>"
    "  <interface name='org.freedesktop.DBus'>"
    "    <method name='Hello'>"
    "      <arg direction='out' type='s' name='unique_name' />"
    "    </method>"
    "    <method name='RequestName'>"
    "      <arg direction='in'  type='s' name='name' />"
    "      <arg direction='in'  type='u' name='flags' />"
    "      <arg direction='out' type='u' />"
    "    </method>"
    "    <method name='ReleaseName'>"
    "      <arg direction='in'  type='s' name='name' />"
    "      <arg direction='out' type='u' />"
    "    </method>"
    "    <method name='StartServiceByName'>"
    "      <arg direction='in'  type='s' />"
    "      <arg direction='in'  type='u' />"
    "      <arg direction='out' type='u' />"
    "    </method>"
    "    <method name='UpdateActivationEnvironment'>"
    "      <arg direction='in' type='a{ss}'/>"
    "    </method>"
    "    <method name='NameHasOwner'>"
    "      <arg direction='in'  type='s' name='name' />"
    "      <arg direction='out' type='b' />"
    "    </method>"
    "    <method name='ListNames'>"
    "      <arg direction='out' type='as' />"
    "    </method>"
    "    <method name='ListActivatableNames'>"
    "      <arg direction='out' type='as' />"
    "    </method>"
    "    <method name='AddMatch'>"
    "      <arg direction='in'  type='s' name='match_rule' />"
    "    </method>"
    "    <method name='RemoveMatch'>"
    "      <arg direction='in'  type='s' name='match_rule' />"
    "    </method>"
    "    <method name='GetNameOwner'>"
    "      <arg direction='in'  type='s' name='name' />"
    "      <arg direction='out' type='s' name='unique_name' />"
    "    </method>"
    "    <method name='ListQueuedOwners'>"
    "      <arg direction='in'  type='s' name='name' />"
    "      <arg direction='out' type='as' />"
    "    </method>"
    "    <method name='GetConnectionUnixUser'>"
    "      <arg direction='in'  type='s' />"
    "      <arg direction='out' type='u' />"
    "    </method>"
    "    <method name='GetConnectionUnixProcessID'>"
    "      <arg direction='in'  type='s' />"
    "      <arg direction='out' type='u' />"
    "    </method>"
    "    <method name='GetAdtAuditSessionData'>"
    "      <arg direction='in'  type='s' />"
    "      <arg direction='out' type='ay' />"
    "    </method>"
    "    <method name='GetConnectionSELinuxSecurityContext'>"
    "      <arg direction='in'  type='s' />"
    "      <arg direction='out' type='ay' />"
    "    </method>"
    "    <method name='ReloadConfig' />"
    "    <method name='GetId'>"
    "      <arg direction='out' type='s' />"
    "    </method>"
    "    <signal name='NameOwnerChanged'>"
    "      <arg type='s' name='name' />"
    "      <arg type='s' name='old_owner' />"
    "      <arg type='s' name='new_owner' />"
    "    </signal>"
    "    <signal name='NameLost'>"
    "      <arg type='s' name='name' />"
    "    </signal>"
    "    <signal name='NameAcquired'>"
    "      <arg type='s' name='name' />"
    "    </signal>"
    "  </interface>"
    "</node>";

static void
bus_connection_owner_set_flags (BusConnectionOwner *owner,
                                guint32             flags)
{
    owner->allow_replacement =
        (flags & IBUS_BUS_NAME_FLAG_ALLOW_REPLACEMENT) != 0;

    owner->do_not_queue =
        (flags & IBUS_BUS_NAME_FLAG_DO_NOT_QUEUE) != 0;
}

static BusConnectionOwner *
bus_connection_owner_new (BusConnection *connection,
                          guint32        flags)
{
    BusConnectionOwner *owner = NULL;

    g_assert (BUS_IS_CONNECTION (connection));

    owner = g_slice_new (BusConnectionOwner);
    if (owner != NULL) {
        owner->conn = g_object_ref (connection);
        bus_connection_owner_set_flags (owner, flags);
    }

    return owner;
}

static void
bus_connection_owner_free (BusConnectionOwner *owner)
{
    g_assert (owner != NULL);

    g_object_unref (owner->conn);
    owner->conn = NULL;
    g_slice_free (BusConnectionOwner, owner);
}

static GSList *
bus_name_service_find_owner_link (BusNameService *service,
                                   BusConnection  *connection)
{
    GSList *owners = service->owners;

    while (owners) {
        BusConnectionOwner *owner = (BusConnectionOwner *) owners->data;
        if (owner->conn == connection) {
            break;
        }
        owners = owners->next;
    }

    return owners;
}

static BusNameService *
bus_name_service_new (const gchar *name)
{
    BusNameService *service = NULL;

    g_assert (name != NULL);

    service = g_slice_new (BusNameService);
    g_assert (service != NULL);

    service->name = g_strdup (name);
    service->owners = NULL;

    return service;
}

static void
bus_name_service_free (BusNameService *service)
{
    g_assert (service != NULL);

    g_slist_free_full (service->owners,
                       (GDestroyNotify) bus_connection_owner_free);
    service->owners = NULL;

    g_free (service->name);
    g_slice_free (BusNameService, service);
}

static void
bus_name_service_set_primary_owner (BusNameService     *service,
                                    BusConnectionOwner *owner,
                                    BusDBusImpl        *dbus)
{
    gboolean has_old_owner = FALSE;

    g_assert (service != NULL);
    g_assert (owner != NULL);
    g_assert (dbus != NULL);

    BusConnectionOwner *old = service->owners != NULL ?
            (BusConnectionOwner *)service->owners->data : NULL;

    /* rhbz#1432252 If bus_connection_get_unique_name() == NULL,
     * "Hello" method is not received yet.
     */
    if (old != NULL && bus_connection_get_unique_name (old->conn) != NULL) {
        has_old_owner = TRUE;
    }

    if (old != NULL) {
        g_signal_emit (dbus,
                       dbus_signals[NAME_LOST],
                       0,
                       old->conn,
                       service->name);
    }

    g_signal_emit (dbus,
                   dbus_signals[NAME_ACQUIRED],
                   0,
                   owner->conn,
                   service->name ? service->name : "");

    g_signal_emit (dbus,
                   dbus_signals[NAME_OWNER_CHANGED],
                   0,
                   owner->conn,
                   service->name,
                   has_old_owner ? bus_connection_get_unique_name (old->conn) :
                           "",
                   bus_connection_get_unique_name (owner->conn));

    if (old != NULL && old->do_not_queue != 0) {
        /* If old primary owner does not want to be in queue, we remove it. */
        service->owners = g_slist_remove (service->owners, old);
        bus_connection_remove_name (old->conn, service->name);
        bus_connection_owner_free (old);
    }

    service->owners = g_slist_prepend (service->owners, (gpointer) owner);
}

static BusConnectionOwner *
bus_name_service_get_primary_owner (BusNameService *service)
{
    g_assert (service != NULL);

    if (service->owners == NULL) {
        return NULL;
    }

    return (BusConnectionOwner *) service->owners->data;
}

static void
bus_name_service_add_non_primary_owner (BusNameService     *service,
                                        BusConnectionOwner *owner,
                                        BusDBusImpl        *dbus)
{
    g_assert (service != NULL);
    g_assert (owner != NULL);
    g_assert (dbus != NULL);
    g_assert (service->owners != NULL);

    service->owners = g_slist_append (service->owners, (gpointer) owner);
}

static BusConnectionOwner *
bus_name_service_find_owner (BusNameService *service,
                             BusConnection  *connection)
{
    g_assert (service != NULL);
    g_assert (connection != NULL);

    GSList *owners = bus_name_service_find_owner_link (service, connection);
    if (owners != NULL)
        return (BusConnectionOwner *)owners->data;
    return NULL;
}

static void
bus_name_service_remove_owner (BusNameService     *service,
                               BusConnectionOwner *owner,
                               BusDBusImpl        *dbus)
{
    GSList *owners;
    gboolean has_new_owner = FALSE;

    g_assert (service != NULL);
    g_assert (owner != NULL);


    owners = bus_name_service_find_owner_link (service, owner->conn);
    g_assert (owners != NULL);

    if (owners->data == bus_name_service_get_primary_owner (service)) {
        BusConnectionOwner *_new = NULL;
        if (owners->next != NULL) {
            _new = (BusConnectionOwner *)owners->next->data;
            /* rhbz#1406699 If bus_connection_get_unique_name() == NULL,
             * "Hello" method is not received yet.
             */
            if (_new != NULL &&
                bus_connection_get_unique_name (_new->conn) != NULL) {
                has_new_owner = TRUE;
            }
        }

        if (dbus != NULL) {
            g_signal_emit (dbus,
                           dbus_signals[NAME_LOST],
                           0,
                           owner->conn,
                           service->name);
            if (has_new_owner) {
                g_signal_emit (dbus,
                               dbus_signals[NAME_ACQUIRED],
                               0,
                               _new->conn,
                               service->name);
            }
            g_signal_emit (dbus,
                    dbus_signals[NAME_OWNER_CHANGED],
                    0,
                    _new != NULL ? _new->conn : NULL,
                    service->name,
                    bus_connection_get_unique_name (owner->conn),
                    has_new_owner
                            ? bus_connection_get_unique_name (_new->conn)
                            : "");

        }
    }

    /* Should use g_slist_delete_link() instead of g_slist_remove_link(), to
     * delete the slice link in g_slist_prepend() in
     * bus_name_service_set_primary_owner().
     */
    service->owners = g_slist_delete_link (service->owners, (gpointer) owners);
}

static gboolean
bus_name_service_get_allow_replacement (BusNameService *service)
{
    BusConnectionOwner *owner = NULL;

    g_assert (service != NULL);

    owner = bus_name_service_get_primary_owner (service);
    if (owner == NULL) {
        return TRUE;
    }
    return owner->allow_replacement;
}

static BusMethodCall *
bus_method_call_new (BusDBusImpl           *dbus,
                     BusConnection         *connection,
                     GVariant              *parameters,
                     GDBusMethodInvocation *invocation)
{
    BusMethodCall *call = g_slice_new0 (BusMethodCall);
    call->dbus = g_object_ref (dbus);
    call->connection = g_object_ref (connection);
    call->parameters = g_variant_ref (parameters);
    call->invocation = g_object_ref (invocation);
    return call;
}

static void
bus_method_call_free (BusMethodCall *call)
{
    if (call->timeout_id != 0) {
        g_source_remove (call->timeout_id);
    }

    g_object_unref (call->dbus);
    g_object_unref (call->connection);
    g_variant_unref (call->parameters);
    g_object_unref (call->invocation);
    g_slice_free (BusMethodCall, call);
}

static void
bus_dbus_impl_class_init (BusDBusImplClass *class)
{
    GObjectClass *gobject_class = G_OBJECT_CLASS (class);

    IBUS_OBJECT_CLASS (gobject_class)->destroy =
            (IBusObjectDestroyFunc) bus_dbus_impl_destroy;

    /* override the default implementations in the parent class. */
    IBUS_SERVICE_CLASS (class)->service_method_call =
            bus_dbus_impl_service_method_call;
    IBUS_SERVICE_CLASS (class)->service_get_property =
            bus_dbus_impl_service_get_property;
    IBUS_SERVICE_CLASS (class)->service_set_property =
            bus_dbus_impl_service_set_property;

    ibus_service_class_add_interfaces (IBUS_SERVICE_CLASS (class),
                                       introspection_xml);

    /* register a handler of the name-owner-changed signal below. */
    class->name_owner_changed = bus_dbus_impl_name_owner_changed;

    /* register a handler of the name-lost signal below. */
    class->name_lost = bus_dbus_impl_name_lost;

    /* register a handler of the name-acquired signal below. */
    class->name_acquired = bus_dbus_impl_name_acquired;

    /* install signals */
    dbus_signals[NAME_OWNER_CHANGED] =
        g_signal_new (I_("name-owner-changed"),
            G_TYPE_FROM_CLASS (class),
            G_SIGNAL_RUN_FIRST,
            G_STRUCT_OFFSET (BusDBusImplClass, name_owner_changed),
            NULL, NULL,
            bus_marshal_VOID__OBJECT_STRING_STRING_STRING,
            G_TYPE_NONE,
            4,
            BUS_TYPE_CONNECTION,
            G_TYPE_STRING,
            G_TYPE_STRING,
            G_TYPE_STRING);
    g_signal_set_va_marshaller (dbus_signals[NAME_OWNER_CHANGED],
                                G_TYPE_FROM_CLASS (class),
                                bus_marshal_VOID__OBJECT_STRING_STRING_STRINGv);

    dbus_signals[NAME_LOST] =
        g_signal_new (I_("name-lost"),
            G_TYPE_FROM_CLASS (class),
            G_SIGNAL_RUN_FIRST,
            G_STRUCT_OFFSET (BusDBusImplClass, name_lost),
            NULL, NULL,
            bus_marshal_VOID__OBJECT_STRING,
            G_TYPE_NONE,
            2,
            BUS_TYPE_CONNECTION,
            G_TYPE_STRING);
    g_signal_set_va_marshaller (dbus_signals[NAME_LOST],
                                G_TYPE_FROM_CLASS (class),
                                bus_marshal_VOID__OBJECT_STRINGv);

    dbus_signals[NAME_ACQUIRED] =
        g_signal_new (I_("name-acquired"),
            G_TYPE_FROM_CLASS (class),
            G_SIGNAL_RUN_FIRST,
            G_STRUCT_OFFSET (BusDBusImplClass, name_acquired),
            NULL, NULL,
            bus_marshal_VOID__OBJECT_STRING,
            G_TYPE_NONE,
            2,
            BUS_TYPE_CONNECTION,
            G_TYPE_STRING);
    g_signal_set_va_marshaller (dbus_signals[NAME_ACQUIRED],
                                G_TYPE_FROM_CLASS (class),
                                bus_marshal_VOID__OBJECT_STRINGv);
}

static void
bus_dbus_impl_init (BusDBusImpl *dbus)
{
    dbus->unique_names = g_hash_table_new (g_str_hash, g_str_equal);
    dbus->names =
            g_hash_table_new_full (g_str_hash, g_str_equal,
                                   NULL,
                                   (GDestroyNotify) bus_name_service_free);

    g_mutex_init (&dbus->dispatch_lock);
    g_mutex_init (&dbus->forward_lock);

    /* other members are automatically zero-initialized. */
}

static void
bus_dbus_impl_destroy (BusDBusImpl *dbus)
{
    GList *p;

    for (p = dbus->objects; p != NULL; p = p->next) {
        IBusService *object = (IBusService *) p->data;
        g_signal_handlers_disconnect_by_func (object,
                G_CALLBACK (bus_dbus_impl_object_destroy_cb), dbus);
        ibus_object_destroy ((IBusObject *) object);
        g_object_unref (object);
    }
    g_list_free (dbus->objects);
    dbus->objects = NULL;

    for (p = dbus->rules; p != NULL; p = p->next) {
        BusMatchRule *rule = BUS_MATCH_RULE (p->data);
        g_signal_handlers_disconnect_by_func (rule,
                        G_CALLBACK (bus_dbus_impl_rule_destroy_cb), dbus);
        ibus_object_destroy ((IBusObject *) rule);
        g_object_unref (rule);
    }
    g_list_free (dbus->rules);
    dbus->rules = NULL;

    for (p = dbus->connections; p != NULL; p = p->next) {
        BusConnection *connection = BUS_CONNECTION (p->data);
        g_signal_handlers_disconnect_by_func (connection,
                bus_dbus_impl_connection_destroy_cb, dbus);
        ibus_object_destroy (IBUS_OBJECT (connection));
        g_object_unref (connection);
    }
    g_list_free (dbus->connections);
    dbus->connections = NULL;

    /* g_hash_table_destroy() calls both g_hash_table_remove_all() and
     * g_hash_table_unref() and the node destruction is called in
     * g_hash_table_remove_all_nodes().
     */
    g_hash_table_destroy (dbus->unique_names);
    g_hash_table_destroy (dbus->names);

    dbus->unique_names = NULL;
    dbus->names = NULL;

    g_list_free_full (dbus->start_service_calls,
                      (GDestroyNotify) bus_method_call_free);
    dbus->start_service_calls = NULL;

    g_mutex_clear (&dbus->dispatch_lock);
    g_mutex_clear (&dbus->forward_lock);

    /* FIXME destruct _lock and _queue members. */
    IBUS_OBJECT_CLASS(bus_dbus_impl_parent_class)->destroy ((IBusObject *)dbus);
}

/**
 * bus_dbus_impl_hello:
 *
 * Implement the "Hello" method call of the org.freedesktop.DBus interface.
 * Assign a unique bus name like ":1.0" for the connection and return the name
 * (as a D-Bus reply.)
 */
static void
bus_dbus_impl_hello (BusDBusImpl           *dbus,
                     BusConnection         *connection,
                     GVariant              *parameters,
                     GDBusMethodInvocation *invocation)
{
    if (bus_connection_get_unique_name (connection) != NULL) {
        g_dbus_method_invocation_return_error (
                        invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
                        "Already handled an Hello message");
    }
    else {
        gchar *name = g_strdup_printf (":1.%u", ++dbus->id);
        bus_connection_set_unique_name (connection, name);
        g_free (name);

        name = (gchar *) bus_connection_get_unique_name (connection);
        g_hash_table_insert (dbus->unique_names, name, connection);
        g_dbus_method_invocation_return_value (invocation,
                                               g_variant_new ("(s)", name));

        g_signal_emit (dbus,
                       dbus_signals[NAME_OWNER_CHANGED],
                       0,
                       connection,
                       name,
                       "",
                       name);
    }
}

/**
 * bus_dbus_impl_list_names:
 *
 * Implement the "ListNames" method call of the org.freedesktop.DBus interface.
 * Return all bus names (e.g. ":1.0", "org.freedesktop.IBus.Panel") as a D-Bus
 * reply.
 */
static void
bus_dbus_impl_list_names (BusDBusImpl           *dbus,
                          BusConnection         *connection,
                          GVariant              *parameters,
                          GDBusMethodInvocation *invocation)
{
    GVariantBuilder builder;
    g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));

    /* FIXME should add them? */
    g_variant_builder_add (&builder, "s", "org.freedesktop.DBus");
    g_variant_builder_add (&builder, "s", IBUS_SERVICE_IBUS);
    g_variant_builder_add (&builder, "s", IBUS_NAME_OWNER_NAME);

    /* append well-known names */
    GList *names, *name;
    names = g_hash_table_get_keys (dbus->names);
    for (name = names; name != NULL; name = name->next) {
        g_variant_builder_add (&builder, "s", name->data);
    }
    g_list_free (names);

    /* append unique names */
    names = g_hash_table_get_keys (dbus->unique_names);
    for (name = names; name != NULL; name = name->next) {
        g_variant_builder_add (&builder, "s", name->data);
    }
    g_list_free (names);

    g_dbus_method_invocation_return_value (invocation,
                    g_variant_new ("(as)", &builder));
}

/**
 * bus_dbus_impl_list_names:
 *
 * Implement the "NameHasOwner" method call of the org.freedesktop.DBus
 * interface.
 * Return TRUE (as a D-Bus reply) if the name is available in dbus->unique_names
 * or is a well-known name.
 */
static void
bus_dbus_impl_name_has_owner (BusDBusImpl           *dbus,
                              BusConnection         *connection,
                              GVariant              *parameters,
                              GDBusMethodInvocation *invocation)
{
    const gchar *name = NULL;
    g_variant_get (parameters, "(&s)", &name);

    gboolean has_owner;
    if (!g_dbus_is_name (name)) {
        g_dbus_method_invocation_return_error (invocation,
                                               G_DBUS_ERROR,
                                               G_DBUS_ERROR_FAILED,
                                               "'%s' is not a legal bus name",
                                               name ? name : "(null)");
        return;
    }

    if (g_dbus_is_unique_name (name)) {
        has_owner = g_hash_table_lookup (dbus->unique_names, name) != NULL;
    }
    else {
        if (!g_strcmp0 (name, "org.freedesktop.DBus") ||
            !g_strcmp0 (name, "org.freedesktop.IBus")) {
            has_owner = TRUE;
        } else {
            has_owner = g_hash_table_lookup (dbus->names, name) != NULL;
        }
    }
    g_dbus_method_invocation_return_value (invocation,
                    g_variant_new ("(b)", has_owner));
}

/**
 * bus_dbus_impl_get_name_owner:
 *
 * Implement the "GetNameOwner" method call of the org.freedesktop.DBus
 * interface.
 */
static void
bus_dbus_impl_get_name_owner (BusDBusImpl           *dbus,
                              BusConnection         *connection,
                              GVariant              *parameters,
                              GDBusMethodInvocation *invocation)
{
    const gchar *name_owner = NULL;
    const gchar *name = NULL;
    g_variant_get (parameters, "(&s)", &name);

    if (!g_strcmp0 (name, "org.freedesktop.DBus")) {
        name_owner = name;
    } else if (!g_strcmp0 (name, IBUS_SERVICE_IBUS)) {
        name_owner = IBUS_NAME_OWNER_NAME;
    } else {
        BusConnection *owner = bus_dbus_impl_get_connection_by_name (dbus,
                                                                     name);
        if (owner != NULL) {
            name_owner = bus_connection_get_unique_name (owner);
        }
    }

    if (name_owner == NULL) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
                        "Can not get name owner of '%s': no such name", name);
    } else {
        g_dbus_method_invocation_return_value (invocation,
                        g_variant_new ("(s)", name_owner));
    }
}

/**
 * bus_dbus_impl_list_queued_owners:
 *
 * Implement the "ListQueuedOwners" method call of the org.freedesktop.DBus
 * interface.
 */
static void
bus_dbus_impl_list_queued_owners (BusDBusImpl           *dbus,
                                  BusConnection         *connection,
                                  GVariant              *parameters,
                                  GDBusMethodInvocation *invocation)
{
    const gchar *name = NULL;
    const gchar *name_owner = NULL;
    GVariantBuilder builder;
    BusConnection *named_conn = NULL;

    g_variant_get (parameters, "(&s)", &name);

    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (name != NULL);

    g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));

    if (G_LIKELY (g_dbus_is_unique_name (name))) {
        named_conn = (BusConnection *) g_hash_table_lookup (dbus->unique_names,
                                                            name);
        if (named_conn == NULL) {
            g_dbus_method_invocation_return_value (invocation,
                    g_variant_new ("(as)", &builder));
            return;
        }
        name_owner = bus_connection_get_unique_name (named_conn);
        if (name_owner == NULL) {
            g_dbus_method_invocation_return_error (invocation,
                            G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
                            "Can not get name owner of '%s': no such name",
                            name);
            return;
        }
        g_variant_builder_add (&builder, "s", name_owner);
    }
    else {
        BusNameService *service;
        GSList *owners;

        service = (BusNameService *) g_hash_table_lookup (dbus->names, name);
        if (service == NULL) {
            g_dbus_method_invocation_return_value (invocation,
                    g_variant_new ("(as)", &builder));
            return;
        }
        for (owners = service->owners; owners; owners = owners->next) {
            BusConnectionOwner *owner = (BusConnectionOwner *) owners->data;
            if (owner == NULL) {
                continue;
            }
            named_conn = owner->conn;
            if (named_conn == NULL) {
                continue;
            }
            name_owner = bus_connection_get_unique_name (named_conn);
            if (name_owner == NULL) {
                g_dbus_method_invocation_return_error (invocation,
                            G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
                            "Can not get name owner of '%s': no such name",
                            name);
                return;
            }
            g_variant_builder_add (&builder, "s", name_owner);
        }
    }

    g_dbus_method_invocation_return_value (invocation,
                    g_variant_new ("(as)", &builder));
}

/**
 * bus_dbus_impl_get_id:
 *
 * Implement the "GetId" method call of the org.freedesktop.DBus interface.
 * This function is not implemented yet and always returns a dummy string
 * - "FIXME".
 */
static void
bus_dbus_impl_get_id (BusDBusImpl           *dbus,
                      BusConnection         *connection,
                      GVariant              *parameters,
                      GDBusMethodInvocation *invocation)
{
    /* FIXME */
    const gchar *uuid = "FIXME";
    g_dbus_method_invocation_return_value (invocation,
                    g_variant_new ("(s)", uuid));
}

/**
 * bus_dbus_impl_rule_destroy_cb:
 *
 * A function to be called when one of the dbus->rules is destroyed.
 */
static void
bus_dbus_impl_rule_destroy_cb (BusMatchRule *rule,
                               BusDBusImpl  *dbus)
{
    dbus->rules = g_list_remove (dbus->rules, rule);
    g_object_unref (rule);
}

/**
 * bus_dbus_impl_get_id:
 *
 * Implement the "AddMatch" method call of the org.freedesktop.DBus interface.
 */
static void
bus_dbus_impl_add_match (BusDBusImpl           *dbus,
                         BusConnection         *connection,
                         GVariant              *parameters,
                         GDBusMethodInvocation *invocation)
{
    const gchar *rule_text = NULL;
    g_variant_get (parameters, "(&s)", &rule_text);

    BusMatchRule *rule = bus_match_rule_new (rule_text);
    if (rule == NULL) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_MATCH_RULE_INVALID,
                        "Parse match rule [%s] failed", rule_text);
        return;
    }
    /* ibus_bus_watch_ibus_signal() supports IBUS_SERVICE_IBUS sender. */
    if (!g_strcmp0 (bus_match_rule_get_sender (rule), IBUS_SERVICE_IBUS))
        bus_match_rule_set_sender (rule, IBUS_NAME_OWNER_NAME);

    g_dbus_method_invocation_return_value (invocation, NULL);
    GList *p;
    for (p = dbus->rules; p != NULL; p = p->next) {
        if (bus_match_rule_is_equal (rule, (BusMatchRule *) p->data)) {
            /* The same rule is already registered. Just reuse it. */
            bus_match_rule_add_recipient ((BusMatchRule *) p->data, connection);
            g_object_unref (rule);
            return;
        }
    }

    if (rule) {
        bus_match_rule_add_recipient (rule, connection);
        dbus->rules = g_list_append (dbus->rules, rule);
        g_signal_connect (rule,
                          "destroy",
                          G_CALLBACK (bus_dbus_impl_rule_destroy_cb),
                          dbus);
    }
}

/**
 * bus_dbus_impl_get_id:
 *
 * Implement the "RemoveMatch" method call of the org.freedesktop.DBus
 * interface.
 */
static void
bus_dbus_impl_remove_match (BusDBusImpl           *dbus,
                            BusConnection         *connection,
                            GVariant              *parameters,
                            GDBusMethodInvocation *invocation)
{
    const gchar *rule_text = NULL;
    g_variant_get (parameters, "(&s)", &rule_text);

    BusMatchRule *rule = bus_match_rule_new (rule_text);
    if (rule == NULL) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_MATCH_RULE_INVALID,
                        "Parse match rule [%s] failed", rule_text);
        return;
    }

    g_dbus_method_invocation_return_value (invocation, NULL);
    GList *p;
    for (p = dbus->rules; p != NULL; p = p->next) {
        if (bus_match_rule_is_equal (rule, (BusMatchRule *) p->data)) {
            /* p->data will be destroyed when the final recipient is removed. */
            bus_match_rule_remove_recipient ((BusMatchRule *) p->data,
                                             connection);
            break;
        }
        /* FIXME should we return G_DBUS_ERROR if rule is not found in
         * dbus->rules
         */
    }
    g_object_unref (rule);
}

/**
 * bus_dbus_impl_request_name:
 *
 * Implement the "RequestName" method call of the org.freedesktop.DBus
 * interface.
 */
static void
bus_dbus_impl_request_name (BusDBusImpl           *dbus,
                            BusConnection         *connection,
                            GVariant              *parameters,
                            GDBusMethodInvocation *invocation)
{
    const gchar *name = NULL;  // e.g. "org.freedesktop.IBus.Panel"
    guint32 flags = 0;
    BusNameService *service = NULL;
    BusConnectionOwner *primary_owner = NULL;
    BusConnectionOwner *owner = NULL;

    g_variant_get (parameters, "(&su)", &name, &flags);

    if (name == NULL ||
        !g_dbus_is_name (name) ||
        g_dbus_is_unique_name (name)) {
        g_dbus_method_invocation_return_error (invocation,
                G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
                "'%s' is not a legal service name.", name);
        return;
    }

    if (!g_strcmp0 (name, "org.freedesktop.DBus") ||
        !g_strcmp0 (name, "org.freedesktop.IBus")) {
        g_dbus_method_invocation_return_error (invocation,
                G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
                "Can not acquire the service name '%s', it is reserved by IBus",
                name);
        return;
    }

    enum {
        ACTION_INVALID,
        ACTION_IN_QUEUE,
        ACTION_REPLACE,
        ACTION_EXISTS,
        ACTION_ALREADY_OWN,
    } action = ACTION_INVALID;

    service = (BusNameService *) g_hash_table_lookup (dbus->names, name);

    /* If the name servise does not exist, we will create one. */
    if (service == NULL) {
        service = bus_name_service_new (name);
        g_hash_table_insert (dbus->names,
                             service->name,
                             service);
    }
    else {
        primary_owner = bus_name_service_get_primary_owner (service);
    }

    if (primary_owner != NULL) {
        if (primary_owner->conn == connection) {
            action = ACTION_ALREADY_OWN;
        } else {
            action = (flags & IBUS_BUS_NAME_FLAG_DO_NOT_QUEUE) ?
                    ACTION_EXISTS : ACTION_IN_QUEUE;
            if ((bus_name_service_get_allow_replacement (service) == TRUE) &&
                (flags & IBUS_BUS_NAME_FLAG_REPLACE_EXISTING)) {
                action = ACTION_REPLACE;
            }
        }
    } else {
        action = ACTION_REPLACE;
    }

    if (action == ACTION_ALREADY_OWN) {
        g_dbus_method_invocation_return_value (
                invocation,
                g_variant_new ("(u)",
                               IBUS_BUS_REQUEST_NAME_REPLY_ALREADY_OWNER));
        return;
    }

    owner = bus_name_service_find_owner (service, connection);
    /* If connection already in queue, we need remove it at first. */
    if (owner != NULL) {
        bus_connection_remove_name (connection, name);
        bus_name_service_remove_owner (service, owner, NULL);
        bus_connection_owner_free (owner);
    }

    switch (action) {
    case ACTION_EXISTS:
        g_dbus_method_invocation_return_value (invocation,
                g_variant_new ("(u)", IBUS_BUS_REQUEST_NAME_REPLY_EXISTS));
        return;

    case ACTION_IN_QUEUE:
        owner = bus_connection_owner_new (connection, flags);
        g_dbus_method_invocation_return_value (invocation,
                g_variant_new ("(u)", IBUS_BUS_REQUEST_NAME_REPLY_IN_QUEUE));
        bus_name_service_add_non_primary_owner (service, owner, dbus);
        return;

    case ACTION_REPLACE:
        bus_connection_add_name (connection, name);
        owner = bus_connection_owner_new (connection, flags);
        g_dbus_method_invocation_return_value (
                invocation,
                g_variant_new ("(u)",
                               IBUS_BUS_REQUEST_NAME_REPLY_PRIMARY_OWNER));
        bus_name_service_set_primary_owner (service, owner, dbus);
        return;

    default:
        g_assert_not_reached ();
    }
}

/**
 * bus_dbus_impl_release_name:
 *
 * Implement the "ReleaseName" method call of the org.freedesktop.DBus
 * interface.
 */
static void
bus_dbus_impl_release_name (BusDBusImpl           *dbus,
                            BusConnection         *connection,
                            GVariant              *parameters,
                            GDBusMethodInvocation *invocation)
{
    const gchar *name= NULL;
    BusNameService *service;
    g_variant_get (parameters, "(&s)", &name);

    if (name == NULL ||
        !g_dbus_is_name (name) ||
        g_dbus_is_unique_name (name)) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
                        "'%s' is not a legal service name.", name);
        return;
    }

    if (!g_strcmp0 (name, "org.freedesktop.DBus") ||
        !g_strcmp0 (name, "org.freedesktop.IBus")) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
                        "Service name '%s' is owned by IBus.", name);
        return;
    }

    guint retval;
    service = g_hash_table_lookup (dbus->names, name);
    if (service == NULL) {
        retval = 2; /* DBUS_RELEASE_NAME_REPLY_NON_EXISTENT */
    }
    else {
        /* "ReleaseName" method removes the name in connection->names
         * and the connection owner.
         * bus_dbus_impl_connection_destroy_cb() removes all
         * connection->names and the connection owners.
         * See also comments in bus_dbus_impl_connection_destroy_cb().
         */
        if (bus_connection_remove_name (connection, name)) {
            BusConnectionOwner *owner =
                    bus_name_service_find_owner (service, connection);
            bus_name_service_remove_owner (service, owner, dbus);
            if (service->owners == NULL) {
                g_hash_table_remove (dbus->names, service->name);
            }
            bus_connection_owner_free (owner);
            retval = 1; /* DBUS_RELEASE_NAME_REPLY_RELEASED */
        }
        else {
            retval = 3; /* DBUS_RELEASE_NAME_REPLY_NOT_OWNER */
        }
    }
    g_dbus_method_invocation_return_value (invocation,
                                           g_variant_new ("(u)", retval));
}

static gboolean
start_service_timeout_cb (BusMethodCall *call)
{
    const gchar *name= NULL;
    guint32 flags;              /* currently not used in the D-Bus spec */
    g_variant_get (call->parameters, "(&su)", &name, &flags);

    g_dbus_method_invocation_return_error (call->invocation,
                    G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
                    "Timeout reached before starting %s", name);

    GList *p = g_list_find (call->dbus->start_service_calls, call);
    g_return_val_if_fail (p != NULL, FALSE);

    bus_method_call_free ((BusMethodCall *) p->data);
    call->dbus->start_service_calls =
        g_list_delete_link (call->dbus->start_service_calls, p);

    return FALSE;
}

/**
 * bus_dbus_impl_start_service_by_name:
 *
 * Implement the "StartServiceByName" method call of the
 * org.freedesktop.DBus interface.
 */
static void
bus_dbus_impl_start_service_by_name (BusDBusImpl           *dbus,
                                     BusConnection         *connection,
                                     GVariant              *parameters,
                                     GDBusMethodInvocation *invocation)
{
    const gchar *name= NULL;
    guint32 flags;              /* currently not used in the D-Bus spec */
    g_variant_get (parameters, "(&su)", &name, &flags);

    if (name == NULL ||
        !g_dbus_is_name (name) ||
        g_dbus_is_unique_name (name)) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
                        "'%s' is not a legal service name.", name);
        return;
    }

    if (!g_strcmp0 (name, "org.freedesktop.DBus") ||
        !g_strcmp0 (name, "org.freedesktop.IBus")) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
                        "Service name '%s' is owned by IBus.", name);
        return;
    }

    if (g_hash_table_lookup (dbus->names, name) != NULL) {
        g_dbus_method_invocation_return_value (invocation,
                        g_variant_new ("(u)",
                                       IBUS_BUS_START_REPLY_ALREADY_RUNNING));
        return;
    }

    BusComponent *component = bus_ibus_impl_lookup_component_by_name (
            BUS_DEFAULT_IBUS, name);

    if (component == NULL || !bus_component_start (component, g_verbose)) {
        g_dbus_method_invocation_return_error (invocation,
                        G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
                        "Failed to start %s", name);
        return;
    }

    BusMethodCall *call = bus_method_call_new (dbus,
                                               connection,
                                               parameters,
                                               invocation);
    call->timeout_id = g_timeout_add (g_gdbus_timeout,
                                      (GSourceFunc) start_service_timeout_cb,
                                      call);
    dbus->start_service_calls = g_list_prepend (dbus->start_service_calls,
                                                (gpointer) call);
}

/**
 * bus_dbus_impl_name_owner_changed:
 *
 * The function is called on name-owner-changed signal, typically when
 * g_signal_emit (dbus, NAME_OWNER_CHANGED) is called, and broadcasts the
 * signal to clients.
 */
static void
bus_dbus_impl_name_owner_changed (BusDBusImpl   *dbus,
                                  BusConnection *connection,
                                  gchar         *name,
                                  gchar         *old_owner,
                                  gchar         *new_owner)
{
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (name != NULL);
    g_assert (old_owner != NULL);
    g_assert (new_owner != NULL);

    GDBusMessage *message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
                                                       "org.freedesktop.DBus",
                                                       "NameOwnerChanged");
    g_dbus_message_set_sender (message, "org.freedesktop.DBus");

    /* set a non-zero serial to make libdbus happy */
    g_dbus_message_set_serial (message, 1);
    g_dbus_message_set_body (message,
                             g_variant_new ("(sss)",
                                            name, old_owner, new_owner));

    /* broadcast the message to clients that listen to the signal. */
    bus_dbus_impl_dispatch_message_by_rule (dbus, message, NULL);
    g_object_unref (message);
}

/**
 * bus_dbus_impl_name_lost:
 *
 * The function is called on name-lost signal, typically when g_signal_emit
 * (dbus, NAME_LOST) is called, and broadcasts the signal to clients.
 */
static void
bus_dbus_impl_name_lost (BusDBusImpl   *dbus,
                         BusConnection *connection,
                         gchar         *name)
{
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (name != NULL);

    GDBusMessage *message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
                                                       "org.freedesktop.DBus",
                                                       "NameLost");
    g_dbus_message_set_sender (message, "org.freedesktop.DBus");
    g_dbus_message_set_destination (
            message,
            bus_connection_get_unique_name (connection));

    /* set a non-zero serial to make libdbus happy */
    g_dbus_message_set_serial (message, 1);
    g_dbus_message_set_body (message,
                             g_variant_new ("(s)", name));

    bus_dbus_impl_forward_message (dbus, connection, message);
    g_object_unref (message);
}

/**
 * bus_dbus_impl_name_acquired:
 *
 * The function is called on name-acquired signal, typically when g_signal_emit
 * (dbus, NAME_ACQUIRED) is called, and broadcasts the signal to clients.
 */
static void
bus_dbus_impl_name_acquired (BusDBusImpl   *dbus,
                             BusConnection *connection,
                             gchar         *name)
{
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (name != NULL);

    GDBusMessage *message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
                                                       "org.freedesktop.DBus",
                                                       "NameAcquired");
    g_dbus_message_set_sender (message, "org.freedesktop.DBus");
    g_dbus_message_set_destination (
            message,
            bus_connection_get_unique_name (connection));

    /* set a non-zero serial to make libdbus happy */
    g_dbus_message_set_serial (message, 1);
    g_dbus_message_set_body (message,
                             g_variant_new ("(s)", name));

    bus_dbus_impl_forward_message (dbus, connection, message);
    g_object_unref (message);

    GList *p = dbus->start_service_calls;
    while (p != NULL) {
        BusMethodCall *call = p->data;
        const gchar *_name= NULL;
        guint32 flags;
        GList *next = p->next;

        g_variant_get (call->parameters, "(&su)", &_name, &flags);
        if (!g_strcmp0 (name, _name)) {
            g_dbus_method_invocation_return_value (call->invocation,
                            g_variant_new ("(u)",
                                           IBUS_BUS_START_REPLY_SUCCESS));
            bus_method_call_free ((BusMethodCall *) p->data);

            dbus->start_service_calls =
                g_list_delete_link (dbus->start_service_calls, p);
        }
        p = next;
    }
}

/**
 * bus_dbus_impl_service_method_call:
 *
 * Handle a D-Bus method call from a client. This function overrides an
 * implementation in src/ibusservice.c.
 */
static void
bus_dbus_impl_service_method_call (IBusService           *service,
                                   GDBusConnection       *dbus_connection,
                                   const gchar           *sender,
                                   const gchar           *object_path,
                                   const gchar           *interface_name,
                                   const gchar           *method_name,
                                   GVariant              *parameters,
                                   GDBusMethodInvocation *invocation)
{
    BusDBusImpl *dbus = BUS_DBUS_IMPL (service);

    if (g_strcmp0 (interface_name, "org.freedesktop.DBus") != 0) {
        IBUS_SERVICE_CLASS (bus_dbus_impl_parent_class)->service_method_call (
                                        (IBusService *) dbus,
                                        dbus_connection,
                                        sender,
                                        object_path,
                                        interface_name,
                                        method_name,
                                        parameters,
                                        invocation);
        return;
    }

    static const struct {
        const gchar *method_name;
        void (* method) (BusDBusImpl *,
                         BusConnection *,
                         GVariant *,
                         GDBusMethodInvocation *);
    } methods[] =  {
        /* DBus interface */
        { "Hello",              bus_dbus_impl_hello },
        { "ListNames",          bus_dbus_impl_list_names },
        { "NameHasOwner",       bus_dbus_impl_name_has_owner },
        { "GetNameOwner",       bus_dbus_impl_get_name_owner },
        { "ListQueuedOwners",   bus_dbus_impl_list_queued_owners },
        { "GetId",              bus_dbus_impl_get_id },
        { "AddMatch",           bus_dbus_impl_add_match },
        { "RemoveMatch",        bus_dbus_impl_remove_match },
        { "RequestName",        bus_dbus_impl_request_name },
        { "ReleaseName",        bus_dbus_impl_release_name },
        { "StartServiceByName", bus_dbus_impl_start_service_by_name },
    };

    gint i;
    for (i = 0; i < G_N_ELEMENTS (methods); i++) {
        if (!g_strcmp0 (method_name, methods[i].method_name)) {
            BusConnection *connection = bus_connection_lookup (dbus_connection);
            g_assert (BUS_IS_CONNECTION (connection));
            methods[i].method (dbus, connection, parameters, invocation);
            return;
        }
    }

    /* unsupported methods */
    g_dbus_method_invocation_return_error (
            invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD,
            "org.freedesktop.DBus does not support %s", method_name);
}

/**
 * bus_dbus_impl_service_get_property:
 *
 * Handle a D-Bus method call from a client. This function overrides an
 * implementation in src/ibusservice.c.
 */
static GVariant *
bus_dbus_impl_service_get_property (IBusService        *service,
                                    GDBusConnection    *connection,
                                    const gchar        *sender,
                                    const gchar        *object_path,
                                    const gchar        *interface_name,
                                    const gchar        *property_name,
                                    GError            **error)
{
    /* FIXME implement the function. */
    return IBUS_SERVICE_CLASS (bus_dbus_impl_parent_class)->
                service_get_property (service,
                                      connection,
                                      sender,
                                      object_path,
                                      interface_name,
                                      property_name,
                                      error);
}

/**
 * bus_dbus_impl_service_set_property:
 *
 * Handle a D-Bus method call from a client. This function overrides an
 * implementation in src/ibusservice.c.
 */
static gboolean
bus_dbus_impl_service_set_property (IBusService        *service,
                                    GDBusConnection    *connection,
                                    const gchar        *sender,
                                    const gchar        *object_path,
                                    const gchar        *interface_name,
                                    const gchar        *property_name,
                                    GVariant           *value,
                                    GError            **error)
{
    /* FIXME implement the function. */
    return IBUS_SERVICE_CLASS (bus_dbus_impl_parent_class)->
                service_set_property (service,
                                      connection,
                                      sender,
                                      object_path,
                                      interface_name,
                                      property_name,
                                      value,
                                      error);

}

/**
 * bus_dbus_impl_connection_filter_cb:
 * @returns: A GDBusMessage that will be processed by
 * bus_dbus_impl_service_method_call. NULL when dropping the message.
 *
 * A filter function that is called for all incoming and outgoing messages.
 * WARNING - this function could be called by the GDBus's worker thread. So
 * you should not call thread unsafe IBus functions.
 */
static GDBusMessage *
bus_dbus_impl_connection_filter_cb (GDBusConnection *dbus_connection,
                                    GDBusMessage    *message,
                                    gboolean         incoming,
                                    gpointer         user_data)
{
    g_assert (G_IS_DBUS_CONNECTION (dbus_connection));
    g_assert (G_IS_DBUS_MESSAGE (message));
    g_assert (BUS_IS_DBUS_IMPL (user_data));

    BusDBusImpl *dbus = (BusDBusImpl *) user_data;
    BusConnection *connection = bus_connection_lookup (dbus_connection);
    g_assert (connection != NULL);

    if (incoming) {
        /* is incoming message */

        /* get the destination aka bus name of the message. the destination is
         * set by g_dbus_connection_call_sync (for DBus and IBus messages
         * in the IBusBus class) or g_initable_new (for config and context
         * messages in the IBusProxy sub classes.) */
        const gchar *destination = g_dbus_message_get_destination (message);
        GDBusMessageType message_type =
                g_dbus_message_get_message_type (message);

        if (g_dbus_message_get_locked (message)) {
            /* If the message is locked, we need make a copy of it. */
            GDBusMessage *new_message = g_dbus_message_copy (message, NULL);
            g_assert (new_message != NULL);
            g_object_unref (message);
            message = new_message;
        }

        /* connection unique name as sender of the message*/
        g_dbus_message_set_sender (message,
                                   bus_connection_get_unique_name (connection));

        if (!g_strcmp0 (destination, IBUS_SERVICE_IBUS) ||
            !g_strcmp0 (destination, IBUS_NAME_OWNER_NAME)) {
            /* the message is sent to IBus service. messages from ibusbus and
             * ibuscontext may fall into this category. */
            switch (message_type) {
            case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
            case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
            case G_DBUS_MESSAGE_TYPE_ERROR:
                /* dispatch messages by match rule */
                bus_dbus_impl_dispatch_message_by_rule (dbus, message, NULL);
                return message;
            case G_DBUS_MESSAGE_TYPE_SIGNAL:
                /* notreached - signals should not be sent to IBus service.
                 * dispatch signal messages by match rule, just in case. */
                bus_dbus_impl_dispatch_message_by_rule (dbus, message, NULL);
                g_object_unref (message);
                /* return NULL since the service does not handle signals. */
                g_return_val_if_reached (NULL);
            default:
                g_object_unref (message);
                g_return_val_if_reached (NULL);
            }
        } else if (!g_strcmp0 (destination, "org.freedesktop.DBus")) {
            /* the message is sent to DBus service. messages from ibusbus may
             * fall into this category. */
            switch (message_type) {
            case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
            case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
            case G_DBUS_MESSAGE_TYPE_ERROR:
                /* dispatch messages by match rule */
                bus_dbus_impl_dispatch_message_by_rule (dbus, message, NULL);
                return message;
            case G_DBUS_MESSAGE_TYPE_SIGNAL:
                /* notreached - signals should not be sent to IBus service.
                 * dispatch signal messages by match rule, just in case. */
                bus_dbus_impl_dispatch_message_by_rule (dbus, message, NULL);
                g_object_unref (message);
                /* return NULL since the service does not handle signals. */
                g_return_val_if_reached (NULL);
            default:
                g_object_unref (message);
                /* return NULL since the service does not handle signals. */
                g_return_val_if_reached (NULL);
            }
        } else if (destination == NULL) {
            /* the message is sent to the current connection. communications
             * between ibus-daemon and panel/engines may fall into this
             * category since the panel/engine proxies created by ibus-daemon
             * does not set bus name. */
            switch (message_type) {
            case G_DBUS_MESSAGE_TYPE_SIGNAL:
            case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
            case G_DBUS_MESSAGE_TYPE_ERROR:
                /* dispatch messages by match rule */
                bus_dbus_impl_dispatch_message_by_rule (dbus, message, NULL);
                return message;
            case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
                g_warning ("Unknown method call: destination=NULL, path='%s', interface='%s', member='%s'",
                           g_dbus_message_get_path (message),
                           g_dbus_message_get_interface (message),
                           g_dbus_message_get_member (message));
                bus_dbus_impl_dispatch_message_by_rule (dbus, message, NULL);
                /* return the message, GDBus library will handle it */
                return message;
            default:
                /* notreached. */
                g_object_unref (message);
                /* return NULL since the service does not handle messages. */
                g_return_val_if_reached (NULL);
            }
        } else {
            /* The message is sent to an other service. Forward it.
             * For example, the config proxy class in src/ibusconfig.c sets its
             * "g-name" property (i.e. destination) to IBUS_SERVICE_CONFIG.
             */
            bus_dbus_impl_forward_message (dbus, connection, message);
            g_object_unref (message);
            return NULL;
        }
    } else {
        /* is outgoing message */
        if (g_dbus_message_get_sender (message) == NULL) {
            if (g_dbus_message_get_locked (message)) {
                GDBusMessage *new_message = g_dbus_message_copy (message, NULL);
                g_assert (new_message != NULL);
                g_object_unref (message);
                message = new_message;
            }
            /* If the message is sending from ibus-daemon directly,
             * we set the sender to org.freedesktop.DBus */
            g_dbus_message_set_sender (message, "org.freedesktop.DBus");
        }

        /* dispatch the outgoing message by rules. */
        bus_dbus_impl_dispatch_message_by_rule (dbus, message, connection);
        return message;
    }
}

BusDBusImpl *
bus_dbus_impl_get_default (void)
{
    static BusDBusImpl *dbus = NULL;

    if (dbus == NULL) {
        dbus = (BusDBusImpl *) g_object_new (
                BUS_TYPE_DBUS_IMPL,
                "object-path", "/org/freedesktop/DBus",
                NULL);
    }

    return dbus;
}

static void
bus_dbus_impl_connection_destroy_cb (BusConnection *connection,
                                     BusDBusImpl   *dbus)
{
    const gchar *unique_name = bus_connection_get_unique_name (connection);
    const GList *names = NULL;
    BusNameService *service = NULL;

    if (unique_name != NULL) {
        GList *p = dbus->start_service_calls;
        while (p != NULL) {
            BusMethodCall *call = p->data;
            GList *next = p->next;

            if (call->connection == connection) {
                bus_method_call_free ((BusMethodCall *) p->data);
                dbus->start_service_calls =
                    g_list_delete_link (dbus->start_service_calls, p);
            }
            p = next;
        }

        g_hash_table_remove (dbus->unique_names, unique_name);
        g_signal_emit (dbus,
                       dbus_signals[NAME_OWNER_CHANGED],
                       0,
                       connection,
                       unique_name,
                       unique_name,
                       "");
    }

    /* service->owners is the queue of connections.
     * If the connection is the primary owner and
     * bus_name_service_remove_owner() is called, the owner is removed
     * in the queue and the next owner will become the primary owner
     * automatically because service->owners is just a GSList.
     * If service->owners == NULL, it's good to remove the service in
     * dbus->names.
     * I suppose dbus->names are the global queue for every connection
     * and connection->names are the private queue of the connection.
     */
    names = bus_connection_get_names (connection);
    while (names != NULL) {
        const gchar *name = (const gchar *)names->data;
        service = (BusNameService *) g_hash_table_lookup (dbus->names,
                                                          name);
        g_assert (service != NULL);
        BusConnectionOwner *owner = bus_name_service_find_owner (service,
                connection);
        g_assert (owner != NULL);
        bus_name_service_remove_owner (service, owner, dbus);
        if (service->owners == NULL) {
            g_hash_table_remove (dbus->names, service->name);
        }
        bus_connection_owner_free (owner);
        names = names->next;
    }

    dbus->connections = g_list_remove (dbus->connections, connection);
    g_object_unref (connection);
}


gboolean
bus_dbus_impl_new_connection (BusDBusImpl   *dbus,
                              BusConnection *connection)
{
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (BUS_IS_CONNECTION (connection));
    g_assert (g_list_find (dbus->connections, connection) == NULL);

    g_object_ref_sink (connection);
    dbus->connections = g_list_append (dbus->connections, connection);

    bus_connection_set_filter (
            connection,
            bus_dbus_impl_connection_filter_cb,
            g_object_ref (dbus),
            g_object_unref);

    g_signal_connect (connection,
                      "destroy",
                      G_CALLBACK (bus_dbus_impl_connection_destroy_cb),
                      dbus);

    /* add introspection_xml[] (see above) to the connection. */
    ibus_service_register ((IBusService *) dbus,
                    bus_connection_get_dbus_connection (connection), NULL);
    GList *p;
    for (p = dbus->objects; p != NULL; p = p->next) {
        /* add all introspection xmls in dbus->objects to the connection. */
        ibus_service_register ((IBusService *) p->data,
                        bus_connection_get_dbus_connection (connection), NULL);
    }
    return TRUE;
}

BusConnection *
bus_dbus_impl_get_connection_by_name (BusDBusImpl    *dbus,
                                      const gchar    *name)
{
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (name != NULL);

    if (G_LIKELY (g_dbus_is_unique_name (name))) {
        return (BusConnection *) g_hash_table_lookup (dbus->unique_names, name);
    }
    else {
        BusNameService *service;
        BusConnectionOwner *owner;

        service = (BusNameService *) g_hash_table_lookup (dbus->names, name);
        if (service == NULL) {
            return NULL;
        }
        owner = bus_name_service_get_primary_owner (service);
        return owner ? owner->conn : NULL;
    }
}

typedef struct _BusForwardData BusForwardData;
struct _BusForwardData {
    GDBusMessage *message;
    BusConnection *sender_connection;
};

/**
 * bus_dbus_impl_forward_message_ible_cb:
 *
 * Process the first element of the dbus->forward_queue. The first element is
 * forwarded by g_dbus_connection_send_message.
 */
static gboolean
bus_dbus_impl_forward_message_idle_cb (BusDBusImpl   *dbus)
{
    g_return_val_if_fail (dbus->forward_queue != NULL, FALSE);

    g_mutex_lock (&dbus->forward_lock);
    BusForwardData *data = (BusForwardData *) dbus->forward_queue->data;
    dbus->forward_queue = g_list_delete_link (dbus->forward_queue,
                                              dbus->forward_queue);
    gboolean has_message = (dbus->forward_queue != NULL);
    g_mutex_unlock (&dbus->forward_lock);

    do {
        const gchar *destination =
                g_dbus_message_get_destination (data->message);
        BusConnection *dest_connection = NULL;
        if (destination != NULL)
            dest_connection = bus_dbus_impl_get_connection_by_name (
                    dbus,
                    destination);
        if (dest_connection != NULL) {
            /* FIXME workaround for gdbus. gdbus can not set an empty body
             * message with signature '()' */
            if (g_dbus_message_get_body (data->message) == NULL)
                g_dbus_message_set_signature (data->message, NULL);
            GError *error = NULL;
            gboolean retval = g_dbus_connection_send_message (
                      bus_connection_get_dbus_connection (dest_connection),
                      data->message,
                      G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL,
                      NULL, &error);
            if (retval)
                break;
            g_warning ("forward message failed:  %s.", error->message);
            g_error_free (error);
        }
        /* can not forward message */
        if (g_dbus_message_get_message_type (data->message)
                    != G_DBUS_MESSAGE_TYPE_METHOD_CALL) {
            /* skip non method messages */
            break;
        }

        /* reply an error message, if forward method call message failed. */
        GDBusMessage *reply_message = g_dbus_message_new_method_error (
                data->message,
                "org.freedesktop.DBus.Error.ServiceUnknown ",
                "The service name is '%s'.", destination);
        g_dbus_message_set_sender (reply_message, "org.freedesktop.DBus");
        g_dbus_message_set_destination (
                reply_message,
                bus_connection_get_unique_name (data->sender_connection));
        g_dbus_connection_send_message (
                bus_connection_get_dbus_connection (data->sender_connection),
                reply_message,
                G_DBUS_SEND_MESSAGE_FLAGS_NONE,
                NULL, NULL);
        g_object_unref (reply_message);
    } while (0);

    g_object_unref (data->message);
    g_object_unref (data->sender_connection);
    g_slice_free (BusForwardData, data);
    return has_message;
}

void
bus_dbus_impl_forward_message (BusDBusImpl   *dbus,
                               BusConnection *connection,
                               GDBusMessage  *message)
{
    /* WARNING - this function could be called by the GDBus's worker thread. So
     * you should not call thread unsafe IBus functions. */
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (BUS_IS_CONNECTION (connection));
    g_assert (G_IS_DBUS_MESSAGE (message));

    if (G_UNLIKELY (IBUS_OBJECT_DESTROYED (dbus)))
        return;
    /* FIXME the check above might not be sufficient. dbus object could be
     * destroyed in the main thread right after the check, though the
     * dbus structure itself would not be freed (since the dbus object is
     * ref'ed in bus_dbus_impl_new_connection.)
     * Anyway, it'd be better to investigate whether the thread safety issue
     * could cause any real problems.
     */

    BusForwardData *data = g_slice_new (BusForwardData);
    data->message = g_object_ref (message);
    data->sender_connection = g_object_ref (connection);

    g_mutex_lock (&dbus->forward_lock);
    gboolean is_running = (dbus->forward_queue != NULL);
    dbus->forward_queue = g_list_append (dbus->forward_queue, data);
    g_mutex_unlock (&dbus->forward_lock);

    if (!is_running) {
        g_idle_add_full (G_PRIORITY_DEFAULT,
                (GSourceFunc) bus_dbus_impl_forward_message_idle_cb,
                g_object_ref (dbus), (GDestroyNotify) g_object_unref);
        /* the idle callback function will be called from the ibus's main
         * thread. */
    }
}

static BusDispatchData *
bus_dispatch_data_new (GDBusMessage  *message,
                       BusConnection *skip_connection)
{
    BusDispatchData *data = g_slice_new (BusDispatchData);

    data->message = (GDBusMessage *) g_object_ref (message);
    if (skip_connection) {
        data->skip_connection =(BusConnection *) g_object_ref (skip_connection);
    }
    else {
        data->skip_connection = NULL;
    }
    return data;
}

static void
bus_dispatch_data_free (BusDispatchData *data)
{
    g_object_unref (data->message);
    if (data->skip_connection)
        g_object_unref (data->skip_connection);
    g_slice_free (BusDispatchData, data);
}

/**
 * bus_dbus_impl_dispatch_message_by_rule_idle_cb:
 *
 * Process the first element of the dbus->dispatch_queue.
 */
static gboolean
bus_dbus_impl_dispatch_message_by_rule_idle_cb (BusDBusImpl *dbus)
{
    g_return_val_if_fail (dbus->dispatch_queue != NULL, FALSE);

    if (G_UNLIKELY (IBUS_OBJECT_DESTROYED (dbus))) {
        /* dbus was destryed */
        g_mutex_lock (&dbus->dispatch_lock);
        g_list_free_full (dbus->dispatch_queue,
                          (GDestroyNotify) bus_dispatch_data_free);
        dbus->dispatch_queue = NULL;
        g_mutex_unlock (&dbus->dispatch_lock);
        /* return FALSE to prevent this callback to be called again. */
        return FALSE;
    }

    /* remove fist node */
    g_mutex_lock (&dbus->dispatch_lock);
    BusDispatchData *data = (BusDispatchData *) dbus->dispatch_queue->data;
    dbus->dispatch_queue = g_list_delete_link (dbus->dispatch_queue,
                                               dbus->dispatch_queue);
    gboolean has_message = (dbus->dispatch_queue != NULL);
    g_mutex_unlock (&dbus->dispatch_lock);

    GList *link = NULL;
    GList *recipients = NULL;

    /* check each match rules, and get recipients */
    for (link = dbus->rules; link != NULL; link = link->next) {
        GList *list = bus_match_rule_get_recipients (
                (BusMatchRule *) link->data,
                data->message);
        recipients = g_list_concat (recipients, list);
    }

    /* send message to each recipients */
    for (link = recipients; link != NULL; link = link->next) {
        BusConnection *connection = (BusConnection *) link->data;
        if (G_LIKELY (connection != data->skip_connection)) {
            g_dbus_connection_send_message (
                    bus_connection_get_dbus_connection (connection),
                    data->message,
                    G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL,
                    NULL, NULL);
        }
    }
    g_list_free (recipients);
    bus_dispatch_data_free (data);

    /* remove this idle callback if no message is left by returning FALSE. */
    return has_message;
}

void
bus_dbus_impl_dispatch_message_by_rule (BusDBusImpl     *dbus,
                                        GDBusMessage    *message,
                                        BusConnection   *skip_connection)
{
    /* WARNING - this function could be called by the GDBus's worker thread.
     * So you should not call thread unsafe IBus functions. */
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (message != NULL);
    g_assert (skip_connection == NULL || BUS_IS_CONNECTION (skip_connection));

    if (G_UNLIKELY (IBUS_OBJECT_DESTROYED (dbus)))
        return;
    /* FIXME - see the FIXME comment in bus_dbus_impl_forward_message. */

    static GQuark dispatched_quark = 0;
    if (dispatched_quark == 0) {
        dispatched_quark = g_quark_from_static_string ("DISPATCHED");
    }

    /* A message sent or forwarded by
     * bus_dbus_impl_dispatch_message_by_rule_idle_cb is also processed by the
     * filter callback.
     * If this message has been dispatched by rule, do nothing.
     */
    if (g_object_get_qdata ((GObject *) message, dispatched_quark) != NULL)
        return;
    g_object_set_qdata ((GObject *) message,
                        dispatched_quark,
                        GINT_TO_POINTER (1));

    /* append dispatch data into the queue, and start idle task if necessary */
    g_mutex_lock (&dbus->dispatch_lock);
    gboolean is_running = (dbus->dispatch_queue != NULL);
    dbus->dispatch_queue = g_list_append (dbus->dispatch_queue,
                    bus_dispatch_data_new (message, skip_connection));
    g_mutex_unlock (&dbus->dispatch_lock);
    if (!is_running) {
        g_idle_add_full (
                G_PRIORITY_DEFAULT,
                (GSourceFunc)bus_dbus_impl_dispatch_message_by_rule_idle_cb,
                g_object_ref (dbus),
                (GDestroyNotify)g_object_unref);
        /* the idle callback function will be called from the ibus's main
         * thread. */
    }
}

static void
bus_dbus_impl_object_destroy_cb (IBusService *object,
                                 BusDBusImpl *dbus)
{
    bus_dbus_impl_unregister_object (dbus, object);
}


gboolean
bus_dbus_impl_register_object (BusDBusImpl *dbus,
                               IBusService *object)
{
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (IBUS_IS_SERVICE (object));

    if (G_UNLIKELY (IBUS_OBJECT_DESTROYED (dbus))) {
        return FALSE;
    }

    dbus->objects = g_list_prepend (dbus->objects, g_object_ref (object));
    g_signal_connect (object, "destroy",
                      G_CALLBACK (bus_dbus_impl_object_destroy_cb), dbus);

    GList *p;
    for (p = dbus->connections; p != NULL; p = p->next) {
        GDBusConnection *connection =
                bus_connection_get_dbus_connection ((BusConnection *) p->data);
        if (connection != ibus_service_get_connection ((IBusService *) object))
            ibus_service_register ((IBusService *) object,
                                   bus_connection_get_dbus_connection (
                                           (BusConnection *) p->data),
                                   NULL);
    }
    return TRUE;
}

gboolean
bus_dbus_impl_unregister_object (BusDBusImpl *dbus,
                                 IBusService *object)
{
    g_assert (BUS_IS_DBUS_IMPL (dbus));
    g_assert (IBUS_IS_SERVICE (object));

    GList *p = g_list_find (dbus->objects, object);
    if (p == NULL)
        return FALSE;

    g_signal_handlers_disconnect_by_func (object,
                    G_CALLBACK (bus_dbus_impl_object_destroy_cb), dbus);
    dbus->objects = g_list_delete_link (dbus->objects, p);
    if (!IBUS_OBJECT_DESTROYED (object)) {
        GList *p;
        for (p = dbus->connections; p != NULL; p = p->next) {
            ibus_service_unregister ((IBusService *) object,
                                     bus_connection_get_dbus_connection (
                                             (BusConnection *) p->data));
        }
    }
    g_object_unref (object);

    return TRUE;
}

