path: root/dbus.c

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- */
/*  Libnul - Another Utility Library
 *  Copyright (C) 2008  Søren Sandmann
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the 
 *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *  Boston, MA  02111-1307, USA.
 */
#include <stdarg.h>
#include <dbus/dbus.h>
#include <string.h>
#include "libnul.h"

#define INTROSPECT_INTERFACE "org.freedesktop.DBus.Introspectable"
#define INTROSPECT_METHOD "Introspect"

struct nul_dbus_service_t
{
    char *name;
    nul_ptr_t *objects;
    DBusConnection *connection;
    gboolean running;
    DBusBusType type;
};

struct nul_dbus_object_t
{
    char *name;
    nul_ptr_t data;
    nul_ptr_t *interfaces;
};

struct nul_dbus_interface_t
{
    char *name;
    nul_ptr_t *members;
};

struct nul_dbus_member_t
{
    char *                      name;
    
    /* For now only methods are supported, although
     * later we may also have properties and signals
     */
    nul_dbus_interface_t *	interface;	/* containing interface */
    
    nul_dbus_function_t		function;
    
    nul_ptr_t *                 parameters;
    int                         n_inputs;
    int                         n_outputs;

    nul_fun_def_t *		fun_def;
    nul_fun_def_t *		reply_fun;
};

struct nul_dbus_parameter_t
{
    char *		name;
    nul_dbus_type_t *		type;
    gboolean		out;
};

typedef enum
{
    INT32,
    UINT32,
    STRING
} Primitive;

struct nul_dbus_type_t
{
    Primitive type;
};

static void
process_watch (DBusWatch *watch, int flags)
{
    dbus_watch_handle (watch, flags);
}

static void
on_hangup (gpointer data)
{
    DBusWatch *watch = data;
    
    process_watch (watch, DBUS_WATCH_HANGUP);
}

static void
on_error (gpointer data)
{
    DBusWatch *watch = data;
    
    process_watch (watch, DBUS_WATCH_ERROR);
}

static void
on_read (gpointer data)
{
    GList *list = data;
    
    for (list = data; list != NULL; list = list->next)
    {
	DBusWatch *watch = list->data;
        
	if (dbus_watch_get_enabled (watch) &&
	    (dbus_watch_get_flags (watch) & DBUS_WATCH_READABLE))
	{
	    process_watch (watch, DBUS_WATCH_READABLE);
	}
    }
}

static void
on_write (gpointer data)
{
    GList *list = data;
    
    for (list = data; list != NULL; list = list->next)
    {
	DBusWatch *watch = list->data;
        
	if (dbus_watch_get_enabled (watch) &&
	    (dbus_watch_get_flags (watch) & DBUS_WATCH_WRITABLE))
	{
	    process_watch (watch, DBUS_WATCH_WRITABLE);
	}
    }
}

static void
update_fd (int fd)
{
    int enabled, flags;
    GList *watches, *list;
    
    watches = nul_fd_get_data (fd);
    
    enabled = FALSE;
    flags = 0;
    
    for (list = watches; list != NULL; list = list->next)
    {
	DBusWatch *watch = list->data;
        
	if (dbus_watch_get_enabled (watch))
	{
	    enabled = TRUE;
	    flags |= dbus_watch_get_flags (watch);
	}
    }
    
    if (enabled)
    {
	nul_fd_set_error_callback (fd, on_hangup);
	nul_fd_set_hangup_callback (fd, on_error);
        
	if (flags & DBUS_WATCH_READABLE)
	    nul_fd_set_read_callback (fd, on_read);
	else
	    nul_fd_set_read_callback (fd, NULL);
        
	if (flags & DBUS_WATCH_WRITABLE)
	    nul_fd_set_write_callback (fd, on_write);
	else
	    nul_fd_set_write_callback (fd, NULL);
    }
    else
    {
	nul_fd_set_error_callback (fd, NULL);
	nul_fd_set_hangup_callback (fd, NULL);
	nul_fd_set_read_callback (fd, NULL);
	nul_fd_set_write_callback (fd, NULL);
    }
}

