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 

#ifdef WIN32

#include 

#include 

#include 

#else

#include 

#include 

#include 

#include 

#endif

#include 

#include 

#include 

#include 

#include 

#include "marshalers.h"

#include "nntpgrab_glue.h"

#include "nntpgrab.h"

#include "nntpgrab_glue_internal.h"

#include "nntpgrab_internal.h"

#include "nntpgrab_utils.h"

#include "nntpgrab_plugin.h"

#ifdef _MSC_VER

#include "config.h.win32"

#else

#include "config.h"

#endif

#ifdef WIN32

#define CLOSE(x)    closesocket(x)

#else

#define CLOSE(x)    close(x)

#endif

#ifdef _MSC_VER

#undef atoll

#define atoll _atoi64

#undef gai_strerror

#define gai_strerror gai_strerrorA

#endif

#define DEBUG(x)                            \

    g_print("%s\n", x);                     \

    nntpgrab_core_emit_log_message(FALSE, "Glue layer", NG_LOG_LEVEL_DEBUG, x, TRUE, FALSE);

static NntpgrabGlue *glue = NULL;

static gboolean abort_flag = FALSE;

static GThread *thread_listener = NULL;

struct NntpgrabGlueClass

{

    GObjectClass parent;

};

static guint signals[LAST_SIGNAL] = { 0 };

static GModule *module = NULL;

G_DEFINE_TYPE(NntpgrabGlue, glue, G_TYPE_OBJECT)

NGType

nntpgrab_glue_get_type(void)

{

    return (NGType) glue_get_type();

}

static void

glue_init (NntpgrabGlue *obj)

{

    obj->socket.socket_id = -1;

    obj->socket.recv_buf = g_string_new("");

    obj->glue_version = -1;

    obj->standalone_core = NULL;

    obj->is_initialized = FALSE;

}

static void

glue_finalize (GObject *obj)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    if (glue->standalone_core) {

        g_object_unref(glue->standalone_core);

        glue->standalone_core = NULL;

    }

    if (glue->socket.socket_id > 0) {

        CLOSE(glue->socket.socket_id);

        glue->socket.socket_id = -1;

    }

    g_string_free(glue->socket.recv_buf, TRUE);

}

static void

glue_class_init (NntpgrabGlueClass *klass)

