NNTPGrab

/* 

    Copyright (C) 2005-2009  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 

#ifdef WIN32

#include 

#include 

#include 

#endif

#include "configuration.h"

#include "nntpgrab_internal.h"

typedef struct ConfigurationClass ConfigurationClass;

Configuration *configuration_get_object(void);

typedef struct _config_server_details

{

    GList *groups;                  // containing ConfigGroupInfo's

} ConfigServerDetails;

struct Configuration

{

    GObject parent;

    GStaticRWLock rwlock;

    GList *servers;                 // containing ConfigServer's

    GHashTable *group_details;      // containing ConfigGroupInfo's

    ConfigOpts opts;

};

struct ConfigurationClass

{

    GObjectClass parent;

};

enum

{

    CONFIG_CHANGED_SIGNAL,

    LAST_SIGNAL

};

static guint signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE(Configuration, configuration, G_TYPE_OBJECT)

static void

group_details_free_func(gpointer data)

{

    g_slice_free(ConfigGroupInfo, data);

}

static void

configuration_init (Configuration *obj)

{

    g_static_rw_lock_init(&obj->rwlock);

    obj->servers = NULL;

    obj->group_details = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, group_details_free_func);

}

static void

configuration_finalize (GObject *obj)

{

    char *errmsg = NULL;

    Configuration *config = CONFIGURATION(obj);

    GList *list;

    if (!(configuration_save(config, &errmsg))) {

        nntpgrab_core_emit_warning(FALSE, errmsg);

        g_free(errmsg);

    }

    g_static_rw_lock_writer_lock(&config->rwlock);

    list = config->servers;

    while (list) {

        g_slice_free(ConfigServer, list->data);

        list = g_list_next(list);

    }

    g_list_free(config->servers);

    g_hash_table_destroy(config->group_details);

    g_static_rw_lock_writer_unlock(&config->rwlock);

    g_static_rw_lock_free(&config->rwlock);

}

static void

configuration_class_init (ConfigurationClass *klass)

{

    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

    gobject_class->finalize = configuration_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,

                                                    g_cclosure_marshal_VOID__INT,

                                                    G_TYPE_NONE, 1, G_TYPE_INT);

}

Configuration *

configuration_new(char **errmsg, char **warnings)

{

    Configuration *config = g_object_new(CONFIGURATION_TYPE_OBJECT, NULL);

    if (!configuration_load(config, errmsg)) {

        // Load of configuration failed..probably no configuration file created yet.

        // Create a default configuration file

        g_free(*errmsg);

        *errmsg = NULL;

        if (warnings) {

            *warnings = g_strdup(_("Configuration file for the NNTPGrab backend could not be loaded. Default configuration file is now created"));

        }

    }

    return config;

}

void

configuration_destroy(Configuration *obj)

{

    g_object_unref(obj);

}

/** 

 * Retrieve a list of all the available usenet servers

 *

 * @param obj   The configuration object

 * @return      a GList* containing g_malloc'ed char* strings with servernames

 */

GList *

configuration_get_avail_servers(Configuration *obj)