static dbus_bool_t
add_watch (DBusWatch *watch, void *data)
{
    DBusConnection *connection = data;
    int fd = dbus_watch_get_unix_fd (watch);
    
    dbus_watch_set_data (watch, connection, NULL);
    
    /* DBus apparently will create multiple watches for
     * the same fd.
     */
    if (nul_fd_is_watched (fd))
    {
	GList *watches = nul_fd_get_data (fd);
        
	watches = g_list_prepend (watches, watch);
        
	nul_fd_set_data (fd, watches);
    }
    else
    {
	nul_fd_add_watch (fd, g_list_prepend (NULL, watch));
    }
    
    update_fd (fd);
    
    return TRUE;
}

static void
remove_watch (DBusWatch *watch, void *data)
{
    int fd = dbus_watch_get_unix_fd (watch);
    GList *watches = nul_fd_get_data (fd);
    
    watches = g_list_remove (watches, watch);
    
    if (!watches)
    {
	nul_fd_remove_watch (fd);
    }
    else
    {
	nul_fd_set_data (fd, watches);
	update_fd (fd);
    }
}

static void
toggle_watch (DBusWatch *watch, void *data)
{
    update_fd (dbus_watch_get_unix_fd (watch));
}

static gboolean
on_timeout (gpointer data)
{
    DBusTimeout *timeout = data;
    
    dbus_timeout_handle (timeout);
    
    return TRUE;
}

static dbus_bool_t
add_timeout (DBusTimeout *timeout, void *data)
{
    dbus_timeout_set_data (timeout, GINT_TO_POINTER (0), NULL);
    
    if (dbus_timeout_get_enabled (timeout))
    {
	int id;
        
	id = g_timeout_add (dbus_timeout_get_interval (timeout),
			    on_timeout, timeout);
        
	dbus_timeout_set_data (timeout, GINT_TO_POINTER (id), NULL);
    }
    
    return TRUE;
}

static void
remove_timeout (DBusTimeout *timeout, void *data)
{
    int id = GPOINTER_TO_INT (dbus_timeout_get_data (timeout));
    
    if (id)
    {
	g_source_remove (id);
        
	dbus_timeout_set_data (timeout, GINT_TO_POINTER (0), NULL);
    }
}

static void
toggle_timeout (DBusTimeout *timeout, void *data)
{
    remove_timeout (timeout, NULL);
    
    add_timeout (timeout, NULL);
}

static void
unregister_connection (DBusConnection *connection,
		       gpointer        data)
{
    /* nothing */
}

nul_ptr_t *free_us;
static int idle_handler;

static gboolean
do_free (gpointer data)
{
    nul_ptr_t *p;

    for (p = free_us; *p; ++p)
	g_free (*p);

    nul_ptr_array_free (free_us);

    free_us = nul_ptr_array_new ();
    
    idle_handler = 0;
    
    return FALSE;
}

static gpointer
idle_free (gpointer p)
{
    if (!free_us)
	free_us = nul_ptr_array_new ();
    
    free_us = nul_ptr_array_append (free_us, p);
    
    if (!idle_handler)
	idle_handler = g_idle_add (do_free, NULL);
    
    return p;
}

static const char *
make_signature (nul_dbus_type_t *type)
{
    switch (type->type)
    {
    case UINT32:
	return "u";
    case INT32:
	return "i";
    case STRING:
	return "s";
    }
    return "";
}

static const char *
introspect (nul_dbus_object_t *object)
{
    GString *xml = g_string_new (NULL);
    nul_ptr_t *p;
    
    g_string_append_printf (xml, "<node>\n");
    
    for (p = object->interfaces; *p; ++p)
    {
	nul_dbus_interface_t *interface = *p;
	nul_ptr_t *q;
	
	g_string_append_printf (
	    xml, "  <interface name=\"%s\">\n", interface->name);
        
	for (q = interface->members; *q; ++q)
	{
	    nul_dbus_member_t *member = *q;
	    nul_ptr_t *r;
            
	    g_string_append_printf (
		xml, "    <method name=\"%s\">\n", member->name);
            
	    for (r = member->parameters; *r; ++r)
	    {
		nul_dbus_parameter_t *parameter = *r;
                
		g_string_append_printf (
		    xml,
		    "      <arg name=\"%s\" direction=\"%s\" type=\"%s\"/>\n",
		    parameter->name,
		    parameter->out? "out" : "in",
		    make_signature (parameter->type));
	    }
            
	    g_string_append_printf (
		xml, "    </method>\n");
	}
        
	g_string_append_printf (xml, "  </interface>\n");
    }
    
    g_string_append_printf (xml, "</node>\n");
    
    return idle_free (g_string_free (xml, FALSE));
}

