Home /Modules/os-level-support/osls_extended2.c

osls_extended2.c

os-level-support/osls_extended2.c · 442 line(s) · c

#if defined(__APPLE__) && !defined(_DARWIN_C_SOURCE)
/* Expose BSD interfaces used by the macOS headers even with _POSIX_C_SOURCE. */
#  define _DARWIN_C_SOURCE 1
#endif

#include "osls.h"
#include "osls_vm_bridge.h"

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(_WIN32)
#  define WIN32_LEAN_AND_MEAN
#  include <winsock2.h>
#  include <ws2tcpip.h>
#  include <windows.h>
#  include <shlwapi.h>
#  pragma comment(lib, "shlwapi.lib")
#  pragma comment(lib, "ws2_32.lib")
#else
#  include <unistd.h>
#  include <limits.h>
#  include <stdlib.h>
#  include <sys/types.h>
#  include <netdb.h>
#  include <arpa/inet.h>
#  include <sys/socket.h>
#  if defined(__linux__)
#    include <sys/statvfs.h>
#    include <sys/sysinfo.h>
#  elif defined(__APPLE__)
#    include <sys/statvfs.h>
#    include <sys/mount.h>
#    include <sys/sysctl.h>
#    include <mach/mach.h>
#    include <mach/mach_host.h>
#  endif
#endif

static int osls2_copy(char *dst, size_t cap, const char *src) {
    size_t n;
    if (!dst || !cap || !src) return 0;
    n = strlen(src);
    if (n >= cap) return 0;
    memcpy(dst, src, n + 1);
    return 1;
}

/* -------------------------------------------------------------------------
 * Memory
 * ---------------------------------------------------------------------- */
osls_status osls_get_memory_info(osls_memory_info *out_info) {
    if (!out_info) return OSLS_INVALID_ARGUMENT;
    memset(out_info, 0, sizeof(*out_info));
#if defined(_WIN32)
    {
        MEMORYSTATUSEX mem;
        SYSTEM_INFO si;
        mem.dwLength = sizeof(mem);
        if (!GlobalMemoryStatusEx(&mem)) return OSLS_SYSTEM_ERROR;
        GetSystemInfo(&si);
        out_info->total_bytes = mem.ullTotalPhys;
        out_info->available_bytes = mem.ullAvailPhys;
        out_info->used_bytes = mem.ullTotalPhys - mem.ullAvailPhys;
        out_info->page_size_bytes = si.dwPageSize;
    }
    return OSLS_OK;
#elif defined(__linux__)
    {
        struct sysinfo info;
        long page = sysconf(_SC_PAGESIZE);
        long avail_pages = sysconf(_SC_AVPHYS_PAGES);
        if (sysinfo(&info) != 0) return OSLS_SYSTEM_ERROR;
        out_info->total_bytes = (uint64_t)info.totalram * (uint64_t)info.mem_unit;
        if (avail_pages > 0 && page > 0) out_info->available_bytes = (uint64_t)avail_pages * (uint64_t)page;
        else out_info->available_bytes = (uint64_t)info.freeram * (uint64_t)info.mem_unit;
        out_info->used_bytes = out_info->total_bytes > out_info->available_bytes
            ? out_info->total_bytes - out_info->available_bytes : 0;
        out_info->page_size_bytes = page > 0 ? (uint64_t)page : 0;
    }
    return OSLS_OK;
#elif defined(__APPLE__)
    {
        uint64_t mem = 0; size_t len = sizeof(mem);
        vm_size_t page = 0;
        mach_port_t host = mach_host_self();
        vm_statistics64_data_t vmstat;
        mach_msg_type_number_t cnt = HOST_VM_INFO64_COUNT;
        if (sysctlbyname("hw.memsize", &mem, &len, NULL, 0) == 0) out_info->total_bytes = mem;
        if (host_page_size(host, &page) == KERN_SUCCESS) out_info->page_size_bytes = (uint64_t)page;
        if (host_statistics64(host, HOST_VM_INFO64, (host_info64_t)&vmstat, &cnt) == KERN_SUCCESS && page) {
            out_info->available_bytes = (uint64_t)(vmstat.free_count + vmstat.inactive_count) * (uint64_t)page;
            out_info->used_bytes = out_info->total_bytes > out_info->available_bytes
                ? out_info->total_bytes - out_info->available_bytes : 0;
        }
    }
    return OSLS_OK;
#else
    return OSLS_UNSUPPORTED;
#endif
}

