/* -*- 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) 2008-2013 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)

{

    g_assert (service != NULL);

    g_assert (owner != NULL);

    g_assert (dbus != NULL);

    BusConnectionOwner *old = service->owners != NULL ?

            (BusConnectionOwner *)service->owners->data : NULL;

    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,

                   old != NULL ? 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;

    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;

        }

        if (dbus != NULL) {

            g_signal_emit (dbus,

                           dbus_signals[NAME_LOST],

                           0,

                           owner->conn,

                           service->name);

            if (_new != NULL) {

                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),

                    _new != NULL ? bus_connection_get_unique_name (_new->conn) : "");

        }

    }

    service->owners = g_slist_remove_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);

    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);

    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);

}

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_remove_all (dbus->unique_names);

    g_hash_table_remove_all (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", "org.freedesktop.IBus");

    /* 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") == 0 ||

            g_strcmp0 (name, "org.freedesktop.IBus") == 0)

            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") == 0 ||

        g_strcmp0 (name, "org.freedesktop.IBus") == 0) {

        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));

}