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

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include 

#include 

#include 

#include 

#include "nntpgrab_plugin.h"

#include "nntpgrab_utils.h"

#include "mongoose.h"

#include "json.h"

#include "jsonrpc.h"

#include "marshalers.h"

static struct mg_context *ctx = NULL;

static NGPlugin *plugin_data_global = NULL;

static int current_listen_port = 0;

static ngboolean ignore_config_changes = FALSE;

/* Webserver methods */

static void set_ignore_config_changes(NGPlugin *plugin_data);

static ngboolean start_webserver(NGPlugin *plugin_data, int port, char **errmsg);

static void stop_webserver(NGPlugin *plugin_data);

static void on_config_changed(NGPlugin *plugin_data, gpointer data);

static void on_log_message_received(struct mg_connection *conn, const struct mg_request_info *info, void *message);

static void process_favicon_request(struct mg_connection *conn, const struct mg_request_info *request_info, void *user_data);

static void process_jsonrpc_request(struct mg_connection *conn, const struct mg_request_info *request_info, void *user_data);

static void process_upload_request(struct mg_connection *conn, const struct mg_request_info *request_info, void *user_data);

void mongoose_hacks_set_plugin_data(NGPlugin *plugin_data);

ngboolean listen_on_port(struct mg_context *ctx, char *port);

void jsonrpc_tcp_force_disconnect(void);

/* JSON-RPC methods */

void jsonrpc_methods_register_methods(NGPlugin *plugin_data);

void jsonrpc_methods_unregister_methods(void);

/* JSON-RPC events */

void jsonrpc_connect_signal_handlers(NGPlugin *plugin_data);

void jsonrpc_disconnect_signal_handlers(NGPlugin *plugin_data);

void

nntpgrab_plugin_initialize(NGPlugin *plugin_data)

{

    ng_plugin_set_name(plugin_data, "JSON-RPC");

    ng_plugin_set_version(plugin_data, PACKAGE_VERSION);

    ng_plugin_set_author(plugin_data, "Erik van Pienbroek");

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

    ng_plugin_set_description(plugin_data, "Allow NNTPGrab to be remotely controlled using JSON-RPC");

    ng_plugin_register_function(plugin_data,

                                "webserver_start",

                                NG_PLUGIN_FUNCTION(start_webserver),

                                ng_plugin_marshal_BOOLEAN__INT_POINTER,

                                G_TYPE_BOOLEAN,

                                2, G_TYPE_INT, G_TYPE_POINTER);

    ng_plugin_register_function(plugin_data,

                                "webserver_ignore_config_changes",

                                NG_PLUGIN_FUNCTION(set_ignore_config_changes),

                                ng_plugin_marshal_VOID__VOID,

                                G_TYPE_NONE,

                                0);

    ng_plugin_set_required_event(plugin_data, "config_changed");

    ng_plugin_set_required_event(plugin_data, "part_download_start");

    ng_plugin_set_required_event(plugin_data, "part_done");

    ng_plugin_set_required_event(plugin_data, "part_failed");

    ng_plugin_set_required_event(plugin_data, "traffic_monitor_update");

    ng_plugin_set_required_event(plugin_data, "part_progress_update");

    ng_plugin_set_required_event(plugin_data, "collection_added");

    ng_plugin_set_required_event(plugin_data, "collection_removed");

    ng_plugin_set_required_event(plugin_data, "collection_modified");

    ng_plugin_set_required_event(plugin_data, "file_added");

    ng_plugin_set_required_event(plugin_data, "file_removed");

    ng_plugin_set_required_event(plugin_data, "file_download_state_update");

    ng_plugin_set_required_event(plugin_data, "file_state_changed");

    ng_plugin_set_required_event(plugin_data, "connection_connecting");

    ng_plugin_set_required_event(plugin_data, "connection_connected");

    ng_plugin_set_required_event(plugin_data, "connection_disconnect");

    ng_plugin_set_required_event(plugin_data, "schedular_state_changed");

    ng_plugin_set_required_event(plugin_data, "log_message");

    ng_plugin_set_required_event(plugin_data, "task_moved");

    ng_plugin_set_required_event(plugin_data, "collection_moved");

    ng_plugin_set_required_event(plugin_data, "all_downloads_completed");

    ng_plugin_set_required_event(plugin_data, "plugin_loaded");

    ng_plugin_set_required_event(plugin_data, "plugin_unloaded");

    ng_plugin_set_required_event(plugin_data, "plugin_event");

    ng_plugin_create_event(plugin_data, "num_active_connections_changed", 1);

}

