/*
    Copyright (C) ABRT Team
    Copyright (C) RedHat inc.

    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.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include <glib.h>
#include <sys/time.h>
#include "problem_api.h"

/*
 * Goes through all problems and for problems accessible by caller_uid
 * calls callback. If callback returns non-0, returns that value.
 */
int for_each_problem_in_dir(const char *path,
                        uid_t caller_uid,
                        int (*callback)(struct dump_dir *dd, void *arg),
                        void *arg)
{
    DIR *dp = opendir(path);
    if (!dp)
    {
        /* We don't want to yell if, say, $XDG_CACHE_DIR/abrt/spool doesn't exist */
        //perror_msg("Can't open directory '%s'", path);
        return 0;
    }

    int brk = 0;
    struct dirent *dent;
    while ((dent = readdir(dp)) != NULL)
    {
        if (dot_or_dotdot(dent->d_name))
            continue; /* skip "." and ".." */

        char *full_name = concat_path_file(path, dent->d_name);

        struct dump_dir *dd = dd_opendir(full_name,   DD_OPEN_FD_ONLY
                                                    | DD_FAIL_QUIETLY_ENOENT
                                                    | DD_FAIL_QUIETLY_EACCES);
        if (dd == NULL)
        {
            VERB2 perror_msg("can't open problem directory '%s'", full_name);
            free(full_name);
            continue;
        }

        if (caller_uid == -1 || dd_accessible_by_uid(dd, caller_uid))
        {
            /* Silently ignore *any* errors, not only EACCES.
             * We saw "lock file is locked by process PID" error
             * when we raced with wizard.
             */
            int sv_logmode = logmode;
            /* Silently ignore errors only in the silent log level. */
            logmode = g_verbose == 0 ? 0: sv_logmode;
            dd = dd_fdopendir(dd, DD_OPEN_READONLY | DD_DONT_WAIT_FOR_LOCK);
            logmode = sv_logmode;
            if (dd)
                brk = callback ? callback(dd, arg) : 0;
        }

        if (dd)
            dd_close(dd);

        free(full_name);
        if (brk)
            break;
    }
    closedir(dp);

    return brk;
}

/* get_problem_dirs_for_uid and its helpers */

static int add_dirname_to_GList(struct dump_dir *dd, void *arg)
{
    if (!dir_has_correct_permissions(dd->dd_dirname, DD_PERM_DAEMONS))
    {
        log_warning("Ignoring '%s': invalid owner, group or mode", dd->dd_dirname);
        /*Do not break*/
        return 0;
    }

    GList **list = arg;
    *list = g_list_prepend(*list, xstrdup(dd->dd_dirname));
    return 0;
}

GList *get_problem_dirs_for_uid(uid_t uid, const char *dump_location)
{
    GList *list = NULL;
    for_each_problem_in_dir(dump_location, uid, add_dirname_to_GList, &list);
    /*
     * Why reverse?
     * Because N*prepend+reverse is faster than N*append
     */
    return g_list_reverse(list);
}

/* get_problem_dirs_not_accessible_by_uid and its helpers */
struct add_dirname_to_GList_if_not_accessible_args
{
    uid_t uid;
    GList *list;
};

static int add_dirname_to_GList_if_not_accessible(struct dump_dir *dd, void *args)
{
    struct add_dirname_to_GList_if_not_accessible_args *param = (struct add_dirname_to_GList_if_not_accessible_args *)args;
    /* Append if not accessible */
    if (!dump_dir_accessible_by_uid(dd->dd_dirname, param->uid))
        param->list = g_list_prepend(param->list, xstrdup(dd->dd_dirname));

    return 0;
}

GList *get_problem_dirs_not_accessible_by_uid(uid_t uid, const char *dump_location)
{
    struct add_dirname_to_GList_if_not_accessible_args args = {
        .uid = uid,
        .list = NULL,
    };

    for_each_problem_in_dir(dump_location, /*disable default uid check*/-1, add_dirname_to_GList_if_not_accessible, &args);
    return g_list_reverse(args.list);
}


/* get_problem_storages */

GList *get_problem_storages(void)
{
    GList *paths = NULL;
    load_abrt_conf();
    paths = g_list_append(paths, xstrdup(g_settings_dump_location));
    free_abrt_conf_data();

    return paths;
}

int problem_dump_dir_is_complete(struct dump_dir *dd)
{
    return dd_exist(dd, FILENAME_COUNT);
}