#define _POSIX_C_SOURCE 200809L #include "osls_vm_bridge.h" #include "osls.h" #include #include #include 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;itype = 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); }