ngboolean

nntpgrab_plugin_load(NGPlugin *plugin_data, char **errmsg)

{

    NGConfigOpts opts;

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    g_return_val_if_fail(ctx == NULL, FALSE);

    plugin_data_global = plugin_data;

    jsonrpc_methods_register_methods(plugin_data);

    ng_plugin_connect_event(plugin_data, "config_changed", NG_PLUGIN_FUNCTION(on_config_changed), NULL);

    opts = plugin_data->core_funcs.config_get_opts();

    if (!opts.enable_webserver) {

        return TRUE;

    }

    return start_webserver(plugin_data, opts.webserver_port, errmsg);

}

static void

set_ignore_config_changes(NGPlugin *plugin_data)

{

    ignore_config_changes = TRUE;

}

static ngboolean

start_webserver(NGPlugin *plugin_data, int port, char **errmsg)

{

    char *path;

    char port_str[16];

    char opt[128];

    g_return_val_if_fail(plugin_data != NULL, FALSE);

    g_return_val_if_fail(errmsg != NULL, FALSE);

    if (ctx) {

        if (current_listen_port == port) {

            return TRUE;

        }

        stop_webserver(plugin_data);

    }

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

    snprintf(port_str, sizeof(port_str) - 1, "%i", port);

    if ((ctx = mg_start()) == NULL) {

        *errmsg = g_strdup(_("Unable to start embedded webserver"));

        return FALSE;

    }

    mg_set_log_callback(ctx, on_log_message_received);

    listen_on_port(ctx, port_str);

    mg_set_option(ctx, "idle_time", "3");

    mg_set_option(ctx, "dir_list", "0");

    if (g_getenv("NNTPGRAB_WWWDIR")) {

        path = (char*) g_getenv("NNTPGRAB_WWWDIR");

    } else {

        path = WWW_DIR;

    }

    mg_set_option(ctx, "root", path);

    mg_set_option(ctx, "auth_realm", "NNTPGrab embedded webserver");

    if (g_getenv("NNTPGRAB_CONFIG_DIR")) {

        path = g_build_filename(g_getenv("NNTPGRAB_CONFIG_DIR"), "NNTPGrab", "htpasswd", NULL);

    } else {

        path = g_build_filename(g_get_user_config_dir(), "NNTPGrab", "htpasswd", NULL);

    }

    if (!g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {

        /* Password file doesn't exist yet, generate a default one */

        mg_modify_passwords_file(ctx, path, "admin", "admin");

    }

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

    snprintf(opt, sizeof(opt) - 1, "/jsonrpc=%s", path);

    mg_set_option(ctx, "protect", opt);

    g_free(path);

    //mg_set_uri_callback(ctx, "/", &process_index_request, NULL);

    mg_set_uri_callback(ctx, "/favicon.ico", &process_favicon_request, NULL);

    mg_set_uri_callback(ctx, "/jsonrpc", &process_jsonrpc_request, NULL);

    mg_set_uri_callback(ctx, "/upload", &process_upload_request, plugin_data);

    mongoose_hacks_set_plugin_data(plugin_data);

    jsonrpc_connect_signal_handlers(plugin_data);

    current_listen_port = port;

    return TRUE;

}

ngboolean

nntpgrab_plugin_can_unload(NGPlugin *plugin_data, char **reason)

{

    return TRUE;

}

void

nntpgrab_plugin_unload(NGPlugin *plugin_data)

{

    NGConfigOpts opts = plugin_data->core_funcs.config_get_opts();

    g_return_if_fail(plugin_data != NULL);

    if (opts.enable_webserver) {

        g_return_if_fail(ctx != NULL);

        stop_webserver(plugin_data);

    }

    mongoose_hacks_set_plugin_data(NULL);

    plugin_data_global = NULL;

    /* Free the buffer containing the most recent JSON-RPC events */

    jsonrpc_set_event_list_size(0);

}

static void

stop_webserver(NGPlugin *plugin_data)

{

    g_return_if_fail(plugin_data != NULL);

    g_return_if_fail(ctx != NULL);

    jsonrpc_tcp_force_disconnect();

    mg_stop(ctx);

    ctx = NULL;

    current_listen_port = 0;

    jsonrpc_disconnect_signal_handlers(plugin_data);

}

void

nntpgrab_plugin_destroy(NGPlugin *plugin_data)

{

    jsonrpc_methods_unregister_methods();

}

int

nntpgrab_plugin_get_version(void)

{

    return NNTPGRAB_PLUGIN_API_VERSION;

}

static void

on_config_changed(NGPlugin *plugin_data, gpointer data)

{

    NGConfigOpts opts = plugin_data->core_funcs.config_get_opts();

    char *errmsg = NULL;

    if (ignore_config_changes) {

        return;

    }

    /* Do we need to stop the embedded webserver? */

    if (!opts.enable_webserver && ctx != NULL) {

        stop_webserver(plugin_data);

        return;

    }

    /* Do we need to start the embedded webserver? */

    if (opts.enable_webserver && ctx == NULL) {

        if (!start_webserver(plugin_data, opts.webserver_port, &errmsg)) {

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_WARNING, _("Unable to start the embedded webserver: %s"), errmsg);

            g_free(errmsg);

        }

    }

    /* Did the webserver port change? */

    if (opts.enable_webserver && opts.webserver_port != current_listen_port) {

        stop_webserver(plugin_data);

        if (!start_webserver(plugin_data, opts.webserver_port, &errmsg)) {

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_WARNING, _("Unable to re-start the embedded webserver: %s"), errmsg);

            g_free(errmsg);

        }

    }

}