{

    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

    gobject_class->finalize = glue_finalize;

    /** 

     * NntpgrabGlue::config-changed:

     * @obj: An instance of the NntpgrabGlue

     *

     * Something in the configuration has changed

     */

    signals[CONFIG_CHANGED_SIGNAL] =       g_signal_new("config_changed",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__VOID,

                                                        G_TYPE_NONE, 0);

    /** 

     * NntpgrabGlue::part-download-start:

     * @obj:              An instance of the NntpgrabGlue

     * @servername:       The name of the server on which this part is being downloaded

     * @conn_id:          The connection id which is used to download this part

     * @collection_name:  The name of the collection from which this part is

     * @subject:          The name of the subject from which this part is

     * @part_num:         The number of the part

     *

     * The download of a part has just started

     */

    signals[PART_DOWNLOAD_START_SIGNAL] = g_signal_new ("part_download_start",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_INT_STRING_STRING_INT,

                                                        G_TYPE_NONE, 5, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);

    /** 

     * NntpgrabGlue::part-done:

     * @obj:                An instance of the NntpgrabGlue

     * @servername:         The name of the server on which this part has just been downloaded

     * @conn_id:            The connection id which was used to download this part

     * @collection_name:    The name of the collection from which this part is

     * @subject:            The name of the subject from which this part is

     * @part_num:           The number of the part

     * @size:               The size of the part in bytes. This can be different from the size which was mentioned earlier in other calls like nntpgrab_core_schedular_foreach_task()

     *

     * The download of a part has completed successfully

     */

    signals[PART_DONE_SIGNAL] =           g_signal_new ("part_done",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_INT_STRING_STRING_INT_INT,

                                                        G_TYPE_NONE, 6, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);

    /** 

     * NntpgrabGlue::part-failed:

     * @obj:                An instance of the NntpgrabGlue

     * @servername:         The name of the server on which this part was tried

     * @conn_id:            The connection id which was used to try to download this part

     * @collection_name:    The name of the collection from which this part is

     * @subject:            The name of the subject from which this part is

     * @part_num:           The number of the part

     * @size:               The size of the part in bytes

     * @all_servers_tried:  If TRUE, all configured servers have tried to download this file and none of them succeeded

     *

     * The download of a part has failed (probably because the part isn't available on the server)

     */

    signals[PART_FAILED_SIGNAL] =         g_signal_new ("part_failed",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_INT_STRING_STRING_INT_INT_BOOLEAN,

                                                        G_TYPE_NONE, 7, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN);

    /** 

     * NntpgrabGlue::part-progress-update:

     * @obj:                An instance of the NntpgrabGlue

     * @servername:         The name of the server on which this part is being downloaded

     * @conn_id:            The connection id which is being used to download this part

     * @collection_name:    The name of the collection from which this part is

     * @subject:            The name of the subject from which this part is

     * @part_num:           The number of the part

     * @bytes_downloaded:   The number of bytes already downloaded from this part

     * @bytes_total:        The total size of this part in bytes. This can be different from the size which was mentioned earlier in other calls like nntpgrab_schedular_foreach_task()

     *

     * Every 1/10th second of a part download, this message will be sent

     */

    signals[PART_PROGRESS_UPDATE_SIGNAL] = g_signal_new ("part_progress_update",

                                                         G_OBJECT_CLASS_TYPE (klass),

                                                         G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                         0,

                                                         NULL, NULL,

                                                         nntpgrab_marshal_VOID__STRING_INT_STRING_STRING_INT_INT_INT,

                                                         G_TYPE_NONE, 7, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);

    /** 

     * NntpgrabGlue::traffic-monitor-update:

     * @obj:                An instance of the NntpgrabGlue

     * @bytes_received1:    The number of bytes received in now() - 10

     * @bytes_received2:    The number of bytes received in now() - 9

     * @bytes_received3:    The number of bytes received in now() - 8

     * @bytes_received4:    The number of bytes received in now() - 7

     * @bytes_received5:    The number of bytes received in now() - 6

     * @bytes_received6:    The number of bytes received in now() - 5

     * @bytes_received7:    The number of bytes received in now() - 4

     * @bytes_received8:    The number of bytes received in now() - 3

     * @bytes_received9:    The number of bytes received in now() - 2

     * @bytes_received10:   The number of bytes received in now() - 1

     * @stamp:              The timestamp of the last measurement

     * @average:            The average number of bytes per second

     *

     * Every second, traffic statistics about the last 10 seconds are given

     */

    signals[TRAFFIC_MONITOR_UPDATE_SIGNAL] = g_signal_new ("traffic_monitor_update",

                                                         G_OBJECT_CLASS_TYPE (klass),

                                                         G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                         0,

                                                         NULL, NULL,

                                                         nntpgrab_marshal_VOID__INT_INT_INT_INT_INT_INT_INT_INT_INT_INT_INT64_DOUBLE,

                                                         G_TYPE_NONE, 12, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT64, G_TYPE_DOUBLE);

    /** 

     * NntpgrabGlue::collection-added:

     * @obj:                                An instance of the NntpgrabGlue

     * @collection_name:                    The name of the collection which was just added

     * @poster:             (allow-none):   The poster of this collection. If multiple posters are involved, this value will be NULL

     *

     * A new collection was added

     */

    signals[COLLECTION_ADDED_SIGNAL] =    g_signal_new ("collection_added",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_STRING,

                                                        G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::collection-removed:

     * @obj:                An instance of the NntpgrabGlue

     * @collection_name:    The name of the collection which was just removed

     *

     * A collection was removed

     */

    signals[COLLECTION_REMOVED_SIGNAL] =  g_signal_new ("collection_removed",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING,

                                                        G_TYPE_NONE, 1, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::collection-modified:

     * @obj:                                An instance of the NntpgrabGlue

     * @collection_name:                    The name of the collection which was just changed

     * @poster:             (allow-none):   The name of the poster of this collection. This value can be NULL if multiple posters are involved

     *

     * The poster of a collection was modified

     */

    signals[COLLECTION_MODIFIED_SIGNAL] =  g_signal_new ("collection_modified",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_STRING,

                                                        G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::file-added:

     * @obj:                                            An instance of the NntpgrabGlue

     * @collection_name:                                The name of the collection in which this file belongs

     * @subject:                                        The subject of the file which was just added

     * @poster:                                         The poster of the file which was just added

     * @stamp:                                          The stamp mentioning when the first part of this file was posted

     * @file_size:                                      The size of this file in bytes

     * @total_size:                                     The size of the entire collection in bytes

     * @total_size_remaining:                           The number of bytes which still need to be downloaded from the entire collection

     * @status:                                         The current status of this file. This is of the type #NGTaskState

     * @num_parts:                                      The number of parts of which this file consists

     * @groups:                 (element-type utf8):    A list containing the groups in which this file is posted

     *

     * A file was added to a already existing collection

     */

    signals[FILE_ADDED_SIGNAL] =          g_signal_new ("file_added",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_STRING_STRING_UINT64_UINT64_UINT64_UINT64_INT_INT_POINTER,

                                                        G_TYPE_NONE, 10, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_INT, G_TYPE_INT, G_TYPE_POINTER);

    /** 

     * NntpgrabGlue::file-removed:

     * @obj:                    An instance of the NntpgrabGlue

     * @collection_name:        The name of the collection in which this file was situated

     * @subject:                The subject of the file

     * @total_size:             The new total size of the entire collection

     * @total_size_remaining:   The new total size remaining of the entire collection

     *

     * A file was removed from the download queue

     */

    signals[FILE_REMOVED_SIGNAL] =        g_signal_new ("file_removed",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_STRING_UINT64_UINT64,

                                                        G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64);

    /** 

     * NntpgrabGlue::file-download-state-update:

     * @obj:                    An instance of the NntpgrabGlue

     * @collection_name:        The collection name

     * @subject:                The subject

     * @num_parts_total:        The number of parts of which this file consists

     * @num_parts_done:         The number of parts of this file which are already downloaded

     * @num_parts_failed:       The number of parts of this file which failed to download

     * @file_size:              The size of this file in bytes

     * @file_size_remaining:    The number of bytes remaining from this file

     * @total_size:             The total size of the entire collection in bytes

     * @total_size_remaining:   The number of bytes remaining from the entire collection

     *

     * The state of a file in the download queue has changed

     */

    signals[FILE_DOWNLOAD_STATE_UPDATE_SIGNAL] =  g_signal_new ("file_download_state_update",

                                                                G_OBJECT_CLASS_TYPE (klass),

                                                                G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                                0,

                                                                NULL, NULL,

                                                                nntpgrab_marshal_VOID__STRING_STRING_INT_INT_INT_UINT64_UINT64_UINT64_UINT64,

                                                                G_TYPE_NONE, 9, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64);

    /** 

     * NntpgrabGlue::file-state-changed:

     * @obj:                                An instance of the NntpgrabGlue

     * @collection_name:                    The name of the collection in which the state changed

     * @subject:                            The subject of the file which changed state

     * @real_filename:      (allow-none):   The file name of the physical resulting file. Will be NULL if the file isn't completely downloaded and decoded yet

     * @old_state:                          The old state of the file

     * @new_state:                          The new state of the file

     *

     * A file in the download queue was restarted

     */

    signals[FILE_STATE_CHANGED_SIGNAL] =  g_signal_new ("file_state_changed",

                                                        G_OBJECT_CLASS_TYPE (klass),

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

                                                        nntpgrab_marshal_VOID__STRING_STRING_STRING_INT_INT_UINT64_UINT64_UINT64,

                                                        G_TYPE_NONE, 8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64);

    /** 

     * NntpgrabGlue::connection-connecting:

     * @obj:                An instance of the NntpgrabGlue

     * @servername:         The name of the server to which a connection is being made

     * @conn_id:            An identifier for this connection

     *

     * A new connection is being made to a usenet server

     */

    signals[CONNECTION_CONNECTING_SIGNAL] =  g_signal_new   ("connection_connecting",

                                                             G_OBJECT_CLASS_TYPE (klass),

                                                             G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                             0,

                                                             NULL, NULL,

                                                             nntpgrab_marshal_VOID__STRING_INT,

                                                             G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);

    /** 

     * NntpgrabGlue::connection-connected:

     * @obj:                An instance of the NntpgrabGlue

     * @servername:         The name of the server to which a connection has just been made

     * @conn_id:            An identifier for this connection

     * @welcome_msg:        The welcome message which was returned from the server

     *

     * A connection attempt has succeeded

     */

    signals[CONNECTION_CONNECTED_SIGNAL] =  g_signal_new    ("connection_connected",

                                                             G_OBJECT_CLASS_TYPE (klass),

                                                             G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                             0,

                                                             NULL, NULL,

                                                             nntpgrab_marshal_VOID__STRING_INT_STRING,

                                                             G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::connection-disconnect:

     * @obj:                             An instance of the NntpgrabGlue

     * @servername:                      The name of the server which was just disconnected

     * @conn_id:                         An identifier for this connection

     * @disconnect_type:                 One of the values from #NNTPDisconnectType

     * @reason:           (allow-none):  The reason which indicates why the disconnect occured. Can be NULL

     *

     * A connection to a usenet server was disconnected

     */

    signals[CONNECTION_DISCONNECT_SIGNAL] = g_signal_new ("connection_disconnect",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING_INT_ENUM_STRING,

                                                          G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::schedular-state-changed:

     * @obj:                        An instance of the NntpgrabGlue

     * @new_state:                  The new state of the schedular

     * @reason:     (allow-none):   The reason why the schedular changed state. Will be NULL if it's caused by request of the user (nntpgrab_core_schedular_start() / nntpgrab_core_schedular_stop())

     *

     * The state of the schedular has changed

     */

    signals[SCHEDULAR_STATE_CHANGED_SIGNAL] = g_signal_new ("schedular_state_changed",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__INT_STRING,

                                                          G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::log-message:

     * @obj:                    An instance of the NntpgrabGlue

     * @component:              The component which emit this log message

     * @log_level:              One of the values from #NGLogLevel

     * @msg:                    The log message which was emit

     *

     * A log message has been emitted

     */

    signals[LOG_MESSAGE_SIGNAL] =           g_signal_new ("log_message",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING_INT_STRING,

                                                          G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::connection-lost:

     * @obj:                    An instance of the NntpgrabGlue

     * @reason:                 The reason why the connection was lost

     *

     * The connection to the NNTPGrab Server has been lost

     */

    signals[CONNECTION_LOST_SIGNAL] =       g_signal_new ("connection_lost",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING,

                                                          G_TYPE_NONE, 1, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::task-moved:

     * @obj:                    An instance of the NntpgrabGlue

     * @orig_collection_name:   The name of the original collection of which the file was a member of

     * @subject:                The subject of the file

     * @new_collection_name:    The name of the new collection to which the file is moved (which can be the same of @orig_collection_name)

     * @old_position:           The original position of the file in the original collection

     * @new_position:           The new position of the file in the new collection

     *

     * The position of a task in the download queue has changed

     */

    signals[TASK_MOVED_SIGNAL] =            g_signal_new ("task_moved",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING_STRING_STRING_INT_INT,

                                                          G_TYPE_NONE, 5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);

    /** 

     * NntpgrabGlue::collection-moved:

     * @obj:                    An instance of the NntpgrabGlue

     * @collection_name:        The name of the collection which has just been moved

     * @old_position:           The original position in the download queue of the collection

     * @new_position:           The new position in the download queue of the collection

     *

     * The position of a collection in the download queue has changed

     */

    signals[COLLECTION_MOVED_SIGNAL] =      g_signal_new ("collection_moved",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING_INT_INT,

                                                          G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);

    /** 

     * NntpgrabGlue::collection-downloaded:

     * @obj:                     An instance of the NntpgrabGlue

     * @collection_name:         The name of the collection which has been fully downloaded

     *

     * A collection has been completely downloaded

     */

    signals[COLLECTION_DOWNLOADED_SIGNAL] =    g_signal_new("collection_downloaded",

                                                            G_OBJECT_CLASS_TYPE (klass),

                                                            G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                            0,

                                                            NULL, NULL,

                                                            nntpgrab_marshal_VOID__STRING,

                                                            G_TYPE_NONE, 1, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::all-downloads-completed:

     * @obj:                   An instance of the NntpgrabGlue

     *

     * This message is emit when all the items in the download queue are completed

     */

    signals[ALL_DOWNLOADS_COMPLETED_SIGNAL] =  g_signal_new("all_downloads_completed",

                                                            G_OBJECT_CLASS_TYPE (klass),

                                                            G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                            0,

                                                            NULL, NULL,

                                                            nntpgrab_marshal_VOID__VOID,

                                                            G_TYPE_NONE, 0);

    /** 

     * NntpgrabGlue::plugin-loaded:

     * @obj:                   An instance of the NntpgrabGlue

     * @plugin_name:           The name of the plugin

     * @is_persistent:         Unused in NNTPGrab 0.7

     *

     * A plugin has been loaded

     */

    signals[PLUGIN_LOADED_SIGNAL] =          g_signal_new("plugin_loaded",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING_BOOL,

                                                          G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN);

    /** 

     * NntpgrabGlue::plugin-unloaded:

     * @obj:                 An instance of the NntpgrabGlue

     * @plugin_name:         The name of the plugin

     *

     * A plugin has been unloaded

     */

    signals[PLUGIN_UNLOADED_SIGNAL] =        g_signal_new("plugin_unloaded",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING,

                                                          G_TYPE_NONE, 1, G_TYPE_STRING);

    /** 

     * NntpgrabGlue::plugin-event:

     * @obj:                 An instance of the NntpgrabGlue

     * @plugin_name:         The name of the plugin

     * @event_name:          The name of the plugin event

     * @values:              The values belonging to this event. This is a NULL-terminated array

     *

     * A plugin has emit an event

     */

    signals[PLUGIN_EVENT_SIGNAL] =           g_signal_new("plugin_event",

                                                          G_OBJECT_CLASS_TYPE (klass),

                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                          0,

                                                          NULL, NULL,

                                                          nntpgrab_marshal_VOID__STRING_STRING_BOXED,

                                                          G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRV);

}

static void

strip_newline(char *line)

{

    if (strlen(line) <= 1) {

        return;

    }

    if (line[strlen(line) - 1]  == '\n') {

        line[strlen(line) - 1] = '\0';

    }

    if (line[strlen(line) - 1]  == '\r') {

        line[strlen(line) - 1] = '\0';

    }

}

static gboolean

read_line(Connection *sock, char **ret_line, int timeout, gboolean *error_flag)

{

    int i;

    int len;

    char *line;

    time_t stamp;

    char buf[1024];

    g_return_val_if_fail(ret_line != NULL, FALSE);

    if (error_flag) {

        *error_flag = FALSE;

    }

    g_return_val_if_fail(sock > 0, FALSE);

    stamp = time(NULL);

    do {

        struct timeval tv;

        fd_set recv_fds;

        // Check is there is a newline in the buffer

        for (i = 0; i < sock->recv_buf->len; i++) {

            if (sock->recv_buf->str[i] == '\n') {

                // Newline found, split the buffer into a line and process it

                line = g_strndup(sock->recv_buf->str, i);

                strip_newline(line);

                g_string_erase(sock->recv_buf, 0, i + 1);

                /* Shrink the recv buffer if it became really large by the last line */

                if (sock->recv_buf->allocated_len > 1024 && sock->recv_buf->len < 1024) {

                    /* GLib doesn't have an API function to shrink a GString so we do it manually here */

                    sock->recv_buf->str = g_realloc (sock->recv_buf->str, 1024);

                    sock->recv_buf->allocated_len = 1024;

                }

                *ret_line = line;

                return TRUE;

            }

        }

        /* Ignore really long lines (> 1MB) */

        if (sock->recv_buf->len > 1024 * 1024 * 1) {

            CLOSE(sock->socket_id);

            sock->socket_id = -1;

            if (error_flag) {

                *error_flag = TRUE;

            }

            *ret_line = g_strdup("Too long line received from server. Disconnecting");

            return FALSE;

        }

        // No newline found, try to read new data from the socket

        do {

            FD_ZERO(&recv_fds);

            FD_SET(sock->socket_id, &recv_fds);

            tv.tv_sec = timeout;

            tv.tv_usec = 0;

            len = select(sock->socket_id + 1, &recv_fds, NULL, NULL, &tv);

            if (len == 0) {

                // Read timeout

                *ret_line = g_strdup("Read timeout");

                return FALSE;

            } else if (len == 1) {

                gboolean beenhere = FALSE;

                do {

                    if (beenhere) {

                        g_usleep(G_USEC_PER_SEC / 10);

                    } else {

                        beenhere = TRUE;

                    }

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

                    len = recv(sock->socket_id, buf, sizeof(buf) - 1, 0);

                    if (len > 0) {

                        g_string_append_len(sock->recv_buf, buf, len);

                    }

                } while (len == -1 && errno == EAGAIN && stamp + timeout > time(NULL));

            }

        } while (len == -1 && errno == EINTR && stamp + timeout > time(NULL));

        if (len == -1) {

            if (errno == EAGAIN) {

                // Read timeout

                *ret_line = g_strdup("Read timeout");

                return FALSE;

            }

            // Error occured

g_print(__FILE__":%i Error occured: %s\n", __LINE__, strerror(errno));

            if (error_flag) {

                *error_flag = TRUE;

            }

            CLOSE(sock->socket_id);

            sock->socket_id = -1;

            *ret_line = g_strdup_printf("Unexpected error occured while performing read: %s", strerror(errno));

            return FALSE;

        }

        if (len == 0) {

            // EOF, disconnect

g_print(__FILE__":%i EOF detected\n", __LINE__);

            if (error_flag) {

                *error_flag = TRUE;

            }

            CLOSE(sock->socket_id);

            sock->socket_id = -1;

            *ret_line = g_strdup(_("NNTPGrab server has disconnected"));

            return FALSE;

        }

    } while (TRUE);

    g_assert_not_reached();

    return FALSE;

}

gboolean

write_line(Connection *sock, const char *format, ...)

{

    char *line;

    va_list ap;

    va_start(ap, format);

    g_vasprintf(&line, format, ap);

    va_end(ap);

    if (send(sock->socket_id, line, strlen(line), 0) == -1) {

        free(line);

        CLOSE(sock->socket_id);

        sock->socket_id = -1;

        return FALSE;

    }

    free(line);

    return TRUE;

}

static void

connect_to_server(Connection *sock, const char *hostname, int port, char **errmsg)

{

    struct addrinfo hints, *res, *ressave;

    int n;

    char *str_port;

    struct timeval tv;

#if 0 

    SSL *ssl;

#endif

    g_return_if_fail(sock != NULL);

    g_return_if_fail(hostname != NULL);

    g_return_if_fail(port > 0);

    g_return_if_fail(port < 65535);

    g_return_if_fail(errmsg != NULL);

    g_return_if_fail(*errmsg == NULL);

    if (sock->socket_id >= 0) {

        CLOSE(sock->socket_id);

    }

    sock->socket_id = -1;

    memset(&hints, 0, sizeof(struct addrinfo));

    hints.ai_family = AF_UNSPEC;

    hints.ai_socktype = SOCK_STREAM;

    str_port = g_strdup_printf("%i", port);

    n = getaddrinfo(hostname, str_port, &hints, &res);

    g_free(str_port);

    if (n != 0) {

        *errmsg = g_strdup(gai_strerror(n));

        return;

    }

    ressave = res;

    while (res) {

        sock->socket_id = socket(res->ai_family, res->ai_socktype, res->ai_protocol);

#ifdef WIN32

        if ((sock->socket_id == INVALID_SOCKET)) {

#else

        if ((sock->socket_id == -1)) {

#endif

            // The socket couldn't be created

            // Save the errno and try the next item in the list

            res = res->ai_next;

            sock->socket_id = -1;

            if (*errmsg) {

                g_free(*errmsg);

            }

            *errmsg = g_strdup(strerror(errno));

            continue;

        }

        // Set the connection timeout on the socket

        tv.tv_sec = 5;

        tv.tv_usec = 0;

        setsockopt(sock->socket_id, SOL_SOCKET, SO_RCVTIMEO, (const void*) &tv, sizeof(tv));

        setsockopt(sock->socket_id, SOL_SOCKET, SO_SNDTIMEO, (const void*) &tv, sizeof(tv));

        if (connect(sock->socket_id, res->ai_addr, (int) res->ai_addrlen) == 0) {

            // Connection succesfull

            break;

        }

        // Connection could not be made

#ifndef WIN32

        if (errno == EINPROGRESS) {

            // The connection could not be established within the connect time limit.

            // This provides a more clear error message

            errno = ETIMEDOUT;

        }

#endif

        if (*errmsg) {

            g_free(*errmsg);

        }

#ifdef WIN32

        switch(WSAGetLastError()) {

            case WSAECONNREFUSED:

                *errmsg = g_strdup(_("Connection refused"));

                break;

            case WSAETIMEDOUT:

                *errmsg = g_strdup(_("Connection timed out"));

                break;

            default:

                *errmsg = g_strdup_printf(_("Unknown error occured, WSAGetLastError() = %i"), WSAGetLastError());

                break;

        }

#else

            *errmsg = g_strdup(strerror(errno));

#endif

        CLOSE(sock->socket_id);

        sock->socket_id = -1;

        res = res->ai_next;

    }

    if (sock->socket_id == -1) {

        freeaddrinfo(ressave);

        return;

    }

    freeaddrinfo(ressave);

#if 0 

    if (use_ssl) {

        if ((ssl = prepare_ssl_connection(*conn_id, errmsg)) == NULL) {

            CLOSE(*conn_id);

            return NNTP_ERROR_SSL_INITIALISE;

        }

    } else {

        ssl = NULL;

    }

#endif

}

NntpgrabCore *

get_core(void)

{

    return (NntpgrabCore*) glue;

}

gboolean

has_signal_handler_pending(int signal_id)

{

    if (glue->standalone_core && signal_id != CONNECTION_LOST_SIGNAL) {

        return g_signal_has_handler_pending(glue->standalone_core, signals[signal_id], 0, TRUE);

    } else {

        return g_signal_has_handler_pending(glue, signals[signal_id], 0, TRUE);

    }

}

static gboolean

do_emit_connection_lost(gpointer data)

{

    char *errmsg = (char *) data;

    if (!get_core()) {

        g_free(errmsg);

        return FALSE;

    }

    g_signal_emit_by_name(get_core(), "connection_lost", errmsg);

    g_free(errmsg);

    return FALSE;

}

static void

emit_connection_lost(const char *errmsg)

{

    if (!get_core()) {

        return;

    }

    g_idle_add(do_emit_connection_lost, (gpointer) g_strdup(errmsg));

}

static gpointer

callbacks_thread(gpointer data)

{

    NntpgrabGlue *core = data;

    do {

        gboolean error_flag;

        char *line = NULL;

        if (!read_line(&core->socket, &line, 1, &error_flag)) {

            if (error_flag) {

                // An error occured!

                char *msg = g_strdup_printf(__FILE__ ":%i Connection lost from NNTPGrab Server: %s", __LINE__, line);

                emit_connection_lost(msg);

                DEBUG(msg);

                g_free(line);

                g_free(msg);

                return NULL;

            }

            if (line) {

                g_free(line);

            }

            // No data received, sleep

            g_usleep(G_USEC_PER_SEC / 10);

            continue;

        }

        glue_process_jsonrpc_msg(line);

        g_free(line);

    } while (!abort_flag);

    return NULL;

}

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

 Public functions

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

NntpgrabGlue *

nntpgrab_glue_new(void)

{

    return g_object_new((GType) NNTPGRAB_TYPE_GLUE, NULL);

}

ngboolean

nntpgrab_glue_init(NntpgrabGlue *obj, int glue_version, char **err)

{

#ifdef WIN32

    WORD wVersionRequested;

    WSADATA wsaData;

    int ret;

#endif

    glue = NNTPGRAB_GLUE(obj);

    g_return_val_if_fail(obj != NULL, FALSE);

    g_return_val_if_fail(glue != NULL, FALSE);

    if (glue->is_initialized) {

        if (err) {

            *err = g_strdup_printf(_("NNTPGrab Core already initialized"));

        }

        return FALSE;

    }

    // Check if the API version matches

    if (glue_version != NNTPGRAB_GLUE_VERSION) {

        if (err) {

            *err = g_strdup_printf(_("NNTPGrab Glue API mismatch (Glue API version = %i, frontend's version = %i)"), NNTPGRAB_GLUE_VERSION, glue_version);

        }

        return FALSE;

    }

#ifdef WIN32

    // 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. */

        if (err) {

            *err = g_strdup_printf(_("Winsock could not be initialised"));

        }

        return FALSE;

    }

    /* 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( );

        if (err) {

            *err = g_strdup_printf(_("Winsock 2.2 or higher is required for this program"));

        }

        return FALSE;

    }

#endif

    glue->glue_version = glue_version;

    glue->is_initialized = TRUE;

    return TRUE;

}

static gboolean

ensure_core_library_is_loaded(char **err)

{

    if (module) {

        return TRUE;

    }

#ifdef WIN32

#define EXT "-0.dll"

#elif DARWIN

#define EXT ".0.dylib"

#else

#define EXT ".so.0"

#endif

    module = g_module_open("libnntpgrab" EXT, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);

    if (!module) {

        if (err) {

            *err = g_strdup_printf(_("Error while loading NNTPGrab Core library:\n%s\n"), g_module_error());

        } else {

            g_error(_("Error while loading NNTPGrab Core library:\n%s\n"), g_module_error());

        }

        return FALSE;

    }

    g_module_make_resident(module);

    return TRUE;

}

static void

bind_func(const char *name, void **func, char **err)

{

    if (!ensure_core_library_is_loaded(err)) {

        return;

    }

    if (!(*func)) {

        g_module_symbol(module, name, func);

    }

    if (!(*func)) {

        if (err) {

            *err = g_strdup_printf(_("Unable to bind the function '%s'\n%s"), name, g_module_error());

        } else {

            g_critical(_("Unable to bind the function '%s'\n%s"), name, g_module_error());

        }

    }

}

static ngboolean

nntpgrab_core_new_and_init(NntpgrabGlue *glue, int version, char **err, char **warnings)

{

    static NntpgrabCore *(*new_func) (void) = NULL;

    static ngboolean (*init_func) (NntpgrabCore *, int, char **, char **) = NULL;

    g_return_val_if_fail(glue != NULL, FALSE);

    if (!ensure_core_library_is_loaded(err)) {

        return FALSE;

    }

    bind_func("nntpgrab_core_new", (void**) &new_func, err);

    g_return_val_if_fail(new_func != NULL, FALSE);

    glue->standalone_core = new_func();

    bind_func("nntpgrab_core_init", (void**) &init_func, err);

    g_return_val_if_fail(init_func != NULL, FALSE);

    if (!init_func(glue->standalone_core, version, err, warnings)) {

        return FALSE;

    }

    return TRUE;

}

ngboolean

nntpgrab_glue_connect(NntpgrabGlue *obj, const char *hostname, int port, const char *username, const char *password, ngboolean use_ssl, char **err, char **warnings)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    int api_version = 0;

    char *line = NULL;

    g_return_val_if_fail(glue != NULL, FALSE);

    g_return_val_if_fail(glue->is_initialized == TRUE, FALSE);

    g_return_val_if_fail(err != NULL, FALSE);

    g_return_val_if_fail(*err == NULL, FALSE);

    g_return_val_if_fail(warnings != NULL, FALSE);

    g_return_val_if_fail(*warnings == NULL, FALSE);

    if (!hostname || strlen(hostname) == 0) {

        return nntpgrab_core_new_and_init(glue, NNTPGRAB_API_VERSION, err, warnings);

    }

    connect_to_server(&glue->socket, hostname, port, err);

    if (glue->socket.socket_id < 0) {

        return FALSE;

    }

    // API check

    if (!write_line(&glue->socket, "NNTPGrab - API version %i\r\n\r\n", NNTPGRAB_PLUGIN_API_VERSION)) {

        *err = g_strdup_printf(_("NNTPGrab Server API mismatch (Server API version = %i, frontend's version = %i)"), NNTPGRAB_PLUGIN_API_VERSION, api_version);

        return FALSE;

    }

    if (!read_line(&glue->socket, &line, READ_TIMEOUT_VALUE, NULL)) {

        char msg[128];

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

        snprintf(msg, sizeof(msg) - 1, __FILE__ ":%i Connection lost from NNTPGrab Server: %s\n", __LINE__, line);

        DEBUG(msg);

        g_free(line);

        return FALSE;

    }

    if (strcmp(line, "OK")) {

        char msg[128];

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

        snprintf(msg, sizeof(msg) - 1, __FILE__ ":%i unknown response received: %s\n", __LINE__, (line ? line : ""));

        DEBUG(msg);

        g_free(line);

        return FALSE;

    }

    g_free(line);

    thread_listener = g_thread_create(callbacks_thread, glue, TRUE, NULL);

    return TRUE;

}

ngboolean

nntpgrab_glue_get_is_connected(NntpgrabGlue *obj)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    if (glue->socket.socket_id < 0) {

        return FALSE;

    }

    return TRUE;

}

void

nntpgrab_glue_destroy(NntpgrabGlue *obj)

{

    g_object_unref(obj);

}

void

nntpgrab_glue_kill_server(NntpgrabGlue *obj)

{

    nntpgrab_glue_internal_kill_server(obj);

}

NGList *

nntpgrab_glue_config_get_avail_servers(NntpgrabGlue *obj)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    static NGList *(*func) (NntpgrabCore *) = NULL;

    g_return_val_if_fail(glue->is_initialized == TRUE, FALSE);

    if (glue->standalone_core) {

        bind_func("nntpgrab_core_config_get_avail_servers", (void**) &func, NULL);

        g_return_val_if_fail(func != NULL, NULL);

        return func(glue->standalone_core);

    } else {

        return nntpgrab_glue_internal_config_get_avail_servers(glue);

    }

}

void

nntpgrab_glue_config_free_avail_servers(NntpgrabGlue *obj, NGList *servers)

{

    NGList *list;

    list = servers;

    while (list) {

        g_free(list->data);

        list = ng_list_next(list);

    }

    g_list_free((GList*) servers);

}

gboolean

nntpgrab_glue_config_get_server_info(NntpgrabGlue *obj, const char *servername, NGConfigServer *ret)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    static gboolean (*func) (NntpgrabCore *, const char *, NGConfigServer *) = NULL;

    g_return_val_if_fail(glue->is_initialized == TRUE, FALSE);

    if (glue->standalone_core) {

        bind_func("nntpgrab_core_config_get_server_info", (void**) &func, NULL);

        g_return_val_if_fail(func != NULL, FALSE);

        return func(glue->standalone_core, servername, ret);

    } else {

        return nntpgrab_glue_internal_config_get_server_info(glue, servername, ret);

    }

}

gboolean

nntpgrab_glue_config_add_server(NntpgrabGlue *obj, NGConfigServer new_server, char **errmsg)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    static gboolean (*func) (NntpgrabCore *, NGConfigServer, char **) = NULL;

    g_return_val_if_fail(glue->is_initialized == TRUE, FALSE);

    if (glue->standalone_core) {

        bind_func("nntpgrab_core_config_add_server", (void**) &func, NULL);

        g_return_val_if_fail(func != NULL, FALSE);

        return func(glue->standalone_core, new_server, errmsg);

    } else {

        return nntpgrab_glue_internal_config_add_server(glue, new_server, errmsg);

    }

}

gboolean

nntpgrab_glue_config_del_server(NntpgrabGlue *obj, const char *servername, char **errmsg)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    static gboolean (*func) (NntpgrabCore *, const char *, char **) = NULL;

    g_return_val_if_fail(glue->is_initialized == TRUE, FALSE);

    if (glue->standalone_core) {

        bind_func("nntpgrab_core_config_del_server", (void**) &func, NULL);

        g_return_val_if_fail(func != NULL, FALSE);

        return func(glue->standalone_core, servername, errmsg);

    } else {

        return nntpgrab_glue_internal_config_del_server(glue, servername, errmsg);

    }

}

gboolean

nntpgrab_glue_config_edit_server(NntpgrabGlue *obj, const char *servername, NGConfigServer new_server, char **errmsg)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    static gboolean (*func) (NntpgrabCore *, const char *, NGConfigServer, char **) = NULL;

    g_return_val_if_fail(glue->is_initialized == TRUE, FALSE);

    if (glue->standalone_core) {

        bind_func("nntpgrab_core_config_edit_server", (void**) &func, NULL);

        g_return_val_if_fail(func != NULL, FALSE);

        return func(glue->standalone_core, servername, new_server, errmsg);

    } else {

        return nntpgrab_glue_internal_config_edit_server(glue, servername, new_server, errmsg);

    }

}

NGConfigOpts

nntpgrab_glue_config_get_opts(NntpgrabGlue *obj)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    static NGConfigOpts (*func) (NntpgrabCore *) = NULL;

    NGConfigOpts dummy;

    memset(&dummy, 0, sizeof(NGConfigOpts));

    g_return_val_if_fail(glue->is_initialized == TRUE, dummy);

    if (glue->standalone_core) {

        bind_func("nntpgrab_core_config_get_opts", (void**) &func, NULL);

        g_return_val_if_fail(func != NULL, dummy);

        return func(glue->standalone_core);

    } else {

        NGConfigOpts ret;

        memset(&ret, 0, sizeof(NGConfigOpts));

        if (!nntpgrab_glue_internal_config_get_opts(glue, &ret)) {

            return dummy;

        } else {

            return ret;

        }

    }

}

void

nntpgrab_glue_config_set_opts(NntpgrabGlue *obj, NGConfigOpts opts)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    static void (*func) (NntpgrabCore *, NGConfigOpts) = NULL;

    g_return_if_fail(glue->is_initialized == TRUE);

    if (glue->standalone_core) {

        bind_func("nntpgrab_core_config_set_opts", (void**) &func, NULL);

        g_return_if_fail(func != NULL);

        func(glue->standalone_core, opts);

    } else {

        nntpgrab_glue_internal_config_set_opts(glue, opts);

    }

}

ngboolean

nntpgrab_glue_config_get_folder_listing(NntpgrabGlue *obj, const char *parent, NGList **folders)

{

    NntpgrabGlue *glue = NNTPGRAB_GLUE(obj);

    g_return_val_if_fail(glue->is_initialized == TRUE, FALSE);

    if (glue->standalone_core) {

        return nntpgrab_utils_get_folder_listing(parent, folders);

    } else {

        return nntpgrab_glue_internal_config_get_folder_listing(glue, parent, folders);

    }

}

void

nntpgrab_glue_config_free_folder_listing(NntpgrabGlue *obj, NGList *folders)

{

    nntpgrab_utils_free_folder_listing(folders);

}

gboolean

nntpgrab_glue_schedular_start(NntpgrabGlue *obj)