NNTPGrab

/* 

    Copyright (C) 2005-2010  Erik van Pienbroek

    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include 

#include 

#include 

#include 

#include 

#include "nntpgrab.h"

#include "nntpgrab_plugin.h"

#include "nntpgrab_utils.h"

#include "nntpgrab_internal.h"

#include "plugins.h"

#include "marshalers.h"

#include "config.h"

#include "download_queue.h"

#include "download_thread.h"

#include "configuration.h"

static GList *all_available_plugins = NULL;

static GHashTable *all_plugin_events = NULL;

static GList *all_connected_events = NULL;

static NGPlugin *function_plugin_data = NULL;

//static NGPlugin *event_plugin_data = NULL;

static Configuration *config = NULL;

struct _connected_event {

    NGPlugin *plugin_data;

    char event_name[128];

    guint event_name_hash;

    NGPluginFunction impl;

};

typedef struct _ng_plugin_function_or_event_ptr {

    char function_or_event_name[128];

    NGPluginFunction impl;

    GSignalCMarshaller marshaller;

    GType return_type;

    int num_params;

    GType *params;

    gboolean is_plugin_event;

} NgPluginFunctionOrEventPtr;

typedef struct _ng_plugin_class {

    GObjectClass parent;

} NGPluginClass;

G_DEFINE_TYPE(NGPlugin, ng_plugin, G_TYPE_OBJECT);

#define NG_TYPE_PLUGIN              (ng_plugin_get_type ())

#define NG_PLUGIN(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), NG_TYPE_PLUGIN, NGPlugin))

#define NG_PLUGIN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), NG_TYPE_PLUGIN, NGPluginClass))

#define IS_NG_PLUGIN(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), NG_TYPE_PLUGIN))

#define IS_NG_PLUGIN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), NG_TYPE_PLUGIN))

#define NG_PLUGIN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), NG_TYPE_PLUGIN, NGPluginClass))

NntpgrabCore *get_core(void);

static void plugins_set_emit_log_messages_to_plugins(ngboolean val);

static void config_changed(Configuration *obj, gpointer data);

static void plugin_loaded(NntpgrabCore *core, const char *plugin_name, gboolean is_persistent, gpointer data);

static NGList *

config_get_avail_servers_wrapper(void)

{

    g_return_val_if_fail(config != NULL, NULL);

    return (NGList*) configuration_get_avail_servers(config);

}

static void

config_free_avail_servers_wrapper(NGList *servers)

{

    g_return_if_fail(config != NULL);

    configuration_free_avail_servers(config, (GList *) servers);

}

static ngboolean

config_get_server_info_wrapper(const char *servername, NGConfigServer *server)

{

    NGConfigServer *tmp;

    g_return_val_if_fail(config != NULL, FALSE);

    g_return_val_if_fail(servername != NULL, FALSE);

    g_return_val_if_fail(server != NULL, FALSE);

    tmp = configuration_get_server_info(config, servername);

    if (!tmp) {

        return FALSE;

    }

    memcpy(server, tmp, sizeof(NGConfigServer));

    g_slice_free(NGConfigServer, tmp);

    return TRUE;

}

static ngboolean

config_add_server_wrapper(NGConfigServer new_server, char **errmsg)

{

    g_return_val_if_fail(config != NULL, FALSE);

    return configuration_add_server(config, new_server, errmsg);

}

static ngboolean

config_del_server_wrapper(const char *servername, char **errmsg)

{

    g_return_val_if_fail(servername != NULL, FALSE);

    g_return_val_if_fail(config != NULL, FALSE);

    return configuration_del_server(config, servername, errmsg);

}

static ngboolean

config_edit_server_wrapper(const char *servername, NGConfigServer server, char **errmsg)

{

    g_return_val_if_fail(config != NULL, FALSE);

    return configuration_edit_server(config, servername, server, errmsg);

}

static NGConfigOpts

config_get_opts_wrapper(void)

{

    NGConfigOpts nil;

    memset(&nil, 0, sizeof(nil));

    g_return_val_if_fail(config != NULL, nil);

    return configuration_get_opts(config);

}

static void

config_set_opts_wrapper(NGConfigOpts opts)

{

    g_return_if_fail(config != NULL);

    configuration_set_opts(config, opts);

}

static ngboolean

config_save_wrapper(char **errmsg)

{

    g_return_val_if_fail(config != NULL, FALSE);

    return configuration_save(config, errmsg);

}

static ngboolean

schedular_start_wrapper(void)

{

    g_return_val_if_fail(config != NULL, FALSE);

    return download_thread_start(config);

}

static ngboolean

schedular_stop_wrapper(const char *reason, ngboolean wait)

{

    if (wait) {

        return download_thread_stop(FALSE, reason);

    } else {

        download_thread_abort_without_waiting("%s", (reason ? reason : ""));

        return TRUE;

    }

}

static void

server_request_quit(void)

{

    NntpgrabCore *core = get_core();

    if (!core) {

        return;

    }

    g_signal_emit_by_name(core, "quit_requested");

}

static void

ng_plugin_init(NGPlugin *obj)

{

    obj->core_data = g_slice_new0(NGPluginCoreData);

    memset(&obj->core_funcs, 0, sizeof(obj->core_funcs));

    obj->core_funcs.config_get_avail_servers = config_get_avail_servers_wrapper;

    obj->core_funcs.config_free_avail_servers = config_free_avail_servers_wrapper;

    obj->core_funcs.config_get_server_info = config_get_server_info_wrapper;

    obj->core_funcs.config_add_server = config_add_server_wrapper;

    obj->core_funcs.config_del_server = config_del_server_wrapper;

    obj->core_funcs.config_edit_server = config_edit_server_wrapper;

    obj->core_funcs.config_get_opts = config_get_opts_wrapper;

    obj->core_funcs.config_set_opts = config_set_opts_wrapper;

    obj->core_funcs.config_save = config_save_wrapper;

    obj->core_funcs.config_get_config_folder = configuration_get_config_folder;

    obj->core_funcs.schedular_start = schedular_start_wrapper;

    obj->core_funcs.schedular_stop = schedular_stop_wrapper;

    obj->core_funcs.schedular_get_state = download_thread_get_state;

    obj->core_funcs.schedular_add_file_to_queue = download_queue_add_file_to_queue;

    obj->core_funcs.schedular_del_file_from_queue = download_queue_del_file_from_queue;

    obj->core_funcs.schedular_restart_file = download_queue_restart_file;

    obj->core_funcs.schedular_save_queue = download_queue_save;

    obj->core_funcs.schedular_foreach_file = download_queue_foreach_file;

    obj->core_funcs.schedular_move_file = download_queue_move_file;

    obj->core_funcs.schedular_move_collection = download_queue_move_collection;

    obj->core_funcs.schedular_mark_task_optional = download_queue_mark_task_optional;

    obj->core_funcs.plugins_get_avail_plugins = plugins_get_avail_plugins;

    obj->core_funcs.plugins_free_avail_plugins = plugins_free_avail_plugins;

    obj->core_funcs.plugins_get_plugin_info = plugins_get_plugin_info;

    obj->core_funcs.plugins_load_plugin = plugins_load_plugin_by_name;

    obj->core_funcs.plugins_unload_plugin = plugins_unload_plugin_by_name;

    obj->core_funcs.plugins_call_plugin_method = plugins_call_plugin_method;

    obj->core_funcs.plugins_set_persistent = plugins_set_persistent;

    obj->core_funcs.server_request_quit = server_request_quit;

    obj->core_funcs.set_emit_log_messages = plugins_set_emit_log_messages_to_plugins;

}

static void

ng_plugin_finalize(GObject *obj)

{

    NGPlugin *plugin_data = NG_PLUGIN(obj);

    GList *list;

    list = plugin_data->core_data->exported_functions;

    while (list) {

        g_slice_free(NgPluginFunctionOrEventPtr, list->data);

        list = g_list_next(list);

    }

    g_list_free(plugin_data->core_data->exported_functions);

    plugin_data->core_data->exported_functions = NULL;

    list = plugin_data->core_data->exported_events;

    while (list) {

        g_slice_free(NgPluginFunctionOrEventPtr, list->data);

        list = g_list_next(list);

    }

    g_list_free(plugin_data->core_data->exported_events);

    plugin_data->core_data->exported_events = NULL;

    list = plugin_data->core_data->required_functions_and_events;

    while (list) {

        g_free(list->data);

        list = g_list_next(list);

    }

    g_list_free(plugin_data->core_data->required_functions_and_events);

    plugin_data->core_data->required_functions_and_events = NULL;

    if (plugin_data->core_data->plugin) {

#ifndef WIN32

        /* This function causes a crash on Win32 environments */

        g_module_close(plugin_data->core_data->plugin);