{

    Configuration *config = CONFIGURATION(obj);

    GList *list;

    GList *ret = NULL;

    g_static_rw_lock_reader_lock(&config->rwlock);

    list = config->servers;

    while (list) {

        ConfigServer *server = list->data;

        ret = g_list_append(ret, g_strdup(server->servername));

        list = g_list_next(list);

    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return ret;

}

/** 

 * Frees the list returned by configuration_get_avail_servers()

 *

 * @param obj       The configuration object

 * @param servers   A GList* containing g_malloc'ed char* strings with servernames

 */

void

configuration_free_avail_servers(Configuration *obj, GList *servers)

{

    GList *list;

    list = servers;

    while (list) {

        g_free(list->data);

        list = g_list_next(list);

    }

    g_list_free(servers);

}

/** 

 * Retrieve information about a specific usenet server

 *

 * @param obj           The Configuration object

 * @param servername    The name of the usenet server whose info should be lookup up

 * @return              A g_slice_new'ed ConfigServer structure containing the requested info or NULL when the servername could not be found

 */

ConfigServer *

configuration_get_server_info(Configuration *obj, const char *servername)

{

    Configuration *config = CONFIGURATION(obj);

    GList *list;

    g_static_rw_lock_reader_lock(&config->rwlock);

    list = config->servers;

    while (list) {

        ConfigServer *server = list->data;

        if (!strcmp(server->servername, servername)) {

            ConfigServer *ret = g_slice_new0(ConfigServer);

            memcpy(ret, server, sizeof(ConfigServer));

            g_static_rw_lock_reader_unlock(&config->rwlock);

            return ret;

        }

        list = g_list_next(list);

    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return NULL;

}

/** 

 * Add a new server to the list of known usenet servers

 *

 * @param obj           The configuration object

 * @param new_server    The structure containing the settings of the new server

 * @param errmsg        If an error occurs, an error message will be set in this variable

 * @return              TRUE on success, FALSE on error (errmsg will be set)

 */

gboolean

configuration_add_server(Configuration *obj, ConfigServer new_server, char **errmsg)

{

    Configuration *config = CONFIGURATION(obj);

    ConfigServer *server;

    GList *list;

    // Check is the new_server contains sane data

    g_assert(new_server.port > 0 && new_server.port < 65536);

    g_assert(new_server.max_threads > 0);

    if (!strcmp(new_server.servername, "options")) {

        if (errmsg) {

            *errmsg = g_strdup_printf("%s%s", _("The servername 'options' cannot be used.\n"), _("Please use a different servername"));

        }

        return FALSE;

    }

    // Check if the servername of the new_server is already known

    g_static_rw_lock_reader_lock(&config->rwlock);

    list = config->servers;

    while (list) {

        server = list->data;

        if (!strcmp(new_server.servername, server->servername)) {

            // servername already exists, refuse the addition of a new server

            g_static_rw_lock_reader_unlock(&config->rwlock);

            if (errmsg) {

                *errmsg = g_strdup_printf("%s%s", _("The given servername already exists in the configuration.\n"), _("Please use a different servername"));

            }

            return FALSE;

        }

        list = g_list_next(list);

    }

    // Prevent the addition of more than MAX_NNTP_SERVERS servers

    if (g_list_length(config->servers) == MAX_NNTP_SERVERS - 1) {

        g_static_rw_lock_reader_unlock(&config->rwlock);

        if (errmsg) {

            *errmsg = g_strdup(_("There are too many servers configured"));

        }

        return FALSE;

    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    // servername not found, it is safe to add the new configuration

    g_static_rw_lock_writer_lock(&config->rwlock);

    server = g_slice_new0(ConfigServer);

    memcpy(server, &new_server, sizeof(ConfigServer));

    config->servers = g_list_append(config->servers, server);

    g_static_rw_lock_writer_unlock(&config->rwlock);

    // Notify listeners that the configuration has changed

    g_static_rw_lock_reader_lock(&config->rwlock);

    g_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_ADDED);

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return TRUE;

}

/** 

 * Delete the settings from the specified servername from the list of known usenet servers

 *

 * @param obj           The configuration object

 * @param servername    The name of the server whose settings need to be removed

 * @param errmsg        If an error occurs, an error message will be set in this variable

 *

 * @return              TRUE on success, FALSE on error (errmsg will be set)

 */

gboolean

configuration_del_server(Configuration *obj, const char *servername, char **errmsg)

{

    Configuration *config = CONFIGURATION(obj);

    ConfigServer *server;

    GList *list;

    // Check if the servername is known

    g_static_rw_lock_reader_lock(&config->rwlock);

    list = config->servers;

    while (list) {

        server = list->data;

        if (!strcmp(servername, server->servername)) {

            // servername exists, remove it from the list

            g_static_rw_lock_reader_unlock(&config->rwlock);

            g_static_rw_lock_writer_lock(&config->rwlock);

            g_slice_free(ConfigServer, server);

            config->servers = g_list_remove(config->servers, server);

            g_static_rw_lock_writer_unlock(&config->rwlock);

            // Notify listeners that the configuration has changed

            g_static_rw_lock_reader_lock(&config->rwlock);

            g_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_DELETED);

            g_static_rw_lock_reader_unlock(&config->rwlock);

            return TRUE;

        }

        list = g_list_next(list);

    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    if (errmsg) {

        *errmsg = g_strdup(_("The given servername doesn't exist in the NNTPGrab configuration"));

    }

    return FALSE;

}

/** 

 * Change the settings from the specified servername in the list of known usenet servers

 *

 * @param obj           The configuration object

 * @param servername    The name of the server whose settings need to be changed

 * @param new_server    The new settings of the server which need to be saved

 * @param errmsg        If an error occurs, an error message will be set in this variable

 *

 * @return              TRUE on success, FALSE on error (errmsg will be set)

 */

gboolean

configuration_edit_server(Configuration *obj, const char *servername, ConfigServer new_server, char **errmsg)

{

    Configuration *config = CONFIGURATION(obj);

    ConfigServer *server;

    GList *list;

    if (!strcmp(new_server.servername, "options")) {

        if (errmsg) {

            *errmsg = g_strdup_printf("%s%s", _("The servername 'options' cannot be used.\n"), _("Please use a different servername"));

        }

        return FALSE;

    }

    // Check if the servername of the new_server is already known

    g_static_rw_lock_reader_lock(&config->rwlock);

    list = config->servers;

    while (list) {

        server = list->data;

        if (!strcmp(servername, server->servername)) {

            // servername exists, edit the settings

            g_static_rw_lock_reader_unlock(&config->rwlock);

            g_static_rw_lock_writer_lock(&config->rwlock);

            // apply the new settings

            memcpy(server, &new_server, sizeof(ConfigServer));

            g_static_rw_lock_writer_unlock(&config->rwlock);

            // Notify listeners that the configuration has changed

            g_static_rw_lock_reader_lock(&config->rwlock);

            g_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_ADDED);

            g_static_rw_lock_reader_unlock(&config->rwlock);

            return TRUE;

        }

        list = g_list_next(list);

    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    if (errmsg) {

        *errmsg = g_strdup(_("The given servername doesn't exist in the NNTPGrab configuration"));

    }

    return FALSE;

}

/** 

 * Retrieves the configuration options

 *

 * @param obj       The configuration object

 * @return          A structure containing configuration data

 */

ConfigOpts

configuration_get_opts(Configuration *obj)

{

    Configuration *config = CONFIGURATION(obj);

    ConfigOpts ret;

    g_static_rw_lock_reader_lock(&config->rwlock);

    ret = config->opts;

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return ret;

}

/** 

 * Set the configuration options

 *

 * @param obj   The configuration object

 * @param opts  A structure containing configuration data

 */

void

configuration_set_opts(Configuration *obj, ConfigOpts opts)

{

    Configuration *config = CONFIGURATION(obj);

    g_static_rw_lock_writer_lock(&config->rwlock);

    // Hack for Win32, if the download folder or temp folder is the root of a drive, append an extra \ to it

#ifdef WIN32

    if (strlen(opts.download_directory) == 2 && opts.download_directory[1] == ':') {

        opts.download_directory[2] = '\\';

        opts.download_directory[3] = '\0';

    }

    if (strlen(opts.temp_directory) == 2 && opts.temp_directory[1] == ':') {

        opts.temp_directory[2] = '\\';

        opts.temp_directory[3] = '\0';

    }

    if (strlen(opts.auto_import_directory) == 2 && opts.auto_import_directory[1] == ':') {

        opts.temp_directory[2] = '\\';

        opts.temp_directory[3] = '\0';

    }

#endif

    config->opts = opts;

    g_static_rw_lock_writer_unlock(&config->rwlock);

    // Notify listeners that the configuration has changed

    g_static_rw_lock_reader_lock(&config->rwlock);

    g_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_OPTS_CHANGED);

    g_static_rw_lock_reader_unlock(&config->rwlock);

}

/** 

 * Get the details concerning the given server and newsgroup

 *

 * @param obj           The configuration object

 * @param servername    The name of the server

 * @param newsgroup     The name of the newsgroup

 *

 * @return              Structure containing the details

 */

ConfigGroupInfo

configuration_get_newsgroup_info(Configuration *obj, const char *servername, const char *newsgroup)

{

    ConfigGroupInfo ret;

    ConfigGroupInfo *info;

    Configuration *config = CONFIGURATION(obj);

    char *hash;

    g_static_rw_lock_reader_lock(&config->rwlock);

    hash = g_strdup_printf("%s_%s", servername, newsgroup);

    info = g_hash_table_lookup(config->group_details, hash);

    g_free(hash);

    if (info) {

        memcpy(&ret, info, sizeof(ConfigGroupInfo));

    } else {

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

        strncpy((char *) ret.newsgroup, newsgroup, sizeof(ret.newsgroup));

    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return ret;

}

/** 

 * Set the details concerning the given server and newsgroup

 *

 * @param obj           The configuration object

 * @param servername    The name of the server

 * @param newsgroup     The name of the newsgroup

 * @param info          Structure containing the details

 */

void

configuration_set_newsgroup_info(Configuration *obj, const char *servername, const char *newsgroup, ConfigGroupInfo info)

{

    Configuration *config = CONFIGURATION(obj);

    ConfigGroupInfo *info_new;

    char *hash;

    g_static_rw_lock_writer_lock(&config->rwlock);

    info_new = g_slice_new(ConfigGroupInfo);

    memcpy(info_new, &info, sizeof(ConfigGroupInfo));

    hash = g_strdup_printf("%s_%s", servername, newsgroup);

    g_hash_table_replace(config->group_details, hash, info_new);

    g_free(hash);

    g_static_rw_lock_writer_unlock(&config->rwlock);

}

/** 

 * Load all settings from a local file on the harddrive

 *

 * @param obj           The configuration object

 * @param errmsg        A pointer to a char* to save a possible error message

 * @return              TRUE on success, FALSE on failure (errmsg will be set and needs to be g_free'd after use)

 */

gboolean

configuration_load(Configuration *obj, char **errmsg)

{

    Configuration *config = CONFIGURATION(obj);

    GKeyFile *keyfile;

    GError *err = NULL;

    char *filename;

    char **groups;

    int i;

    GList *list;

    g_static_rw_lock_writer_lock(&config->rwlock);

    // Free the already known settings

    list = config->servers;

    while (list) {

        ConfigServer *server = list->data;

        g_slice_free(ConfigServer, server);

        list = g_list_next(list);

    }

    g_list_free(config->servers);

    config->servers = NULL;

    // Try to load the config file

    if (g_getenv("NNTPGRAB_CONFIG_DIR")) {

        filename = g_build_filename(g_getenv("NNTPGRAB_CONFIG_DIR"), "NNTPGrab", "nntpgrab.conf", NULL);

    } else {

        filename = g_build_filename(g_get_user_config_dir(), "NNTPGrab", "nntpgrab.conf", NULL);

    }

    keyfile = g_key_file_new();

    if (!g_key_file_load_from_file(keyfile, filename, G_KEY_FILE_NONE, &err)) {

        char *tmp;

        const char *homedir;

        if (errmsg) {

            *errmsg = g_strdup_printf(_("configuration_load(): Error while opening file '%s'\n%s"), filename, err->message);

        }

        g_free(filename);

        g_error_free(err);

        g_key_file_free(keyfile);

#ifdef WIN32

        homedir = g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS);

#else

        if (g_getenv("NNTPGRAB_DEFAULT_DL_DIR")) {

            homedir = g_getenv("NNTPGRAB_DEFAULT_DL_DIR");

        } else {

            homedir = g_get_home_dir();

        }

#endif

        // Set up sane defaults

        tmp = g_build_path(G_DIR_SEPARATOR_S, homedir, "NNTPGrab", "Downloads", NULL);

        strncpy(config->opts.download_directory, tmp, sizeof(config->opts.download_directory));

        g_mkdir_with_parents(tmp, 0700);

        g_free(tmp);

        tmp = g_build_path(G_DIR_SEPARATOR_S, homedir, "NNTPGrab", "Temp", NULL);

        strncpy(config->opts.temp_directory, tmp, sizeof(config->opts.temp_directory));

        g_mkdir_with_parents(tmp, 0700);

        g_free(tmp);

        tmp = g_build_path(G_DIR_SEPARATOR_S, homedir, "NNTPGrab", "NZB", NULL);

        strncpy(config->opts.auto_import_directory, tmp, sizeof(config->opts.auto_import_directory));

        g_mkdir_with_parents(tmp, 0700);

        g_free(tmp);

        config->opts.enable_par2_repair = TRUE;

        config->opts.enable_auto_unpack = TRUE;

        config->opts.enable_bandwidth_shaping = FALSE;

        config->opts.max_bandwidth = 100;

        config->opts.enable_webserver = FALSE;

        config->opts.webserver_port = 5423;

        config->opts.enable_logger = FALSE;

        config->opts.auto_remove_files = FALSE;

        g_static_rw_lock_writer_unlock(&config->rwlock);

        return FALSE;

    }

    g_free(filename);

    groups = g_key_file_get_groups(keyfile, NULL);

    i = 0;

    while (groups[i]) {

        char *value;

        ConfigServer *server;

        if (!strcmp(groups[i], "options")) {

            char *tmp;

            tmp = g_key_file_get_string(keyfile, groups[i], "download_directory", NULL);

            if (tmp) {

                strncpy(config->opts.download_directory, tmp, sizeof(config->opts.download_directory));

                g_free(tmp);

            }

            tmp = g_key_file_get_string(keyfile, groups[i], "temp_directory", NULL);

            if (tmp) {

                strncpy(config->opts.temp_directory, tmp, sizeof(config->opts.temp_directory));

                g_free(tmp);

            }

            if (g_key_file_has_key(keyfile, groups[i], "enable_intelligent_par2_downloading", NULL)) {

                config->opts.enable_intelligent_par2_downloading = g_key_file_get_boolean(keyfile, groups[i], "enable_intelligent_par2_downloading", NULL);

            } else {

                config->opts.enable_intelligent_par2_downloading = TRUE;

            }

            if (g_key_file_has_key(keyfile, groups[i], "enable_par2_repair", NULL)) {

                config->opts.enable_par2_repair = g_key_file_get_boolean(keyfile, groups[i], "enable_par2_repair", NULL);

            } else {

                config->opts.enable_par2_repair = TRUE;

            }

            if (g_key_file_has_key(keyfile, groups[i], "enable_auto_unpack", NULL)) {

                config->opts.enable_auto_unpack = g_key_file_get_boolean(keyfile, groups[i], "enable_auto_unpack", NULL);

            } else {

                config->opts.enable_auto_unpack = TRUE;

            }

            tmp = g_key_file_get_string(keyfile, groups[i], "auto_import_directory", NULL);

            if (tmp) {

                strncpy(config->opts.auto_import_directory, tmp, sizeof(config->opts.auto_import_directory));

                g_free(tmp);

            }

            if (g_key_file_has_key(keyfile, groups[i], "enable_auto_import", NULL)) {

                config->opts.enable_auto_import = g_key_file_get_boolean(keyfile, groups[i], "enable_auto_import", NULL);

            } else {

                config->opts.enable_auto_import = TRUE;

            }

            if (g_key_file_has_key(keyfile, groups[i], "move_file_after_auto_import", NULL)) {

                config->opts.move_file_after_auto_import = g_key_file_get_boolean(keyfile, groups[i], "move_file_after_auto_import", NULL);

            } else {

                config->opts.move_file_after_auto_import = TRUE;

            }

            if (g_key_file_has_key(keyfile, groups[i], "enable_bandwidth_shaping", NULL)) {

                config->opts.enable_bandwidth_shaping = g_key_file_get_boolean(keyfile, groups[i], "enable_bandwidth_shaping", NULL);

            } else {

                config->opts.enable_bandwidth_shaping = FALSE;

            }

            if (g_key_file_has_key(keyfile, groups[i], "max_bandwidth", NULL)) {

                config->opts.max_bandwidth = g_key_file_get_integer(keyfile, groups[i], "max_bandwidth", NULL);

            } else {

                config->opts.max_bandwidth = 100;

            }

            if (g_key_file_has_key(keyfile, groups[i], "enable_webserver", NULL)) {

                config->opts.enable_webserver = g_key_file_get_boolean(keyfile, groups[i], "enable_webserver", NULL);

            } else {

                config->opts.enable_webserver = FALSE;

            }

            if (g_key_file_has_key(keyfile, groups[i], "webserver_port", NULL)) {

                config->opts.webserver_port = g_key_file_get_integer(keyfile, groups[i], "webserver_port", NULL);

            } else {

                config->opts.webserver_port = 5423;

            }

            if (g_key_file_has_key(keyfile, groups[i], "enable_logger", NULL)) {

                config->opts.enable_logger = g_key_file_get_boolean(keyfile, groups[i], "enable_logger", NULL);

            } else {

                config->opts.enable_logger = FALSE;

            }

            if (g_key_file_has_key(keyfile, groups[i], "auto_remove_files", NULL)) {

                config->opts.auto_remove_files = g_key_file_get_boolean(keyfile, groups[i], "auto_remove_files", NULL);

            } else {

                config->opts.auto_remove_files = FALSE;

            }

            i++;

            continue;

        }

        server = g_slice_new(ConfigServer);

        strncpy(server->servername, groups[i], sizeof(server->servername));

        value = g_key_file_get_string(keyfile, groups[i], "hostname", NULL);

        if (!value) {

            g_print(_("No hostname could be found for servername '%s'. Ignoring server\n"), groups[i]);

            i++;

            continue;

        }

        strncpy(server->hostname, value, sizeof(server->hostname));

        g_free(value);

        server->port = g_key_file_get_integer(keyfile, groups[i], "port", NULL);

        value = g_key_file_get_string(keyfile, groups[i], "username", NULL);

        if (value) {

            strncpy(server->username, value, sizeof(server->username));

            g_free(value);

        }

        value = g_key_file_get_string(keyfile, groups[i], "password", NULL);

        if (value) {

            strncpy(server->password, value, sizeof(server->password));

            g_free(value);

        }

        server->max_threads = g_key_file_get_integer(keyfile, groups[i], "max_threads", NULL);

        server->use_ssl = g_key_file_get_boolean(keyfile, groups[i], "use_ssl", NULL);

        // backwards compatibility

        if (!g_key_file_has_key(keyfile, groups[i], "priority", NULL)) {

            server->priority = SERVER_PRIORITY_NORMAL;

        } else {

            server->priority = g_key_file_get_integer(keyfile, groups[i], "priority", NULL);

        }

        if (!g_key_file_has_key(keyfile, groups[i], "enabled", NULL)) {

            server->enabled = TRUE;

        } else {

            server->enabled = g_key_file_get_boolean(keyfile, groups[i], "enabled", NULL);

        }

        config->servers = g_list_append(config->servers, server);

        i++;

    }

    g_strfreev(groups);

    g_key_file_free(keyfile);

    // Do we have sane values for the download and temp directory ?

#ifdef WIN32

    if (strlen(config->opts.download_directory) == 2) {

        config->opts.download_directory[2] = '\\';

        config->opts.download_directory[3] = '\0';

    }

    if (strlen(config->opts.temp_directory) == 2) {

        config->opts.temp_directory[2] = '\\';

        config->opts.temp_directory[3] = '\0';

    }

#endif

    if (!g_file_test(config->opts.download_directory, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {

        char *tmp;

#ifdef WIN32

        tmp = g_build_path(G_DIR_SEPARATOR_S, g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS), "NNTPGrab", "Downloads", NULL);

#else

        tmp = g_build_path(G_DIR_SEPARATOR_S, g_get_home_dir(), "NNTPGrab", "Downloads", NULL);

#endif

        strncpy(config->opts.download_directory, tmp, sizeof(config->opts.download_directory));

        g_mkdir_with_parents(tmp, 0700);

        g_free(tmp);

    }

    if (!g_file_test(config->opts.temp_directory, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {

        char *tmp;

#ifdef WIN32

        tmp = g_build_path(G_DIR_SEPARATOR_S, g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS), "NNTPGrab", "Temp", NULL);

#else

        tmp = g_build_path(G_DIR_SEPARATOR_S, g_get_home_dir(), "NNTPGrab", "Temp", NULL);

#endif

        strncpy(config->opts.temp_directory, tmp, sizeof(config->opts.temp_directory));

        g_mkdir_with_parents(tmp, 0700);

        g_free(tmp);

    }

    if (!g_file_test(config->opts.auto_import_directory, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {

        char *tmp;

#ifdef WIN32

        tmp = g_build_path(G_DIR_SEPARATOR_S, g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS), "NNTPGrab", "NZB", NULL);

#else

        tmp = g_build_path(G_DIR_SEPARATOR_S, g_get_home_dir(), "NNTPGrab", "NZB", NULL);

#endif

        strncpy(config->opts.auto_import_directory, tmp, sizeof(config->opts.auto_import_directory));

        g_mkdir_with_parents(tmp, 0700);

        g_free(tmp);

    }

    g_static_rw_lock_writer_unlock(&config->rwlock);

    // Notify listeners that the configuration has changed

    g_static_rw_lock_reader_lock(&config->rwlock);

    g_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_ADDED | CONFIG_CHANGED_SERVER_DELETED);

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return TRUE;

}

/** 

 * Save all settings to a local file on the harddrive

 *

 * @param obj           The configuration object

 * @param errmsg        A pointer to a char* to save a possible error message

 * @return              TRUE on success, FALSE on failure (errmsg will be set and needs to be g_free'd after use)

 */

gboolean

configuration_save(Configuration *obj, char **errmsg)

{

    Configuration *config = CONFIGURATION(obj);

    GKeyFile *keyfile;

    GError *err = NULL;

    char *filename;

    char *dirname;

    char *contents;

    GList *list;

    const char *config_dir;

    g_static_rw_lock_reader_lock(&config->rwlock);

    keyfile = g_key_file_new();

    g_key_file_set_string(keyfile, "options", "download_directory", config->opts.download_directory);

    g_key_file_set_string(keyfile, "options", "temp_directory", config->opts.temp_directory);

    g_key_file_set_boolean(keyfile, "options", "enable_intelligent_par2_downloading", config->opts.enable_intelligent_par2_downloading);

    g_key_file_set_boolean(keyfile, "options", "enable_par2_repair", config->opts.enable_par2_repair);

    g_key_file_set_boolean(keyfile, "options", "enable_auto_unpack", config->opts.enable_auto_unpack);

    g_key_file_set_boolean(keyfile, "options", "enable_auto_import", config->opts.enable_auto_import);

    g_key_file_set_string (keyfile, "options", "auto_import_directory", config->opts.auto_import_directory);

    g_key_file_set_boolean(keyfile, "options", "move_file_after_auto_import", config->opts.move_file_after_auto_import);

    g_key_file_set_boolean(keyfile, "options", "enable_bandwidth_shaping", config->opts.enable_bandwidth_shaping);

    g_key_file_set_integer(keyfile, "options", "max_bandwidth", config->opts.max_bandwidth);

    g_key_file_set_boolean(keyfile, "options", "enable_webserver", config->opts.enable_webserver);

    g_key_file_set_integer(keyfile, "options", "webserver_port", config->opts.webserver_port);

    g_key_file_set_boolean(keyfile, "options", "enable_logger", config->opts.enable_logger);

    g_key_file_set_boolean(keyfile, "options", "auto_remove_files", config->opts.auto_remove_files);

    list = config->servers;

    while (list) {

        ConfigServer *server = list->data;

        g_key_file_set_string (keyfile, server->servername, "hostname", server->hostname);

        g_key_file_set_integer(keyfile, server->servername, "port", server->port);

        g_key_file_set_string (keyfile, server->servername, "username", server->username);

        g_key_file_set_string (keyfile, server->servername, "password", server->password);

        g_key_file_set_integer(keyfile, server->servername, "max_threads", server->max_threads);

        g_key_file_set_boolean(keyfile, server->servername, "use_ssl", server->use_ssl);

        g_key_file_set_integer(keyfile, server->servername, "priority", server->priority);

        g_key_file_set_boolean(keyfile, server->servername, "enabled", server->enabled);

        list = g_list_next(list);

    }

    contents = g_key_file_to_data(keyfile, NULL, &err);

    if (!contents) {

        if (errmsg) {

            *errmsg = g_strdup(err->message);

        }

        g_error_free(err);

        g_free(contents);

        g_key_file_free(keyfile);

        g_static_rw_lock_reader_unlock(&config->rwlock);

        return FALSE;

    }

    // Create the folder ~/.config/NNTPGrab if it didn't exist already

    if (g_getenv("NNTPGRAB_CONFIG_DIR")) {

        config_dir = g_getenv("NNTPGRAB_CONFIG_DIR");

    } else {

        config_dir = g_get_user_config_dir();

    }

    dirname = g_build_path(G_DIR_SEPARATOR_S, config_dir, "NNTPGrab", NULL);

    g_mkdir_with_parents(dirname, 0700);

    g_free(dirname);

    filename = g_build_filename(config_dir, "NNTPGrab", "nntpgrab.conf", NULL);

    if (!g_file_set_contents(filename, contents, -1, &err)) {

        if (errmsg) {

            *errmsg = g_strdup_printf(_("configuration_save(): Error while opening file '%s'\n%s"), filename, err->message);

        }

        g_error_free(err);

        g_free(contents);

        g_free(filename);

        g_key_file_free(keyfile);

        g_static_rw_lock_reader_unlock(&config->rwlock);

        return FALSE;

    }

    g_free(contents);

    g_free(filename);

    g_key_file_free(keyfile);

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return TRUE;

}