/*

    Copyright (C) 2010  ABRT team

    Copyright (C) 2010  RedHat Inc

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along

    with this program; if not, write to the Free Software Foundation, Inc.,

    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#include <dbus/dbus.h>

#include "internal_abrt_dbus.h"

DBusConnection* g_dbus_conn;

/*

 * Helpers for building DBus messages

 */

//void store_bool(DBusMessageIter* iter, bool val)

//{

//    dbus_bool_t db = val;

//    if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &db))

//        die_out_of_memory();

//}

void store_int32(DBusMessageIter* iter, int32_t val)

{

    if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &val))

        die_out_of_memory();

}

void store_uint32(DBusMessageIter* iter, uint32_t val)

{

    if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val))

        die_out_of_memory();

}

void store_int64(DBusMessageIter* iter, int64_t val)

{

    if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_INT64, &val))

        die_out_of_memory();

}

void store_uint64(DBusMessageIter* iter, uint64_t val)

{

    if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &val))

        die_out_of_memory();

}

void store_string(DBusMessageIter* iter, const char* val)

{

    /* dbus daemon will simply close our connection if we send broken utf8.

     * Therefore we must never do that.

     */

    const char *sanitized = sanitize_utf8(val, /*ctrl:*/ 0);

    if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, sanitized ? &sanitized : &val))

        die_out_of_memory();

    free((char*)sanitized);

}

/*

 * Helpers for parsing DBus messages

 */

//int load_bool(DBusMessageIter* iter, bool& val)

//{

//    int type = dbus_message_iter_get_arg_type(iter);

//    if (type != DBUS_TYPE_BOOLEAN)

//        error_msg_and_die("%s expected in dbus message, but not found ('%c')", "bool", type);

//    dbus_bool_t db;

//    dbus_message_iter_get_basic(iter, &db);

//    val = db;

//    return dbus_message_iter_next(iter);

//}

int load_int32(DBusMessageIter* iter, int32_t *val)

{

    int type = dbus_message_iter_get_arg_type(iter);

    if (type != DBUS_TYPE_INT32)

    {

        error_msg("%s expected in dbus message, but not found ('%c')", "int32", type);

        return -1;

    }

    dbus_message_iter_get_basic(iter, val);

    return dbus_message_iter_next(iter);

}

int load_uint32(DBusMessageIter* iter, uint32_t *val)

{

    int type = dbus_message_iter_get_arg_type(iter);

    if (type != DBUS_TYPE_UINT32)

    {

        error_msg("%s expected in dbus message, but not found ('%c')", "uint32", type);

        return -1;

    }

    dbus_message_iter_get_basic(iter, val);

    return dbus_message_iter_next(iter);

}

int load_int64(DBusMessageIter* iter, int64_t *val)

{

    int type = dbus_message_iter_get_arg_type(iter);

    if (type != DBUS_TYPE_INT64)

    {

        error_msg("%s expected in dbus message, but not found ('%c')", "int64", type);

        return -1;

    }

    dbus_message_iter_get_basic(iter, val);

    return dbus_message_iter_next(iter);

}

int load_uint64(DBusMessageIter* iter, uint64_t *val)

{

    int type = dbus_message_iter_get_arg_type(iter);

    if (type != DBUS_TYPE_UINT64)

    {

        error_msg("%s expected in dbus message, but not found ('%c')", "uint64", type);

        return -1;

    }

    dbus_message_iter_get_basic(iter, val);

    return dbus_message_iter_next(iter);

}

int load_charp(DBusMessageIter* iter, const char** val)

{

    *val = NULL;

    int type = dbus_message_iter_get_arg_type(iter);

    if (type != DBUS_TYPE_STRING)

    {

        error_msg("%s expected in dbus message, but not found ('%c')", "string", type);

        return -1;

    }

    dbus_message_iter_get_basic(iter, val);

//log_warning("load_charp:'%s'", *val);

    return dbus_message_iter_next(iter);

}

/*

 * Glib integration machinery

 */