#endif

        plugin_data->core_data->plugin = NULL;

    }

    g_slice_free(NGPluginCoreData, plugin_data->core_data);

    plugin_data->core_data = NULL;

}

static void

ng_plugin_class_init(NGPluginClass *klass)

{

    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

    gobject_class->finalize = ng_plugin_finalize;

}

static gboolean

bind_plugin_function(GModule *plugin, const char *function_name, gpointer *symbol)

{

    if (!g_module_symbol(plugin, function_name, symbol)) {

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, __FILE__ ":%i Unable to find function '%s' in plugin '%s'. Ignoring plugin", __LINE__, function_name, g_module_name(plugin));

        return FALSE;

    }

    return TRUE;

}

static void

init_internal_plugin(void)

{

    NGPlugin *plugin_data = g_object_new(NG_TYPE_PLUGIN, NULL);

    ng_plugin_set_name(plugin_data, "Internal");

    ng_plugin_set_author(plugin_data, "Erik van Pienbroek");

    ng_plugin_set_version(plugin_data, PACKAGE_VERSION);

    ng_plugin_set_url(plugin_data, "https://www.nntpgrab.nl");

    ng_plugin_set_description(plugin_data, "Plugin which provides internal NNTPGrab functions");

    ng_plugin_set_required_function(plugin_data, "decode_file");

    plugin_data->core_data->is_required = TRUE;

    all_available_plugins = g_list_append(all_available_plugins, plugin_data);

}

static void

try_to_init_plugin(const char *path, const char *filename)

