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

osls_vm_bridge.c

os-level-support/osls_vm_bridge.c · 400 line(s) · c

#define _POSIX_C_SOURCE 200809L
#include "osls_vm_bridge.h"
#include "osls.h"

#include <stdarg.h>
#include <stdio.h>
#include <string.h>

typedef struct { char *p; size_t cap, used; int failed; } json_out;
static void raw(json_out *j, const char *s) {
    size_t n = s ? strlen(s) : 0;
    if (j->failed || n >= j->cap - j->used) { j->failed = 1; return; }
    memcpy(j->p + j->used, s, n); j->used += n; j->p[j->used] = 0;
}
static void fmt(json_out *j, const char *f, ...) {
    va_list ap; int n;
    if (j->failed || j->used >= j->cap) { j->failed = 1; return; }
    va_start(ap, f); n = vsnprintf(j->p + j->used, j->cap - j->used, f, ap); va_end(ap);
    if (n < 0 || (size_t)n >= j->cap - j->used) { j->failed = 1; return; }
    j->used += (size_t)n;
}
static void str(json_out *j, const char *s) {
    const unsigned char *p = (const unsigned char *)(s ? s : "");
    raw(j, "\"");
    while (*p && !j->failed) {
        char b[7];
        switch (*p) {
            case '"': raw(j, "\\\""); break;
            case '\\': raw(j, "\\\\"); break;
            case '\n': raw(j, "\\n"); break;
            case '\r': raw(j, "\\r"); break;
            case '\t': raw(j, "\\t"); break;
            default:
                if (*p < 0x20) { snprintf(b, sizeof(b), "\\u%04x", (unsigned)*p); raw(j, b); }
                else { b[0] = (char)*p; b[1] = 0; raw(j, b); }
        }
        ++p;
    }
    raw(j, "\"");
}
static void status(json_out *j, osls_status s) { fmt(j, "{\"status\":%d", (int)s); }
static void field_string(json_out *j, const char *key, const char *value) {
    raw(j, ","); str(j, key); raw(j, ":"); str(j, value);
}
static void field_u64(json_out *j, const char *key, uint64_t value) {
    raw(j, ","); str(j, key); fmt(j, ":%llu", (unsigned long long)value);
}
static void field_i64(json_out *j, const char *key, int64_t value) {
    raw(j, ","); str(j, key); fmt(j, ":%lld", (long long)value);
}
static void field_bool(json_out *j, const char *key, int value) {
    raw(j, ","); str(j, key); raw(j, value ? ":true" : ":false");
}
static void finish(json_out *j) { raw(j, "}"); }