osls_status osls_get_available_memory(uint64_t *out_bytes) {
    osls_memory_info info;
    osls_status s;
    if (!out_bytes) return OSLS_INVALID_ARGUMENT;
    *out_bytes = 0;
    s = osls_get_memory_info(&info);
    if (s != OSLS_OK) return s;
    *out_bytes = info.available_bytes;
    return OSLS_OK;
}

/* -------------------------------------------------------------------------
 * Disk space and volume
 * ---------------------------------------------------------------------- */
osls_status osls_get_disk_space(const char *path, osls_disk_space *out_info) {
    if (!path || !*path || !out_info) return OSLS_INVALID_ARGUMENT;
    memset(out_info, 0, sizeof(*out_info));
    if (!osls2_copy(out_info->path, sizeof(out_info->path), path)) return OSLS_BUFFER_TOO_SMALL;
#if defined(_WIN32)
    {
        ULARGE_INTEGER avail, total, free_bytes;
        wchar_t wpath[OSLS_PATH_MAX];
        if (MultiByteToWideChar(CP_UTF8, 0, path, -1, wpath, OSLS_PATH_MAX) == 0) return OSLS_INVALID_ARGUMENT;
        if (!GetDiskFreeSpaceExW(wpath, &avail, &total, &free_bytes))
            return GetLastError() == ERROR_PATH_NOT_FOUND ? OSLS_NOT_FOUND : OSLS_SYSTEM_ERROR;
        out_info->total_bytes = total.QuadPart;
        out_info->free_bytes = free_bytes.QuadPart;
        out_info->available_bytes = avail.QuadPart;
    }
    return OSLS_OK;
#else
    {
        struct statvfs st;
        if (statvfs(path, &st) != 0) return errno == ENOENT ? OSLS_NOT_FOUND : OSLS_SYSTEM_ERROR;
        out_info->total_bytes = (uint64_t)st.f_blocks * (uint64_t)st.f_frsize;
        out_info->free_bytes = (uint64_t)st.f_bfree * (uint64_t)st.f_frsize;
        out_info->available_bytes = (uint64_t)st.f_bavail * (uint64_t)st.f_frsize;
    }
    return OSLS_OK;
#endif
}

osls_status osls_get_volume_info(const char *path, osls_volume_info *out_info) {
    if (!path || !*path || !out_info) return OSLS_INVALID_ARGUMENT;
    memset(out_info, 0, sizeof(*out_info));
    if (!osls2_copy(out_info->path, sizeof(out_info->path), path)) return OSLS_BUFFER_TOO_SMALL;
#if defined(_WIN32)
    {
        ULARGE_INTEGER avail, total, free_bytes;
        wchar_t wpath[OSLS_PATH_MAX];
        wchar_t fsname[64] = {0};
        char fsname8[64] = {0};
        DWORD serial = 0, maxlen = 0, flags = 0;
        if (MultiByteToWideChar(CP_UTF8, 0, path, -1, wpath, OSLS_PATH_MAX) == 0) return OSLS_INVALID_ARGUMENT;
        if (GetDiskFreeSpaceExW(wpath, &avail, &total, &free_bytes)) {
            out_info->total_bytes = total.QuadPart;
            out_info->available_bytes = avail.QuadPart;
        }
        if (GetVolumeInformationW(wpath, NULL, 0, &serial, &maxlen, &flags, fsname, 64)) {
            WideCharToMultiByte(CP_UTF8, 0, fsname, -1, fsname8, (int)sizeof(fsname8), NULL, NULL);
            osls2_copy(out_info->filesystem, sizeof(out_info->filesystem), fsname8);
            out_info->is_read_only = (flags & FILE_READ_ONLY_VOLUME) != 0;
        }
    }
    return OSLS_OK;
#elif defined(__APPLE__)
    {
        struct statfs st;
        if (statfs(path, &st) != 0) return errno == ENOENT ? OSLS_NOT_FOUND : OSLS_SYSTEM_ERROR;
        out_info->total_bytes = (uint64_t)st.f_blocks * (uint64_t)st.f_bsize;
        out_info->available_bytes = (uint64_t)st.f_bavail * (uint64_t)st.f_bsize;
        out_info->block_size = (uint64_t)st.f_bsize;
        out_info->is_read_only = (st.f_flags & MNT_RDONLY) != 0;
        osls2_copy(out_info->filesystem, sizeof(out_info->filesystem), st.f_fstypename);
    }
    return OSLS_OK;
#else
    {
        struct statvfs st;
        if (statvfs(path, &st) != 0) return errno == ENOENT ? OSLS_NOT_FOUND : OSLS_SYSTEM_ERROR;
        out_info->total_bytes = (uint64_t)st.f_blocks * (uint64_t)st.f_frsize;
        out_info->available_bytes = (uint64_t)st.f_bavail * (uint64_t)st.f_frsize;
        out_info->block_size = (uint64_t)st.f_frsize;
        out_info->is_read_only = (st.f_flag & ST_RDONLY) != 0;
        /* statvfs does not name the filesystem type portably. */
        osls2_copy(out_info->filesystem, sizeof(out_info->filesystem), "unknown");
    }
    return OSLS_OK;
#endif
}