{

    char *complete_path;

    GModule *plugin;

    NGPlugin *plugin_data;

#ifdef WIN32

#define EXT "-0.dll"

#else

#define EXT ".so"

#endif

    /* Verify the extension */

    if (!g_str_has_suffix(filename, EXT)) {

        /* Unknown extension, ignore */

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, __FILE__ ":%i file %s ignored", __LINE__, filename);

        return;

    }

    /* Try to load the plugin */

    complete_path = g_build_filename(path, filename, NULL);

    plugin = g_module_open(complete_path, G_MODULE_BIND_LOCAL);

    if (!plugin) {

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_WARNING, __FILE__ ":%i unable to load plugin %s: %s", __LINE__, complete_path, g_module_error());

        g_free(complete_path);

        return;

    }

    g_free(complete_path);

    /* Initialize the NGPlugin structure */

    plugin_data = g_object_new(NG_TYPE_PLUGIN, NULL);

    plugin_data->core_data->plugin = plugin;

    /* Mark plugins as required by default (if they turn out to be optional it will be updated automatically while determing the dependency order) */

    plugin_data->core_data->is_required = TRUE;

    /* Try to bind the functions which NNTPGrab plugins should export */

    if (!bind_plugin_function(plugin, "nntpgrab_plugin_initialize", (gpointer*) &plugin_data->core_data->init_func) ||

        !bind_plugin_function(plugin, "nntpgrab_plugin_load", (gpointer*) &plugin_data->core_data->load_func) ||

        !bind_plugin_function(plugin, "nntpgrab_plugin_unload", (gpointer*) &plugin_data->core_data->unload_func) ||

        !bind_plugin_function(plugin, "nntpgrab_plugin_destroy", (gpointer*) &plugin_data->core_data->destroy_func) ||

        !bind_plugin_function(plugin, "nntpgrab_plugin_can_unload", (gpointer*) &plugin_data->core_data->can_unload_func) ||

        !bind_plugin_function(plugin, "nntpgrab_plugin_get_version", (gpointer*) &plugin_data->core_data->get_version_func) ||

        !bind_plugin_function(plugin, "nntpgrab_plugin_call_plugin_method", (gpointer*) &plugin_data->core_data->call_plugin_method_func)) {

        g_object_unref(plugin_data);

        return;

    }

    /* Verify the API version */

    if (plugin_data->core_data->get_version_func() != NNTPGRAB_PLUGIN_API_VERSION) {

#ifdef WIN32

        /* The Win32 setup for NNTPGrab 0.6.90 contained an older version of the example plugin 

         * which causes a harmless error message. Suppress this error message with an ugly hack */

        if (strstr(g_module_name(plugin), "libnntpgrab_plugin_example-0.dll") && plugin_data->core_data->get_version_func() == 20091225) {

            /* Broken example plugin detected, ignore */

            g_object_unref(plugin_data);

            return;

        }

#endif

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_WARNING, __FILE__ ":%i unable to load plugin '%s' due to an API mismatch (plugin API version = %i, expected = %i)", __LINE__, g_module_name(plugin), plugin_data->core_data->get_version_func(), NNTPGRAB_PLUGIN_API_VERSION);

        g_object_unref(plugin_data);

        return;

    }

    /* Allow the plugin to indicate which functions and events are needed or exported */

    plugin_data->core_data->init_func(plugin_data);

    /* Plugin initialised succesfully */

    all_available_plugins = g_list_append(all_available_plugins, plugin_data);

    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, __FILE__ ":%i successfully loaded plugin '%s'", __LINE__, g_module_name(plugin));

}

static gboolean

load_plugin_base(NGPlugin *plugin_data, char **errmsg)

{

    g_return_val_if_fail(function_plugin_data != NULL, FALSE);

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(plugin_data->core_data->is_loaded == FALSE, FALSE);

    if (plugin_data->core_data->load_func &&

        !plugin_data->core_data->load_func(plugin_data, errmsg)) {

        return FALSE;

    }

    return TRUE;

}

static gboolean

load_plugin_functions(NGPlugin *plugin_data)

{

    GList *list;

    g_return_val_if_fail(function_plugin_data != NULL, FALSE);

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    /* Register all the functions */

    list = plugin_data->core_data->exported_functions;

    while (list) {

        NgPluginFunctionOrEventPtr *func_ptr = list->data;

        g_signal_newv(  func_ptr->function_or_event_name,

                        NG_TYPE_PLUGIN,

                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                        0,

                        NULL, NULL,

                        func_ptr->marshaller,

                        func_ptr->return_type,

                        func_ptr->num_params,

                        (func_ptr->num_params > 0) ? func_ptr->params : NULL);

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, __FILE__ ":%i Registered implementation for plugin function '%s'", __LINE__, func_ptr->function_or_event_name);

        g_signal_connect_swapped(function_plugin_data, func_ptr->function_or_event_name, G_CALLBACK(func_ptr->impl), plugin_data);

        list = g_list_next(list);

    }

    return TRUE;

}

static gboolean

load_plugin_events(NGPlugin *plugin_data)

{

    GList *list;

    int num_params;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    /* Register all the events */

    list = plugin_data->core_data->exported_events;

    while (list) {

        NgPluginFunctionOrEventPtr *func_ptr = list->data;

        if (func_ptr->is_plugin_event) {

            num_params = 2;

        } else {

            num_params = func_ptr->num_params;

        }

        g_signal_newv(  func_ptr->function_or_event_name,

                        NG_TYPE_PLUGIN,

                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                        0,

                        NULL, NULL,

                        func_ptr->marshaller,

                        func_ptr->return_type,

                        num_params,

                        (num_params > 0) ? func_ptr->params : NULL);

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, __FILE__ ":%i Registered event for plugin function '%s'", __LINE__, func_ptr->function_or_event_name);

        list = g_list_next(list);

    }

    return TRUE;

}

NGPlugin *

get_plugin_by_name(const char *name)

{

    GList *list = all_available_plugins;

    while (list) {

        NGPlugin *plugin_data = list->data;

        if (!strcmp(plugin_data->core_data->name, name)) {

            return plugin_data;

        }

        list = g_list_next(list);

    }

    /* No plugin found */

    return NULL;

}

static gboolean

unload_plugin(NGPlugin *plugin_data, gboolean forced, char **errmsg)

