import { resolve } from "../path/mod.ts";
const CLOCKID_REALTIME = 0;const CLOCKID_MONOTONIC = 1;const CLOCKID_PROCESS_CPUTIME_ID = 2;const CLOCKID_THREAD_CPUTIME_ID = 3;
const ERRNO_SUCCESS = 0;const ERRNO_2BIG = 1;const ERRNO_ACCES = 2;const ERRNO_ADDRINUSE = 3;const ERRNO_ADDRNOTAVAIL = 4;const ERRNO_AFNOSUPPORT = 5;const ERRNO_AGAIN = 6;const ERRNO_ALREADY = 7;const ERRNO_BADF = 8;const ERRNO_BADMSG = 9;const ERRNO_BUSY = 10;const ERRNO_CANCELED = 11;const ERRNO_CHILD = 12;const ERRNO_CONNABORTED = 13;const ERRNO_CONNREFUSED = 14;const ERRNO_CONNRESET = 15;const ERRNO_DEADLK = 16;const ERRNO_DESTADDRREQ = 17;const ERRNO_DOM = 18;const ERRNO_DQUOT = 19;const ERRNO_EXIST = 20;const ERRNO_FAULT = 21;const ERRNO_FBIG = 22;const ERRNO_HOSTUNREACH = 23;const ERRNO_IDRM = 24;const ERRNO_ILSEQ = 25;const ERRNO_INPROGRESS = 26;const ERRNO_INTR = 27;const ERRNO_INVAL = 28;const ERRNO_IO = 29;const ERRNO_ISCONN = 30;const ERRNO_ISDIR = 31;const ERRNO_LOOP = 32;const ERRNO_MFILE = 33;const ERRNO_MLINK = 34;const ERRNO_MSGSIZE = 35;const ERRNO_MULTIHOP = 36;const ERRNO_NAMETOOLONG = 37;const ERRNO_NETDOWN = 38;const ERRNO_NETRESET = 39;const ERRNO_NETUNREACH = 40;const ERRNO_NFILE = 41;const ERRNO_NOBUFS = 42;const ERRNO_NODEV = 43;const ERRNO_NOENT = 44;const ERRNO_NOEXEC = 45;const ERRNO_NOLCK = 46;const ERRNO_NOLINK = 47;const ERRNO_NOMEM = 48;const ERRNO_NOMSG = 49;const ERRNO_NOPROTOOPT = 50;const ERRNO_NOSPC = 51;const ERRNO_NOSYS = 52;const ERRNO_NOTCONN = 53;const ERRNO_NOTDIR = 54;const ERRNO_NOTEMPTY = 55;const ERRNO_NOTRECOVERABLE = 56;const ERRNO_NOTSOCK = 57;const ERRNO_NOTSUP = 58;const ERRNO_NOTTY = 59;const ERRNO_NXIO = 60;const ERRNO_OVERFLOW = 61;const ERRNO_OWNERDEAD = 62;const ERRNO_PERM = 63;const ERRNO_PIPE = 64;const ERRNO_PROTO = 65;const ERRNO_PROTONOSUPPORT = 66;const ERRNO_PROTOTYPE = 67;const ERRNO_RANGE = 68;const ERRNO_ROFS = 69;const ERRNO_SPIPE = 70;const ERRNO_SRCH = 71;const ERRNO_STALE = 72;const ERRNO_TIMEDOUT = 73;const ERRNO_TXTBSY = 74;const ERRNO_XDEV = 75;const ERRNO_NOTCAPABLE = 76;
const RIGHTS_FD_DATASYNC = 0x0000000000000001n;const RIGHTS_FD_READ = 0x0000000000000002n;const RIGHTS_FD_SEEK = 0x0000000000000004n;const RIGHTS_FD_FDSTAT_SET_FLAGS = 0x0000000000000008n;const RIGHTS_FD_SYNC = 0x0000000000000010n;const RIGHTS_FD_TELL = 0x0000000000000020n;const RIGHTS_FD_WRITE = 0x0000000000000040n;const RIGHTS_FD_ADVISE = 0x0000000000000080n;const RIGHTS_FD_ALLOCATE = 0x0000000000000100n;const RIGHTS_PATH_CREATE_DIRECTORY = 0x0000000000000200n;const RIGHTS_PATH_CREATE_FILE = 0x0000000000000400n;const RIGHTS_PATH_LINK_SOURCE = 0x0000000000000800n;const RIGHTS_PATH_LINK_TARGET = 0x0000000000001000n;const RIGHTS_PATH_OPEN = 0x0000000000002000n;const RIGHTS_FD_READDIR = 0x0000000000004000n;const RIGHTS_PATH_READLINK = 0x0000000000008000n;const RIGHTS_PATH_RENAME_SOURCE = 0x0000000000010000n;const RIGHTS_PATH_RENAME_TARGET = 0x0000000000020000n;const RIGHTS_PATH_FILESTAT_GET = 0x0000000000040000n;const RIGHTS_PATH_FILESTAT_SET_SIZE = 0x0000000000080000n;const RIGHTS_PATH_FILESTAT_SET_TIMES = 0x0000000000100000n;const RIGHTS_FD_FILESTAT_GET = 0x0000000000200000n;const RIGHTS_FD_FILESTAT_SET_SIZE = 0x0000000000400000n;const RIGHTS_FD_FILESTAT_SET_TIMES = 0x0000000000800000n;const RIGHTS_PATH_SYMLINK = 0x0000000001000000n;const RIGHTS_PATH_REMOVE_DIRECTORY = 0x0000000002000000n;const RIGHTS_PATH_UNLINK_FILE = 0x0000000004000000n;const RIGHTS_POLL_FD_READWRITE = 0x0000000008000000n;const RIGHTS_SOCK_SHUTDOWN = 0x0000000010000000n;
const WHENCE_SET = 0;const WHENCE_CUR = 1;const WHENCE_END = 2;
const FILETYPE_UNKNOWN = 0;const FILETYPE_BLOCK_DEVICE = 1;const FILETYPE_CHARACTER_DEVICE = 2;const FILETYPE_DIRECTORY = 3;const FILETYPE_REGULAR_FILE = 4;const FILETYPE_SOCKET_DGRAM = 5;const FILETYPE_SOCKET_STREAM = 6;const FILETYPE_SYMBOLIC_LINK = 7;
const ADVICE_NORMAL = 0;const ADVICE_SEQUENTIAL = 1;const ADVICE_RANDOM = 2;const ADVICE_WILLNEED = 3;const ADVICE_DONTNEED = 4;const ADVICE_NOREUSE = 5;
const FDFLAGS_APPEND = 0x0001;const FDFLAGS_DSYNC = 0x0002;const FDFLAGS_NONBLOCK = 0x0004;const FDFLAGS_RSYNC = 0x0008;const FDFLAGS_SYNC = 0x0010;
const FSTFLAGS_ATIM = 0x0001;const FSTFLAGS_ATIM_NOW = 0x0002;const FSTFLAGS_MTIM = 0x0004;const FSTFLAGS_MTIM_NOW = 0x0008;
const LOOKUPFLAGS_SYMLINK_FOLLOW = 0x0001;
const OFLAGS_CREAT = 0x0001;const OFLAGS_DIRECTORY = 0x0002;const OFLAGS_EXCL = 0x0004;const OFLAGS_TRUNC = 0x0008;
const EVENTTYPE_CLOCK = 0;const EVENTTYPE_FD_READ = 1;const EVENTTYPE_FD_WRITE = 2;
const EVENTRWFLAGS_FD_READWRITE_HANGUP = 1;const SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME = 1;
const SIGNAL_NONE = 0;const SIGNAL_HUP = 1;const SIGNAL_INT = 2;const SIGNAL_QUIT = 3;const SIGNAL_ILL = 4;const SIGNAL_TRAP = 5;const SIGNAL_ABRT = 6;const SIGNAL_BUS = 7;const SIGNAL_FPE = 8;const SIGNAL_KILL = 9;const SIGNAL_USR1 = 10;const SIGNAL_SEGV = 11;const SIGNAL_USR2 = 12;const SIGNAL_PIPE = 13;const SIGNAL_ALRM = 14;const SIGNAL_TERM = 15;const SIGNAL_CHLD = 16;const SIGNAL_CONT = 17;const SIGNAL_STOP = 18;const SIGNAL_TSTP = 19;const SIGNAL_TTIN = 20;const SIGNAL_TTOU = 21;const SIGNAL_URG = 22;const SIGNAL_XCPU = 23;const SIGNAL_XFSZ = 24;const SIGNAL_VTALRM = 25;const SIGNAL_PROF = 26;const SIGNAL_WINCH = 27;const SIGNAL_POLL = 28;const SIGNAL_PWR = 29;const SIGNAL_SYS = 30;
const RIFLAGS_RECV_PEEK = 0x0001;const RIFLAGS_RECV_WAITALL = 0x0002;
const ROFLAGS_RECV_DATA_TRUNCATED = 0x0001;
const SDFLAGS_RD = 0x0001;const SDFLAGS_WR = 0x0002;
const PREOPENTYPE_DIR = 0;
const clock_res_realtime = function (): bigint { return BigInt(1e6);};
const clock_res_monotonic = function (): bigint { return BigInt(1e3);};
const clock_res_process = clock_res_monotonic;const clock_res_thread = clock_res_monotonic;
const clock_time_realtime = function (): bigint { return BigInt(Date.now()) * BigInt(1e6);};
const clock_time_monotonic = function (): bigint { const t = performance.now(); const s = Math.trunc(t); const ms = Math.floor((t - s) * 1e3);
return BigInt(s) * BigInt(1e9) + BigInt(ms) * BigInt(1e6);};
const clock_time_process = clock_time_monotonic;const clock_time_thread = clock_time_monotonic;
function errno(err: Error) { switch (err.name) { case "NotFound": return ERRNO_NOENT;
case "PermissionDenied": return ERRNO_ACCES;
case "ConnectionRefused": return ERRNO_CONNREFUSED;
case "ConnectionReset": return ERRNO_CONNRESET;
case "ConnectionAborted": return ERRNO_CONNABORTED;
case "NotConnected": return ERRNO_NOTCONN;
case "AddrInUse": return ERRNO_ADDRINUSE;
case "AddrNotAvailable": return ERRNO_ADDRNOTAVAIL;
case "BrokenPipe": return ERRNO_PIPE;
case "InvalidData": return ERRNO_INVAL;
case "TimedOut": return ERRNO_TIMEDOUT;
case "Interrupted": return ERRNO_INTR;
case "BadResource": return ERRNO_BADF;
case "Busy": return ERRNO_BUSY;
default: return ERRNO_INVAL; }}
export interface ModuleOptions { args?: string[]; env?: { [key: string]: string | undefined }; preopens?: { [key: string]: string }; memory?: WebAssembly.Memory;}
export default class Module { args: string[]; env: { [key: string]: string | undefined }; memory: WebAssembly.Memory;
fds: any[];
exports: { [key: string]: any };
constructor(options: ModuleOptions) { this.args = options.args ? options.args : []; this.env = options.env ? options.env : {}; this.memory = options.memory!;
this.fds = [ { type: FILETYPE_CHARACTER_DEVICE, handle: Deno.stdin, }, { type: FILETYPE_CHARACTER_DEVICE, handle: Deno.stdout, }, { type: FILETYPE_CHARACTER_DEVICE, handle: Deno.stderr, }, ];
if (options.preopens) { for (const [vpath, path] of Object.entries(options.preopens)) { const type = FILETYPE_DIRECTORY; const entries = Array.from(Deno.readDirSync(path));
const entry = { type, entries, path, vpath, };
this.fds.push(entry); } }
this.exports = { args_get: (argv_ptr: number, argv_buf_ptr: number): number => { const args = this.args; const text = new TextEncoder(); const heap = new Uint8Array(this.memory.buffer); const view = new DataView(this.memory.buffer);
for (let arg of args) { view.setUint32(argv_ptr, argv_buf_ptr, true); argv_ptr += 4;
const data = text.encode(`${arg}\0`); heap.set(data, argv_buf_ptr); argv_buf_ptr += data.length; }
return ERRNO_SUCCESS; },
args_sizes_get: (argc_out: number, argv_buf_size_out: number): number => { const args = this.args; const text = new TextEncoder(); const view = new DataView(this.memory.buffer);
view.setUint32(argc_out, args.length, true); view.setUint32( argv_buf_size_out, args.reduce(function (acc, arg) { return acc + text.encode(`${arg}\0`).length; }, 0), true, );
return ERRNO_SUCCESS; },
environ_get: (environ_ptr: number, environ_buf_ptr: number): number => { const entries = Object.entries(this.env); const text = new TextEncoder(); const heap = new Uint8Array(this.memory.buffer); const view = new DataView(this.memory.buffer);
for (let [key, value] of entries) { view.setUint32(environ_ptr, environ_buf_ptr, true); environ_ptr += 4;
const data = text.encode(`${key}=${value}\0`); heap.set(data, environ_buf_ptr); environ_buf_ptr += data.length; }
return ERRNO_SUCCESS; },
environ_sizes_get: ( environc_out: number, environ_buf_size_out: number, ): number => { const entries = Object.entries(this.env); const text = new TextEncoder(); const view = new DataView(this.memory.buffer);
view.setUint32(environc_out, entries.length, true); view.setUint32( environ_buf_size_out, entries.reduce(function (acc, [key, value]) { return acc + text.encode(`${key}=${value}\0`).length; }, 0), true, );
return ERRNO_SUCCESS; },
clock_res_get: (id: number, resolution_out: number): number => { const view = new DataView(this.memory.buffer);
switch (id) { case CLOCKID_REALTIME: view.setBigUint64(resolution_out, clock_res_realtime(), true); break;
case CLOCKID_MONOTONIC: view.setBigUint64(resolution_out, clock_res_monotonic(), true); break;
case CLOCKID_PROCESS_CPUTIME_ID: view.setBigUint64(resolution_out, clock_res_process(), true); break;
case CLOCKID_THREAD_CPUTIME_ID: view.setBigUint64(resolution_out, clock_res_thread(), true); break;
default: return ERRNO_INVAL; }
return ERRNO_SUCCESS; },
clock_time_get: ( id: number, precision: bigint, time_out: number, ): number => { const view = new DataView(this.memory.buffer);
switch (id) { case CLOCKID_REALTIME: view.setBigUint64(time_out, clock_time_realtime(), true); break;
case CLOCKID_MONOTONIC: view.setBigUint64(time_out, clock_time_monotonic(), true); break;
case CLOCKID_PROCESS_CPUTIME_ID: view.setBigUint64(time_out, clock_time_process(), true); break;
case CLOCKID_THREAD_CPUTIME_ID: view.setBigUint64(time_out, clock_time_thread(), true); break;
default: return ERRNO_INVAL; }
return ERRNO_SUCCESS; },
fd_advise: ( fd: number, offset: bigint, len: bigint, advice: number, ): number => { return ERRNO_NOSYS; },
fd_allocate: (fd: number, offset: bigint, len: bigint): number => { return ERRNO_NOSYS; },
fd_close: (fd: number): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (entry.handle) { entry.handle.close(); }
delete this.fds[fd];
return ERRNO_SUCCESS; },
fd_datasync: (fd: number): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
try { Deno.fdatasyncSync(entry.handle.rid); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
fd_fdstat_get: (fd: number, stat_out: number): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const view = new DataView(this.memory.buffer); view.setUint8(stat_out, entry.type); view.setUint16(stat_out + 4, 0, true); view.setBigUint64(stat_out + 8, 0n, true); view.setBigUint64(stat_out + 16, 0n, true);
return ERRNO_SUCCESS; },
fd_fdstat_set_flags: (fd: number, flags: number): number => { return ERRNO_NOSYS; },
fd_fdstat_set_rights: ( fd: number, fs_rights_base: bigint, fs_rights_inheriting: bigint, ): number => { return ERRNO_NOSYS; },
fd_filestat_get: (fd: number, buf_out: number): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const view = new DataView(this.memory.buffer);
try { const info = Deno.fstatSync(entry.handle.rid);
if (entry.type === undefined) { switch (true) { case info.isFile: entry.type = FILETYPE_REGULAR_FILE; break;
case info.isDirectory: entry.type = FILETYPE_DIRECTORY; break;
case info.isSymlink: entry.type = FILETYPE_SYMBOLIC_LINK; break;
default: entry.type = FILETYPE_UNKNOWN; break; } }
view.setBigUint64(buf_out, BigInt(info.dev ? info.dev : 0), true); buf_out += 8;
view.setBigUint64(buf_out, BigInt(info.ino ? info.ino : 0), true); buf_out += 8;
view.setUint8(buf_out, entry.type); buf_out += 8;
view.setUint32(buf_out, Number(info.nlink), true); buf_out += 8;
view.setBigUint64(buf_out, BigInt(info.size), true); buf_out += 8;
view.setBigUint64( buf_out, BigInt(info.atime ? info.atime.getTime() * 1e6 : 0), true, ); buf_out += 8;
view.setBigUint64( buf_out, BigInt(info.mtime ? info.mtime.getTime() * 1e6 : 0), true, ); buf_out += 8;
view.setBigUint64( buf_out, BigInt(info.birthtime ? info.birthtime.getTime() * 1e6 : 0), true, ); buf_out += 8; } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
fd_filestat_set_size: (fd: number, size: bigint): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
try { Deno.ftruncateSync(entry.handle.rid, Number(size)); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
fd_filestat_set_times: ( fd: number, atim: bigint, mtim: bigint, fst_flags: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
if ((fst_flags & FSTFLAGS_ATIM_NOW) == FSTFLAGS_ATIM_NOW) { atim = BigInt(Date.now() * 1e6); }
if ((fst_flags & FSTFLAGS_MTIM_NOW) == FSTFLAGS_MTIM_NOW) { mtim = BigInt(Date.now() * 1e6); }
try { Deno.utimeSync(entry.path, Number(atim), Number(mtim)); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
fd_pread: ( fd: number, iovs_ptr: number, iovs_len: number, offset: bigint, nread_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const seek = entry.handle.seekSync(0, Deno.SeekMode.Current); const view = new DataView(this.memory.buffer);
let nread = 0; for (let i = 0; i < iovs_len; i++) { const data_ptr = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
const data_len = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
const data = new Uint8Array(this.memory.buffer, data_ptr, data_len); nread += entry.handle.readSync(data); }
entry.handle.seekSync(seek, Deno.SeekMode.Start); view.setUint32(nread_out, nread, true);
return ERRNO_SUCCESS; },
fd_prestat_get: (fd: number, buf_out: number): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.vpath) { return ERRNO_BADF; }
const view = new DataView(this.memory.buffer); view.setUint8(buf_out, PREOPENTYPE_DIR); view.setUint32( buf_out + 4, new TextEncoder().encode(entry.vpath).byteLength, true, );
return ERRNO_SUCCESS; },
fd_prestat_dir_name: ( fd: number, path_ptr: number, path_len: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.vpath) { return ERRNO_BADF; }
const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); data.set(new TextEncoder().encode(entry.vpath));
return ERRNO_SUCCESS; },
fd_pwrite: ( fd: number, iovs_ptr: number, iovs_len: number, offset: bigint, nwritten_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const seek = entry.handle.seekSync(0, Deno.SeekMode.Current); const view = new DataView(this.memory.buffer);
let nwritten = 0; for (let i = 0; i < iovs_len; i++) { const data_ptr = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
const data_len = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
const data = new Uint8Array(this.memory.buffer, data_ptr, data_len); nwritten += entry.handle.writeSync(data); }
entry.handle.seekSync(seek, Deno.SeekMode.Start); view.setUint32(nwritten_out, nwritten, true);
return ERRNO_SUCCESS; },
fd_read: ( fd: number, iovs_ptr: number, iovs_len: number, nread_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const view = new DataView(this.memory.buffer);
let nread = 0; for (let i = 0; i < iovs_len; i++) { const data_ptr = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
const data_len = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
const data = new Uint8Array(this.memory.buffer, data_ptr, data_len); nread += entry.handle.readSync(data); }
view.setUint32(nread_out, nread, true);
return ERRNO_SUCCESS; },
fd_readdir: ( fd: number, buf_ptr: number, buf_len: number, cookie: bigint, bufused_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const heap = new Uint8Array(this.memory.buffer); const view = new DataView(this.memory.buffer);
let bufused = 0;
try { const entries = Array.from(Deno.readDirSync(entry.path)); for (let i = Number(cookie); i < entries.length; i++) { const name_data = new TextEncoder().encode(entries[i].name);
const entry_info = Deno.statSync( resolve(entry.path, entries[i].name), ); const entry_data = new Uint8Array(24 + name_data.byteLength); const entry_view = new DataView(entry_data.buffer);
entry_view.setBigUint64(0, BigInt(i + 1), true); entry_view.setBigUint64( 8, BigInt(entry_info.ino ? entry_info.ino : 0), true, ); entry_view.setUint32(16, name_data.byteLength, true);
switch (true) { case entries[i].isFile: var type = FILETYPE_REGULAR_FILE; break;
case entries[i].isDirectory: var type = FILETYPE_REGULAR_FILE; break;
case entries[i].isSymlink: var type = FILETYPE_SYMBOLIC_LINK; break;
default: var type = FILETYPE_REGULAR_FILE; break; }
entry_view.setUint8(20, type); entry_data.set(name_data, 24);
const data = entry_data.slice( 0, Math.min(entry_data.length, buf_len - bufused), ); heap.set(data, buf_ptr + bufused); bufused += data.byteLength; } } catch (err) { return errno(err); }
view.setUint32(bufused_out, bufused, true);
return ERRNO_SUCCESS; },
fd_renumber: (fd: number, to: number): number => { if (!this.fds[fd]) { return ERRNO_BADF; }
if (!this.fds[to]) { return ERRNO_BADF; }
this.fds[to].handle.close(); this.fds[to] = this.fds[fd]; delete this.fds[fd];
return ERRNO_SUCCESS; },
fd_seek: ( fd: number, offset: bigint, whence: number, newoffset_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const view = new DataView(this.memory.buffer);
try {
const newoffset = entry.handle.seekSync(Number(offset), whence); view.setBigUint64(newoffset_out, BigInt(newoffset), true); } catch (err) { return ERRNO_INVAL; }
return ERRNO_SUCCESS; },
fd_sync: (fd: number): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
try { Deno.fsyncSync(entry.handle.rid); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
fd_tell: (fd: number, offset_out: number): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const view = new DataView(this.memory.buffer);
try { const offset = entry.handle.seekSync(0, Deno.SeekMode.Current); view.setBigUint64(offset_out, offset, true); } catch (err) { return ERRNO_INVAL; }
return ERRNO_SUCCESS; },
fd_write: ( fd: number, iovs_ptr: number, iovs_len: number, nwritten_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
const view = new DataView(this.memory.buffer);
let nwritten = 0; for (let i = 0; i < iovs_len; i++) { const data_ptr = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
const data_len = view.getUint32(iovs_ptr, true); iovs_ptr += 4;
nwritten += entry.handle.writeSync( new Uint8Array(this.memory.buffer, data_ptr, data_len), ); }
view.setUint32(nwritten_out, nwritten, true);
return ERRNO_SUCCESS; },
path_create_directory: ( fd: number, path_ptr: number, path_len: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); const path = resolve(entry.path, text.decode(data));
try { Deno.mkdirSync(path); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_filestat_get: ( fd: number, flags: number, path_ptr: number, path_len: number, buf_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); const path = resolve(entry.path, text.decode(data));
const view = new DataView(this.memory.buffer);
try { const info = (flags & LOOKUPFLAGS_SYMLINK_FOLLOW) != 0 ? Deno.statSync(path) : Deno.lstatSync(path);
view.setBigUint64(buf_out, BigInt(info.dev ? info.dev : 0), true); buf_out += 8;
view.setBigUint64(buf_out, BigInt(info.ino ? info.ino : 0), true); buf_out += 8;
switch (true) { case info.isFile: view.setUint8(buf_out, FILETYPE_REGULAR_FILE); buf_out += 8; break;
case info.isDirectory: view.setUint8(buf_out, FILETYPE_DIRECTORY); buf_out += 8; break;
case info.isSymlink: view.setUint8(buf_out, FILETYPE_SYMBOLIC_LINK); buf_out += 8; break;
default: view.setUint8(buf_out, FILETYPE_UNKNOWN); buf_out += 8; break; }
view.setUint32(buf_out, Number(info.nlink), true); buf_out += 8;
view.setBigUint64(buf_out, BigInt(info.size), true); buf_out += 8;
view.setBigUint64( buf_out, BigInt(info.atime ? info.atime.getTime() * 1e6 : 0), true, ); buf_out += 8;
view.setBigUint64( buf_out, BigInt(info.mtime ? info.mtime.getTime() * 1e6 : 0), true, ); buf_out += 8;
view.setBigUint64( buf_out, BigInt(info.birthtime ? info.birthtime.getTime() * 1e6 : 0), true, ); buf_out += 8; } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_filestat_set_times: ( fd: number, flags: number, path_ptr: number, path_len: number, atim: bigint, mtim: bigint, fst_flags: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); const path = resolve(entry.path, text.decode(data));
if ((fst_flags & FSTFLAGS_ATIM_NOW) == FSTFLAGS_ATIM_NOW) { atim = BigInt(Date.now()) * BigInt(1e6); }
if ((fst_flags & FSTFLAGS_MTIM_NOW) == FSTFLAGS_MTIM_NOW) { mtim = BigInt(Date.now()) * BigInt(1e6); }
try { Deno.utimeSync(path, Number(atim), Number(mtim)); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_link: ( old_fd: number, old_flags: number, old_path_ptr: number, old_path_len: number, new_fd: number, new_path_ptr: number, new_path_len: number, ): number => { const old_entry = this.fds[old_fd]; const new_entry = this.fds[new_fd]; if (!old_entry || !new_entry) { return ERRNO_BADF; }
if (!old_entry.path || !new_entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const old_data = new Uint8Array( this.memory.buffer, old_path_ptr, old_path_len, ); const old_path = resolve(old_entry.path, text.decode(old_data)); const new_data = new Uint8Array( this.memory.buffer, new_path_ptr, new_path_len, ); const new_path = resolve(new_entry.path, text.decode(new_data));
try { Deno.linkSync(old_path, new_path); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_open: ( fd: number, dirflags: number, path_ptr: number, path_len: number, oflags: number, fs_rights_base: bigint, fs_rights_inherting: bigint, fdflags: number, opened_fd_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); const path = resolve(entry.path, text.decode(data));
if ((oflags & OFLAGS_DIRECTORY) !== 0) { try { const entries = Array.from(Deno.readDirSync(path)); const opened_fd = this.fds.push({ entries, path, }) - 1;
const view = new DataView(this.memory.buffer); view.setUint32(opened_fd_out, opened_fd, true); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; }
const options = { read: false, write: false, append: false, truncate: false, create: false, createNew: false, };
if ((oflags & OFLAGS_CREAT) !== 0) { options.create = true; options.write = true; }
if ((oflags & OFLAGS_EXCL) !== 0) { options.createNew = true; }
if ((oflags & OFLAGS_TRUNC) !== 0) { options.truncate = true; options.write = true; }
const read = ( RIGHTS_FD_READ | RIGHTS_FD_READDIR );
if ((fs_rights_base & read) != 0n) { options.read = true; }
const write = ( RIGHTS_FD_DATASYNC | RIGHTS_FD_WRITE | RIGHTS_FD_ALLOCATE | RIGHTS_FD_FILESTAT_SET_SIZE );
if ((fs_rights_base & write) != 0n) { options.write = true; }
if ((fdflags & FDFLAGS_APPEND) != 0) { options.append = true; }
if ((fdflags & FDFLAGS_DSYNC) != 0) { }
if ((fdflags & FDFLAGS_NONBLOCK) != 0) { }
if ((fdflags & FDFLAGS_RSYNC) != 0) { }
if ((fdflags & FDFLAGS_SYNC) != 0) { }
if (!options.read && !options.write && !options.truncate) { options.read = true; }
try { const handle = Deno.openSync(path, options); const opened_fd = this.fds.push({ handle, path, }) - 1;
const view = new DataView(this.memory.buffer); view.setUint32(opened_fd_out, opened_fd, true); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_readlink: ( fd: number, path_ptr: number, path_len: number, buf_ptr: number, buf_len: number, bufused_out: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const view = new DataView(this.memory.buffer); const heap = new Uint8Array(this.memory.buffer);
const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); const path = resolve(entry.path, new TextDecoder().decode(data));
try { const link = Deno.readLinkSync(path); const data = new TextEncoder().encode(link); heap.set(new Uint8Array(data, 0, buf_len), buf_ptr);
const bufused = Math.min(data.byteLength, buf_len); view.setUint32(bufused_out, bufused, true); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_remove_directory: ( fd: number, path_ptr: number, path_len: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); const path = resolve(entry.path, text.decode(data));
try { if (!Deno.statSync(path).isDirectory) { return ERRNO_NOTDIR; }
Deno.removeSync(path); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_rename: ( fd: number, old_path_ptr: number, old_path_len: number, new_fd: number, new_path_ptr: number, new_path_len: number, ): number => { const old_entry = this.fds[fd]; const new_entry = this.fds[new_fd]; if (!old_entry || !new_entry) { return ERRNO_BADF; }
if (!old_entry.path || !new_entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const old_data = new Uint8Array( this.memory.buffer, old_path_ptr, old_path_len, ); const old_path = resolve(old_entry.path, text.decode(old_data)); const new_data = new Uint8Array( this.memory.buffer, new_path_ptr, new_path_len, ); const new_path = resolve(new_entry.path, text.decode(new_data));
try { Deno.renameSync(old_path, new_path); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_symlink: ( old_path_ptr: number, old_path_len: number, fd: number, new_path_ptr: number, new_path_len: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const old_data = new Uint8Array( this.memory.buffer, old_path_ptr, old_path_len, ); const old_path = text.decode(old_data); const new_data = new Uint8Array( this.memory.buffer, new_path_ptr, new_path_len, ); const new_path = resolve(entry.path, text.decode(new_data));
try { Deno.symlinkSync(old_path, new_path); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
path_unlink_file: ( fd: number, path_ptr: number, path_len: number, ): number => { const entry = this.fds[fd]; if (!entry) { return ERRNO_BADF; }
if (!entry.path) { return ERRNO_INVAL; }
const text = new TextDecoder(); const data = new Uint8Array(this.memory.buffer, path_ptr, path_len); const path = resolve(entry.path, text.decode(data));
try { Deno.removeSync(path); } catch (err) { return errno(err); }
return ERRNO_SUCCESS; },
poll_oneoff: ( in_ptr: number, out_ptr: number, nsubscriptions: number, nevents_out: number, ): number => { return ERRNO_NOSYS; },
proc_exit: (rval: number): never => { Deno.exit(rval); },
proc_raise: (sig: number): number => { return ERRNO_NOSYS; },
sched_yield: (): number => { return ERRNO_SUCCESS; },
random_get: (buf_ptr: number, buf_len: number): number => { const buffer = new Uint8Array(this.memory.buffer, buf_ptr, buf_len); crypto.getRandomValues(buffer);
return ERRNO_SUCCESS; },
sock_recv: ( fd: number, ri_data_ptr: number, ri_data_len: number, ri_flags: number, ro_datalen_out: number, ro_flags_out: number, ): number => { return ERRNO_NOSYS; },
sock_send: ( fd: number, si_data_ptr: number, si_data_len: number, si_flags: number, so_datalen_out: number, ): number => { return ERRNO_NOSYS; },
sock_shutdown: (fd: number, how: number): number => { return ERRNO_NOSYS; }, }; }}