static void

process_favicon_request(struct mg_connection *conn, const struct mg_request_info *request_info, void *user_data)

{

    mg_printf(conn, "%s", "HTTP/1.1 404 File not found\r\n\r\n");

}

static void

process_jsonrpc_request(struct mg_connection *conn, const struct mg_request_info *request_info, void *user_data)

{

    char *response;

    char post_data[1024];

    int response_length = 0;

    mg_printf(conn, "%s", "HTTP/1.1 200 OK\r\n");

    mg_printf(conn, "%s", "Content-Type: text/plain\r\n");

    if (strcmp(request_info->request_method, "POST") ||

        request_info->post_data_len == 0) {

        mg_printf(conn, "\r\n%s", "This URI should only be used for JSON-RPC requests\r\n");

        return;

    }

    /* We need to duplicate the post_data here as it isn't NULL-terminated.. */

    if (request_info->post_data_len > sizeof(post_data) - 1) {

        /* Refuse to handle such a large request */

        mg_printf(conn, "\r\n%s", "Request is too large to process\r\n");

        return;

    }

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

    strncpy(post_data, request_info->post_data, request_info->post_data_len);

    response = jsonrpc_process(post_data, conn);

    g_print("post_data = %s\n", post_data);

    g_print("post_data_len = %i\n", request_info->post_data_len);

    g_print("response = %s\n", response);

    g_return_if_fail(response != NULL);

    response_length = strlen(response);

    mg_printf(conn, "Content-Length: %d\r\n\r\n", response_length);

    mg_write(conn, response, response_length);

    free(response);

}

