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 "nilorea/n_common.h" /* Malloc/Free, TRUE/FALSE, __windows__ */
 
#include <errno.h>
#include <stdio.h>
#include <string.h>
 
#ifdef __windows__
#include "nilorea/n_windows.h" /* MoveFileExA */
#include <io.h>                /* _commit */
#else
#include <fcntl.h>    /* open, O_* */
#include <sys/stat.h> /* fchmod, mode_t */
#include <unistd.h>   /* fsync, fchmod */
#endif

 
#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;
}
 
int n_file_read_bounded(const char* path, size_t max_size, unsigned char** out, size_t* out_len) {
    __n_assert(path, return FALSE);
    __n_assert(out, return FALSE);
 
    *out = NULL;
    if (out_len) *out_len = 0;
 
    FILE* f = fopen(path, "rb");
    if (!f) {
        n_log(LOG_ERR, "n_file_read_bounded: cannot open %s: %s", path, strerror(errno));
        return FALSE;
    }
    if (fseek(f, 0, SEEK_END) != 0) {
        fclose(f);
        return FALSE;
    }
    long sz = ftell(f);
    if (sz < 0) {
        fclose(f);
        return FALSE;
    }
    if ((size_t)sz > max_size) {
        n_log(LOG_ERR, "n_file_read_bounded: %s is %ld bytes, over the %zu cap", path, sz, max_size);
        fclose(f);
        return FALSE;
    }
    /* not rewind(): it returns void and reports failure only by setting errno, so a
       failed seek would go unnoticed and leave the read at the wrong offset. fseek
       reports the same failure by return value. */
    if (fseek(f, 0, SEEK_SET) != 0) {
        n_log(LOG_ERR, "n_file_read_bounded: cannot seek back to the start of %s: %s", path, strerror(errno));
        fclose(f);
        return FALSE;
    }
 
    size_t len = (size_t)sz;
    unsigned char* buf = NULL;
    Malloc(buf, unsigned char, len + 1);
    if (!buf) {
        fclose(f);
        return FALSE;
    }
    if (len && fread(buf, 1, len, f) != len) {
        n_log(LOG_ERR, "n_file_read_bounded: short read on %s", path);
        Free(buf);
        fclose(f);
        return FALSE;
    }
    buf[len] = '\0';
    fclose(f);
 
    *out = buf;
    if (out_len) *out_len = len;
    return TRUE;
}

#define N_FILE_COPY_BLOCK 262144

static int n_file_streams_equal(FILE* a, FILE* b) {
    unsigned char* x = NULL;
    unsigned char* y = NULL;
    int same = TRUE;
 
    Malloc(x, unsigned char, N_FILE_COPY_BLOCK);
    Malloc(y, unsigned char, N_FILE_COPY_BLOCK);
    if (!x || !y) {
        Free(x);
        Free(y);
        return FALSE;
    }
    for (;;) {
        size_t got_a = fread(x, 1, N_FILE_COPY_BLOCK, a);
        size_t got_b = fread(y, 1, N_FILE_COPY_BLOCK, b);
 
        if (got_a != got_b || (got_a && memcmp(x, y, got_a) != 0)) {
            same = FALSE;
            break;
        }
        if (got_a < N_FILE_COPY_BLOCK) {
            /* Both ended together; an error on either is not "equal". */
            if (ferror(a) || ferror(b)) same = FALSE;
            break;
        }
    }
    Free(x);
    Free(y);
    return same;
}
 
int n_file_same_content(const char* a, const char* b) {
    FILE* fa = NULL;
    FILE* fb = NULL;
    int same = FALSE;
 
    __n_assert(a, return FALSE);
    __n_assert(b, return FALSE);
    fa = fopen(a, "rb");
    fb = fa ? fopen(b, "rb") : NULL;
    if (fa && fb) same = n_file_streams_equal(fa, fb);
    if (fa) fclose(fa);
    if (fb) fclose(fb);
    return same;
}
 