{

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    /* FIXME: Perform a dependency check */

    if (!plugin_data->core_data->is_loaded) {

        /* Plugin wasn't loaded. Assume a success */

        return TRUE;

    }

    if (plugin_data->core_data->can_unload_func && !plugin_data->core_data->can_unload_func(plugin_data, errmsg)) {

        if (!forced) {

            return FALSE;

        }

    }

    if (plugin_data->core_data->unload_func) {

        plugin_data->core_data->unload_func(plugin_data);

    }

    plugin_data->core_data->is_loaded = FALSE;

    /* FIXME: Implement proper un-registering of functions and events */

    nntpgrab_core_emit_plugin_unloaded(FALSE, plugin_data->core_data->name);

    return TRUE;

}

static void

destroy_plugin(NGPlugin *plugin_data)

{

    GList *list;

    char *errmsg = NULL;

    g_return_if_fail(plugin_data != NULL);

    ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, __FILE__ ":%i Request received to unload plugin '%s'", __LINE__, plugin_data->core_data->name);

    if (!unload_plugin(plugin_data, TRUE, &errmsg)) {

        ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, __FILE__ ":%i Unable to unload plugin '%s' due to an error: %s - Forcing unload anyway", __LINE__, plugin_data->core_data->name, errmsg);

        g_free(errmsg);

    }

    if (plugin_data->core_data->destroy_func) {

        plugin_data->core_data->destroy_func(plugin_data);

    }

    all_available_plugins = g_list_remove(all_available_plugins, plugin_data);

    list = all_connected_events;

    while (list) {

        struct _connected_event *connection = list->data;

        if (connection->plugin_data == plugin_data) {

            g_slice_free(struct _connected_event, connection);

            all_connected_events = g_list_remove(all_connected_events, connection);

            list = all_connected_events;

            continue;

        }

        list = g_list_next(list);

    }

    ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, __FILE__ ":%i Plugin '%s' was successfully unloaded", __LINE__, plugin_data->core_data->name);

    g_object_unref(plugin_data);

}

void

destroy_plugin_by_name(const char *name)

{

    GList *list = all_available_plugins;

    while (list) {

        NGPlugin *plugin_data = list->data;

        if (!strcmp(plugin_data->core_data->name, name)) {

            destroy_plugin(plugin_data);

            return;

        }

        list = g_list_next(list);

    }

    /* No plugin found */

}

void

plugins_initialize(void)

{

    g_return_if_fail(function_plugin_data == NULL);

    g_return_if_fail(all_available_plugins == NULL);

    g_return_if_fail(all_plugin_events == NULL);

    function_plugin_data = g_object_new(NG_TYPE_PLUGIN, NULL);

    all_plugin_events = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);

    init_internal_plugin();

}

gboolean

plugins_populate_list(char **errmsg)

{

    const char *filename;

    const char *path;

    GDir *dir;

    GError *err = NULL;

    g_return_val_if_fail(function_plugin_data != NULL, FALSE);

    g_return_val_if_fail(all_available_plugins != NULL, FALSE);

    g_return_val_if_fail(all_plugin_events != NULL, FALSE);

    if (g_getenv("NNTPGRAB_LIBDIR")) {

        path = g_getenv("NNTPGRAB_LIBDIR");

    } else {

        path = PLUGIN_DIR;

    }

    dir = g_dir_open(path, 0, &err);

    if (!dir) {

        if (errmsg) {

            *errmsg = g_strdup_printf(_("Unable to open plugin directory: %s"), err->message);

        }

        return FALSE;

    }

    while ((filename = g_dir_read_name(dir))) {

        try_to_init_plugin(path, filename);

    }

    g_dir_close(dir);

    return TRUE;

}

static const char *

ng_plugins_find_plugin_function_or_event(const char *function_or_event_name)

{

    GList *list_plugins = all_available_plugins;

    while (list_plugins) {

        NGPlugin *plugin_data = list_plugins->data;

        GList *list_functions = plugin_data->core_data->exported_functions;

        GList *list_events = plugin_data->core_data->exported_events;

        while (list_functions) {

            NgPluginFunctionOrEventPtr *func_ptr = list_functions->data;

            if (!strcmp(function_or_event_name, func_ptr->function_or_event_name)) {

                return plugin_data->core_data->name;

            }

            list_functions = g_list_next(list_functions);

        }

        while (list_events) {

            NgPluginFunctionOrEventPtr *func_ptr = list_events->data;

            if (!strcmp(function_or_event_name, func_ptr->function_or_event_name)) {

                return plugin_data->core_data->name;

            }

            list_events = g_list_next(list_events);

        }

        list_plugins = g_list_next(list_plugins);

    }

    /* No plugin found providing the given function */

    return NULL;

}

static void

ng_plugins_add_dependency(NGPluginCoreData *core_data, const char *plugin_name)

{

    GList *list = core_data->dependencies;

    /* Is this dependency already registered? */

    while (list) {

        char *name = list->data;

        if (!strcmp(name, plugin_name)) {

            /* Yes it is, bail out */

            return;

        }

        list = g_list_next(list);

    }

    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Added dependency on plugin '%s' to plugin '%s'", plugin_name, core_data->name);

    /* Dependency not known yet, add it to the list */

    core_data->dependencies = g_list_append(core_data->dependencies, (char*) plugin_name);

}

static gboolean

test_all_plugin_deps_found(GList *ordered_list, NGPlugin *plugin_data)