static void

process_upload_request(struct mg_connection *conn, const struct mg_request_info *request_info, void *user_data)

{

    NGPlugin *plugin_data = (NGPlugin*) user_data;

    NNTPGrabNZB *nzb;

    NGList *list;

    char *errmsg = NULL;

    char *warnings = NULL;

    char *nzb_data;

    char *collection_name;

    g_return_if_fail(plugin_data != NULL);

    if (strcmp(request_info->request_method, "POST") ||

        request_info->post_data_len == 0) {

        mg_printf(conn, "%s", "HTTP/1.1 400 Bad request\r\n");

        mg_printf(conn, "%s", "Content-Type: text/plain\r\n\r\n");

        mg_printf(conn, "%s", "This URI should only be used for NZB upload requests\r\n");

        return;

    }

    collection_name = mg_get_var(conn, "collection_name");

    if (!collection_name) {

        mg_printf(conn, "%s", "HTTP/1.1 400 Bad request\r\n");

        mg_printf(conn, "%s", "Content-Type: text/plain\r\n\r\n");

        mg_printf(conn, "%s", "The argument collection_name is missing\r\n");

        return;

    }

    nzb_data = mg_get_var(conn, "nzb_data");

    if (!nzb_data) {

        mg_printf(conn, "%s", "HTTP/1.1 400 Bad request\r\n");

        mg_printf(conn, "%s", "Content-Type: text/plain\r\n\r\n");

        mg_printf(conn, "%s", "The argument nzb_data is missing\r\n");

        return;

    }

    g_print("collection_name = %s\n", collection_name);

    g_print("nzb_data = %s\n", nzb_data);

    g_print("post_data_len = %i\n", request_info->post_data_len);

    mg_printf(conn, "%s", "HTTP/1.1 200 OK\r\n");

    mg_printf(conn, "%s", "Content-Type: text/plain\r\n\r\n");

    /* Try to parse the NZB file */

    if (!(nzb = nntpgrab_utils_parse_nzb_file(nzb_data, &errmsg))) {

        mg_printf(conn, "ERROR: Unable to parse NZB file: %s\r\n", errmsg);

        ng_free(errmsg);

        goto out;

    }

    /* Add all the files to the download queue */

    list = nzb->files;

    while (list) {

        NNTPGrabNZBFile *file = list->data;

        if (!plugin_data->core_funcs.schedular_add_file_to_queue(collection_name, file->subject, file->poster, file->stamp, file->filesize, file->groups, file->segments, &errmsg)) {

            if (warnings) {

                char *tmp = g_strdup_printf("%s\n%s", warnings, errmsg);

                g_free(warnings);

                warnings = tmp;

            } else {

                warnings = g_strdup_printf(_("File could not be added to the download queue:\r\n%s"), errmsg);

            }

            g_free(errmsg);

            errmsg = NULL;

        }

        list = ng_list_next(list);

    }

    /* Save the download queue */

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

        char *msg;

        if (errmsg) {

            msg = g_strdup_printf(_("Download queue could not be saved:\r\n%s"), errmsg);

            g_free(errmsg);

        } else {

            msg = g_strdup_printf(_("Download queue could not be saved"));

        }

        mg_printf(conn, "ERROR: %s\r\n", msg);

        g_free(msg);

        goto out;

    }

    g_print("warnings = %s\n", warnings);

    if (!warnings) {

        mg_printf(conn, "OK: NZB file imported successfully\r\n");

    } else {

        mg_printf(conn, "WARN: %s\r\n", warnings);

        g_free(warnings);

    }

out:

    free(collection_name);

    free(nzb_data);

    return;

}

static void

on_log_message_received(struct mg_connection *conn, const struct mg_request_info *info, void *message)

{

    g_return_if_fail(plugin_data_global != NULL);

    ng_plugin_emit_log_msg(plugin_data_global, NG_LOG_LEVEL_INFO, "%s", (char*) message);

}