nntpgrab_core.c

Go to the documentation of this file.

/*
 Copyright (C) 2005-2007 Erik van Pienbroek

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

#include 
#include 
#include 
#include 
#include 
#include "nntpgrab.h"
#include "nntpgrab_internal.h"
#include "nntpgrab_utils.h"
#include "marshalers.h"
#include "configuration.h"
#include "schedular.h"
#include "nntpconnection.h"
#include "decoder.h"
#include "par2.h"

#define NNTPGRAB_TYPE_CORE (core_get_type ())
#define NNTPGRAB_CORE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), NNTPGRAB_TYPE_CORE, NNTPGrabCore))
#define NNTPGRAB_CORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NNTPGRAB_TYPE_CORE, NNTPGrabCoreClass))
#define IS_NNTPGRAB_CORE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), NNTPGRAB_TYPE_CORE))
#define IS_NNTPGRAB_CORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NNTPGRAB_TYPE_CORE))
#define NNTPGRAB_CORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NNTPGRAB_TYPE_CORE, NNTPGrabCoreClass))

struct NNTPGrabCore
{
    GObject parent;

    Configuration *config;
    Schedular *schedular;
    gboolean is_finalizing;
};

static NNTPGrabCore *core = NULL;

struct NNTPGrabCoreClass
{
    GObjectClass parent;
};

enum
{
    CONFIG_CHANGED_SIGNAL,
    PART_DOWNLOAD_START_SIGNAL,
    PART_DONE_SIGNAL,
    PART_FAILED_SIGNAL,
    PART_PROGRESS_UPDATE_SIGNAL,
    TRAFFIC_MONITOR_UPDATE_SIGNAL,
    COLLECTION_ADDED_SIGNAL,
    COLLECTION_REMOVED_SIGNAL,
    FILE_ADDED_SIGNAL,
    FILE_REMOVED_SIGNAL,
    FILE_DOWNLOAD_STATE_UPDATE_SIGNAL,
    FILE_STATE_CHANGED_SIGNAL,
    CONNECTION_CONNECTING_SIGNAL,
    CONNECTION_CONNECTED_SIGNAL,
    CONNECTION_DISCONNECT_SIGNAL,
    SCHEDULAR_STATE_CHANGED_SIGNAL,
    FATAL_ERROR_SIGNAL,
    WARNING_MESSAGE_SIGNAL,
    DEBUG_MESSAGE_SIGNAL,
    TASK_MOVED_SIGNAL,
    COLLECTION_MOVED_SIGNAL,
    LAST_SIGNAL
};

static guint signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE(NNTPGrabCore, core, G_TYPE_OBJECT)

static void
core_init (NNTPGrabCore *obj)
{
    obj->is_finalizing = FALSE;
}

static void
core_finalize (GObject *obj)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    core->is_finalizing = TRUE;

    if (core->config) {
        configuration_destroy(core->config);
    }

    if (core->schedular) {
        schedular_destroy(core->schedular);
    }
}

static void
core_class_init (NNTPGrabCoreClass *klass)
{
    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

    gobject_class->finalize = core_finalize;

    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);

    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);

    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);

    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);

    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_INT_INT_INT,
                                                         G_TYPE_NONE, 6, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);

    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);

    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,
                                                        G_TYPE_NONE, 1, G_TYPE_STRING);

    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);

    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);

    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);

    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);

    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_INT_INT,
                                                        G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);

    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);

    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);

    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);


    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);


    signals[FATAL_ERROR_SIGNAL] =           g_signal_new ("fatal_error",
                                                          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);

    signals[WARNING_MESSAGE_SIGNAL] =       g_signal_new ("warning_message",
                                                          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);

    signals[DEBUG_MESSAGE_SIGNAL] =         g_signal_new ("debug_message",
                                                          G_OBJECT_CLASS_TYPE (klass),
                                                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
                                                          0,
                                                          NULL, NULL,
                                                          nntpgrab_marshal_VOID__POINTER_STRING,
                                                          G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_STRING);

    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);

    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);
}

NNTPGrabCore *
get_core(void)
{
    if (core && core->is_finalizing) {
        return NULL;
    }

    return core;
}

static gboolean
on_config_changed(Configuration *config, gpointer data)
{
    nntpgrab_core_emit_config_changed();
    return FALSE;
}

/***************************************************************/
/* */
/* Public methods */
/* */
/***************************************************************/