{

    GList *list_deps = plugin_data->core_data->dependencies;

    while (list_deps) {

        const char *plugin_name = list_deps->data;

        GList *list_loaded = ordered_list;

        gboolean dep_found = FALSE;

        while (list_loaded) {

            NGPlugin *plugin_data_loaded = list_loaded->data;

            if (!strcmp(plugin_data_loaded->core_data->name, plugin_name)) {

                /* Dependency of this plugin was already processed */

                dep_found = TRUE;

                break;

            }

            list_loaded = g_list_next(list_loaded);

        }

        if (!dep_found) {

            return FALSE;

        }

        list_deps = g_list_next(list_deps);

    }

    /* All dependencies are already resolved */

    return TRUE;

}

static gboolean

test_if_plugin_is_needed_by_another_plugin(NGPlugin *plugin_to_test)

{

    GList *list = all_available_plugins;

    g_return_val_if_fail(plugin_to_test != NULL, FALSE);

    /* Ignore the 'Internal' plugin as it always needs to be loaded */

    if (!strcmp(plugin_to_test->core_data->name, "Internal")) {

        return TRUE;

    }

    /* Traverse the list with plugins in order to find out if the 'plugin_to_test' isn't required by anything else */

    while (list) {

        NGPlugin *plugin_data = (NGPlugin*) list->data;

        GList *list_deps = plugin_data->core_data->dependencies;

        while (list_deps) {

            const char *plugin_name = (const char*) list_deps->data;

            if (!strcmp(plugin_name, plugin_to_test->core_data->name)) {

                ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Plugin '%s' is required by plugin '%s'", plugin_to_test->core_data->name, plugin_data->core_data->name);

                plugin_to_test->core_data->is_required = TRUE;

                return TRUE;

            }

            list_deps = g_list_next(list_deps);

        }

        list = g_list_next(list);

    }

    plugin_to_test->core_data->is_required = FALSE;

    return FALSE;

}

static int

calculate_num_required_plugins(void)

{

    GList *list = all_available_plugins;

    int count = 0;

    while (list) {

        NGPlugin *plugin_data = list->data;

        if (plugin_data->core_data->is_required) {

            count++;

        }

        list = g_list_next(list);

    }

    return count;

}

static void

log_dependency_tree(GList *ordered_list)

{

    char list_str[1024];

    GList *list;

    memset(&list_str, 0, sizeof(list_str));

    list = ordered_list;

    while (list) {

        NGPlugin *plugin_data = list->data;

        if (strlen(list_str) > 0) {

            strncat(list_str, ", ", sizeof(list_str) - strlen(list_str) - 1);

            strncat(list_str, plugin_data->core_data->name, sizeof(list_str) - strlen(list_str) - 1);

        } else {

            strncpy(list_str, plugin_data->core_data->name, sizeof(list_str));

        }

        list = g_list_next(list);

    }

    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Ordered list = %s", list_str);

    memset(&list_str, 0, sizeof(list_str));

    list = all_available_plugins;

    while (list) {

        NGPlugin *plugin_data = list->data;

        if (strlen(list_str) > 0) {

            strncat(list_str, ", ", sizeof(list_str) - strlen(list_str) - 1);

            strncat(list_str, plugin_data->core_data->name, sizeof(list_str) - strlen(list_str) - 1);

        } else {

            strncpy(list_str, plugin_data->core_data->name, sizeof(list_str));

        }

        list = g_list_next(list);

    }

    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "All available plugins = %s", list_str);

}

static GList *

plugins_generate_dependency_tree(gboolean only_load_required_plugins, char **errmsg)

{

    GList *ordered_list = NULL;

    GList *list_plugins = all_available_plugins;

    int expected_length;

    int num_iterations = 0;

    /* Find out which plugins depend on each other */

    while (list_plugins) {

        NGPlugin *plugin_data = list_plugins->data;

        /* Find out which plugins offer the functions which this plugin requires */

        GList *list_funcs_and_events_required = plugin_data->core_data->required_functions_and_events;

        while (list_funcs_and_events_required) {

            char *function_or_event_name = list_funcs_and_events_required->data;

            const char *plugin_name;

            plugin_name = ng_plugins_find_plugin_function_or_event(function_or_event_name);

            if (!plugin_name) {

                plugin_data->core_data->initialisation_error = TRUE;

                snprintf(plugin_data->core_data->initialisation_errmsg, sizeof(plugin_data->core_data->initialisation_errmsg) - 1, _("Unable to find a plugin which offers the function or event '%s' (required by the plugin '%s')"), function_or_event_name, plugin_data->core_data->name);

                ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_FATAL, "%s", plugin_data->core_data->initialisation_errmsg);

                break;

            }

            ng_plugins_add_dependency(plugin_data->core_data, plugin_name);

            list_funcs_and_events_required = g_list_next(list_funcs_and_events_required);

        }

        list_plugins = g_list_next(list_plugins);

    }

    /* Find out the order in which we need to load plugins */

    expected_length = g_list_length(all_available_plugins);

    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Expected length of ordered list initially set to %i", expected_length);

    while (g_list_length(ordered_list) != expected_length) {

        /* Keep on traversing the list of plugins until the order is fully known */

        list_plugins = all_available_plugins;

        gboolean dep_added = FALSE;

        num_iterations++;

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Iteration %i in dependency resolving", num_iterations);

        while (list_plugins) {

            NGPlugin *plugin_data = list_plugins->data;

            if (!plugin_data->core_data->initialisation_error &&

                !g_list_find(ordered_list, plugin_data) &&

                test_all_plugin_deps_found(ordered_list, plugin_data)) {

                if (only_load_required_plugins && !test_if_plugin_is_needed_by_another_plugin(plugin_data)) {

                    list_plugins = g_list_next(list_plugins);

                    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Marked plugin '%s' as optional plugin", plugin_data->core_data->name);

                    expected_length = calculate_num_required_plugins();

                    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Expected length of ordered list updated to %i", expected_length);

                    continue;

                }

                ordered_list = g_list_append(ordered_list, plugin_data);

                dep_added = TRUE;

                ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "Added plugin '%s' to the ordered_list", plugin_data->core_data->name);

            }

            list_plugins = g_list_next(list_plugins);

        }

        if (!dep_added && g_list_length(ordered_list) != expected_length) {

            /* Endless loop detected! */

            if (errmsg) {

                *errmsg = g_strdup_printf(__FILE__ ":%i Unable to resolve dependency order", __LINE__);

            }

            ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_FATAL, "Unable to resolve dependency order");

            log_dependency_tree(ordered_list);

            return NULL;

        }

    }

    log_dependency_tree(ordered_list);

    return ordered_list;

}