static gboolean
decode_message (DBusMessage           *message,
		int                    n_parameters,
		nul_dbus_parameter_t **parameters,
		nul_arg_t	      *args)
{
    gboolean has_args;
    int i;
    DBusMessageIter iter;
    const char *error;
    
    has_args = dbus_message_iter_init (message, &iter);

    /* FIXME: this function should make sure args are initialized
     * to NULL values when it fails
     */
    
    for (i = 0; i < n_parameters; ++i)
    {
	int dbus_type;
        
	if (!has_args)
	{
	    error = "Received too few arguments method\n";
	    goto fail;
	}
        
	dbus_type = dbus_message_iter_get_arg_type (&iter);
        
	switch (parameters[i]->type->type)
	{
	case UINT32:
	    if (dbus_type != DBUS_TYPE_UINT32)
	    {
		error = "Received wrong type, should be UINT32";
		goto fail;
	    }
	    dbus_message_iter_get_basic (&iter, &(args[i].v_uint32));
	    break;
            
	case INT32:
	    if (dbus_type != DBUS_TYPE_INT32)
	    {
		error = "Received wrong type, should be INT32";
		goto fail;
	    }
	    dbus_message_iter_get_basic (&iter, &(args[i].v_int32));
	    break;
            
	case STRING:
	    if (dbus_type != DBUS_TYPE_STRING)
	    {
		error = "Received wrong type, should be STRING";
		goto fail;
	    }
	    dbus_message_iter_get_basic (&iter, &(args[i].v_pointer));
	    break;
	}
        
	if (dbus_type == DBUS_TYPE_INVALID)
	    has_args = FALSE;
        
	dbus_message_iter_next (&iter);
    }
    
    return TRUE;
    
fail:
    g_print ("ERROR: %s\n", error);
    return FALSE;
}

static void
encode_message (DBusMessage *message,
		int n_parameters,
		nul_dbus_parameter_t **parameters,
		nul_arg_t *args)
{
    DBusMessageIter iter;
    int i;
    
    dbus_message_iter_init_append (message, &iter);
    
    for (i = 0; i < n_parameters; ++i)
    {
	nul_dbus_parameter_t *parameter = parameters[i];
        
	switch (parameter->type->type)
	{
	case UINT32:
	    dbus_message_iter_append_basic (
		&iter, DBUS_TYPE_UINT32, &(args[i].v_uint32));
	    break;
            
	case INT32:
	    dbus_message_iter_append_basic (
		&iter, DBUS_TYPE_INT32, &(args[i].v_int32));
	    break;
            
	case STRING:
	    dbus_message_iter_append_basic (
		&iter, DBUS_TYPE_STRING, &(args[i].v_pointer));
            
	    /* FIXME: it feels wrong that we are freeing data
	     * passed in by the user. Maybe we should just make the
	     * user idle_free it.
	     *
	     * Even better actually: Have a nul_dbus_return (...) that
	     * the user is expected to call.
	     */
	    g_free (args[i].v_pointer);
	    break;
	}
    }
}

