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 

#include 

#include 

#include 

#ifdef ENABLE_GUI

#include "nntpgrab_gui_base.h"

#endif

#ifdef WIN32

#include 

#include 

#include  /* freeaddrinfo for Win2k */

#else

#include 

#include 

#include 

#include 

#endif /* WIN32 */

#include "nntpgrab.h"

#include "nntpgrab_utils.h"

#ifdef WIN32

#define CLOSE(x)    closesocket(x)

#else

#define CLOSE(x)    close(x)

#endif

static NntpgrabCore *core = NULL;

#ifdef ENABLE_GUI

static gboolean gui_enabled = FALSE;

#endif

#ifdef ENABLE_GUI

static gboolean

on_plugin_event(NntpgrabCore *core, const char *plugin_name, const char *event_name, const char **params, gpointer data)

{

    GtkWidget *lblNumActiveConnections;

    if (!strcmp(plugin_name, "JSON-RPC") && !strcmp(event_name, "num_active_connections_changed")) {

        lblNumActiveConnections= nntpgrab_gui_base_get_widget("lblNumActiveConnections");

        gtk_label_set_text(GTK_LABEL(lblNumActiveConnections), params[0]);

    }

    return FALSE;

}

#endif

#ifdef ENABLE_GUI

G_MODULE_EXPORT void

on_btnQuit_clicked(GtkWidget *caller, gpointer data)

{

    GtkWidget *windowMain;

    windowMain = nntpgrab_gui_base_get_widget("windowMain");

    gtk_widget_hide(windowMain);

    gtk_main_quit();

}

static void

on_schedular_state_changed(NntpgrabCore *core, NGSchedularState new_state, const char *reason)

{

    GtkWidget *btnPauseSchedular;

    GtkWidget *lblSchedularState;

    btnPauseSchedular = nntpgrab_gui_base_get_widget("btnPauseSchedular");

    lblSchedularState = nntpgrab_gui_base_get_widget("lblSchedularState");

    switch (new_state) {

        case SCHEDULAR_STATE_RUNNING:

            gtk_widget_set_sensitive(btnPauseSchedular, TRUE);

            gtk_button_set_label(GTK_BUTTON(btnPauseSchedular), _("Stop the schedular"));

            gtk_label_set_text(GTK_LABEL(lblSchedularState), _("Running"));

            break;

        case SCHEDULAR_STATE_STOPPING:

            gtk_widget_set_sensitive(btnPauseSchedular, FALSE);

            gtk_button_set_label(GTK_BUTTON(btnPauseSchedular), _("Stop the schedular"));

            gtk_label_set_text(GTK_LABEL(lblSchedularState), _("Stopping"));

            break;

        case SCHEDULAR_STATE_STOPPED:

        default:

            gtk_widget_set_sensitive(btnPauseSchedular, TRUE);

            gtk_button_set_label(GTK_BUTTON(btnPauseSchedular), _("Start the schedular"));

            gtk_label_set_text(GTK_LABEL(lblSchedularState), _("Stopped"));

            break;

    }

}

G_MODULE_EXPORT void

on_btnPauseSchedular_clicked(GtkWidget *caller, gpointer data)

{

    switch(nntpgrab_core_schedular_get_state(core)) {

        case SCHEDULAR_STATE_RUNNING:

            nntpgrab_core_schedular_stop(core, FALSE);

            break;

        case SCHEDULAR_STATE_STOPPED:

            nntpgrab_core_schedular_start(core);

            break;

        default:

            g_return_if_reached();

    }

}

static gboolean

print_handler2(gpointer data)

{

    char *message = (char*) data;

    static gboolean mark_initialized = FALSE;

    GtkTextIter iter;

    GtkWidget *textviewLog;

    GtkTextBuffer *buffer;

    GtkTextMark *mark;

    textviewLog = nntpgrab_gui_base_get_widget("textviewLog");

    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textviewLog));

    gtk_text_buffer_get_end_iter(buffer, &iter);

    gtk_text_buffer_insert(buffer, &iter, message, -1);

    // Scroll to the end

    if (!mark_initialized) {

        mark_initialized = TRUE;

        gtk_text_buffer_create_mark (buffer, "scroll", &iter, TRUE);

    }

    mark = gtk_text_buffer_get_mark (buffer, "scroll");

    gtk_text_buffer_get_end_iter (buffer, &iter);

    // Move the iterator to the beginning of line, so we don't scroll in horizontal direction

    gtk_text_iter_set_line_offset (&iter, 0);

    gtk_text_buffer_move_mark (buffer, mark, &iter);

    gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(textviewLog), mark);

    g_free(message);

    return FALSE;

}