static int osls_vm_dispatch_native(int op, const char *arg, int64_t number, char *out, size_t cap) {
    json_out j;
    osls_status rc = OSLS_UNSUPPORTED;
    if (!out || cap < 32) return -1;
    out[0] = 0; j.p = out; j.cap = cap; j.used = 0; j.failed = 0;
    if (op < 0 || op >= OSLS_VM_OPERATION_COUNT) return -1;
    switch (op) {
    case OSLS_VM_SYSTEM_INFO: {
        osls_system_info v; rc = osls_get_system_info(&v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_i64(&j,"platform",v.platform); field_u64(&j,"processId",v.process_id);
            field_i64(&j,"unixTimeSeconds",v.unix_time_seconds);
            field_u64(&j,"monotonicTimeNanoseconds",v.monotonic_time_nanoseconds);
            field_string(&j,"hostname",v.hostname); field_string(&j,"userName",v.user_name);
            field_string(&j,"workingDirectory",v.working_directory);
        }
        finish(&j); break;
    }
    case OSLS_VM_PROCESS_INFO: {
        osls_process_info v; rc = osls_get_process_info(number < 0 ? UINT64_MAX : (uint64_t)number, &v);
        status(&j, rc);
        if (rc == OSLS_OK) {
            field_u64(&j,"pid",v.pid); field_u64(&j,"parentPid",v.parent_pid);
            field_u64(&j,"threadCount",v.thread_count); field_i64(&j,"startEpochSeconds",v.start_epoch_seconds);
            field_string(&j,"executablePath",v.executable_path); field_string(&j,"commandLine",v.command_line);
            field_string(&j,"currentDirectory",v.current_directory); field_string(&j,"state",v.state);
            field_string(&j,"userName",v.user_name);
        }
        finish(&j); break;
    }
    case OSLS_VM_ENUMERATE_PROCESSES: {
        osls_process_info v[1]; size_t n = 0; rc = osls_enumerate_processes(v, 1, &n);
        status(&j, rc); fmt(&j, ",\"count\":%llu,\"items\":[", (unsigned long long)n);
        if (rc == OSLS_OK && n) {
            fmt(&j, "{\"pid\":%llu,\"parentPid\":%llu,\"threadCount\":%llu,",
                (unsigned long long)v[0].pid,(unsigned long long)v[0].parent_pid,(unsigned long long)v[0].thread_count);
            raw(&j,"\"executablePath\":"); str(&j,v[0].executable_path);
            raw(&j,",\"commandLine\":"); str(&j,v[0].command_line);
            raw(&j,",\"currentDirectory\":"); str(&j,v[0].current_directory);
            raw(&j,",\"state\":"); str(&j,v[0].state); raw(&j,"}");
        }
        raw(&j,"]"); finish(&j); break;
    }
    case OSLS_VM_GET_ENVIRONMENT_VALUE: {
        char value[1024] = {0}; rc = osls_get_environment_value(arg, value, sizeof(value));
        status(&j, rc); if (rc == OSLS_OK) field_string(&j,"value",value); finish(&j); break;
    }
    case OSLS_VM_ENUMERATE_ENVIRONMENT: {
        osls_environment_entry v[128]; size_t n = 0; rc = osls_enumerate_environment(v, 128, &n);
        status(&j, rc); fmt(&j,",\"count\":%llu,\"items\":[",(unsigned long long)n);
        if (rc == OSLS_OK) for (size_t i=0;i<n;i++) {
            if (i) raw(&j,",");
            raw(&j,"{\"name\":"); str(&j,v[i].name);
            raw(&j,",\"value\":"); str(&j,v[i].value); raw(&j,"}");
        }
        raw(&j,"]"); finish(&j); break;
    }
    case OSLS_VM_GET_FILE_INFO: {
        osls_file_info v; rc = osls_get_file_info(arg, &v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_string(&j,"path",v.path); field_u64(&j,"sizeBytes",v.size_bytes);
            field_i64(&j,"modifiedEpochSeconds",v.modified_epoch_seconds);
            field_i64(&j,"createdEpochSeconds",v.created_epoch_seconds);
            field_bool(&j,"isDirectory",v.is_directory); field_bool(&j,"isRegularFile",v.is_regular_file);
            field_bool(&j,"isReadable",v.is_readable); field_bool(&j,"isWritable",v.is_writable);
            field_bool(&j,"isExecutable",v.is_executable);
        }
        finish(&j); break;
    }
    case OSLS_VM_LIST_DIRECTORY: {
        char names[32768]; size_t n = 0; rc = osls_list_directory(arg, names, sizeof(names), &n);
        status(&j, rc); raw(&j,",\"entries\":[");
        if (rc == OSLS_OK) {
            size_t pos = 0; int first = 1;
            while (pos < n) { size_t len = strlen(names + pos); if (!first) raw(&j,","); str(&j,names + pos); first = 0; pos += len + 1; }
        }
        raw(&j,"]"); finish(&j); break;
    }
    case OSLS_VM_GET_CPU_INFO: {
        osls_cpu_info v; rc = osls_get_cpu_info(&v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_string(&j,"vendor",v.vendor); field_string(&j,"model",v.model);
            field_u64(&j,"logicalCores",v.logical_cores); field_u64(&j,"physicalCores",v.physical_cores);
            field_u64(&j,"cacheLineSize",v.cache_line_size); field_u64(&j,"totalMemoryBytes",v.total_memory_bytes);
        }
        finish(&j); break;
    }
    case OSLS_VM_GET_TIMEZONE_INFO: {
        osls_timezone_info v; rc = osls_get_timezone_info(&v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_string(&j,"id",v.id); field_string(&j,"abbreviation",v.abbreviation);
            field_i64(&j,"offsetMinutesFromUtc",v.offset_minutes_from_utc); field_bool(&j,"isDst",v.is_dst);
        }
        finish(&j); break;
    }
    case OSLS_VM_GET_NETWORK_INTERFACES: {
        osls_network_interface v[64]; size_t n = 0; rc = osls_get_network_interfaces(v, 64, &n);
        status(&j, rc); fmt(&j,",\"count\":%llu,\"items\":[",(unsigned long long)n);
        if (rc == OSLS_OK) for (size_t i=0;i<n;i++) {
            if (i) raw(&j,",");
            raw(&j,"{\"name\":"); str(&j,v[i].name);
            raw(&j,",\"macAddress\":"); str(&j,v[i].mac_address);
            raw(&j,",\"ipv4\":"); str(&j,v[i].ipv4); raw(&j,",\"ipv6\":"); str(&j,v[i].ipv6);
            field_bool(&j,"isUp",v[i].is_up); field_bool(&j,"isLoopback",v[i].is_loopback); raw(&j,"}");
        }
        raw(&j,"]"); finish(&j); break;
    }
    case OSLS_VM_CRON_VALIDATE:
        rc = osls_cron_validate(arg); status(&j, rc); finish(&j); break;
    case OSLS_VM_CRON_NEXT_AFTER: {
        int64_t next = 0; rc = osls_cron_next_after(arg, number, &next); status(&j, rc);
        if (rc == OSLS_OK) field_i64(&j,"nextEpochSeconds",next); finish(&j); break;
    }
    case OSLS_VM_GET_MEMORY_INFO: {
        osls_memory_info v; rc = osls_get_memory_info(&v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_u64(&j,"totalBytes",v.total_bytes); field_u64(&j,"availableBytes",v.available_bytes);
            field_u64(&j,"usedBytes",v.used_bytes); field_u64(&j,"pageSizeBytes",v.page_size_bytes);
        }
        finish(&j); break;
    }
    case OSLS_VM_GET_AVAILABLE_MEMORY: {
        uint64_t bytes = 0; rc = osls_get_available_memory(&bytes); status(&j, rc);
        if (rc == OSLS_OK) field_u64(&j,"availableBytes",bytes); finish(&j); break;
    }
    case OSLS_VM_GET_DISK_SPACE: {
        osls_disk_space v; rc = osls_get_disk_space(arg, &v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_string(&j,"path",v.path); field_u64(&j,"totalBytes",v.total_bytes);
            field_u64(&j,"freeBytes",v.free_bytes); field_u64(&j,"availableBytes",v.available_bytes);
        }
        finish(&j); break;
    }
    case OSLS_VM_GET_VOLUME_INFO: {
        osls_volume_info v; rc = osls_get_volume_info(arg, &v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_string(&j,"path",v.path); field_string(&j,"filesystem",v.filesystem);
            field_u64(&j,"totalBytes",v.total_bytes); field_u64(&j,"availableBytes",v.available_bytes);
            field_u64(&j,"blockSize",v.block_size); field_bool(&j,"isReadOnly",v.is_read_only);
        }
        finish(&j); break;
    }
    case OSLS_VM_GET_SYSTEM_LOAD: {
        osls_system_load v; rc = osls_get_system_load(&v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_i64(&j,"loadAverage1minMilli",v.load_average_1min_milli);
            field_i64(&j,"loadAverage5minMilli",v.load_average_5min_milli);
            field_i64(&j,"loadAverage15minMilli",v.load_average_15min_milli);
            field_u64(&j,"logicalCores",v.logical_cores);
        }
        finish(&j); break;
    }
    case OSLS_VM_GET_CAPABILITIES: {
        uint64_t caps = 0; rc = osls_get_capabilities(&caps); status(&j, rc);
        if (rc == OSLS_OK) field_u64(&j,"capabilities",caps); finish(&j); break;
    }
    case OSLS_VM_GET_RUNTIME_INFO: {
        osls_runtime_info v; rc = osls_get_runtime_info(&v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_string(&j,"backend",v.backend); field_string(&j,"abiVersion",v.abi_version);
            field_u64(&j,"operationCount",v.operation_count); field_u64(&j,"capabilities",v.capabilities);
        }
        finish(&j); break;
    }
    case OSLS_VM_GET_NATIVE_ERROR: {
        osls_native_error v; rc = osls_get_native_error(&v); status(&j, rc);
        if (rc == OSLS_OK) { field_i64(&j,"code",v.code); field_string(&j,"message",v.message); }
        finish(&j); break;
    }
    case OSLS_VM_PATH_NORMALIZE: {
        char buf[OSLS_PATH_MAX]; rc = osls_path_normalize(arg, buf, sizeof(buf)); status(&j, rc);
        if (rc == OSLS_OK) field_string(&j,"path",buf); finish(&j); break;
    }
    case OSLS_VM_PATH_JOIN: {
        /* Two UTF-8 args arrive packed: left in arg; right not available via the
         * single-text dispatch path, so path_join is exposed with both operands
         * marshalled by the typed invoker below. This record builds from args. */
        rc = OSLS_INVALID_ARGUMENT; status(&j, rc); finish(&j); break;
    }
    case OSLS_VM_PATH_RESOLVE: {
        char buf[OSLS_PATH_MAX]; rc = osls_path_resolve(arg, buf, sizeof(buf)); status(&j, rc);
        if (rc == OSLS_OK) field_string(&j,"path",buf); finish(&j); break;
    }
    case OSLS_VM_GET_PATH_INFO: {
        osls_path_info v; rc = osls_get_path_info(arg, &v); status(&j, rc);
        if (rc == OSLS_OK) {
            field_string(&j,"input",v.input); field_string(&j,"normalized",v.normalized);
            field_string(&j,"root",v.root); field_bool(&j,"isAbsolute",v.is_absolute);
            field_bool(&j,"exists",v.exists);
        }
        finish(&j); break;
    }
    case OSLS_VM_NETWORK_RESOLVE: {
        char buf[1024]; rc = osls_network_resolve(arg, buf, sizeof(buf)); status(&j, rc);
        if (rc == OSLS_OK) field_string(&j,"addresses",buf); finish(&j); break;
    }
    default: return -1;
    }
    return j.failed ? -1 : (int)j.used;
}

