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 "nntpgrab_plugin.h"

#include "nntpgrab_utils.h"

#include "json.h"

#include "jsonrpc.h"

#include "config.h"

#include "collections.h"

#include 

static NGPlugin *plugin_data_global = NULL;

static void json_get_version_info(struct json_object *request, struct json_object *response, void *user_data);

static void json_server_request_quit(struct json_object *request, struct json_object *response, void *user_data);

static void json_config_get_avail_servers(struct json_object *request, struct json_object *response, void *user_data);

static void json_config_get_server_info(struct json_object *request, struct json_object *response, void *user_data);

static void json_config_add_server(struct json_object *request, struct json_object *response, void *user_data);

static void json_config_del_server(struct json_object *request, struct json_object *response, void *user_data);

static void json_config_edit_server(struct json_object *request, struct json_object *response, void *user_data);

static void json_config_get_opts(struct json_object *request, struct json_object *response, void *user_data);

static void json_config_set_opts(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_start(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_stop(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_get_state(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_add_file_to_queue(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_del_file_from_queue(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_restart_file(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_save_queue(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_get_all_tasks(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_foreach_task(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_move_file(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_move_collection(struct json_object *request, struct json_object *response, void *user_data);

static void json_schedular_mark_task_optional(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_get_avail_plugins(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_get_plugin_info(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_load_plugin(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_unload_plugin(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_set_persistent(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_call_plugin_method(struct json_object *request, struct json_object *response, void *user_data);

static void json_set_emit_log_messages(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_utils_strip_subject(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_utils_calculate_file_size(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_utils_calculate_estimated_time_remaining(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_utils_get_readable_time_remaining(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_utils_get_readable_finished_time(struct json_object *request, struct json_object *response, void *user_data);

static void json_plugins_utils_get_folder_listing(struct json_object *request, struct json_object *response, void *user_data);

/* mongoose_hacks.c */

void jsonrpc_tcp_emit_event_to_connection(const char *json_data, void *conn);

void

jsonrpc_methods_register_methods(NGPlugin *plugin_data)

{

    static gboolean been_here = FALSE;

    plugin_data_global = plugin_data;

    if (been_here) {

        return;

    }

    been_here = TRUE;

    jsonrpc_add_method("nntpgrab_get_version_info", json_get_version_info);

    jsonrpc_add_method("nntpgrab_server_request_quit", json_server_request_quit);

    jsonrpc_add_method("nntpgrab_config_get_avail_servers", json_config_get_avail_servers);

    jsonrpc_add_method("nntpgrab_config_get_server_info", json_config_get_server_info);

    jsonrpc_add_method("nntpgrab_config_add_server", json_config_add_server);

    jsonrpc_add_method("nntpgrab_config_del_server", json_config_del_server);

    jsonrpc_add_method("nntpgrab_config_edit_server", json_config_edit_server);

    jsonrpc_add_method("nntpgrab_config_get_opts", json_config_get_opts);

    jsonrpc_add_method("nntpgrab_config_set_opts", json_config_set_opts);

    jsonrpc_add_method("nntpgrab_schedular_start", json_schedular_start);

    jsonrpc_add_method("nntpgrab_schedular_stop", json_schedular_stop);

    jsonrpc_add_method("nntpgrab_schedular_get_state", json_schedular_get_state);

    jsonrpc_add_method("nntpgrab_schedular_add_file_to_queue", json_schedular_add_file_to_queue);

    jsonrpc_add_method("nntpgrab_schedular_del_file_from_queue", json_schedular_del_file_from_queue);

    jsonrpc_add_method("nntpgrab_schedular_restart_file", json_schedular_restart_file);

    jsonrpc_add_method("nntpgrab_schedular_save_queue", json_schedular_save_queue);

    jsonrpc_add_method("nntpgrab_schedular_get_all_tasks", json_schedular_get_all_tasks);

    jsonrpc_add_method("nntpgrab_schedular_foreach_task", json_schedular_foreach_task);

    jsonrpc_add_method("nntpgrab_schedular_move_file", json_schedular_move_file);

    jsonrpc_add_method("nntpgrab_schedular_move_collection", json_schedular_move_collection);

    jsonrpc_add_method("nntpgrab_schedular_mark_task_optional", json_schedular_mark_task_optional);

    jsonrpc_add_method("nntpgrab_plugins_get_avail_plugins", json_plugins_get_avail_plugins);

    jsonrpc_add_method("nntpgrab_plugins_get_plugin_info", json_plugins_get_plugin_info);

    jsonrpc_add_method("nntpgrab_plugins_load_plugin", json_plugins_load_plugin);

    jsonrpc_add_method("nntpgrab_plugins_unload_plugin", json_plugins_unload_plugin);

    jsonrpc_add_method("nntpgrab_plugins_set_persistent", json_plugins_set_persistent);

    jsonrpc_add_method("nntpgrab_plugins_call_plugin_method", json_plugins_call_plugin_method);

    jsonrpc_add_method("nntpgrab_set_emit_log_messages", json_set_emit_log_messages);

    jsonrpc_add_method("nntpgrab_utils_strip_subject", json_plugins_utils_strip_subject);

    jsonrpc_add_method("nntpgrab_utils_calculate_file_size", json_plugins_utils_calculate_file_size);

    jsonrpc_add_method("nntpgrab_utils_calculate_estimated_time_remaining", json_plugins_utils_calculate_estimated_time_remaining);

    jsonrpc_add_method("nntpgrab_utils_get_readable_time_remaining", json_plugins_utils_get_readable_time_remaining);

    jsonrpc_add_method("nntpgrab_utils_get_readable_finished_time", json_plugins_utils_get_readable_finished_time);

    jsonrpc_add_method("nntpgrab_utils_get_folder_listing", json_plugins_utils_get_folder_listing);

}

void

jsonrpc_methods_unregister_methods(void)

{

    plugin_data_global = NULL;

}

/***********************************************************************/

/* JSON-RPC methods */

/***********************************************************************/

static void

json_prepare_response(struct json_object *request, struct json_object *response, const char *errmsg)

{

    json_object_object_add(response, "id", json_object_get(json_object_object_get(request, "id")));

    if (errmsg) {

        json_object_object_add(response, "error", json_object_new_string((char*) errmsg));

    } else {

        json_object_object_add(response, "error", NULL);

    }

}

static gboolean

json_verify_parameters(struct json_object *request, struct json_object *response, struct json_object *params, int num_params_expected)

{

    if (!plugin_data_global) {

        json_prepare_response(request, response, "Internal plugin error: plugin_data_global == NULL");

        return FALSE;

    }

    if (!params) {

        params = json_object_object_get(request, "params");

    }

    if (!params) {

        json_prepare_response(request, response, "JSON request lacks a 'params' field");

        return FALSE;

    }

    if (json_object_get_type(params) != json_type_array) {

        json_prepare_response(request, response, "Parameter is of invalid type");

        return FALSE;

    }

    if (json_object_array_length(params) != num_params_expected) {

        char msg[64];

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

        snprintf(msg, sizeof(msg) - 1, "Invalid number of arguments: %i (Expected: %i)", json_object_array_length(params), num_params_expected);

        json_prepare_response(request, response, msg);

        return FALSE;

    }

    return TRUE;

}

static gboolean

test_if_required_argument_is_supplied(struct json_object *request, struct json_object *response, struct json_object *params, int index)

{

    if (!json_object_array_get_idx(params, index)) {

        char msg[64];

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

        snprintf(msg, sizeof(msg) - 1, "Parameter %i is required but it wasn't supplied", index + 1);

        json_prepare_response(request, response, msg);

        return FALSE;

    }

    return TRUE;

}

static void

json_get_version_info(struct json_object *request, struct json_object *response, void *user_data)

{

    struct json_object *obj = json_object_new_object();

    json_object_object_add(obj, "api_version", json_object_new_int(NNTPGRAB_PLUGIN_API_VERSION));

    json_object_object_add(obj, "major_version", json_object_new_int(MAJOR_VERSION));

    json_object_object_add(obj, "minor_version", json_object_new_int(MINOR_VERSION));

    json_object_object_add(obj, "micro_version", json_object_new_int(MICRO_VERSION));

    json_object_object_add(obj, "version", json_object_new_string(PACKAGE_VERSION));

    json_object_object_add(response, "result", obj);

    json_prepare_response(request, response, NULL);

}

static void

json_server_request_quit(struct json_object *request, struct json_object *response, void *user_data)

{

    g_return_if_fail(plugin_data_global != NULL);

    plugin_data_global->core_funcs.server_request_quit();

    json_object_object_add(response, "result", json_object_new_boolean(TRUE));

    json_prepare_response(request, response, NULL);

}

static void

json_config_get_avail_servers(struct json_object *request, struct json_object *response, void *user_data)

{

    NGList *servers;

    NGList *list;

    struct json_object *arr;

    if (!json_verify_parameters(request, response, NULL, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    servers = plugin_data_global->core_funcs.config_get_avail_servers();

    arr = json_object_new_array();

    json_object_object_add(response, "result", arr);

    list = servers;

    while (list) {

        const char *servername = list->data;

        json_object_array_add(arr, json_object_new_string((char*) servername));

        list = ng_list_next(list);

    }

    plugin_data_global->core_funcs.config_free_avail_servers(servers);

    json_prepare_response(request, response, NULL);

}

static void

json_config_get_server_info(struct json_object *request, struct json_object *response, void *user_data)

{

    const char *servername;

    NGConfigServer server;

    struct json_object *ret;

    struct json_object *params;

    params = json_object_object_get(request, "params");

    if (!json_verify_parameters(request, response, params, 1) ||

        !test_if_required_argument_is_supplied(request, response, params, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    if (json_object_get_type(json_object_array_get_idx(params, 0)) != json_type_string) {

        json_prepare_response(request, response, "Parameter is of invalid type");

        return;

    }

    servername = json_object_get_string(json_object_array_get_idx(params, 0));

    if (!servername) {

        json_prepare_response(request, response, "Invalid argument");

        return;

    }

    g_return_if_fail(servername != NULL);

    if (!plugin_data_global->core_funcs.config_get_server_info(servername, &server)) {

        json_prepare_response(request, response, "No server by that name found");

        return;

    }

    ret = json_object_new_object();

    json_object_object_add(ret, "servername", json_object_new_string((char*) server.servername));

    json_object_object_add(ret, "hostname", json_object_new_string((char*) server.hostname));

    json_object_object_add(ret, "port", json_object_new_int(server.port));

    json_object_object_add(ret, "username", json_object_new_string((char*) server.username));

    json_object_object_add(ret, "password", json_object_new_string((char*) server.password));

    json_object_object_add(ret, "max_threads", json_object_new_int(server.max_threads));

    json_object_object_add(ret, "priority", json_object_new_int(server.priority));

    json_object_object_add(ret, "send_group_command", json_object_new_boolean(server.send_group_command));

    json_object_object_add(ret, "use_ssl", json_object_new_boolean(server.use_ssl));

    json_object_object_add(ret, "enabled", json_object_new_boolean(server.enabled));

    json_object_object_add(response, "result", ret);

    json_prepare_response(request, response, NULL);

}

#define json_process_parameter_str(param_obj, param, dest)                  \

    {                                                                       \

        struct json_object *obj = json_object_object_get(param_obj, param); \

        if (!obj) {                                                         \

            missing_param = param;                                          \

            goto missing_parameter;                                         \

        } else if (json_object_get_type(obj) != json_type_string) {         \

            invalid_param = param;                                          \

            goto invalid_parameter;                                         \

        }                                                                   \

        strncpy(dest, json_object_get_string(obj), sizeof(dest) - 1);       \

    }

#define json_process_parameter_int(param_obj, param, dest)                  \

    {                                                                       \

        struct json_object *obj = json_object_object_get(param_obj, param); \

        if (!obj) {                                                         \

            missing_param = param;                                          \

            goto missing_parameter;                                         \

        } else if (json_object_get_type(obj) != json_type_int) {            \

            invalid_param = param;                                          \

            goto invalid_parameter;                                         \

        }                                                                   \

        dest = json_object_get_int(obj);                                    \

    }

#define json_process_parameter_bool(param_obj, param, dest)                 \

    {                                                                       \

        struct json_object *obj = json_object_object_get(param_obj, param); \

        if (!obj) {                                                         \

            missing_param = param;                                          \

            goto missing_parameter;                                         \

        } else if (json_object_get_type(obj) != json_type_boolean) {        \

            invalid_param = param;                                          \

            goto invalid_parameter;                                         \

        }                                                                   \

        dest = json_object_get_boolean(obj);                                \

    }

static void

json_config_add_server(struct json_object *request, struct json_object *response, void *user_data)

{

    NGConfigServer server;

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_server;

    const char *missing_param = NULL;

    const char *invalid_param = NULL;

    char msg[128];

    ngboolean ret;

    char *errmsg = NULL;

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

    if (!json_verify_parameters(request, response, params, 1) ||

        !test_if_required_argument_is_supplied(request, response, params, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_server = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_server) != json_type_object) {

        json_prepare_response(request, response, "Parameter is of invalid type");

        return;

    }

    json_process_parameter_str (param_server, "servername", server.servername);

    json_process_parameter_str (param_server, "hostname", server.hostname);

    json_process_parameter_int (param_server, "port", server.port);

    json_process_parameter_str (param_server, "username", server.username);

    json_process_parameter_str (param_server, "password", server.password);

    json_process_parameter_int (param_server, "max_threads", server.max_threads);

    json_process_parameter_int (param_server, "priority", server.priority);

    json_process_parameter_bool(param_server, "send_group_command", server.send_group_command);

    json_process_parameter_bool(param_server, "use_ssl", server.use_ssl);

    json_process_parameter_bool(param_server, "enabled", server.enabled);

    /* add the server */

    ret = plugin_data_global->core_funcs.config_add_server(server, &errmsg);

    if (!ret) {

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

        return;

    }

    if (!plugin_data_global->core_funcs.config_save(&errmsg)) {

        json_object_object_add(response, "result", json_object_new_boolean(FALSE));

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

    } else {

        json_object_object_add(response, "result", json_object_new_boolean(TRUE));

        json_prepare_response(request, response, NULL);

    }

    return;

missing_parameter:

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

    snprintf(msg, sizeof(msg), "Missing parameter in array: '%s'", missing_param);

    json_prepare_response(request, response, msg);

    return;

invalid_parameter:

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

    snprintf(msg, sizeof(msg), "Parameter '%s' is of the invalid type", invalid_param);

    json_prepare_response(request, response, msg);

    return;

}

static void

json_config_del_server(struct json_object *request, struct json_object *response, void *user_data)

{

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_server;

    const char *servername;

    ngboolean ret;

    char *errmsg = NULL;

    if (!json_verify_parameters(request, response, params, 1) ||

        !test_if_required_argument_is_supplied(request, response, params, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_server = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_server) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'servername' is of invalid type");

        return;

    }

    servername = json_object_get_string(param_server);

    g_return_if_fail(servername != NULL);

    /* delete the server */

    ret = plugin_data_global->core_funcs.config_del_server(servername, &errmsg);

    if (!ret) {

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

        return;

    }

    if (!plugin_data_global->core_funcs.config_save(&errmsg)) {

        json_object_object_add(response, "result", json_object_new_boolean(FALSE));

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

    } else {

        json_object_object_add(response, "result", json_object_new_boolean(TRUE));

        json_prepare_response(request, response, NULL);

    }

}

static void

json_config_edit_server(struct json_object *request, struct json_object *response, void *user_data)

{

    NGConfigServer server;

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_server;

    const char *missing_param = NULL;

    const char *invalid_param = NULL;

    const char *servername;

    char msg[128];

    ngboolean ret;

    char *errmsg = NULL;

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

    if (!json_verify_parameters(request, response, params, 2) ||

        !test_if_required_argument_is_supplied(request, response, params, 0) ||

        !test_if_required_argument_is_supplied(request, response, params, 1)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_server = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_server) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'servername_old' is of invalid type");

        return;

    }

    servername = json_object_get_string(param_server);

    g_return_if_fail(servername != NULL);

    param_server = json_object_array_get_idx(params, 1);

    if (json_object_get_type(param_server) != json_type_object) {

        json_prepare_response(request, response, "Parameter 'server', is of invalid type");

        return;

    }

    json_process_parameter_str (param_server, "servername", server.servername);

    json_process_parameter_str (param_server, "hostname", server.hostname);

    json_process_parameter_int (param_server, "port", server.port);

    json_process_parameter_str (param_server, "username", server.username);

    json_process_parameter_str (param_server, "password", server.password);

    json_process_parameter_int (param_server, "max_threads", server.max_threads);

    json_process_parameter_int (param_server, "priority", server.priority);

    json_process_parameter_bool(param_server, "send_group_command", server.send_group_command);

    json_process_parameter_bool(param_server, "use_ssl", server.use_ssl);

    json_process_parameter_bool(param_server, "enabled", server.enabled);

    /* edit the server */

    ret = plugin_data_global->core_funcs.config_edit_server(servername, server, &errmsg);

    if (!ret) {

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

        return;

    }

    if (!plugin_data_global->core_funcs.config_save(&errmsg)) {

        json_object_object_add(response, "result", json_object_new_boolean(FALSE));

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

    } else {

        json_object_object_add(response, "result", json_object_new_boolean(TRUE));

        json_prepare_response(request, response, NULL);

    }

    return;

missing_parameter:

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

    snprintf(msg, sizeof(msg), "Missing parameter in array: '%s'", missing_param);

    json_prepare_response(request, response, msg);

    return;

invalid_parameter:

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

    snprintf(msg, sizeof(msg), "Parameter '%s' is of the invalid type", invalid_param);

    json_prepare_response(request, response, msg);

    return;

}

static void

json_config_get_opts(struct json_object *request, struct json_object *response, void *user_data)

{

    NGConfigOpts opts;

    struct json_object *ret;

    if(!json_verify_parameters(request, response, NULL, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    opts = plugin_data_global->core_funcs.config_get_opts();

    ret = json_object_new_object();

    json_object_object_add(ret, "download_directory", json_object_new_string((char*) opts.download_directory));

    json_object_object_add(ret, "temp_directory", json_object_new_string((char*) opts.temp_directory));

    json_object_object_add(ret, "enable_intelligent_par2_downloading", json_object_new_boolean(opts.enable_intelligent_par2_downloading));

    json_object_object_add(ret, "enable_par2_repair", json_object_new_boolean(opts.enable_par2_repair));

    json_object_object_add(ret, "auto_import_directory", json_object_new_string((char*) opts.auto_import_directory));

    json_object_object_add(ret, "enable_auto_import", json_object_new_boolean(opts.enable_auto_import));

    json_object_object_add(ret, "move_file_after_auto_import", json_object_new_boolean(opts.move_file_after_auto_import));

    json_object_object_add(ret, "enable_auto_unpack", json_object_new_boolean(opts.enable_auto_unpack));

    json_object_object_add(ret, "enable_bandwidth_shaping", json_object_new_boolean(opts.enable_bandwidth_shaping));

    json_object_object_add(ret, "max_bandwidth", json_object_new_int(opts.max_bandwidth));

    json_object_object_add(ret, "enable_webserver", json_object_new_boolean(opts.enable_webserver));

    json_object_object_add(ret, "webserver_port", json_object_new_int(opts.webserver_port));

    json_object_object_add(ret, "enable_logger", json_object_new_boolean(opts.enable_logger));

    json_object_object_add(ret, "auto_remove_files_after_repair", json_object_new_boolean(opts.auto_remove_files_after_repair));

    json_object_object_add(ret, "auto_remove_files_after_unpack", json_object_new_boolean(opts.auto_remove_files_after_unpack));

    json_object_object_add(ret, "auto_remove_collections_after_download", json_object_new_boolean(opts.auto_remove_collections_after_download));

    json_object_object_add(response, "result", ret);

    json_prepare_response(request, response, NULL);

}

static void

json_config_set_opts(struct json_object *request, struct json_object *response, void *user_data)

{

    NGConfigOpts opts;

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_opts;

    const char *missing_param = NULL;

    const char *invalid_param = NULL;

    char msg[128];

    char *errmsg = NULL;

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

    if (!json_verify_parameters(request, response, params, 1) ||

        !test_if_required_argument_is_supplied(request, response, params, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_opts = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_opts) != json_type_object) {

        json_prepare_response(request, response, "Parameter 'opts' is of invalid type");

        return;

    }

    json_process_parameter_str (param_opts, "download_directory", opts.download_directory);

    json_process_parameter_str (param_opts, "temp_directory", opts.temp_directory);

    json_process_parameter_bool(param_opts, "enable_intelligent_par2_downloading", opts.enable_intelligent_par2_downloading);

    json_process_parameter_bool(param_opts, "enable_par2_repair", opts.enable_par2_repair);

    json_process_parameter_str (param_opts, "auto_import_directory", opts.auto_import_directory);

    json_process_parameter_bool(param_opts, "enable_auto_import", opts.enable_auto_import);

    json_process_parameter_bool(param_opts, "move_file_after_auto_import", opts.move_file_after_auto_import);

    json_process_parameter_bool(param_opts, "enable_auto_unpack", opts.enable_auto_unpack);

    json_process_parameter_bool(param_opts, "enable_bandwidth_shaping", opts.enable_bandwidth_shaping);

    json_process_parameter_int (param_opts, "max_bandwidth", opts.max_bandwidth);

    json_process_parameter_bool(param_opts, "enable_webserver", opts.enable_webserver);

    json_process_parameter_int (param_opts, "webserver_port", opts.webserver_port);

    json_process_parameter_bool(param_opts, "enable_logger", opts.enable_logger);

    json_process_parameter_bool(param_opts, "auto_remove_files_after_repair", opts.auto_remove_files_after_repair);

    json_process_parameter_bool(param_opts, "auto_remove_files_after_unpack", opts.auto_remove_files_after_unpack);

    json_process_parameter_bool(param_opts, "auto_remove_collections_after_download", opts.auto_remove_collections_after_download);

    plugin_data_global->core_funcs.config_set_opts(opts);

    if (!plugin_data_global->core_funcs.config_save(&errmsg)) {

        json_object_object_add(response, "result", json_object_new_boolean(FALSE));

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

    } else {

        json_object_object_add(response, "result", json_object_new_boolean(TRUE));

        json_prepare_response(request, response, NULL);

    }

    return;

missing_parameter:

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

    snprintf(msg, sizeof(msg), "Missing parameter in array: '%s'", missing_param);

    json_prepare_response(request, response, msg);

    return;

invalid_parameter:

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

    snprintf(msg, sizeof(msg), "Parameter '%s' is of the invalid type", invalid_param);

    json_prepare_response(request, response, msg);

    return;

}

static void

json_schedular_start(struct json_object *request, struct json_object *response, void *user_data)

{

    ngboolean ret;

    if(!json_verify_parameters(request, response, NULL, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    ret = plugin_data_global->core_funcs.schedular_start();

    json_object_object_add(response, "result", json_object_new_boolean(ret));

    json_prepare_response(request, response, NULL);

}

static void

json_schedular_stop(struct json_object *request, struct json_object *response, void *user_data)

{

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_schedular;

    ngboolean ret;

    char *reason = NULL;

    if (!json_verify_parameters(request, response, params, 1) ||

        !test_if_required_argument_is_supplied(request, response, params, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_schedular = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_schedular) != json_type_boolean) {

        json_prepare_response(request, response, "Parameter 'wait' is of invalid type");

        return;

    }

    ret = json_object_get_boolean(param_schedular);

    if(!plugin_data_global->core_funcs.schedular_stop(reason, ret))

    {

        json_prepare_response(request, response, reason);

        return;

    }

    json_object_object_add(response, "result", json_object_new_boolean(TRUE));

    json_prepare_response(request, response, NULL);

}

static void

json_schedular_get_state(struct json_object *request, struct json_object *response, void *user_data)

{

    NGSchedularState state;

    if(!json_verify_parameters(request, response, NULL, 0)) {

            return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    state = plugin_data_global->core_funcs.schedular_get_state();

    json_object_object_add(response, "result", json_object_new_int(state));

    json_prepare_response(request, response, NULL);

}

static void

json_schedular_add_file_to_queue(struct json_object *request, struct json_object *response, void *user_data)

{

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *obj;

    char *collection_name;

    char *subject;

    char *poster;

    time_t timestamp;

    guint64 file_size;

    NGList *groups = NULL;

    NGList *parts = NULL;

    NGList *list;

    int i, len;

    const char *missing_param = NULL;

    const char *invalid_param = NULL;

    char *errmsg = NULL;

    char msg[1024];

    if (!json_verify_parameters(request, response, NULL, 7) ||

        !test_if_required_argument_is_supplied(request, response, params, 0) ||

        !test_if_required_argument_is_supplied(request, response, params, 1) ||

        !test_if_required_argument_is_supplied(request, response, params, 2) ||

        !test_if_required_argument_is_supplied(request, response, params, 3) ||

        !test_if_required_argument_is_supplied(request, response, params, 4) ||

        !test_if_required_argument_is_supplied(request, response, params, 5) ||

        !test_if_required_argument_is_supplied(request, response, params, 6)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    obj = json_object_array_get_idx(params, 0);

    if (json_object_get_type(obj) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'collection_name' is of invalid type");

        return;

    }

    collection_name = json_object_get_string(obj);

    obj = json_object_array_get_idx(params, 1);

    if (json_object_get_type(obj) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'subject' is of invalid type");

        return;

    }

    subject = json_object_get_string(obj);

    obj = json_object_array_get_idx(params, 2);

    if (json_object_get_type(obj) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'poster' is of invalid type");

        return;

    }

    poster = json_object_get_string(obj);

    obj = json_object_array_get_idx(params, 3);

    if (json_object_get_type(obj) != json_type_int) {

        json_prepare_response(request, response, "Parameter 'timestamp' is of invalid type");

        return;

    }

    timestamp = json_object_get_int(obj);

    obj = json_object_array_get_idx(params, 4);

    if (json_object_get_type(obj) != json_type_int) {

        json_prepare_response(request, response, "Parameter 'file_size' is of invalid type");

        return;

    }

    file_size = json_object_get_int(obj);

    obj = json_object_array_get_idx(params, 5);

    if (json_object_get_type(obj) != json_type_array) {

        json_prepare_response(request, response, "Parameter 'groups' is of invalid type");

        return;

    }

    len = json_object_array_length(obj);

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

        struct json_object *group_obj = json_object_array_get_idx(obj, i);

        char *groupname;

        g_return_if_fail(group_obj != NULL);

        if (json_object_get_type(group_obj) != json_type_string) {

            char msg[1024];

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

            snprintf(msg, sizeof(msg) - 1, "Element %i of parameter 'groups' is of invalid type", i);

            json_prepare_response(request, response, msg);

            return;

        }

        groupname = json_object_get_string(group_obj);

        g_return_if_fail(groupname != NULL);

        groups = ng_list_append(groups, groupname);

    }

    obj = json_object_array_get_idx(params, 6);

    if (json_object_get_type(obj) != json_type_array) {

        json_prepare_response(request, response, "Parameter 'parts' is of invalid type");

        return;

    }

    len = json_object_array_length(obj);

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

        struct json_object *part_obj = json_object_array_get_idx(obj, i);

        NNTPPart *part;

        g_return_if_fail(part_obj != NULL);

        if (json_object_get_type(part_obj) != json_type_object) {

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

            snprintf(msg, sizeof(msg) - 1, "Element %i of parameter 'parts' is of invalid type", i);

            json_prepare_response(request, response, msg);

            return;

        }

        part = g_slice_new0(NNTPPart);

        json_process_parameter_str(part_obj, "message_id", part->message_id);   /* NOTE: This line can give a compiler warning, but this is intentional! */

        json_process_parameter_int(part_obj, "part_num", part->part_num);

        json_process_parameter_int(part_obj, "size", part->size);

        parts = ng_list_append(parts, part);

    }

    if (!plugin_data_global->core_funcs.schedular_add_file_to_queue(collection_name, subject, poster, timestamp, file_size * 1024, groups, parts, &errmsg)) {

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

        return;

    }

    json_object_object_add(response, "result", json_object_new_boolean(TRUE));

    json_prepare_response(request, response, NULL);

    ng_list_free(groups);

    list = parts;

    while (list) {

        NNTPPart *part = list->data;

        g_slice_free(NNTPPart, part);

        list = ng_list_next(list);

    }

    ng_list_free(parts);

    return;

missing_parameter:

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

    snprintf(msg, sizeof(msg), "Missing parameter in array: '%s'", missing_param);

    json_prepare_response(request, response, msg);

    return;

invalid_parameter:

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

    snprintf(msg, sizeof(msg), "Parameter '%s' is of the invalid type", invalid_param);

    json_prepare_response(request, response, msg);

    return;

}

static void

json_schedular_del_file_from_queue(struct json_object *request, struct json_object *response, void *user_data)

{

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_collection;

    char *collection_name;

    char *subject = NULL;

    char *errmsg = NULL;

    if (!json_verify_parameters(request, response, NULL, 2) ||

        !test_if_required_argument_is_supplied(request, response, params, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_collection = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_collection) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'collection_name' is of invalid type");

        return;

    }

    collection_name = json_object_get_string(param_collection);

    g_return_if_fail(collection_name != NULL);

    param_collection = json_object_array_get_idx(params, 1);

    if (test_if_required_argument_is_supplied(request, response, params, 1))

    {

        if(json_object_get_type(param_collection) != json_type_string)

        {

            json_prepare_response(request, response, "Parameter 'subject', is of invalid type");

            return;

        }

        else

        {

            subject = json_object_get_string(param_collection);

            g_return_if_fail(subject != NULL);

        }

    }

    if (!plugin_data_global->core_funcs.schedular_del_file_from_queue(collection_name, subject, &errmsg)) {

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

        return;

    }

    json_object_object_add(response, "result", json_object_new_boolean(TRUE));

    json_prepare_response(request, response, NULL);

}

static void

json_schedular_restart_file(struct json_object *request, struct json_object *response, void *user_data)

{

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_file;

    char *collection_name;

    char *subject = NULL;

    char *errmsg = NULL;

    if (!json_verify_parameters(request, response, NULL, 2) ||

        !test_if_required_argument_is_supplied(request, response, params, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_file = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_file) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'collection_name' is of invalid type");

        return;

    }

    collection_name = json_object_get_string(param_file);

    g_return_if_fail(collection_name != NULL);

    param_file = json_object_array_get_idx(params, 1);

    if (test_if_required_argument_is_supplied(request, response, params, 1))

    {

        if(json_object_get_type(param_file) != json_type_string)

        {

            json_prepare_response(request, response, "Parameter 'subject', is of invalid type");

            return;

        }

        else

        {

            subject = json_object_get_string(param_file);

            g_return_if_fail(subject != NULL);

        }

    }

    if (!plugin_data_global->core_funcs.schedular_restart_file(collection_name, subject, &errmsg)) {

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

        return;

    }

    json_object_object_add(response, "result", json_object_new_boolean(TRUE));

    json_prepare_response(request, response, NULL);

}

static void

json_schedular_save_queue(struct json_object *request, struct json_object *response, void *user_data)

{

    char *errmsg = NULL;

    if (!json_verify_parameters(request, response, NULL, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    if (!plugin_data_global->core_funcs.schedular_save_queue(&errmsg)) {

        json_prepare_response(request, response, errmsg);

        g_free(errmsg);

        return;

    }

    json_object_object_add(response, "result", json_object_new_boolean(TRUE));

    json_prepare_response(request, response, NULL);

}

struct _foreach_cb_data {

    struct json_object *collections;

    struct json_object *collection;

    struct json_object *files;

    struct json_object *file;

    struct json_object *groups;

    boolean only_emit;

    void *connection;

};

static void

foreach_collection_func(const char *collection_name, const char *poster, nguint64 total_size, nguint64 total_size_remaining, int position, void *data)

{

    struct _foreach_cb_data *cb_data = data;

    int i_total_size;

    int i_total_size_remaining;

    total_size /= 1024;

    total_size_remaining /= 1024;

    i_total_size = total_size;

    i_total_size_remaining = total_size_remaining;

    cb_data->collection = json_object_new_object();

    json_object_object_add(cb_data->collection, "collection_name", json_object_new_string((char*) collection_name));

    json_object_object_add(cb_data->collection, "poster", json_object_new_string((char*) poster));

    /* The total size needs to be divided by 1024 as JSON doesn't 

     * know 64bit long integers, so we keep the size in KB here */

    json_object_object_add(cb_data->collection, "total_size", json_object_new_int(i_total_size));

    json_object_object_add(cb_data->collection, "total_size_remaining", json_object_new_int(i_total_size_remaining));

    if (cb_data->only_emit) {

        struct json_object *emit_event = json_object_new_object();

        json_object_object_add(cb_data->collection, "position", json_object_new_int(position));

        json_object_object_add(emit_event, "id", NULL);

        json_object_object_add(emit_event, "method", json_object_new_string("foreach_collection_event"));

        json_object_object_add(emit_event, "params", cb_data->collection);

        jsonrpc_tcp_emit_event_to_connection(json_object_to_json_string(emit_event), cb_data->connection);

        json_object_put(emit_event);

        cb_data->collection = NULL;

        return;

    }

    json_object_array_add(cb_data->collections, cb_data->collection);

    cb_data->files = json_object_new_array();

    json_object_object_add(cb_data->collection, "files", cb_data->files);

}

static void

foreach_file_func(const char *collection_name, const char *subject, const char *poster, ngint64 stamp, nguint64 file_size, nguint64 file_size_remaining, int position, int num_parts_total, int num_parts_downloaded, int num_parts_failed, NGTaskState status, const char *filename, void *data)

{

    struct _foreach_cb_data *cb_data = data;

    int i_file_size;

    int i_file_size_remaining;

    file_size /= 1024;

    file_size_remaining /= 1024;

    i_file_size = file_size;

    i_file_size_remaining = file_size_remaining;

    cb_data->file = json_object_new_object();

    if (cb_data->only_emit) {

        json_object_object_add(cb_data->file, "collection_name", json_object_new_string((char*) collection_name));

    }

    json_object_object_add(cb_data->file, "subject", json_object_new_string((char*) subject));

    json_object_object_add(cb_data->file, "poster", json_object_new_string((char*) poster));

    json_object_object_add(cb_data->file, "stamp", json_object_new_int((int) stamp));

    json_object_object_add(cb_data->file, "file_size", json_object_new_int(i_file_size));

    json_object_object_add(cb_data->file, "file_size_remaining", json_object_new_int(i_file_size_remaining));

    json_object_object_add(cb_data->file, "num_parts_total", json_object_new_int(num_parts_total));

    json_object_object_add(cb_data->file, "num_parts_downloaded", json_object_new_int(num_parts_downloaded));

    json_object_object_add(cb_data->file, "num_parts_failed", json_object_new_int(num_parts_failed));

    json_object_object_add(cb_data->file, "status", json_object_new_int(status));

    json_object_object_add(cb_data->file, "filename", json_object_new_string((char*) filename));

    if (cb_data->only_emit) {

        struct json_object *emit_event = json_object_new_object();

        json_object_object_add(cb_data->file, "position", json_object_new_int(position));

        json_object_object_add(emit_event, "id", NULL);

        json_object_object_add(emit_event, "method", json_object_new_string("foreach_file_event"));

        json_object_object_add(emit_event, "params", cb_data->file);

        jsonrpc_tcp_emit_event_to_connection(json_object_to_json_string(emit_event), cb_data->connection);

        json_object_put(emit_event);

        cb_data->file = NULL;

        return;

    }

    json_object_array_add(cb_data->files, cb_data->file);

    cb_data->groups = json_object_new_array();

    json_object_object_add(cb_data->file, "groups", cb_data->groups);

}

static void

foreach_group_func(const char *collection_name, const char *subject, const char *group, void *data)

{

    struct _foreach_cb_data *cb_data = data;

    if (cb_data->only_emit) {

        struct json_object *obj = json_object_new_object();

        struct json_object *emit_event = json_object_new_object();

        json_object_object_add(obj, "collection_name", json_object_new_string((char *) collection_name));

        json_object_object_add(obj, "subject", json_object_new_string((char *) subject));

        json_object_object_add(obj, "group", json_object_new_string((char *) group));

        json_object_object_add(emit_event, "id", NULL);

        json_object_object_add(emit_event, "method", json_object_new_string("foreach_group_event"));

        json_object_object_add(emit_event, "params", obj);

        jsonrpc_tcp_emit_event_to_connection(json_object_to_json_string(emit_event), cb_data->connection);

        json_object_put(emit_event);

        return;

    }

    json_object_array_add(cb_data->groups, json_object_new_string((char *) group));

}

static void

json_schedular_get_all_tasks(struct json_object *request, struct json_object *response, void *user_data)

{

    struct _foreach_cb_data cb_data;

    if (!json_verify_parameters(request, response, NULL, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

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

    cb_data.collections = json_object_new_array();

    cb_data.only_emit = FALSE;

    plugin_data_global->core_funcs.schedular_foreach_file(foreach_collection_func, foreach_file_func, foreach_group_func, &cb_data);

    json_prepare_response(request, response, NULL);

    json_object_object_add(response, "result", cb_data.collections);

}

static void

json_schedular_foreach_task(struct json_object *request, struct json_object *response, void *user_data)

{

    struct _foreach_cb_data cb_data;

    if (!json_verify_parameters(request, response, NULL, 0)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

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

    cb_data.only_emit = TRUE;

    cb_data.connection = user_data;

    plugin_data_global->core_funcs.schedular_foreach_file(foreach_collection_func, foreach_file_func, foreach_group_func, &cb_data);

    json_prepare_response(request, response, NULL);

    json_object_object_add(response, "result", json_object_new_boolean(TRUE));

}

static void

json_schedular_move_file(struct json_object *request, struct json_object *response, void *user_data)

{

    struct json_object *params = json_object_object_get(request, "params");

    struct json_object *param_file;

    char *collection_name_src;

    char *subject;

    char *collection_name_dest;

    int position;

    ngboolean ret;

    if (!json_verify_parameters(request, response, NULL, 4) ||

        !test_if_required_argument_is_supplied(request, response, params, 0) ||

        !test_if_required_argument_is_supplied(request, response, params, 1) ||

        !test_if_required_argument_is_supplied(request, response, params, 2) ||

        !test_if_required_argument_is_supplied(request, response, params, 3)) {

        return;

    }

    g_return_if_fail(plugin_data_global != NULL);

    param_file = json_object_array_get_idx(params, 0);

    if (json_object_get_type(param_file) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'collection_name_src' is of invalid type");

        return;

    }

    collection_name_src = json_object_get_string(param_file);

    g_return_if_fail(collection_name_src != NULL);

    param_file = json_object_array_get_idx(params, 1);

    if (json_object_get_type(param_file) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'subject' is of invalid type");

        return;

    }

    subject = json_object_get_string(param_file);

    g_return_if_fail(subject != NULL);

    param_file = json_object_array_get_idx(params, 2);

    if (json_object_get_type(param_file) != json_type_string) {

        json_prepare_response(request, response, "Parameter 'collection_name_dest' is of invalid type");

        return;

    }

    collection_name_dest = json_object_get_string(param_file);

    g_return_if_fail(collection_name_dest != NULL);

    param_file = json_object_array_get_idx(params, 3);

    if (json_object_get_type(param_file) != json_type_int) {

        json_prepare_response(request, response, "Parameter 'position' is of invalid type");

        return;

    }

    position = json_object_get_int(param_file);

    ret = plugin_data_global->core_funcs.schedular_move_file(collection_name_src, subject, collection_name_dest, position);

    json_object_object_add(response, "result", json_object_new_boolean(ret));