n_files.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include "nilorea/n_files.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <dirent.h>
#include <sys/stat.h>
#include <errno.h>
 
void n_free_file_info(void* ptr) {
    __n_assert(ptr, return);
    N_FILE_INFO* file = (N_FILE_INFO*)ptr;
    if (file->name)
        free(file->name);
    free(file);
    return;
}
 
char* n_path_join(const char* dir, const char* name) {
    if (!dir || !name) return NULL;
 
    size_t dl = strlen(dir);
    size_t nl = strlen(name);
 
    int need_sep = 1;
    if (dl == 0) {
        need_sep = 0;
    } else {
        char last = dir[dl - 1];
        if (last == '/' || last == '\\') need_sep = 0;
    }
 
    /* We use '/' for output paths. */
    size_t out_len = dl + (need_sep ? 1 : 0) + nl + 1;
    char* out = (char*)malloc(out_len);
    if (!out) return NULL;
 
    if (need_sep)
        snprintf(out, out_len, "%s/%s", dir, name);
    else
        snprintf(out, out_len, "%s%s", dir, name);
 
    return out;
}
 
int n_comp_file_info(const void* a, const void* b) {
    const N_FILE_INFO* f1 = (const N_FILE_INFO*)a;
    const N_FILE_INFO* f2 = (const N_FILE_INFO*)b;
 
    if (!f1) return -1;
    if (!f2) return 1;
 
    if (f1->filetime < f2->filetime) return -1;
    if (f1->filetime > f2->filetime) return 1;
 
    if (f1->filetime_nsec < f2->filetime_nsec) return -1;
    if (f1->filetime_nsec > f2->filetime_nsec) return 1;
 
    return 0;
}
 
void n_set_time_from_stat(N_FILE_INFO* file, const struct stat* st) {
    if (!file || !st) return;
 
#if defined(__linux__) || defined(__sun)
    file->filetime = (int64_t)st->st_mtim.tv_sec;
    file->filetime_nsec = (int32_t)st->st_mtim.tv_nsec;
#else
    file->filetime = (int64_t)st->st_mtime;
    file->filetime_nsec = 0;
#endif
}
 
int n_scan_dir(const char* dir, LIST* result, const int recurse) {
    DIR* dp = NULL;
    const struct dirent* entry = NULL;
 
    __n_assert(dir, return FALSE);
    __n_assert(result, return FALSE);
 
    int error = 0;
    dp = opendir(dir);
    error = errno;
    if (!dp) {
        n_log(LOG_ERR, "cannot open directory: %s, %s", dir, strerror(error));
        return FALSE;
    }
 
    while ((entry = readdir(dp)) != NULL) {
        const char* name = entry->d_name;
 
        if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
            errno = 0;
            continue;
        }
 
        char* fullpath = n_path_join(dir, name);
        if (!fullpath) {
            n_log(LOG_ERR, "malloc failed building path for %s/%s", dir, name);
            closedir(dp);
            return FALSE;
        }
 
        struct stat st;
        if (stat(fullpath, &st) == -1) {
            error = errno;
            n_log(LOG_ERR, "unable to stat %s, %s", fullpath, strerror(error));
            free(fullpath);
            continue;
        }
 
        if (S_ISDIR(st.st_mode)) {
            if (recurse != FALSE) {
                if (n_scan_dir(fullpath, result, recurse) == FALSE) {
                    n_log(LOG_ERR, "error while recursively scanning %s", fullpath);
                }
            }
        } else if (S_ISREG(st.st_mode)) {
            N_FILE_INFO* file = NULL;
            Malloc(file, N_FILE_INFO, 1);
 
            if (file) {
                /* Store full path to avoid ambiguity in recursion results */
                file->name = strdup(fullpath);
                n_set_time_from_stat(file, &st);
 
                list_push_sorted(result, file, n_comp_file_info, n_free_file_info);
            }
        } else {
            /* Ignore non-regular / non-directory entries (symlinks, sockets, etc.) */
            /* If you want to include symlinks, use lstat() and handle S_ISLNK. */
        }
 
        free(fullpath);
        errno = 0;
    }
 
    if (errno != 0) {
        n_log(LOG_ERR, "readdir failed for %s: %s", dir, strerror(errno));
        closedir(dp);
        return FALSE;
    }
 
    closedir(dp);
    return TRUE;
}