NNTPGrabCore *
nntpgrab_core_init(int version, char **err, char **warnings)
{
    static gboolean initialized = FALSE;
#ifdef WIN32
    char *installation_path;
#endif

    if (initialized) {
        if (err) {
            *err = g_strdup_printf(_("NNTPGrab Core already initialized"));
        }
        return NULL;
    }

    if (!g_thread_supported ()) g_thread_init (NULL);
    g_type_init();

    // Check if the API version matches
    if (version != NNTPGRAB_API_VERSION) {
        if (err) {
            *err = g_strdup_printf(_("NNTPGrab Core API mismatch (Core API version = %i, frontend's version = %i)"), NNTPGRAB_API_VERSION, version);
        }
        return NULL;
    }

#ifdef WIN32
    // Detect the installation directory on Win32
    installation_path = g_win32_get_package_installation_directory_of_module(NULL);
    g_return_val_if_fail(installation_path != NULL, NULL);

    if (!g_getenv("NNTPGRAB_LIBDIR")) {
        char *path = g_strdup_printf("%s\\lib\\nntpgrab", installation_path);
        g_setenv("NNTPGRAB_LIBDIR", path, TRUE);
        g_free(path);
    }
    g_free(installation_path);
#endif

    core = g_object_new(NNTPGRAB_TYPE_CORE, NULL);

    if (!(core->config = configuration_new(err, warnings))) {
        g_object_unref(core);
        return NULL;
    }

    g_signal_connect(core->config, "config_changed", G_CALLBACK(on_config_changed), NULL);

    if (!nntpconnection_initialize(err)) {
        g_object_unref(core);
        return NULL;
    }

    if (!(core->schedular = schedular_new(core->config, err))) {
        g_object_unref(core);
        return NULL;
    }

    if (!decoder_initialize(err)) {
        g_object_unref(core);
        return NULL;
    }

    if (!par2_initialize(err)) {
        g_object_unref(core);
        return NULL;
    }

    initialized = TRUE;

    return core;
}

void
nntpgrab_core_cleanup(NNTPGrabCore *obj)
{
    g_object_unref(obj);
}

GList *
nntpgrab_config_get_avail_servers(NNTPGrabCore *obj)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->config);

    return configuration_get_avail_servers(core->config);
}

void
nntpgrab_config_free_avail_servers(NNTPGrabCore *obj, GList *servers)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->config);

    configuration_free_avail_servers(core->config, servers);
}

gboolean
nntpgrab_config_get_server_info(NNTPGrabCore *obj, const char *servername, ConfigServer *ret)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);
    ConfigServer *config;

    g_assert(core->config);

    config = configuration_get_server_info(core->config, servername);
    if (config) {
        memcpy(ret, config, sizeof(ConfigServer));
        g_slice_free(ConfigServer, config);
        return TRUE;
    } else {
        return FALSE;
    }
}

gboolean
nntpgrab_config_add_server(NNTPGrabCore *obj, ConfigServer new_server)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);
    gboolean retval;
    char *errmsg;

    g_assert(core->config);

    retval = configuration_add_server(core->config, new_server);

    if (!configuration_save(core->config, &errmsg)) {
        nntpgrab_core_emit_fatal_error(errmsg);
        g_free(errmsg);
    }

    return retval;
}

gboolean
nntpgrab_config_del_server(NNTPGrabCore *obj, const char *servername)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);
    gboolean retval;
    char *errmsg;

    g_assert(core->config);

    retval = configuration_del_server(core->config, servername);

    if (!configuration_save(core->config, &errmsg)) {
        nntpgrab_core_emit_fatal_error(errmsg);
        g_free(errmsg);
    }

    return retval;
}

gboolean
nntpgrab_config_edit_server(NNTPGrabCore *obj, const char *servername, ConfigServer server)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);
    gboolean retval;
    char *errmsg;

    g_assert(core->config);

    retval = configuration_edit_server(core->config, servername, server);

    if (!configuration_save(core->config, &errmsg)) {
        nntpgrab_core_emit_fatal_error(errmsg);
        g_free(errmsg);
    }

    return retval;
}

ConfigOpts
nntpgrab_config_get_opts(NNTPGrabCore *obj)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->config);

    return configuration_get_opts(core->config);
}

void
nntpgrab_config_set_opts(NNTPGrabCore *obj, ConfigOpts opts)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);
    char *errmsg;

    g_assert(core->config);

    configuration_set_opts(core->config, opts);

    if (!configuration_save(core->config, &errmsg)) {
        nntpgrab_core_emit_fatal_error(errmsg);
        g_free(errmsg);
    }
}

gboolean
nntpgrab_config_get_folder_listing(NNTPGrabCore *obj, const char *parent, GList **folders)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    return configuration_get_folder_listing(core->config, parent, folders);
}

void
nntpgrab_config_free_folder_listing(NNTPGrabCore *obj, GList *folders)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    configuration_free_folder_listing(core->config, folders);
}

gboolean
nntpgrab_schedular_start(NNTPGrabCore *obj)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    return schedular_start(core->schedular);
}