gboolean

plugins_load_plugin(NGPlugin *plugin_data, char **errmsg)

{

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, __FILE__ ":%i Request received to load plugin '%s'", __LINE__, plugin_data->core_data->name);

    /* TODO: Test if all dependencies are already loaded */

    if (plugin_data->core_data->is_loaded) {

        if (errmsg) {

            *errmsg = g_strdup_printf(_("Plugin is already loaded"));

        }

        return FALSE;

    }

    if (!load_plugin_base(plugin_data, errmsg) ||

        !load_plugin_functions(plugin_data) ||

        !load_plugin_events(plugin_data)) {

        ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, __FILE__ ":%i Loading of plugin '%s' FAILED: %s", __LINE__, plugin_data->core_data->name, *errmsg);

        return FALSE;

    } else {

        plugin_data->core_data->is_loaded = TRUE;

        nntpgrab_core_emit_plugin_loaded(FALSE, plugin_data->core_data->name, TRUE);

        ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, __FILE__ ":%i Plugin '%s' successfully loaded", __LINE__, plugin_data->core_data->name);

        return TRUE;

    }

}

gboolean

plugins_load(NntpgrabCore *core, Configuration *configuration, char **errmsg)

{

    GList *list = NULL;

    GList *ordered_list = NULL;

    g_return_val_if_fail(configuration != NULL, FALSE);

    config = configuration;

    g_signal_connect(config, "config_changed", G_CALLBACK(config_changed), NULL);

    g_signal_connect(core, "plugin_loaded", G_CALLBACK(plugin_loaded), NULL);

    config_changed(config, NULL);

    list = ordered_list = plugins_generate_dependency_tree(TRUE, errmsg);

    if (!ordered_list) {

        return FALSE;

    }

    while (list) {

        NGPlugin *plugin_data = list->data;

        if (!plugins_load_plugin(plugin_data, errmsg)) {

            g_list_free(ordered_list);

            return FALSE;

        }

        list = g_list_next(list);

    }

    g_list_free(ordered_list);

    /* As we have a circular dependency between the Internal plugin and the PAR2 plugin we need to create the link manually here */

    ng_plugin_connect_event(NULL, "par2_repair_failure", NG_PLUGIN_FUNCTION(download_queue_on_par2_repair_failure), NULL);

    return TRUE;

}

void

plugins_destroy(void)

{

    GList *list = NULL;

    GList *ordered_list = NULL;

    g_return_if_fail(function_plugin_data != NULL);

    g_return_if_fail(all_plugin_events != NULL);

    /* Perform a cleanup in reverse order */

    list = ordered_list = g_list_reverse(plugins_generate_dependency_tree(FALSE, NULL));

    if (!ordered_list) {

        return;

    }

    while (list) {

        NGPlugin *plugin_data = list->data;

        destroy_plugin(plugin_data);

        list = g_list_next(list);

    }

    g_list_free(ordered_list);

    ordered_list = NULL;

    g_object_unref(function_plugin_data);

    function_plugin_data = NULL;

    g_hash_table_destroy(all_plugin_events);

    all_plugin_events = NULL;

    g_list_free(all_available_plugins);

    all_available_plugins = NULL;

}

ngboolean

ng_plugin_get_is_loaded(NGPlugin *plugin_data)

{

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    if (plugin_data->core_data && plugin_data->core_data->is_loaded) {

        return TRUE;

    } else {

        return FALSE;

    }

}

void ng_plugin_set_name(NGPlugin *plugin_data, const char *name)

{

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(name != NULL);

    strncpy(plugin_data->core_data->name, name, sizeof(plugin_data->core_data->name) - 1);

}

void ng_plugin_set_version(NGPlugin *plugin_data, const char *version)

{

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(version != NULL);

    strncpy(plugin_data->core_data->version, version, sizeof(plugin_data->core_data->version) - 1);

}

void ng_plugin_set_author(NGPlugin *plugin_data, const char *author)

{

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(author != NULL);

    strncpy(plugin_data->core_data->author, author, sizeof(plugin_data->core_data->author) - 1);

}

void ng_plugin_set_url(NGPlugin *plugin_data, const char *url)

{

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(url != NULL);

    strncpy(plugin_data->core_data->url, url, sizeof(plugin_data->core_data->url) - 1);

}

void ng_plugin_set_description(NGPlugin *plugin_data, const char *description)

{

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(description != NULL);

    strncpy(plugin_data->core_data->description, description, sizeof(plugin_data->core_data->description) - 1);

}

static ngboolean

ng_plugin_register_function_or_event_va(GList **exported_list, NGPlugin *plugin_data, const char *function_or_event_name, gboolean is_plugin_event, NGPluginFunction impl, GSignalCMarshaller marshaller, GType return_type, int num_params, va_list args)

