configuration.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 
#ifdef WIN32
#include 
#include 
#include 
#endif

#include "configuration.h"
#include "nntpgrab_internal.h"

typedef struct ConfigurationClass ConfigurationClass;

Configuration *configuration_get_object(void);
GType configuration_get_type (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;
    Configuration *config = CONFIGURATION(obj);
    GList *list;

    if (!(configuration_save(config, &errmsg))) {
        nntpgrab_core_emit_warning(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);
}


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

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

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

gboolean
configuration_add_server(Configuration *obj, ConfigServer new_server)
{
    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 00255     g_assert(new_server.max_threads > 0);

    if (!strcmp(new_server.servername, "options")) {
        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);
            return FALSE;
        }

        list = g_list_next(list);
    }

    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_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_ADDED);

    return TRUE;
}

gboolean
configuration_del_server(Configuration *obj, const char *servername)
{
    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_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_DELETED);

            return TRUE;
        }

        list = g_list_next(list);
    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return FALSE;
}

gboolean
configuration_edit_server(Configuration *obj, const char *servername, ConfigServer new_server)
{
    Configuration *config = CONFIGURATION(obj);
    ConfigServer *server;
    GList *list;

    if (!strcmp(new_server.servername, "options")) {
        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_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_ADDED);


            return TRUE;
        }

        list = g_list_next(list);
    }

    g_static_rw_lock_reader_unlock(&config->rwlock);

    return FALSE;
}

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

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';
    }
#endif

    config->opts = opts;

    g_static_rw_lock_writer_unlock(&config->rwlock);

    // Notify listeners that the configuration has changed
    g_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_OPTS_CHANGED);
}

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

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

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_free(server);

        list = g_list_next(list);
    }

    g_list_free(config->servers);
    config->servers = NULL;

    // Try to load the config file
    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;

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

        // Set up sane defaults
#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);

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

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

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

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

    g_static_rw_lock_writer_unlock(&config->rwlock);

    // Notify listeners that the configuration has changed
    g_signal_emit (config, signals[CONFIG_CHANGED_SIGNAL], 0, CONFIG_CHANGED_SERVER_ADDED | CONFIG_CHANGED_SERVER_DELETED);

    return TRUE;
}

gboolean
configuration_save(Configuration *obj, char **errmsg)
{
    Configuration *config = CONFIGURATION(obj);
    GKeyFile *keyfile;
    GError *err = NULL;
    char *filename;
    char *dirname;
    char *contents;
    GList *list;

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

    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
    dirname = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), "NNTPGrab", NULL);
    g_mkdir_with_parents(dirname, 0700);
    g_free(dirname);

    filename = g_build_filename(g_get_user_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;
}

static gint
sort_folders_func(gconstpointer a, gconstpointer b)
{
    const ConfigFolder *folderA = a;
    const ConfigFolder *folderB = b;

    if (a == NULL) {
        return 1;
    }

    if (b == NULL) {
        return 1;
    }

    return g_strcasecmp(folderA->folder, folderB->folder);
}

gboolean
configuration_get_folder_listing(Configuration *obj, const char *parent, GList **folders)
{
    GDir *dir;
    const char *filename;
#ifdef WIN32
    char *tmp;
#endif

    g_assert(folders);

    *folders = NULL;

    if (!parent) {
#ifdef WIN32
        DWORD logicalDrives = GetLogicalDrives() 00836         int i = 1;
        char driveLetter = 'A';

        while(driveLetter 'Z') {
            char *path;

            if(logicalDrives & (int)pow(2,i)) {
                GDir *dir;
                ConfigFolder *folder = g_slice_new0(ConfigFolder);

                path = g_strdup_printf("%c:\\", driveLetter);

#ifdef WIN32
                // Prevent the message 'No disk in drive' by checking via another method if
                // the given path is reachable
                if (!PathFileExistsA(path)) {
                    i++;
                    driveLetter++;
                    g_free(folder);
                    g_free(path);
                    continue;
                }
#endif

                dir = g_dir_open(path, 0, NULL);

                folder->has_subfolders = FALSE;

                if (dir) {
                    const char *filename;
                    while ((filename = g_dir_read_name(dir))) {
                        char *path2 = g_build_filename(path, filename, NULL);
                        if (g_file_test(path2, G_FILE_TEST_IS_DIR)) {
                            folder->has_subfolders = TRUE;
                        }
                        g_free(path2);
                    }
                    g_dir_close(dir);
                }

                // Strip the \ character from the path
                path[strlen(path) - 1] = '\0';
                strncpy(folder->folder, path, sizeof(folder->folder) - 1);

                *folders = g_list_append(*folders, folder);

                g_free(path);
            }

            i++;
            driveLetter++;
        }

        return TRUE;
#else
        ConfigFolder *folder = g_slice_new0(ConfigFolder);
        folder->has_subfolders = TRUE;      // There's no need to test this as there is always a root directory containing subdirectories
        folder->folder[0] = '/';
        folder->folder[1] = '\0';
        *folders = g_list_append(*folders, folder);
        return TRUE;
#endif
    }

#ifdef WIN32
    if (strlen(parent) == 2) {
        tmp = g_strdup_printf("%s\\", parent);
    } else {
        tmp = g_strdup(parent);
    }
    dir = g_dir_open(tmp, 0, NULL);
    g_free(tmp);
#else
    dir = g_dir_open(parent, 0, NULL);
#endif
    if (!dir) {
        return FALSE;
    }

    while ((filename = g_dir_read_name(dir))) {
        // Is this a directory ?
        char *path = g_build_filename(parent, filename, NULL);
        if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
            GDir *dir2 = g_dir_open(path, 0, NULL);
            if (dir2) {
                ConfigFolder *folder = g_slice_new0(ConfigFolder);
                const char *filename2;

                folder->has_subfolders = FALSE;
                while ((filename2 = g_dir_read_name(dir2))) {
                    char *path2 = g_build_filename(parent, filename, filename2, NULL);
                    if (g_file_test(path2, G_FILE_TEST_IS_DIR)) {
                        folder->has_subfolders = TRUE;
                        g_free(path2);
                        break;
                    }
                    g_free(path2);
                }
                g_dir_close(dir2);

                strncpy(folder->folder, filename, sizeof(folder->folder) - 1);

                *folders = g_list_append(*folders, folder);
            }
        }
        g_free(path);
    }

    g_dir_close(dir);

    *folders = g_list_sort(*folders, sort_folders_func);

    return TRUE;
}

void
configuration_free_folder_listing(Configuration *obj, GList *folders)
{
    GList *list = folders;
    while (list) {
        g_slice_free(ConfigFolder, list->data);
        list = g_list_next(list);
    }
    g_list_free(folders);
}

---