static gpointer
schedular_stop_func(gpointer data)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(data);

    g_assert(core->schedular);

    schedular_stop(core->schedular);

    return NULL;
}

gboolean
nntpgrab_schedular_stop(NNTPGrabCore *obj, gboolean wait)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    if (wait) {
        return schedular_stop(core->schedular);
    } else {
        // Is the schedular queue already stopped?
        if (schedular_get_state(core->schedular) != SCHEDULAR_STATE_RUNNING) {
            return FALSE;
        }

        g_thread_create(schedular_stop_func, obj, FALSE, NULL);

        return TRUE;
    }
}

SchedularState
nntpgrab_schedular_get_state(NNTPGrabCore *obj)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    return (schedular_get_state(core->schedular));
}

gboolean
nntpgrab_schedular_add_task_to_queue(NNTPGrabCore *obj, const char *collection_name, const char *subject, const char *poster, time_t stamp, guint64 file_size, GList *groups, GList *parts, char **errmsg)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);
    NNTPFile *file;
    GList *list;
    char *tmp;
    char *tmp2;
    ConfigOpts opts;

    g_assert(core->schedular);

    file = g_slice_new0(NNTPFile);
    strncpy((char *) file->subject, subject, sizeof(file->subject));
    strncpy((char *) file->poster, poster, sizeof(file->poster));
    file->stamp = stamp;
    file->file_size = file_size;
    file->file_size_remaining = file_size;

    opts = configuration_get_opts(core->config);
    tmp = tempnam(opts.temp_directory, NULL);
    tmp2 = g_path_get_basename(tmp);
    strncpy((char *) file->tmp_filename, tmp2, sizeof(file->tmp_filename));
    g_free(tmp2);
    free(tmp);                  // Don't use g_free here as tempnam is a libc function!

    // Detect the file type and the par2 blocks
    if (!nntpgrab_utils_strip_subject(file->subject, NULL, NULL, NULL, NULL, NULL, NULL, &file->file_type, &file->par2_startnum, &file->num_par2_blocks, NULL, &file->numparts)) {
        // Sanitize values
        file->file_type = NNTP_FILE_TYPE_UNKNOWN;
        file->par2_startnum = -1;
        file->num_par2_blocks =-1;
        file->numparts = g_list_length(parts);
    }

    file->status = TASK_STATE_WAITING_FOR_DOWNLOAD;

    if (file->par2_startnum == -1) {
        file->par2_endnum = -1;
    } else {
        file->par2_endnum = file->par2_startnum + file->num_par2_blocks;
    }

    list = groups;
    while (list) {
        const char *group = list->data;
        file->groups = g_list_append(file->groups, g_strdup(group));
        list = g_list_next(list);
    }

    list = parts;
    while (list) {
        NNTPGrabPart *part = list->data;
        NNTPPart *new_part;

        new_part = g_slice_new0(NNTPPart);

        strncpy((char *) new_part->message_id, part->message_id, sizeof(new_part->message_id));
        new_part->size = part->size;
        new_part->partnum = part->partnum;

        file->parts = g_list_append(file->parts, new_part);

        list = g_list_next(list);
    }

    return schedular_add_task_to_queue(core->schedular, collection_name, file, errmsg);
}

gboolean
nntpgrab_schedular_del_task_from_queue(NNTPGrabCore *obj, const char *collection_name, const char *subject, char **errmsg)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);
    g_assert(collection_name);

    return schedular_del_task_from_queue(core->schedular, collection_name, subject, errmsg);
}

gboolean
nntpgrab_schedular_restart_task(NNTPGrabCore *obj, const char *collection_name, const char *subject, char **errmsg)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    return schedular_restart_task(core->schedular, collection_name, subject, errmsg);
}

gboolean
nntpgrab_schedular_save_queue(NNTPGrabCore *obj, char **errmsg)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    return schedular_save_queue(core->schedular, errmsg);
}

void
nntpgrab_schedular_foreach_task(NNTPGrabCore *obj, ForeachCollectionFunc collection_func, ForeachFileFunc file_func, ForeachGroupFunc group_func, gpointer data)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    schedular_foreach_task(core->schedular, collection_func, file_func, group_func, data);
}

gboolean
nntpgrab_schedular_move_task(NNTPGrabCore *obj, const char *collection_name_src, const char *subject_src, const char *collection_name_dest, int position_dest)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    return schedular_move_task(core->schedular, collection_name_src, subject_src, collection_name_dest, position_dest);
}

gboolean
nntpgrab_schedular_move_collection(NNTPGrabCore *obj, const char *collection_name, int new_position)
{
    NNTPGrabCore *core = NNTPGRAB_CORE(obj);

    g_assert(core->schedular);

    return schedular_move_collection(core->schedular, collection_name, new_position);
}

---