osal_file_win32.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright (C) 2026 Sylvain Labopin
 */
 
#include "internal/osal_file_internal.h"
 
#include "osal/file/osal_file_ops.h"
 
#include "osal/mem/osal_mem_ops.h"
#include "osal/mem/osal_mem.h"
 
#include "policy/lexleo_cstd_lib.h"
#include "policy/lexleo_cstd_errno.h"
#include "policy/lexleo_cstd_io.h"
#include "policy/lexleo_cstd_wchar.h"
#include "policy/lexleo_cstring.h"
#include "policy/lexleo_win32_base.h"
#include "policy/lexleo_assert.h"
 
static osal_file_status_t osal_file_map_errno(int errnum)
{
    switch (errnum) {
        case 0:
            return OSAL_FILE_STATUS_OK;
 
#ifdef EINVAL
        case EINVAL:
            return OSAL_FILE_STATUS_INVALID;
#endif
 
#ifdef ENOENT
        case ENOENT:
            return OSAL_FILE_STATUS_NOENT;
#endif
 
#ifdef EACCES
        case EACCES:
            return OSAL_FILE_STATUS_PERM;
#endif
 
#ifdef EPERM
        case EPERM:
            return OSAL_FILE_STATUS_PERM;
#endif
 
#ifdef EEXIST
        case EEXIST:
            return OSAL_FILE_STATUS_EXISTS;
#endif
 
#ifdef ENOSPC
        case ENOSPC:
            return OSAL_FILE_STATUS_NOSPC;
#endif
 
#ifdef ENAMETOOLONG
        case ENAMETOOLONG:
            return OSAL_FILE_STATUS_NAMETOOLONG;
#endif
 
#ifdef ENOTDIR
        case ENOTDIR:
            return OSAL_FILE_STATUS_NOTDIR;
#endif
 
#ifdef EISDIR
        case EISDIR:
            return OSAL_FILE_STATUS_ISDIR;
#endif
 
#ifdef EBADF
        case EBADF:
            return OSAL_FILE_STATUS_BADF;
#endif
 
#ifdef EFBIG
        case EFBIG:
            return OSAL_FILE_STATUS_FBIG;
#endif
 
#ifdef EINTR
        case EINTR:
            return OSAL_FILE_STATUS_INTR;
#endif
 
#ifdef EMFILE
        case EMFILE:
            return OSAL_FILE_STATUS_MFILE;
#endif
 
#ifdef ENFILE
        case ENFILE:
            return OSAL_FILE_STATUS_NFILE;
#endif
 
#ifdef ELOOP
        case ELOOP:
            return OSAL_FILE_STATUS_LOOP;
#endif
 
#ifdef EROFS
        case EROFS:
            return OSAL_FILE_STATUS_ROFS;
#endif
 
#ifdef ESPIPE
        case ESPIPE:
            return OSAL_FILE_STATUS_SPIPE;
#endif
 
#ifdef EXDEV
        case EXDEV:
            return OSAL_FILE_STATUS_XDEV;
#endif
 
#ifdef ENODEV
        case ENODEV:
            return OSAL_FILE_STATUS_NODEV;
#endif
 
#ifdef ENXIO
        case ENXIO:
            return OSAL_FILE_STATUS_NXIO;
#endif
 
#ifdef ESTALE
        case ESTALE:
            return OSAL_FILE_STATUS_STALE;
#endif
 
#ifdef ENOMEM
        case ENOMEM:
            return OSAL_FILE_STATUS_OOM;
#endif
 
        default:
            return OSAL_FILE_STATUS_IO;
    }
}
 
static osal_file_status_t osal_file_win32_error(DWORD err)
{
    switch (err) {
        case ERROR_SUCCESS:
            return OSAL_FILE_STATUS_OK;
 
        case ERROR_FILE_NOT_FOUND:
        case ERROR_PATH_NOT_FOUND:
            return OSAL_FILE_STATUS_NOENT;
 
        case ERROR_ACCESS_DENIED:
        case ERROR_SHARING_VIOLATION:
            return OSAL_FILE_STATUS_PERM;
 
        case ERROR_ALREADY_EXISTS:
        case ERROR_FILE_EXISTS:
            return OSAL_FILE_STATUS_EXISTS;
 
        case ERROR_DISK_FULL:
        case ERROR_HANDLE_DISK_FULL:
            return OSAL_FILE_STATUS_NOSPC;
 
        case ERROR_FILENAME_EXCED_RANGE:
            return OSAL_FILE_STATUS_NAMETOOLONG;
 
        case ERROR_DIRECTORY:
            return OSAL_FILE_STATUS_NOTDIR;
 
        case ERROR_INVALID_NAME:
        case ERROR_BAD_PATHNAME:
        case ERROR_INVALID_PARAMETER:
        case ERROR_NO_UNICODE_TRANSLATION:
            return OSAL_FILE_STATUS_INVALID;
 
        case ERROR_TOO_MANY_OPEN_FILES:
            return OSAL_FILE_STATUS_MFILE;
 
        case ERROR_NOT_READY:
        case ERROR_DEV_NOT_EXIST:
            return OSAL_FILE_STATUS_NODEV;
 
        case ERROR_OUTOFMEMORY:
        case ERROR_NOT_ENOUGH_MEMORY:
            return OSAL_FILE_STATUS_OOM;
 
        case ERROR_WRITE_PROTECT:
            return OSAL_FILE_STATUS_ROFS;
 
        default:
            return OSAL_FILE_STATUS_IO;
    }
}
 
