sslc/compat.c

#include "compat.h"

int strcpy_s(char* dest, size_t destsz, const char* src) {
    if (!dest || !src || destsz == 0) return EINVAL;
    size_t len = strlen(src);
    if (len >= destsz) {
        dest[0] = '\0';
        return ERANGE;
    }
    strcpy(dest, src);
    return 0;
}

int strcat_s(char *dest, size_t destsz, const char *src) {
    if (!dest || !src || destsz == 0) return EINVAL;

    size_t dest_len = strlen(dest);
    size_t src_len = strlen(src);

    if (dest_len + src_len + 1 > destsz) {
        dest[0] = '\0';
        return ERANGE;
    }

    strcat(dest, src);
    return 0;
}

int rand_s(unsigned int *randomValue) {
    if (!randomValue) return EINVAL;
    *randomValue = (unsigned int)rand();
    return 0;
}

int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...) {
    if (!buffer || sizeOfBuffer == 0 || !format) return EINVAL;

    va_list args;
    va_start(args, format);
    int written = vsnprintf(buffer, sizeOfBuffer, format, args);
    va_end(args);

    if (written < 0 || (size_t)written >= sizeOfBuffer) {
        buffer[0] = '\0'; // mimic Windows behavior
        return ERANGE;
    }

    return 0;
}


intptr_t _findfirst(const char *pattern, struct _finddata_t *data) {
    _find_handle_t *handle = calloc(1, sizeof(_find_handle_t));
    if (!handle) return -1;

    // Split pattern into directory path and wildcard
    const char *slash = strrchr(pattern, '/');
    if (slash) {
        size_t len = (size_t)(slash - pattern + 1);
        if (len >= sizeof(handle->path)) len = sizeof(handle->path) - 1;
        strncpy(handle->path, pattern, len);
        handle->path[len] = '\0';
        strncpy(handle->pattern, slash + 1, sizeof(handle->pattern) - 1);
    } else {
        strncpy(handle->path, "./", sizeof(handle->path) - 1);
        strncpy(handle->pattern, pattern, sizeof(handle->pattern) - 1);
    }

    handle->dir = opendir(handle->path);
    if (!handle->dir) {
        free(handle);
        return -1;
    }

    struct dirent *entry;
    while ((entry = readdir(handle->dir)) != NULL) {
        if (fnmatch(handle->pattern, entry->d_name, 0) == 0) {
            struct stat st;
            char fullpath[512];
            snprintf(fullpath, sizeof(fullpath), "%s%s", handle->path, entry->d_name);
            if (stat(fullpath, &st) == 0) {
                // Make the name absolute
                char abspath[512];
                if (realpath(fullpath, abspath)) {
                    strncpy(data->name, abspath, sizeof(data->name) - 1);
                    data->name[sizeof(data->name) - 1] = '\0';
                } else {
                    // Fallback to relative path
                    strncpy(data->name, fullpath, sizeof(data->name) - 1);
                    data->name[sizeof(data->name) - 1] = '\0';
                }

                data->time_write = st.st_mtime;
                data->size = st.st_size;
                data->attrib = S_ISDIR(st.st_mode) ? _A_SUBDIR : _A_NORMAL;
                return (intptr_t)handle;
            }
        }
    }

    closedir(handle->dir);
    free(handle);
    return -1;
}


int _findnext(intptr_t h, struct _finddata_t *data) {
    _find_handle_t *handle = (_find_handle_t *)h;
    struct dirent *entry;

    while ((entry = readdir(handle->dir)) != NULL) {
        if (fnmatch(handle->pattern, entry->d_name, 0) == 0) {
            struct stat st;
            char fullpath[512];
            snprintf(fullpath, sizeof(fullpath), "%s%s", handle->path, entry->d_name);
            if (stat(fullpath, &st) == 0) {
                strncpy(data->name, entry->d_name, sizeof(data->name));
                data->time_write = st.st_mtime;
                data->size = st.st_size;
                data->attrib = S_ISDIR(st.st_mode) ? _A_SUBDIR : _A_NORMAL;
                return 0;
            }
        }
    }

    return -1;
}

int _findclose(intptr_t h) {
    _find_handle_t *handle = (_find_handle_t *)h;
    if (handle) {
        if (handle->dir) closedir(handle->dir);
        free(handle);
        return 0;
    }
    return -1;
}