/* Callback: "glib says dbus fd is active" */

static gboolean handle_dbus_fd(GIOChannel *gio, GIOCondition condition, gpointer data)

{

    DBusWatch *watch = (DBusWatch*)data;

    log_debug("%s(gio, condition:%x [bits:IN/PRI/OUT/ERR/HUP...], data)", __func__, (int)condition);

    /* Notify the D-Bus library when a previously-added watch

     * is ready for reading or writing, or has an exception such as a hangup.

     */

    int glib_flags = (int)condition;

    int dbus_flags = 0;

    if (glib_flags & G_IO_IN)  dbus_flags |= DBUS_WATCH_READABLE;

    if (glib_flags & G_IO_OUT) dbus_flags |= DBUS_WATCH_WRITABLE;

    if (glib_flags & G_IO_ERR) dbus_flags |= DBUS_WATCH_ERROR;

    if (glib_flags & G_IO_HUP) dbus_flags |= DBUS_WATCH_HANGUP;

    /*

     * TODO:

     * If dbus_watch_handle returns FALSE, then the file descriptor

     * may still be ready for reading or writing, but more memory

     * is needed in order to do the reading or writing. If you ignore

     * the FALSE return, your application may spin in a busy loop

     * on the file descriptor until memory becomes available,

     * but nothing more catastrophic should happen.

     */

    dbus_watch_handle(watch, dbus_flags);

    while (dbus_connection_dispatch(g_dbus_conn) == DBUS_DISPATCH_DATA_REMAINS)

        log_debug("%s: more data to process, looping", __func__);

    return TRUE; /* "glib, do not remove this event source!" */

}

typedef struct watch_app_info_t

{

    GIOChannel *channel;

    guint event_source_id;

    bool watch_enabled;

} watch_app_info_t;

/* Callback: "dbus_watch_get_enabled() may return a different value than it did before" */

static void toggled_watch(DBusWatch *watch, void* data)

{

    log_debug("%s(watch:%p, data)", __func__, watch);

    watch_app_info_t* app_info = (watch_app_info_t*)dbus_watch_get_data(watch);

    if (dbus_watch_get_enabled(watch))

    {

        if (!app_info->watch_enabled)

        {

            app_info->watch_enabled = true;

            int dbus_flags = dbus_watch_get_flags(watch);

            int glib_flags = 0;

            if (dbus_flags & DBUS_WATCH_READABLE) glib_flags |= G_IO_IN;

            if (dbus_flags & DBUS_WATCH_WRITABLE) glib_flags |= G_IO_OUT;

            log_debug(" adding watch to glib main loop. dbus_flags:%x glib_flags:%x", dbus_flags, glib_flags);

            app_info->event_source_id = g_io_add_watch(app_info->channel, (GIOCondition)glib_flags, handle_dbus_fd, watch);

        }

        /* else: it was already enabled */

    }

    else

    {

        if (app_info->watch_enabled)

        {

            app_info->watch_enabled = false;

            /* does it free the hidden GSource too? */

            log_debug(" removing watch from glib main loop");

            g_source_remove(app_info->event_source_id);

        }

        /* else: it was already disabled */

    }

}

/* Callback: "libdbus needs a new watch to be monitored by the main loop" */

static dbus_bool_t add_watch(DBusWatch *watch, void* data)

{

    log_debug("%s(watch:%p, data)", __func__, watch);

    watch_app_info_t* app_info = (watch_app_info_t*)xzalloc(sizeof(*app_info));

    dbus_watch_set_data(watch, app_info, free);

    int fd = dbus_watch_get_unix_fd(watch);

    log_debug(" dbus_watch_get_unix_fd():%d", fd);

    app_info->channel = g_io_channel_unix_new(fd);

    /* _unconditionally_ adding it to event loop would be an error */

    toggled_watch(watch, data);

    return TRUE;

}

/* Callback: "libdbus no longer needs a watch to be monitored by the main loop" */