static void

nntpgrab_server_print_handler(const char *message)

{

    g_idle_add(print_handler2, g_strdup(message));

}

#endif

static void

on_log_message(NntpgrabCore *core, const char *component, NGLogLevel log_level, const char *msg)

{

    char stamp_str[64];

    char *log_level_str;

    struct tm *tm;

    time_t stamp;

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

    stamp = time(NULL);

    tm = localtime(&stamp);

    strftime(stamp_str, sizeof(stamp_str) - 1, "%Y-%m-%d %H:%M:%S", tm);

    switch (log_level) {

        case NG_LOG_LEVEL_INFO:

            log_level_str = "INFO";

            break;

        case NG_LOG_LEVEL_WARNING:

            log_level_str = "WARNING";

            break;

        case NG_LOG_LEVEL_ERROR:

            log_level_str = "ERROR";

            break;

        case NG_LOG_LEVEL_FATAL:

            log_level_str = "FATAL";

            break;

        case NG_LOG_LEVEL_DEBUG:

            log_level_str = "DEBUG";

            break;

        case NG_LOG_LEVEL_ALL:

        default:

            /* Shouldn't happen */

            log_level_str = "UNKNOWN";

            break;

    }

    if (log_level == NG_LOG_LEVEL_WARNING || log_level == NG_LOG_LEVEL_ERROR) {

        g_warning("%s - %s - %s - %s\n", stamp_str, component, log_level_str, msg);

    } else if (log_level == NG_LOG_LEVEL_FATAL) {

        g_error("%s - %s - %s - %s\n", stamp_str, component, log_level_str, msg);

    } else {

        g_print("%s - %s - %s - %s\n", stamp_str, component, log_level_str, msg);

    }

}

static void

quit_request_received(NntpgrabCore *core, gpointer data)

{

    g_print("Received request to abort the NNTPGrab Server\n");

#ifdef ENABLE_GUI

    gtk_main_quit();

#else

    ng_event_handler_loop_quit();

#endif

}

#if !defined(DARWIN) && !defined(WIN32) && !defined(ENABLE_GUI)

static void

print_help(void)

{

    g_print("===============\n");

    g_print("NNTPGrab Server\n");

    g_print("===============\n");

    g_print("\n");

    g_print("Possible arguments:\n");

    g_print("-b / --background\tStart the NNTPGrab Server in the background\n");

    g_print("-h / --help\t\tYou're watching it now\n");

    g_print("\n");

}

#endif

int

main(int argc, char **argv)