/* -------------------------------------------------------------------------
 * System load
 * ---------------------------------------------------------------------- */
osls_status osls_get_system_load(osls_system_load *out_info) {
    long cores;
    if (!out_info) return OSLS_INVALID_ARGUMENT;
    memset(out_info, 0, sizeof(*out_info));
    out_info->load_average_1min_milli = -1;
    out_info->load_average_5min_milli = -1;
    out_info->load_average_15min_milli = -1;
#if defined(_WIN32)
    {
        SYSTEM_INFO si;
        GetSystemInfo(&si);
        out_info->logical_cores = si.dwNumberOfProcessors;
        /* Windows has no POSIX load-average equivalent; leave windows as -1. */
    }
    return OSLS_OK;
#else
    cores = sysconf(_SC_NPROCESSORS_ONLN);
    out_info->logical_cores = cores > 0 ? (uint32_t)cores : 0;
    {
        double avg[3];
        int n = getloadavg(avg, 3);
        if (n >= 1) out_info->load_average_1min_milli = (int64_t)(avg[0] * 1000.0 + 0.5);
        if (n >= 2) out_info->load_average_5min_milli = (int64_t)(avg[1] * 1000.0 + 0.5);
        if (n >= 3) out_info->load_average_15min_milli = (int64_t)(avg[2] * 1000.0 + 0.5);
    }
    return OSLS_OK;
#endif
}

/* -------------------------------------------------------------------------
 * Capability, runtime-info and native-error diagnostics
 * ---------------------------------------------------------------------- */
osls_status osls_get_capabilities(uint64_t *out_capabilities) {
    if (!out_capabilities) return OSLS_INVALID_ARGUMENT;
    /* This user-mode layer satisfies host-read inspection. */
    *out_capabilities = OSLS_VM_CAP_HOST_READ;
    return OSLS_OK;
}

osls_status osls_get_runtime_info(osls_runtime_info *out_info) {
    size_t count = 0;
    if (!out_info) return OSLS_INVALID_ARGUMENT;
    memset(out_info, 0, sizeof(*out_info));
#if defined(_WIN32)
    osls2_copy(out_info->backend, sizeof(out_info->backend), "windows");
#elif defined(__APPLE__)
    osls2_copy(out_info->backend, sizeof(out_info->backend), "macos");
#elif defined(__linux__)
    osls2_copy(out_info->backend, sizeof(out_info->backend), "linux");
#else
    osls2_copy(out_info->backend, sizeof(out_info->backend), "unknown");
#endif
    osls2_copy(out_info->abi_version, sizeof(out_info->abi_version), "1.1.0");
    (void)osls_vm_binding_table(&count);
    out_info->operation_count = (uint32_t)count;
    out_info->capabilities = OSLS_VM_CAP_HOST_READ;
    return OSLS_OK;
}

osls_status osls_get_native_error(osls_native_error *out_error) {
    if (!out_error) return OSLS_INVALID_ARGUMENT;
    memset(out_error, 0, sizeof(*out_error));
#if defined(_WIN32)
    {
        DWORD code = GetLastError();
        out_error->code = (int32_t)code;
        if (code) {
            wchar_t wbuf[256] = {0};
            FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
                           code, 0, wbuf, 256, NULL);
            WideCharToMultiByte(CP_UTF8, 0, wbuf, -1, out_error->message, (int)sizeof(out_error->message), NULL, NULL);
        }
    }