int n_file_copy_verified(const char* from, const char* to, size_t* copied) {
    FILE* in = NULL;
    FILE* out = NULL;
    unsigned char* block = NULL;
    char* part = NULL;
    size_t plen = 0, total = 0;
    int ok = TRUE;
 
    __n_assert(from, return FALSE);
    __n_assert(to, return FALSE);
    if (copied) *copied = 0;
    /* Never over a file that is there: the caller decides what an existing one is. */
    in = fopen(to, "rb");
    if (in) {
        fclose(in);
        n_log(LOG_ERR, "n_file_copy_verified: %s exists, not replaced", to);
        return FALSE;
    }
    plen = strlen(to);
    Malloc(part, char, plen + 6); /* ".part" + NUL */
    Malloc(block, unsigned char, N_FILE_COPY_BLOCK);
    if (!part || !block) {
        Free(part);
        Free(block);
        return FALSE;
    }
    memcpy(part, to, plen);
    memcpy(part + plen, ".part", 6);
 
    in = fopen(from, "rb");
    out = in ? fopen(part, "wb") : NULL;
    if (!in || !out) {
        n_log(LOG_ERR, "n_file_copy_verified: cannot open %s: %s", in ? part : from, strerror(errno));
        ok = FALSE;
    }
    while (ok) {
        size_t got = fread(block, 1, N_FILE_COPY_BLOCK, in);
 
        if (got && fwrite(block, 1, got, out) != got) {
            n_log(LOG_ERR, "n_file_copy_verified: writing %s: %s", part, strerror(errno));
            ok = FALSE;
            break;
        }
        total += got;
        if (got < N_FILE_COPY_BLOCK) {
            if (ferror(in)) {
                n_log(LOG_ERR, "n_file_copy_verified: reading %s: %s", from, strerror(errno));
                ok = FALSE;
            }
            break;
        }
    }
    if (out) {
        if (ok && fflush(out) != 0) ok = FALSE;
        if (ok) {
            int fd = fileno(out);
#ifdef __windows__
            if (fd >= 0) (void)_commit(fd);
#else
            if (fd >= 0) (void)fsync(fd);
#endif
        }
        if (fclose(out) != 0) ok = FALSE;
        out = NULL;
    }
    if (in) {
        fclose(in);
        in = NULL;
    }
    /* Read back from disk, not from what was meant to be written. */
    if (ok && !n_file_same_content(from, part)) {
        n_log(LOG_ERR, "n_file_copy_verified: the copy of %s does not match it", from);
        ok = FALSE;
    }
    if (ok && rename(part, to) != 0) {
        n_log(LOG_ERR, "n_file_copy_verified: cannot name %s: %s", to, strerror(errno));
        ok = FALSE;
    }
    if (!ok) remove(part);
    if (ok && copied) *copied = total;
    Free(part);
    Free(block);
    return ok;
}
 
int n_file_write_atomic(const char* path, const unsigned char* data, size_t len, int mode) {
    __n_assert(path, return FALSE);
    if (!data && len > 0) {
        n_log(LOG_ERR, "n_file_write_atomic: NULL data with len %zu", len);
        return FALSE;
    }
 
    size_t plen = strlen(path);
    char* tmp = NULL;
    Malloc(tmp, char, plen + 5); /* ".tmp" + NUL */
    __n_assert(tmp, return FALSE);
    memcpy(tmp, path, plen);
    memcpy(tmp + plen, ".tmp", 5);
 
    /* the temporary carries the final mode from the moment it exists. Creating it with the
     * default mode and chmod'ing it afterwards leaves the content readable by anyone between
     * the write and the chmod, which matters because callers use this to persist secrets. */
#ifdef __windows__
    FILE* f = fopen(tmp, "wb");
#else
    int tmpfd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, (mode != 0) ? (mode_t)mode : (mode_t)0666);
    FILE* f = (tmpfd >= 0) ? fdopen(tmpfd, "wb") : NULL;
    if (!f && tmpfd >= 0) close(tmpfd);
#endif
    if (!f) {
        n_log(LOG_ERR, "n_file_write_atomic: cannot create %s: %s", tmp, strerror(errno));
        Free(tmp);
        return FALSE;
    }
 
    int ok = TRUE;
    if (len && fwrite(data, 1, len, f) != len) ok = FALSE;
    if (ok && fflush(f) != 0) ok = FALSE;
    if (ok) {
        int fd = fileno(f);
        if (fd >= 0) {
#ifdef __windows__
            (void)_commit(fd); /* FlushFileBuffers under the hood */
            (void)mode;        /* no POSIX mode bits on Windows */
#else
            (void)fsync(fd);
            /* a temporary left behind by an earlier crash keeps the mode it was created
             * with, so the mode is still asserted here rather than trusted from open() */
            if (mode != 0 && fchmod(fd, (mode_t)mode) != 0) ok = FALSE;
#endif
        }
    }
    if (fclose(f) != 0) ok = FALSE;
 
    if (ok) {
#ifdef __windows__
        /* Windows rename() fails if the target exists; MoveFileEx replaces it
         * atomically on NTFS, WRITE_THROUGH for durability. */
        ok = MoveFileExA(tmp, path, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) ? TRUE : FALSE;
#else
        ok = (rename(tmp, path) == 0) ? TRUE : FALSE;
#endif
    }
    if (!ok) {
        remove(tmp);
        Free(tmp);
        return FALSE;
    }
    Free(tmp);
    return TRUE;
}