static void remove_watch(DBusWatch *watch, void* data)

{

    log_debug("%s()", __func__);

    watch_app_info_t* app_info = (watch_app_info_t*)dbus_watch_get_data(watch);

    if (app_info->watch_enabled)

    {

        app_info->watch_enabled = false;

        g_source_remove(app_info->event_source_id);

    }

    g_io_channel_unref(app_info->channel);

}

/* Callback: "libdbus needs a new timeout to be monitored by the main loop" */

static dbus_bool_t add_timeout(DBusTimeout *timeout, void* data)

{

    log_debug("%s()", __func__);

    return TRUE;

}

/* Callback: "libdbus no longer needs a timeout to be monitored by the main loop" */

static void remove_timeout(DBusTimeout *timeout, void* data)

{

    log_debug("%s()", __func__);

}

/* Callback: "dbus_timeout_get_enabled() may return a different value than it did before" */

static void timeout_toggled(DBusTimeout *timeout, void* data)

{

//seems to be never called, let's make it noisy

    error_msg_and_die("%s(): FIXME: some dbus machinery is missing here", __func__);

}

/* Callback: "DBusObjectPathVTable is unregistered (or its connection is freed)" */

static void unregister_vtable(DBusConnection *conn, void* data)

{

    log_debug("%s()", __func__);

}

/*

 * Initialization. Works as follows:

 *

 * we have a DBusConnection* (say, obtained with dbus_bus_get)

 * we call dbus_connection_set_watch_functions

 *  libdbus calls back add_watch(watch:0x2341090, data), this watch is for writing

 *   we call toggled_watch, but it finds that watch is not to be enabled yet

 *  libdbus calls back add_watch(watch:0x23410e0, data), this watch is for reading

 *   we call toggled_watch, it adds watch's fd to glib main loop with POLLIN

 *  (note: these watches are different objects, but they have the same fd)

 * we call dbus_connection_set_timeout_functions

 * we call dbus_connection_register_object_path

 *

 * Note: if user will later call dbus_bus_request_name(conn, ...):

 *  libdbus calls back add_timeout()

 *  libdbus calls back remove_timeout()

 *  note - no callback to timeout_toggled()!

 * (therefore there is no code yet in timeout_toggled (see above), it's not used)

 */

void attach_dbus_conn_to_glib_main_loop(DBusConnection* conn,

        const char* object_path,

        DBusHandlerResult (*message_received_func)(DBusConnection *conn, DBusMessage *msg, void* data)

) {

    if (g_dbus_conn)

        error_msg_and_die("Internal bug: can't connect to more than one dbus");

    g_dbus_conn = conn;

//do we need this? why?

//log_warning("dbus_connection_set_dispatch_status_function");

//    dbus_connection_set_dispatch_status_function(conn,

//                dispatch, /* void dispatch(DBusConnection *conn, DBusDispatchStatus new_status, void* data) */

//                NULL, /* data */

//                NULL /* free_data_function */

//    )

    log_debug("dbus_connection_set_watch_functions");

    if (!dbus_connection_set_watch_functions(conn,

                add_watch,

                remove_watch,

                toggled_watch,

                NULL, /* data */

                NULL /* free_data_function */

                )

    ) {

        die_out_of_memory();

    }

    log_debug("dbus_connection_set_timeout_functions");

    if (!dbus_connection_set_timeout_functions(conn,

                add_timeout,

                remove_timeout,

                timeout_toggled,

                NULL, /* data */

                NULL /* free_data_function */

                )

    ) {

        die_out_of_memory();

    }

    if (object_path && message_received_func)

    {

        /* Table */

        const DBusObjectPathVTable vtable = {

            /* .unregister_function = */ unregister_vtable,

            /* .message_function    = */ message_received_func,

        };

        log_debug("dbus_connection_register_object_path");

        if (!dbus_connection_register_object_path(conn,

                    object_path,

                    &vtable,

                    NULL /* data */

                    )

        ) {

            die_out_of_memory();

        }

    }

}