/* Native invocation adapters. These function pointers are the executable
 * registry entries; native_symbol is retained as the stable ABI identity. */
static const osls_vm_arg_type sig_i64[] = { OSLS_VM_ARG_I64 };
static const osls_vm_arg_type sig_utf8[] = { OSLS_VM_ARG_UTF8 };
static const osls_vm_arg_type sig_utf8_i64[] = { OSLS_VM_ARG_UTF8, OSLS_VM_ARG_I64 };
static const osls_vm_arg_type sig_utf8_utf8[] = { OSLS_VM_ARG_UTF8, OSLS_VM_ARG_UTF8 };

#define OSLS_INVOKER(name, op, text_expr, int_expr) \
static int name(const osls_vm_value *a, size_t n, char *out, size_t cap) { \
    (void)a; (void)n; return osls_vm_dispatch_native((op), (text_expr), (int_expr), out, cap); \
}
OSLS_INVOKER(invoke_system_info, OSLS_VM_SYSTEM_INFO, NULL, 0)
OSLS_INVOKER(invoke_process_info, OSLS_VM_PROCESS_INFO, NULL, a[0].value.i64)
OSLS_INVOKER(invoke_enumerate_processes, OSLS_VM_ENUMERATE_PROCESSES, NULL, 0)
OSLS_INVOKER(invoke_get_environment, OSLS_VM_GET_ENVIRONMENT_VALUE, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_enumerate_environment, OSLS_VM_ENUMERATE_ENVIRONMENT, NULL, 0)
OSLS_INVOKER(invoke_file_info, OSLS_VM_GET_FILE_INFO, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_list_directory, OSLS_VM_LIST_DIRECTORY, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_cpu_info, OSLS_VM_GET_CPU_INFO, NULL, 0)
OSLS_INVOKER(invoke_timezone_info, OSLS_VM_GET_TIMEZONE_INFO, NULL, 0)
OSLS_INVOKER(invoke_network_interfaces, OSLS_VM_GET_NETWORK_INTERFACES, NULL, 0)
OSLS_INVOKER(invoke_cron_validate, OSLS_VM_CRON_VALIDATE, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_cron_next_after, OSLS_VM_CRON_NEXT_AFTER, a[0].value.utf8, a[1].value.i64)
OSLS_INVOKER(invoke_memory_info, OSLS_VM_GET_MEMORY_INFO, NULL, 0)
OSLS_INVOKER(invoke_available_memory, OSLS_VM_GET_AVAILABLE_MEMORY, NULL, 0)
OSLS_INVOKER(invoke_disk_space, OSLS_VM_GET_DISK_SPACE, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_volume_info, OSLS_VM_GET_VOLUME_INFO, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_system_load, OSLS_VM_GET_SYSTEM_LOAD, NULL, 0)
OSLS_INVOKER(invoke_capabilities, OSLS_VM_GET_CAPABILITIES, NULL, 0)
OSLS_INVOKER(invoke_runtime_info, OSLS_VM_GET_RUNTIME_INFO, NULL, 0)
OSLS_INVOKER(invoke_native_error, OSLS_VM_GET_NATIVE_ERROR, NULL, 0)
OSLS_INVOKER(invoke_path_normalize, OSLS_VM_PATH_NORMALIZE, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_path_resolve, OSLS_VM_PATH_RESOLVE, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_path_info, OSLS_VM_GET_PATH_INFO, a[0].value.utf8, 0)
OSLS_INVOKER(invoke_network_resolve, OSLS_VM_NETWORK_RESOLVE, a[0].value.utf8, 0)
#undef OSLS_INVOKER