{

    NgPluginFunctionOrEventPtr *func_ptr;

    int i;

    int num_params_real;

    g_return_val_if_fail(exported_list != NULL, FALSE);

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(plugin_data->core_data != NULL, FALSE);

    g_return_val_if_fail(function_or_event_name != NULL, FALSE);

    g_return_val_if_fail(num_params >= 0, FALSE);

    if (is_plugin_event) {

        num_params_real = 2;

    } else {

        num_params_real = num_params;

    }

    func_ptr = g_slice_new0(NgPluginFunctionOrEventPtr);

    strncpy(func_ptr->function_or_event_name, function_or_event_name, sizeof(func_ptr->function_or_event_name) - 1);

    func_ptr->impl = impl;

    func_ptr->marshaller = marshaller;

    func_ptr->return_type = return_type;

    func_ptr->num_params = num_params;

    func_ptr->params = g_slice_alloc0(sizeof(GType) * num_params_real);

    func_ptr->is_plugin_event = is_plugin_event;

    for (i = 0; i < num_params_real; i++) {

        func_ptr->params[i] = va_arg(args, GType);

    }

    *exported_list = g_list_append(*exported_list, func_ptr);

    return TRUE;

}

ngboolean ng_plugin_register_internal_function(const char *function_name, NGPluginFunction impl, GSignalCMarshaller marshaller, GType return_type, int num_params, ...)

{

    GList *list = all_available_plugins;

    while (list) {

        NGPlugin *plugin_data = list->data;

        if (!strcmp(plugin_data->core_data->name, "Internal")) {

            char function_name_new[128];

            ngboolean ret;

            va_list ap;

            memset(function_name_new, 0, sizeof(function_name_new));

            strcpy(function_name_new, "function_");

            strncat(function_name_new, function_name, sizeof(function_name_new) - strlen(function_name_new) - 1);

            va_start(ap, num_params);

            ret = ng_plugin_register_function_or_event_va(&plugin_data->core_data->exported_functions, plugin_data, function_name_new, FALSE, impl, marshaller, return_type, num_params, ap);

            va_end(ap);

            return ret;

        }

        list = g_list_next(list);

    }

    /* Internal plugin not found */

    return FALSE;

}

ngboolean ng_plugin_register_function(NGPlugin *plugin_data, const char *function_name, NGPluginFunction impl, GSignalCMarshaller marshaller, GType return_type, int num_params, ...)

{

    ngboolean ret;

    va_list ap;

    char function_name_new[128];

    memset(function_name_new, 0, sizeof(function_name_new));

    strcpy(function_name_new, "function_");

    strncat(function_name_new, function_name, sizeof(function_name_new) - strlen(function_name_new) - 1);

    va_start(ap, num_params);

    ret = ng_plugin_register_function_or_event_va(&plugin_data->core_data->exported_functions, function_plugin_data, function_name_new, FALSE, impl, marshaller, return_type, num_params, ap);

    va_end(ap);

    return ret;

}

static void

ng_plugin_set_required_function_or_event(NGPlugin *plugin_data, const char *function_or_event_name)

{

    GList *list;

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(plugin_data->core_data != NULL);

    g_return_if_fail(function_or_event_name != NULL);

    /* Is this function already marked as required? */

    list = plugin_data->core_data->required_functions_and_events;

    while (list) {

        const char *name = list->data;

        if (!strcmp(function_or_event_name, name)) {

            ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, __FILE__ ":%i unable to mark function of event '%s' for plugin '%s' as required. It's already marked as required", __LINE__, function_or_event_name, plugin_data->core_data->name);

            return;

        }

        list = g_list_next(list);

    }

    /* Add it to the list */

    plugin_data->core_data->required_functions_and_events = g_list_append(plugin_data->core_data->required_functions_and_events, g_strdup(function_or_event_name));

}

void

ng_plugin_set_required_function(NGPlugin *plugin_data, const char *function_name)

{

    char function_name_new[128];

    memset(function_name_new, 0, sizeof(function_name_new));

    strcpy(function_name_new, "function_");

    strncat(function_name_new, function_name, sizeof(function_name_new) - strlen(function_name_new) - 1);

    ng_plugin_set_required_function_or_event(plugin_data, function_name_new);

}

static ngboolean

ng_plugin_call_function_or_event_va(NGPlugin *function_or_event, const char *function_or_event_name, va_list ap)

{

    GQuark detail = 0;

    guint signal_id;

    g_return_val_if_fail(function_or_event != NULL, FALSE);

    g_return_val_if_fail(function_or_event->core_data != NULL, FALSE);

    g_return_val_if_fail(function_or_event_name != NULL, FALSE);

    if (!g_signal_parse_name(function_or_event_name, NG_TYPE_PLUGIN, &signal_id, &detail, TRUE)) {

        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, __FILE__ ":%i No plugin implementation found for function or event '%s'", __LINE__, function_or_event_name);

        return FALSE;

    }

    g_signal_emit_valist(function_or_event, signal_id, detail, ap);

    return TRUE;

}

ngboolean

ng_plugin_call(NGPlugin *plugin_data, const char *function_name, ...)

{

    ngboolean ret;

    va_list ap;

    char function_name_new[128];

    g_return_val_if_fail(function_plugin_data != NULL, FALSE);

    g_return_val_if_fail(function_plugin_data->core_data != NULL, FALSE);

    g_return_val_if_fail(function_name != NULL, FALSE);

    memset(function_name_new, 0, sizeof(function_name_new));

    strcpy(function_name_new, "function_");

    strncat(function_name_new, function_name, sizeof(function_name_new) - strlen(function_name_new) - 1);

    va_start(ap, function_name);

    ret = ng_plugin_call_function_or_event_va(function_plugin_data, function_name_new, ap);

    va_end(ap);

    return ret;

}