static DBusHandlerResult
invoke (DBusConnection *connection,
	nul_dbus_object_t      *object,
	nul_dbus_member_t      *member,
	DBusMessage    *message)
{
    nul_arg_t *args = idle_free (
        g_new0 (nul_arg_t, nul_ptr_array_len (member->parameters) + 1));
    DBusMessage *error_reply;
    nul_arg_t result;
    int i;

    if (!member->function)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    
    /* Add the data pointer */
    args[0].v_pointer = object->data;

    if (!decode_message (
            message, member->n_inputs,
            (nul_dbus_parameter_t **)member->parameters, &(args[1])))
    {
	error_reply = dbus_message_new_error (
            message, DBUS_ERROR_FAILED, "FIXME: generate a real error");
	
	dbus_connection_send (connection, error_reply, NULL);
        
	return DBUS_HANDLER_RESULT_HANDLED;
    }
    
    for (i = member->n_inputs; member->parameters[i] != NULL; ++i)
    {
	nul_dbus_parameter_t *parameter = member->parameters[i];
        
	g_assert (parameter->out);
        
	args[i + 1].v_pointer = &(args[i + 1]);
    }
    
    result = nul_fun_def_invoke (member->fun_def, (nul_function_t)member->function, args);
    
    if (result.v_int32)
    {
	DBusMessage *reply = dbus_message_new_method_return (message);
        
	encode_message (reply,
			member->n_outputs,
			(nul_dbus_parameter_t **)&(member->parameters[member->n_inputs]),
			&(args[member->n_inputs + 1]));
        
	dbus_connection_send (connection, reply, NULL);
	dbus_message_unref (reply);
	return DBUS_HANDLER_RESULT_HANDLED;
    }
    else
    {
	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    }
    
}