/* path_join carries two UTF-8 operands, which the shared single-text dispatch
 * cannot express, so it has a bespoke invoker that builds its own JSON. */
static int invoke_path_join(const osls_vm_value *a, size_t n, char *out, size_t cap) {
    char buf[OSLS_PATH_MAX];
    osls_status rc;
    json_out j;
    (void)n;
    if (!out || cap < 32) return -1;
    out[0] = 0; j.p = out; j.cap = cap; j.used = 0; j.failed = 0;
    rc = osls_path_join(a[0].value.utf8, a[1].value.utf8, buf, sizeof(buf));
    status(&j, rc);
    if (rc == OSLS_OK) field_string(&j, "path", buf);
    finish(&j);
    return j.failed ? -1 : (int)j.used;
}

static const osls_vm_binding bindings[] = {
    {0,"oslsSystemInfo","osls_get_system_info",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON system record",invoke_system_info},
    {1,"oslsProcessInfo","osls_get_process_info",1,sig_i64,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(pid:int64; 0=self)","JSON process record",invoke_process_info},
    {2,"oslsEnumerateProcesses","osls_enumerate_processes",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON process array; self only",invoke_enumerate_processes},
    {3,"oslsGetEnvironmentValue","osls_get_environment_value",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(name:utf8)","JSON status/value",invoke_get_environment},
    {4,"oslsEnumerateEnvironment","osls_enumerate_environment",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON environment array",invoke_enumerate_environment},
    {5,"oslsGetFileInfo","osls_get_file_info",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(path:utf8)","JSON file record",invoke_file_info},
    {6,"oslsListDirectory","osls_list_directory",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(path:utf8)","JSON entry array",invoke_list_directory},
    {7,"oslsGetCPUInfo","osls_get_cpu_info",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON CPU record",invoke_cpu_info},
    {8,"oslsGetTimezoneInfo","osls_get_timezone_info",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON timezone record",invoke_timezone_info},
    {9,"oslsGetNetworkInterfaces","osls_get_network_interfaces",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON interface array",invoke_network_interfaces},
    {10,"oslsCronValidate","osls_cron_validate",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(expression:utf8)","JSON status",invoke_cron_validate},
    {11,"oslsCronNextAfter","osls_cron_next_after",2,sig_utf8_i64,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(expression:utf8, epoch:int64)","JSON status/epoch",invoke_cron_next_after},
    {12,"oslsGetMemoryInfo","osls_get_memory_info",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON memory record",invoke_memory_info},
    {13,"oslsGetAvailableMemory","osls_get_available_memory",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON status/availableBytes",invoke_available_memory},
    {14,"oslsGetDiskSpace","osls_get_disk_space",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(path:utf8)","JSON disk-space record",invoke_disk_space},
    {15,"oslsGetVolumeInfo","osls_get_volume_info",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(path:utf8)","JSON volume record",invoke_volume_info},
    {16,"oslsGetSystemLoad","osls_get_system_load",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON system-load record",invoke_system_load},
    {17,"oslsGetCapabilities","osls_get_capabilities",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON status/capabilities",invoke_capabilities},
    {18,"oslsGetRuntimeInfo","osls_get_runtime_info",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON runtime-info record",invoke_runtime_info},
    {19,"oslsGetNativeError","osls_get_native_error",0,NULL,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"()","JSON native-error record",invoke_native_error},
    {20,"oslsPathNormalize","osls_path_normalize",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(path:utf8)","JSON status/path",invoke_path_normalize},
    {21,"oslsPathJoin","osls_path_join",2,sig_utf8_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(left:utf8, right:utf8)","JSON status/path",invoke_path_join},
    {22,"oslsPathResolve","osls_path_resolve",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(path:utf8)","JSON status/path",invoke_path_resolve},
    {23,"oslsGetPathInfo","osls_get_path_info",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(path:utf8)","JSON path-info record",invoke_path_info},
    {24,"oslsNetworkResolve","osls_network_resolve",1,sig_utf8,OSLS_VM_RESULT_JSON_UTF8,OSLS_VM_CAP_HOST_READ,"(host:utf8)","JSON status/addresses",invoke_network_resolve}
};

const osls_vm_binding *osls_vm_binding_table(size_t *out_count) {
    if (out_count) *out_count = sizeof(bindings) / sizeof(bindings[0]);
    return bindings;
}
const osls_vm_binding *osls_vm_binding_by_id(int operation) {
    size_t i;
    for (i = 0; i < sizeof(bindings) / sizeof(bindings[0]); ++i)
        if (bindings[i].operation == operation) return &bindings[i];
    return NULL;
}
const osls_vm_binding *osls_vm_binding_by_symbol(const char *symbol) {
    size_t i;
    if (!symbol || !*symbol) return NULL;
    for (i = 0; i < sizeof(bindings) / sizeof(bindings[0]); ++i)
        if (strcmp(bindings[i].native_symbol, symbol) == 0) return &bindings[i];
    return NULL;
}
int osls_vm_call_authorized(int operation, const osls_vm_value *args, size_t arg_count,
                            uint64_t granted_capabilities, char *out, size_t cap,
                            osls_vm_result *result) {
    const osls_vm_binding *binding = osls_vm_binding_by_id(operation);
    int written;
    size_t i;
    if (result) { result->type = 0; result->utf8 = NULL; result->length = 0; }
    if (out && cap) out[0] = 0;
    if (!out || cap < 32) return -1;
    if (!binding || !binding->invoke || !binding->native_symbol || !*binding->native_symbol)
        return -1;
    if ((binding->required_capabilities & granted_capabilities) != binding->required_capabilities)
        return -1;
    if (arg_count != binding->argument_count || (arg_count && !args)) return -1;
    for (i = 0; i < arg_count; ++i) {
        if (args[i].type != binding->argument_types[i]) return -1;
        if (args[i].type == OSLS_VM_ARG_UTF8 && !args[i].value.utf8) return -1;
    }
    out[0] = 0;
    written = binding->invoke(args, arg_count, out, cap);
    if (written < 0) return -1;
    if (result) {
        result->type = binding->result_type;
        result->utf8 = out;
        result->length = (size_t)written;
    }
    return written;
}
int osls_vm_call_typed(int operation, const osls_vm_value *args, size_t arg_count,
                       char *out, size_t cap, osls_vm_result *result) {
    return osls_vm_call_authorized(operation, args, arg_count, OSLS_VM_CAP_HOST_READ,
                                   out, cap, result);
}
int osls_vm_call(int operation, const char *text, int64_t number, char *out, size_t cap) {
    const osls_vm_binding *binding = osls_vm_binding_by_id(operation);
    osls_vm_value args[2];
    size_t i;
    if (!binding) return -1;
    for (i = 0; i < binding->argument_count; ++i) {
        args[i].type = binding->argument_types[i];
        if (args[i].type == OSLS_VM_ARG_UTF8) args[i].value.utf8 = text;
        else args[i].value.i64 = number;
    }
    return osls_vm_call_typed(operation, args, binding->argument_count, out, cap, NULL);
}