static ngboolean

ng_plugin_create_event_va(NGPlugin *plugin_data, const char *event_name_new, int num_params, ...)

{

    ngboolean ret;

    va_list ap;

    va_start(ap, num_params);

    ret = ng_plugin_register_function_or_event_va(&plugin_data->core_data->exported_events, plugin_data, event_name_new, TRUE, NULL, nntpgrab_marshal_VOID__STRING_BOXED, G_TYPE_NONE, num_params, ap);

    va_end(ap);

    return ret;

}

ngboolean

ng_plugin_create_event(NGPlugin *plugin_data, const char *event_name, int num_params)

{

    ngboolean ret;

    char event_name_new[128];

    memset(event_name_new, 0, sizeof(event_name_new));

    strcpy(event_name_new, "event_");

    strncat(event_name_new, event_name, sizeof(event_name_new) - strlen(event_name_new) - 1);

    ret = ng_plugin_create_event_va(plugin_data, event_name_new, 2, G_TYPE_STRING, G_TYPE_STRV);

    if (ret) {

        /* Add the event_name and plugin data to a hashtable so that it can be used to emit events on the right objects */

        g_hash_table_insert(all_plugin_events, g_strdup(event_name), plugin_data);

    }

    return ret;

}

ngboolean

ng_plugin_create_internal_event(const char *event_name, GSignalCMarshaller marshaller, GType return_type, int num_params, ...)

{

    char event_name_new[128];

    ngboolean ret;

    va_list ap;

    NGPlugin *plugin_data;

    plugin_data = get_plugin_by_name("Internal");

    if (!plugin_data) {

        return FALSE;

    }

    memset(event_name_new, 0, sizeof(event_name_new));

    strcpy(event_name_new, "event_");

    strncat(event_name_new, event_name, sizeof(event_name_new) - strlen(event_name_new) - 1);

    va_start(ap, num_params);

    ret = ng_plugin_register_function_or_event_va(&plugin_data->core_data->exported_events, plugin_data, event_name_new, FALSE, NULL, marshaller, return_type, num_params, ap);

    va_end(ap);

    if (ret) {

        /* Add the event_name and plugin data to a hashtable so that it can be used to emit events on the right objects */

        g_hash_table_insert(all_plugin_events, g_strdup(event_name), plugin_data);

    }

    return ret;

}

void

ng_plugin_set_required_event(NGPlugin *plugin_data, const char *event_name)

{

    char event_name_new[128];

    memset(event_name_new, 0, sizeof(event_name_new));

    strcpy(event_name_new, "event_");

    strncat(event_name_new, event_name, sizeof(event_name_new) - strlen(event_name_new) - 1);

    ng_plugin_set_required_function_or_event(plugin_data, event_name_new);

}

ngboolean

ng_plugin_connect_event(NGPlugin *plugin_data, const char *event_name, NGPluginFunction impl, void *data)

{

    char event_name_new[128];

    NGPlugin *event_plugin;

    struct _connected_event *connection;

    g_return_val_if_fail(event_name != NULL, FALSE);

    g_return_val_if_fail(impl != NULL, FALSE);

    if (!plugin_data) {

        plugin_data = get_plugin_by_name("Internal");

        if (!plugin_data) {

            return FALSE;

        }

    }

    event_plugin = g_hash_table_lookup(all_plugin_events, event_name);

    if (!event_plugin) {

        return FALSE;

    }

    memset(event_name_new, 0, sizeof(event_name_new));

    strcpy(event_name_new, "event_");

    strncat(event_name_new, event_name, sizeof(event_name_new) - strlen(event_name_new) - 1);

    g_signal_connect(plugin_data, event_name_new, G_CALLBACK(impl), data);

    ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, __FILE__ ":%i event handler for event '%s' registered to callback at address %p", __LINE__, event_name, impl);

    /* Keep track of all the connected events so it can be used to emit events more quickly */

    connection = g_slice_new0(struct _connected_event);

    connection->plugin_data = plugin_data;

    strncpy(connection->event_name, event_name, sizeof(connection->event_name) - 1);

    connection->event_name_hash = g_str_hash(event_name);

    connection->impl = impl;

    all_connected_events = g_list_append(all_connected_events, connection);

    return TRUE;

}

ngboolean

ng_plugin_disconnect_event_by_func(NGPlugin *plugin_data, NGPluginFunction impl, void *data)

{

    GList *list;

    g_return_val_if_fail(impl != NULL, FALSE);

    list = all_connected_events;

    while (list) {

        struct _connected_event *connection = list->data;

        if (connection->plugin_data == plugin_data && connection->impl == impl) {

            g_slice_free(struct _connected_event, connection);

            all_connected_events = g_list_remove(all_connected_events, connection);

            g_signal_handlers_disconnect_by_func(plugin_data, G_CALLBACK(impl), data);

            return TRUE;

        }

        list = g_list_next(list);

    }

    return FALSE;

}

ngboolean

ng_plugin_emit_internal_event(const char *event_name, ...)

{

    char event_name_new[128];

    guint event_name_hash;

    ngboolean ret = TRUE;

    va_list ap;

    GList *list;

    g_return_val_if_fail(event_name != NULL, FALSE);

    event_name_hash = g_str_hash(event_name);

    memset(event_name_new, 0, sizeof(event_name_new));

    strcpy(event_name_new, "event_");

    strncat(event_name_new, event_name, sizeof(event_name_new) - strlen(event_name_new) - 1);

    list = all_connected_events;