static DBusHandlerResult
message_function (DBusConnection *connection,
		  DBusMessage *message,
		  gpointer data)
{
    const char *msg_path = dbus_message_get_path (message);
    const char *msg_interface = dbus_message_get_interface (message);
    const char *msg_member = dbus_message_get_member (message);
    nul_dbus_object_t *object = data;
    nul_ptr_t *p;
    
    g_assert (strcmp (object->name, msg_path) == 0);
    
    /* Introspection */
    if (strcmp (msg_interface, INTROSPECT_INTERFACE) == 0 &&
	strcmp (msg_member, INTROSPECT_METHOD) == 0)
    {
	DBusMessage *reply = dbus_message_new_method_return (message);
	const char *xml = introspect (object);
        
	dbus_message_append_args (reply,
				  DBUS_TYPE_STRING, &xml,
				  DBUS_TYPE_INVALID);
        
	dbus_connection_send (connection, reply, NULL);
        
	return DBUS_HANDLER_RESULT_HANDLED;
    }
    
    /* Normal method */
    for (p = object->interfaces; *p; ++p)
    {
	nul_dbus_interface_t *interface = *p;
	
	if (strcmp (msg_interface, interface->name) == 0)
	{
	    nul_ptr_t *q;
	    
	    for (q = interface->members; *q; ++q)
	    {
		nul_dbus_member_t *member = *q;
                
		if (strcmp (member->name, msg_member) == 0)
		    return invoke (connection, object, member, message);
	    }
	}
    }
    
    g_print ("got unknown message\n");
    
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

static const DBusObjectPathVTable vtable =
{
    unregister_connection,
    message_function,
    NULL,
};

static nul_ptr_t *
make_ptr_array (gpointer first, va_list parameters)
{
    nul_ptr_t *array = nul_ptr_array_new ();
    gpointer v;
    
    if (first)
    {
        array = nul_ptr_array_append (array, first);
	
	v = va_arg (parameters, gpointer);
	while (v)
	{
	    array = nul_ptr_array_append (array, v);

	    v = va_arg (parameters, gpointer);
	}
    }
    
    return array;
}

static dbus_int32_t idle_id_slot = -1;

static int
get_idle_id (DBusConnection *connection)
{
    if (idle_id_slot == -1)
        dbus_connection_allocate_data_slot (&idle_id_slot);

    return (int)dbus_connection_get_data (connection, idle_id_slot);
}

static void
set_idle_id (DBusConnection *connection, int id)
{
    if (idle_id_slot == -1)
        dbus_connection_allocate_data_slot (&idle_id_slot);

    dbus_connection_set_data (connection, idle_id_slot, (void *)id, NULL);
}

static gboolean
do_dispatch (gpointer data)
{
    DBusConnection *connection = data;

    while (dbus_connection_dispatch (connection) == DBUS_DISPATCH_DATA_REMAINS)
        ;

    set_idle_id (connection, 0);
    
    return FALSE;
}

static void
on_dispatch_status_changed (DBusConnection *connection,
                            DBusDispatchStatus new_status,
                            void *data)
{
    if (!get_idle_id (connection))
        set_idle_id (connection, g_idle_add (do_dispatch, connection));
}

static DBusConnection *
ensure_connection (DBusConnection **connection,
		   DBusBusType type,
		   DBusError *err)
{
    if (!*connection)
    {
	*connection = dbus_bus_get (type, err);
        
	if (*connection)
	{
            dbus_connection_set_dispatch_status_function (
                *connection,
                on_dispatch_status_changed, *connection, NULL);
            
	    dbus_connection_set_watch_functions (
		*connection,
		add_watch, remove_watch, toggle_watch,
		*connection, NULL);
            
	    dbus_connection_set_timeout_functions (
		*connection,
		add_timeout, remove_timeout, toggle_timeout,
		*connection, NULL);
	}

        do_dispatch (*connection);
    }
    
    return *connection;
}

static DBusConnection *
get_connection (DBusBusType type, DBusError *err)
{
    static DBusConnection *session_bus;
    static DBusConnection *system_bus;
    
    if (type == DBUS_BUS_SESSION)
	return ensure_connection (&session_bus, DBUS_BUS_SESSION, err);
    else if (type == DBUS_BUS_SYSTEM)
	return ensure_connection (&system_bus, DBUS_BUS_SYSTEM, err);
    else
	return NULL;
}

static nul_dbus_service_t *
make_service (const char *name,
	      DBusBusType type,
	      nul_dbus_object_t *object1,
	      va_list args)
{
    nul_dbus_service_t *service = g_new0 (nul_dbus_service_t, 1);
    
    service->name = g_strdup (name);
    
    service->objects = make_ptr_array (object1, args);
    
    service->type = type;
    
    service->connection = get_connection (type, NULL);
    
    if (!service->connection)
    {
	/* FIXME */
	return NULL;
    }
    
    return service;
}

nul_dbus_service_t *
nul_dbus_session_service (const char *name,
                          nul_dbus_object_t *object1,
                          ...)
{
    va_list args;
    nul_dbus_service_t *service;
    
    va_start (args, object1);
    
    service = make_service (name, DBUS_BUS_SESSION, object1, args);
    
    va_end (args);
    
    return service;
}

void
nul_dbus_service_add_object (nul_dbus_service_t *service,
                             nul_dbus_object_t *object)
{
    service->objects = nul_ptr_array_append (service->objects, object);

    dbus_connection_register_object_path (
        service->connection, object->name, &vtable, object);
}

gboolean
nul_dbus_service_start (nul_dbus_service_t *service)
{
    DBusError err = DBUS_ERROR_INIT;
    int i;
    int result;
    
    if (service->running)
	return FALSE;
    
    /* Possible flags:
     *
     * DBUS_NAME_FLAG_ALLOW_REPLACEMENT
     * DBUS_NAME_FLAG_REPLACE_EXISTING
     * DBUS_FLAG_DO_NOT_QUEUE
     */
    result = dbus_bus_request_name (service->connection,
				    service->name,
				    DBUS_NAME_FLAG_DO_NOT_QUEUE,
				    &err);
    
    if (result == -1)
    {
	/* FIXME: handle error */
	return FALSE;
    }
    
    switch (result)
    {
    case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
	g_assert_not_reached();
	break;
        
    case DBUS_REQUEST_NAME_REPLY_EXISTS:
	g_print ("Couldn't get name\n");
	return FALSE;
	break;
        
    case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
	g_print ("We own this already (?)\n");
	return FALSE;
	break;
        
    case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
	break;
    }
    
    /* Register objects */
    for (i = 0; service->objects[i] != NULL; ++i)
    {
	nul_dbus_object_t *object = service->objects[i];
        
	dbus_connection_register_object_path (
	    service->connection, object->name, &vtable, object);
    }
    
    service->running = TRUE;
    
    return TRUE;
}

void
nul_dbus_service_stop (nul_dbus_service_t *service)
{
    nul_ptr_t *p;
    
    if (!service->running)
	return;

    for (p = service->objects; *p != NULL; ++p)
    {
        nul_dbus_object_t *object = *p;

        dbus_connection_unregister_object_path (
            service->connection, object->name);
    }
    
    dbus_bus_release_name (service->connection, service->name, NULL);
    
    service->running = FALSE;
}

nul_dbus_object_t *
nul_dbus_object (const char *name,
                 gpointer data,
                 nul_dbus_interface_t *interface1,
                 ...)
{
    nul_dbus_object_t *object = g_new0 (nul_dbus_object_t, 1);
    va_list args;
    
    object->name = g_strdup (name);
    object->data = data;
    
    va_start (args, interface1);
    object->interfaces = make_ptr_array (interface1, args);
    va_end (args);
    
    /* Add introspection interface */
    
    /* Note: the actual introspection is special cased in invoke(), but we
     * still add it here so that introspection can treat the introspection
     * interface as any other interface
     */
    object->interfaces = nul_ptr_array_append (
        object->interfaces, nul_dbus_interface (
            "org.freedesktop.DBus.Introspectable",
            nul_dbus_method (
                "Introspect",
                (nul_dbus_function_t)NULL,
                nul_dbus_parameter_out (
                    "data",
                    nul_dbus_type_string()),
                NULL),
            NULL));
    
    return object;
}

nul_dbus_interface_t *
nul_dbus_interface (const char *name,
                    nul_dbus_member_t *member1,
                    ...)
{
    nul_dbus_interface_t *interface = g_new0 (nul_dbus_interface_t, 1);
    va_list parameters;
    nul_ptr_t *p;
    
    interface->name = g_strdup (name);
    
    va_start (parameters, member1);
    interface->members = make_ptr_array (member1, parameters);
    va_end (parameters);
    
    for (p = interface->members; *p; ++p)
    {
	nul_dbus_member_t *member = *p;
        
	member->interface = interface;
    }
    
    return interface;
}

static nul_dbus_type_t *
type_copy (const nul_dbus_type_t *type)
{
    nul_dbus_type_t *copy = g_new0 (nul_dbus_type_t, 1);
    
    copy->type = type->type;
    
    return copy;
}

static nul_type_t
invoke_type_from_nul_dbus_type (nul_dbus_type_t *t)
{
    switch (t->type)
    {
    case INT32:
	return NUL_TYPE_INT32;
    case UINT32:
	return NUL_TYPE_UINT32;
    case STRING:
	return NUL_TYPE_POINTER;
    }
    
    g_warning ("Unknown type %d\n", t->type);
    return -1;
}

static nul_fun_def_t *
make_fun_def (nul_dbus_member_t *member)
{
    nul_type_t *types;
    int i;
    
    types = idle_free (g_new0 (nul_type_t,
                               nul_ptr_array_len (member->parameters) + 1));
    types[0] = NUL_TYPE_POINTER; /* For object->data */

    for (i = 1; i < nul_ptr_array_len (member->parameters); ++i)
    {
	nul_dbus_parameter_t *par = member->parameters[i - 1];
        
	if (par->out)
	    types[i] = NUL_TYPE_POINTER;
	else
	    types[i] = invoke_type_from_nul_dbus_type (par->type);
    }
    
    return nul_fun_def_new (NUL_TYPE_INT,
			    nul_ptr_array_len (member->parameters) + 1,
			    types);
}

static nul_fun_def_t *
make_reply_fun (nul_dbus_member_t *member)
{
    nul_type_t *types;
    nul_ptr_t *p;
    int n;
    
    types = idle_free (g_new0 (nul_type_t,
                               nul_ptr_array_len (member->parameters) + 2));

    n = 0;
    for (p = member->parameters; *p; ++p)
    {
	nul_dbus_parameter_t *par = *p;
        
        g_assert (*p != NULL);
        g_assert (par != NULL);
        
	if (par->out)
	    types[n++] = invoke_type_from_nul_dbus_type (par->type);
    }
    
    types[n++] = NUL_TYPE_POINTER;	/* data */
    types[n++] = NUL_TYPE_POINTER;	/* const GError *err */
    
    return nul_fun_def_new (NUL_TYPE_VOID, n, types);
}

nul_dbus_member_t *
nul_dbus_method (const char *name,
                 nul_dbus_function_t function,
                 nul_dbus_parameter_t *parameter1,
                 ...)
{
    nul_dbus_member_t *member = g_new0 (nul_dbus_member_t, 1);
    va_list parameters;
    nul_ptr_t *p;
    
    member->name = g_strdup (name);
    member->function = function;
    
    va_start (parameters, parameter1);
    member->parameters = make_ptr_array ((nul_dbus_type_t *)parameter1, parameters);
    va_end (parameters);
    
    member->n_inputs = 0;
    member->n_outputs = 0;
    for (p = member->parameters; *p; ++p)
    {
	nul_dbus_parameter_t *par = *p;
        
        g_assert (*p != NULL);
        g_assert (par != NULL);
        
	if (par->out)
	{
	    member->n_outputs++;
	}
	else
	{
	    member->n_inputs++;
            
	    if (member->n_outputs)
	    {
		g_critical ("All output parameters must be specified after the input parameters");
		return NULL;
	    }
	}
    }
    
    member->fun_def = make_fun_def (member);
    member->reply_fun = make_reply_fun (member);
    
    return member;
}

static nul_dbus_parameter_t *
make_parameter (const char *name,
		const nul_dbus_type_t *type,
		gboolean out)
{
    nul_dbus_parameter_t *parameter = g_new0 (nul_dbus_parameter_t, 1);
    
    parameter->name = g_strdup (name);
    parameter->type = type_copy (type);
    parameter->out = out;
    
    return parameter;
}    

nul_dbus_parameter_t *
nul_dbus_parameter_in (const char *name,
                       const nul_dbus_type_t *type)
{
    return make_parameter (name, type, FALSE);
}

nul_dbus_parameter_t *
nul_dbus_parameter_out (const char *name,
                        const nul_dbus_type_t *type)
{
    return make_parameter (name, type, TRUE);
}

static nul_dbus_type_t *
make_type (nul_type_t t)
{
    nul_dbus_type_t *type = idle_free (g_new0 (nul_dbus_type_t, 1));
    
    type->type = t;
    
    return type;
}

const nul_dbus_type_t *
nul_dbus_type_int32 (void)
{
    return make_type (INT32);
}

const nul_dbus_type_t *
nul_dbus_type_uint32 (void)
{
    return make_type (UINT32);
}

const nul_dbus_type_t *
nul_dbus_type_string (void)
{
    return make_type (STRING);
}

typedef struct
{
    nul_dbus_function_t callback;
    gpointer data;
    nul_dbus_member_t *method;
} InvokeInfo;

static void
on_reply (DBusPendingCall *pending,
	  gpointer         data)
{
    InvokeInfo *info = data;
    int n_outputs = info->method->n_outputs;
    nul_arg_t *args = idle_free (g_new0 (nul_arg_t, n_outputs + 2));
    DBusMessage *reply;
    
    if (!info->callback)
	return;
    
    reply = dbus_pending_call_steal_reply (pending);
    
    if (!reply)
    {
	/* FIXME: can this happen? If it can, we should
	 * generate an error.
	 */
	return;
    }
    
    args[n_outputs].v_pointer = NULL; /* GError */
    if (!decode_message (reply,
			 n_outputs,
			 (nul_dbus_parameter_t **)&(info->method->parameters[info->method->n_inputs]),
			 args))
    {
	/* FIXME: generate an error into args[n_outputs + 1] */
	args[n_outputs].v_pointer = "ERR";
    }
    
    args[n_outputs + 1].v_pointer = info->data;
    
    nul_fun_def_invoke (info->method->reply_fun, (nul_function_t)info->callback, args);
}

/* Decodes strings like this:
 *
 * /org.gnome.ScreenSaver.Throttle
 *
 */
static gboolean
decode_method_desc (const char *method_desc,
		    char **object_path,
		    char **interface,
		    char **method)
{
    char *m;
    
    g_return_val_if_fail (method_desc != NULL, FALSE);
    g_return_val_if_fail (strchr (method_desc, '/') != NULL, FALSE);
    g_return_val_if_fail (strchr (method_desc, '.') != NULL, FALSE);
    
    m = strrchr (method_desc, '/');
    *object_path = g_strndup (method_desc, m - method_desc);
    method_desc = m + 1;
    
    m = strrchr (method_desc, '.');
    *interface = g_strndup (method_desc, m - method_desc);
    method_desc = m;
    
    *method = g_strdup (m + 1);
    return TRUE;
}

static nul_dbus_object_t *
find_object (nul_dbus_service_t *service, const char *name)
{
    nul_ptr_t *p;
    
    for (p = service->objects; *p != NULL; ++p)
    {
	nul_dbus_object_t *object = *p;
        
	if (strcmp (object->name, name) == 0)
	    return object;
    }
    
    return NULL;
}

static nul_dbus_interface_t *
find_interface (nul_dbus_object_t *object, const char *name)
{
    nul_ptr_t *p;
    
    for (p = object->interfaces; *p; ++p)
    {
	nul_dbus_interface_t *interface = *p;
        
	if (strcmp (interface->name, name) == 0)
	    return interface;
    }
    
    return NULL;
}

static nul_dbus_member_t *
find_member (nul_dbus_interface_t *interface, const char *name)
{
    nul_ptr_t *p;
    
    for (p = interface->members; *p; ++p)
    {
	nul_dbus_member_t *member = *p;
        
	if (strcmp (member->name, name) == 0)
	    return member;
    }
    
    return NULL;
}

void
nul_dbus_invoke (nul_dbus_service_t *service,
                 const char *method_desc,
                 nul_dbus_function_t callback,
                 gpointer data,
                 ...)
{
    char *object_str, *interface_str, *method_str;
    nul_dbus_object_t *object;
    nul_dbus_interface_t *interface;
    nul_dbus_member_t *method;
    DBusMessage *message;
    DBusMessageIter iter;
    DBusConnection *connection;
    va_list args;
    InvokeInfo *info;
    DBusPendingCall *pending;
    nul_ptr_t *p;

    g_return_if_fail (service != NULL);
    
    if (!decode_method_desc (method_desc, &object_str, &interface_str, &method_str))
	return;
    
    object = find_object (service, object_str);

    if (!object)
    {
        g_critical ("Object '%s' not found", object_str);
        return;
    }
    
    interface = find_interface (object, interface_str);

    if (!interface)
    {
        g_critical ("Interface '%s' not found", interface_str);
        return;
    }

    method = find_member (interface, method_str);
    
    if (!method)
    {
        g_critical ("Method '%s' not found", method_str);
        return;
    }

    message = dbus_message_new_method_call (
	service->name, object->name, interface->name, method->name);
    
    dbus_message_iter_init_append (message, &iter);
    
    va_start (args, data);
    
    for (p = method->parameters; *p; ++p)
    {
	nul_dbus_parameter_t *parameter = *p;
	int32_t i32;
	uint32_t u32;
	const char *s;
        
	if (parameter->out)
	    continue;
        
	switch (parameter->type->type)
	{
	case INT32:
	    i32 = va_arg (args, int32_t);
            
	    dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &i32);
	    break;
            
	case UINT32:
	    u32 = va_arg (args, uint32_t);
            
	    dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &u32);
	    break;
            
	case STRING:
	    s = va_arg (args, const char *);
            
	    dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &s);
	    break;
	}
    }
    
    va_end (args);
    
    connection = get_connection (service->type, NULL);
    
    dbus_connection_send_with_reply (connection, message, &pending, -1);
    if (!pending)
    {
	/* FIXME: generate an error and call the callback */
        
	/* Or alternatively, we should deal with getting disconnected,
	 * though it's not clear what we should do with that
	 */
    }
    else
    {
	info = g_new0 (InvokeInfo, 1);
        
	info->callback = callback;
	info->data = data;
	info->method = method;
        
	dbus_pending_call_set_notify (pending, on_reply, info, g_free);
    }
    
    dbus_message_unref (message);
}