#else
    {
        int code = errno;
        out_error->code = (int32_t)code;
        if (code) osls2_copy(out_error->message, sizeof(out_error->message), strerror(code));
    }
#endif
    return OSLS_OK;
}

/* -------------------------------------------------------------------------
 * Path handling
 * ---------------------------------------------------------------------- */
#if defined(_WIN32)
static const char OSLS_SEP = '\\';
#else
static const char OSLS_SEP = '/';
#endif

static int osls2_is_sep(char c) { return c == '/' || c == '\\'; }

#define OSLS_MAX_SEGMENTS 256
osls_status osls_path_normalize(const char *path, char *out_buffer, size_t out_capacity) {
    const char *seg_ptr[OSLS_MAX_SEGMENTS];
    size_t seg_len[OSLS_MAX_SEGMENTS];
    size_t seg_count = 0;
    const char *p;
    int absolute;
    size_t used, i;
    if (!path || !out_buffer || out_capacity == 0) return OSLS_INVALID_ARGUMENT;
    absolute = path[0] && osls2_is_sep(path[0]);
    p = path;
    /* Tokenize into segments, resolving '.' and '..' lexically (no FS access). */
    while (*p) {
        const char *start;
        size_t len;
        while (*p && osls2_is_sep(*p)) ++p;
        start = p;
        while (*p && !osls2_is_sep(*p)) ++p;
        len = (size_t)(p - start);
        if (len == 0) continue;
        if (len == 1 && start[0] == '.') continue;
        if (len == 2 && start[0] == '.' && start[1] == '.') {
            if (seg_count > 0 && !(seg_len[seg_count - 1] == 2 &&
                                   seg_ptr[seg_count - 1][0] == '.' &&
                                   seg_ptr[seg_count - 1][1] == '.')) {
                --seg_count;            /* pop a real parent segment */
                continue;
            }
            if (absolute) continue;      /* '..' above root is dropped */
            /* else: keep leading '..' on a relative path (falls through) */
        }
        if (seg_count >= OSLS_MAX_SEGMENTS) return OSLS_BUFFER_TOO_SMALL;
        seg_ptr[seg_count] = start;
        seg_len[seg_count] = len;
        ++seg_count;
    }
    /* Reassemble. */
    used = 0;
    if (absolute) { if (used + 1 >= out_capacity) return OSLS_BUFFER_TOO_SMALL; out_buffer[used++] = OSLS_SEP; }
    for (i = 0; i < seg_count; ++i) {
        if (i > 0) { if (used + 1 >= out_capacity) return OSLS_BUFFER_TOO_SMALL; out_buffer[used++] = OSLS_SEP; }
        if (used + seg_len[i] >= out_capacity) return OSLS_BUFFER_TOO_SMALL;
        memcpy(out_buffer + used, seg_ptr[i], seg_len[i]);
        used += seg_len[i];
    }
    if (used == 0) { if (out_capacity < 2) return OSLS_BUFFER_TOO_SMALL; out_buffer[used++] = '.'; }
    out_buffer[used] = '\0';
    return OSLS_OK;
}

osls_status osls_path_join(const char *left, const char *right, char *out_buffer, size_t out_capacity) {
    char combined[OSLS_PATH_MAX];
    size_t ln, rn, need;
    if (!left || !right || !out_buffer || out_capacity == 0) return OSLS_INVALID_ARGUMENT;
    /* An absolute right component replaces left. */
    if (right[0] && osls2_is_sep(right[0])) return osls_path_normalize(right, out_buffer, out_capacity);
    ln = strlen(left);
    rn = strlen(right);
    if (ln == 0) return osls_path_normalize(right, out_buffer, out_capacity);
    need = ln + 1 + rn;
    if (need >= sizeof(combined)) return OSLS_BUFFER_TOO_SMALL;
    memcpy(combined, left, ln);
    if (!osls2_is_sep(left[ln - 1])) combined[ln++] = OSLS_SEP;
    memcpy(combined + ln, right, rn);
    combined[ln + rn] = '\0';
    return osls_path_normalize(combined, out_buffer, out_capacity);
}