{

    char *errors = NULL;

    char *warnings = NULL;

    NGConfigOpts opts;

#ifdef WIN32

    WORD wVersionRequested;

    WSADATA wsaData;

    int ret;

#endif

#if !defined(DARWIN) && !defined(WIN32) && !defined(ENABLE_GUI)

    gboolean do_fork = FALSE;

    int i = 1;

    while (argv[i]) {

        if (!strcmp(argv[i], "-b") || !strcmp(argv[i], "--background")) {

            do_fork = TRUE;

        } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {

            print_help();

            return 0;

        }

        i++;

    }

    if (do_fork) {

        pid_t pid = fork();

        if (pid == -1) {

            perror("fork");

            return 1;

        } else if (pid == 0) {

            /* This is the child process */

            fclose(stdin);

            fclose(stdout);

            fclose(stderr);

        } else {

            /* This is the parent process */

            g_print(_("The NNTPGrab Server was successfully started in the background\n"));

            return 0;

        }

    }

#endif

#if defined(WIN32) && !defined(ENABLE_GUI)

    /* Service code here */

#endif

    nntpgrab_utils_perform_base_initialization();

#ifdef WIN32

    // exchndl.dll is part of Dr. MinGW. By loading this DLL, every time the

    // program crashes a .RPT file will be created containing the backtrace

    LoadLibraryA("exchndl.dll");

    // Initialise Winsock

    wVersionRequested = MAKEWORD(2, 2);

    ret = WSAStartup(wVersionRequested, &wsaData);

    if (ret != 0) {

        /* Tell the user that we could not find a usable */

        /* WinSock DLL. */

        g_error(_("Winsock could not be initialised"));

        return -1;

    }

    /* Confirm that the WinSock DLL supports 2.2. */

    /* Note that if the DLL supports versions greater */

    /* than 2.2 in addition to 2.2, it will still return */

    /* 2.2 in wVersion since that is the version we */

    /* requested. */

    if (LOBYTE( wsaData.wVersion ) != 2 ||

        HIBYTE( wsaData.wVersion ) != 2) {

        /* Tell the user that we could not find a usable */

        /* WinSock DLL. */

        WSACleanup();

        g_error(_("Winsock 2.2 or higher is required for this program"));

        return -1;

    }

#endif

#ifdef ENABLE_GUI

    // Is there an graphical environment running?

#if !defined(WIN32) && !defined(DARWIN)

    if (g_getenv("DISPLAY")) {

#else

    if (TRUE) {

#endif

        gtk_init(&argc, &argv);

        nntpgrab_gui_base_create_ui("nntpgrab_server");

        nntpgrab_gui_base_tray_create();

        g_set_print_handler(nntpgrab_server_print_handler);

        gui_enabled = TRUE;

    }

#endif

    g_print(_("Now initialising the NNTPGrab Core...\n"));

    core = nntpgrab_core_new();

    if (!nntpgrab_core_init(core, NNTPGRAB_API_VERSION, &errors, &warnings)) {

        g_critical(_("NNTPGrab initialisation FAILED: %s\n"), errors);

#ifdef ENABLE_GUI

        g_idle_add((GSourceFunc) gtk_main_quit, NULL);

        gtk_main();

#endif

        exit(1);

    }

    /* Load the JSON-RPC plugin */

    opts = nntpgrab_core_config_get_opts(core);

    if (!nntpgrab_core_embedded_server_start(core, opts.webserver_port, &errors)) {

        g_critical(_("Unable to load JSON-RPC plugin: %s\n"), errors);

#ifdef ENABLE_GUI

        g_idle_add((GSourceFunc) gtk_main_quit, NULL);

        gtk_main();

#endif

        nntpgrab_core_destroy(core);

        exit(1);

    }

#ifdef ENABLE_GUI

    if (gui_enabled) {

        GtkWidget *windowMain = nntpgrab_gui_base_get_widget("windowMain");

        gtk_widget_show(windowMain);

        ng_signal_connect(core, "schedular_state_changed", NG_CALLBACK(on_schedular_state_changed), NULL);

        ng_signal_connect(core, "plugin_event", NG_CALLBACK(on_plugin_event), NULL);

    }

#endif

    ng_signal_connect(core, "log_message", NG_CALLBACK(on_log_message), NULL);

    ng_signal_connect(core, "quit_requested", NG_CALLBACK(quit_request_received), NULL);

    nntpgrab_core_set_emit_log_messages(core, TRUE);

    nntpgrab_core_schedular_start(core);

    if (warnings) {

        g_print("Warning:\n%s\n", warnings);

        g_free(warnings);

    }

    /* Main loop */

#ifdef ENABLE_GUI

    if (gui_enabled) {

        gtk_main();

    } else {

#endif

        ng_event_handler_loop_run();

#ifdef ENABLE_GUI

    }

#endif

    /* Cleanup */

#ifdef ENABLE_GUI

#if GTK_CHECK_VERSION(2,10,0)

    if (gui_enabled && nntpgrab_gui_base_tray_icon_get_is_shown()) {

        nntpgrab_gui_base_tray_destroy();

    }

    nntpgrab_gui_base_destroy_ui();

#endif

#endif

    nntpgrab_core_destroy(core);

    return 0;

}