static const wchar_t *osal_file_mode_w(const char *mode)
{
    if (osal_strcmp(mode, "rb") == 0)
        return L"rb";
 
    if (osal_strcmp(mode, "wb") == 0)
        return L"wb";
 
    if (osal_strcmp(mode, "ab") == 0)
        return L"ab";
 
    return NULL;
}
 
static osal_file_status_t osal_utf8_to_utf16_dup(
    wchar_t **out_wstr,
    const char *utf8,
    const osal_mem_ops_t *mem_ops)
{
    LEXLEO_ASSERT(out_wstr);
    LEXLEO_ASSERT(mem_ops && mem_ops->malloc && mem_ops->free);
 
    *out_wstr = NULL;
 
    if (!utf8)
        return OSAL_FILE_STATUS_INVALID;
 
    int wlen = MultiByteToWideChar(
        CP_UTF8,
        MB_ERR_INVALID_CHARS,
        utf8,
        -1,
        NULL,
        0);
 
    if (wlen <= 0)
        return osal_file_win32_error(GetLastError());
 
    size_t bytes = (size_t)wlen * sizeof(wchar_t);
 
    wchar_t *tmp = mem_ops->malloc(bytes);
    if (!tmp)
        return OSAL_FILE_STATUS_OOM;
 
    int converted = MultiByteToWideChar(
        CP_UTF8,
        MB_ERR_INVALID_CHARS,
        utf8,
        -1,
        tmp,
        wlen);
 
    if (converted <= 0) {
        mem_ops->free(tmp);
        return osal_file_win32_error(GetLastError());
    }
 
    *out_wstr = tmp;
    return OSAL_FILE_STATUS_OK;
}
 
static osal_file_status_t osal_file_open(
    OSAL_FILE **out,
    const char *pathname,
    const char *mode,
    const osal_mem_ops_t *mem_ops)
{
    if (
           !out
        || !pathname
        || pathname[0] == '\0'
        || !mode
        || (
               osal_strcmp(mode, "rb") != 0
            && osal_strcmp(mode, "wb") != 0
            && osal_strcmp(mode, "ab") != 0)
        || !mem_ops
    ) {
        return OSAL_FILE_STATUS_INVALID;
    }
 
    LEXLEO_ASSERT(
           mem_ops->malloc
        && mem_ops->free
    );
 
    const wchar_t *wmode = osal_file_mode_w(mode);
    if (!wmode)
        return OSAL_FILE_STATUS_INVALID;
 
    wchar_t *wpath = NULL;
    osal_file_status_t st = osal_utf8_to_utf16_dup(&wpath, pathname, mem_ops);
    if (st != OSAL_FILE_STATUS_OK)
        return st;
 
    FILE *fp = _wfopen(wpath, wmode);
 
    mem_ops->free(wpath);
    wpath = NULL;
 
    if (!fp) {
        /*
         * _wfopen() is a CRT call; errno is the primary error channel here.
         */
        return osal_file_map_errno(errno);
    }
 
    OSAL_FILE *tmp = mem_ops->malloc(sizeof(*tmp));
    if (!tmp) {
        fclose(fp);
        return OSAL_FILE_STATUS_OOM;
    }
 
    tmp->fp = fp;
    tmp->mem_ops = mem_ops;
 
    *out = tmp;
 
    return OSAL_FILE_STATUS_OK;
}
 
static size_t osal_file_read(
    void *ptr,
    size_t size,
    size_t nmemb,
    OSAL_FILE *stream,
    osal_file_status_t *st)
{
    if (
           !ptr
        || !st
        || !stream
        || !stream->fp
    ) {
        if (st)
            *st = OSAL_FILE_STATUS_INVALID;
        return 0;
    }
 
    *st = OSAL_FILE_STATUS_OK;
 
    size_t ret = fread(ptr, size, nmemb, stream->fp);
 
    if (ret < nmemb && ferror(stream->fp))
        *st = osal_file_map_errno(errno);
 
    return ret;
}
 
static size_t osal_file_write(
    const void *ptr,
    size_t size,
    size_t nmemb,
    OSAL_FILE *stream,
    osal_file_status_t *st)
{
    if (
           !ptr
        || !st
        || !stream
        || !stream->fp
    ) {
        if (st)
            *st = OSAL_FILE_STATUS_INVALID;
        return 0;
    }
 
    *st = OSAL_FILE_STATUS_OK;
 
    size_t ret = fwrite(ptr, size, nmemb, stream->fp);
 
    if (ret < nmemb && ferror(stream->fp))
        *st = osal_file_map_errno(errno);
 
    return ret;
}
 
static osal_file_status_t osal_file_flush(OSAL_FILE *stream)
{
    if (!stream || !stream->fp)
        return OSAL_FILE_STATUS_INVALID;
 
    if (fflush(stream->fp) != 0)
        return osal_file_map_errno(errno);
 
    return OSAL_FILE_STATUS_OK;
}
 
static osal_file_status_t osal_file_close(OSAL_FILE *stream)
{
    if (!stream || !stream->fp)
        return OSAL_FILE_STATUS_INVALID;
 
    if (fclose(stream->fp) != 0)
        return osal_file_map_errno(errno);
 
    LEXLEO_ASSERT(stream->mem_ops && stream->mem_ops->free);
    stream->mem_ops->free(stream);
 
    return OSAL_FILE_STATUS_OK;
}
 
const osal_file_ops_t *osal_file_default_ops(void)
{
    static const osal_file_ops_t osal_file_ops = {
        .open  = osal_file_open,
        .read  = osal_file_read,
        .write = osal_file_write,
        .close = osal_file_close,
        .flush = osal_file_flush,
    };
 
    return &osal_file_ops;
}