osls_status osls_path_resolve(const char *path, char *out_buffer, size_t out_capacity) {
    if (!path || !*path || !out_buffer || out_capacity == 0) return OSLS_INVALID_ARGUMENT;
#if defined(_WIN32)
    {
        wchar_t wpath[OSLS_PATH_MAX], wfull[OSLS_PATH_MAX];
        if (MultiByteToWideChar(CP_UTF8, 0, path, -1, wpath, OSLS_PATH_MAX) == 0) return OSLS_INVALID_ARGUMENT;
        if (GetFullPathNameW(wpath, OSLS_PATH_MAX, wfull, NULL) == 0) return OSLS_SYSTEM_ERROR;
        if (WideCharToMultiByte(CP_UTF8, 0, wfull, -1, out_buffer, (int)out_capacity, NULL, NULL) == 0)
            return OSLS_BUFFER_TOO_SMALL;
    }
    return OSLS_OK;
#else
    {
        char resolved[PATH_MAX];
        if (!realpath(path, resolved)) {
            if (errno == ENOENT) return OSLS_NOT_FOUND;
            return OSLS_SYSTEM_ERROR;
        }
        if (strlen(resolved) >= out_capacity) return OSLS_BUFFER_TOO_SMALL;
        strcpy(out_buffer, resolved);
    }
    return OSLS_OK;
#endif
}

osls_status osls_get_path_info(const char *path, osls_path_info *out_info) {
    osls_status s;
    osls_file_info fi;
    if (!path || !*path || !out_info) return OSLS_INVALID_ARGUMENT;
    memset(out_info, 0, sizeof(*out_info));
    if (!osls2_copy(out_info->input, sizeof(out_info->input), path)) return OSLS_BUFFER_TOO_SMALL;
    s = osls_path_normalize(path, out_info->normalized, sizeof(out_info->normalized));
    if (s != OSLS_OK) return s;
#if defined(_WIN32)
    out_info->is_absolute = (path[1] == ':' ) || osls2_is_sep(path[0]);
    if (path[1] == ':') { out_info->root[0] = path[0]; out_info->root[1] = ':'; out_info->root[2] = '\\'; out_info->root[3] = '\0'; }
    else if (osls2_is_sep(path[0])) osls2_copy(out_info->root, sizeof(out_info->root), "\\");
#else
    out_info->is_absolute = osls2_is_sep(path[0]);
    if (out_info->is_absolute) osls2_copy(out_info->root, sizeof(out_info->root), "/");
#endif
    out_info->exists = (osls_get_file_info(path, &fi) == OSLS_OK) ? 1 : 0;
    return OSLS_OK;
}

/* -------------------------------------------------------------------------
 * Hostname/service resolution (read-only DNS query; no connection is made)
 * ---------------------------------------------------------------------- */
osls_status osls_network_resolve(const char *host, char *out_buffer, size_t out_capacity) {
    struct addrinfo hints, *res = NULL, *it;
    char addr[64];
    size_t used = 0;
    int rc;
    if (!host || !*host || !out_buffer || out_capacity == 0) return OSLS_INVALID_ARGUMENT;
    out_buffer[0] = '\0';
#if defined(_WIN32)
    { WSADATA wsa; static int started = 0; if (!started) { if (WSAStartup(MAKEWORD(2,2), &wsa) == 0) started = 1; } }
#endif
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    rc = getaddrinfo(host, NULL, &hints, &res);
    if (rc != 0) return OSLS_NOT_FOUND;
    for (it = res; it; it = it->ai_next) {
        void *src;
        size_t n;
        if (it->ai_family == AF_INET) src = &((struct sockaddr_in *)it->ai_addr)->sin_addr;
        else if (it->ai_family == AF_INET6) src = &((struct sockaddr_in6 *)it->ai_addr)->sin6_addr;
        else continue;
        if (!inet_ntop(it->ai_family, src, addr, sizeof(addr))) continue;
        n = strlen(addr);
        if (used + n + (used ? 1 : 0) >= out_capacity) break;
        if (used) out_buffer[used++] = ',';
        memcpy(out_buffer + used, addr, n);
        used += n;
        out_buffer[used] = '\0';
    }
    freeaddrinfo(res);
    if (used == 0) return OSLS_NOT_FOUND;
    return OSLS_OK;
}