sandboxedjs 0.1.53 → 0.1.55

package/dist/python-abi.js

@@ -33,7 +33,20 @@ var Op = {
   getcwd: 1281,
   chdir: 1282,
   environ: 1283,
-  getrandom: 1536
+  getrandom: 1536,
+  socket: 1792,
+  bind: 1793,
+  listen: 1794,
+  accept: 1795,
+  connect: 1796,
+  send: 1797,
+  recv: 1798,
+  shutdown: 1799,
+  getsockname: 1800,
+  getpeername: 1801,
+  setsockopt: 1802,
+  getsockopt: 1803,
+  socket_close: 1804
 };
 var Errno = {
   EPERM: 1,
@@ -70,6 +83,15 @@ var Errno = {
   ENOTEMPTY: 39,
   ELOOP: 40,
   ENODATA: 61,
+  ENOTSOCK: 88,
+  EAFNOSUPPORT: 97,
+  EADDRINUSE: 98,
+  EADDRNOTAVAIL: 99,
+  ENETUNREACH: 101,
+  ECONNRESET: 104,
+  EISCONN: 106,
+  ENOTCONN: 107,
+  ECONNREFUSED: 111,
   EPROTO: 71,
   EOVERFLOW: 75,
   ETIMEDOUT: 110,
@@ -1079,6 +1101,170 @@ var FileService = class {
   }
 };
 
+// src/net/virtual-socket.ts
+var VirtualTcpSocket = class _VirtualTcpSocket {
+  constructor(network) {
+    this.network = network;
+  }
+  network;
+  listenerValue = null;
+  connectionValue = null;
+  boundPort = 0;
+  boundAddress = "0.0.0.0";
+  bind(address, port) {
+    if (this.listenerValue || this.connectionValue || this.boundPort !== 0) {
+      throw new PosixError(Errno.EINVAL, "socket is already bound");
+    }
+    this.boundAddress = address;
+    this.boundPort = port;
+  }
+  listen(backlog) {
+    if (this.listenerValue) return;
+    if (this.boundPort === 0) {
+      const port = this.findEphemeralPort();
+      this.boundPort = port;
+    }
+    this.listenerValue = this.network.listen(this.boundPort, this.boundAddress, backlog);
+  }
+  connect(port, address = "127.0.0.1") {
+    if (this.listenerValue || this.connectionValue) throw new PosixError(Errno.EISCONN);
+    this.connectionValue = this.network.connect(port, this.boundPort, this.boundAddress);
+    this.boundPort = this.connectionValue.local.port;
+    this.boundAddress = this.connectionValue.local.address;
+  }
+  accept() {
+    if (!this.listenerValue) throw new PosixError(Errno.EINVAL, "socket is not listening");
+    const accepted = this.listenerValue.accept().connection;
+    const socket = new _VirtualTcpSocket(this.network);
+    socket.connectionValue = accepted;
+    socket.boundPort = accepted.local.port;
+    socket.boundAddress = accepted.local.address;
+    return socket;
+  }
+  get listener() {
+    return this.listenerValue;
+  }
+  get connection() {
+    return this.connectionValue;
+  }
+  get local() {
+    return { address: this.boundAddress, port: this.boundPort };
+  }
+  get remote() {
+    return this.connectionValue?.remote ?? null;
+  }
+  get readable() {
+    return this.listenerValue?.readable ?? this.connectionValue?.readable ?? false;
+  }
+  get writable() {
+    return this.connectionValue?.writable ?? false;
+  }
+  waitForChange() {
+    return (this.listenerValue ?? this.connectionValue)?.waitForChange() ?? Promise.resolve();
+  }
+  read(length) {
+    if (!this.connectionValue) throw new PosixError(Errno.EINVAL);
+    return this.connectionValue.read(length);
+  }
+  write(data) {
+    if (!this.connectionValue) throw new PosixError(Errno.EINVAL);
+    return this.connectionValue.write(data);
+  }
+  shutdown(read, write) {
+    if (!this.connectionValue) throw new PosixError(Errno.ENOTCONN);
+    this.connectionValue.shutdown(read, write);
+  }
+  close() {
+    if (this.listenerValue) this.network.close(this.listenerValue);
+    this.connectionValue?.close();
+    this.listenerValue = null;
+    this.connectionValue = null;
+  }
+  findEphemeralPort() {
+    for (let port = 49152; port <= 65535; port += 1) if (!this.network.hasListener(port)) return port;
+    throw new PosixError(Errno.EADDRINUSE, "no ephemeral ports available");
+  }
+};
+var SocketDescription = class _SocketDescription {
+  kind = "socket";
+  flags;
+  resource;
+  closed = false;
+  options = /* @__PURE__ */ new Map();
+  constructor(resource, flags = 0) {
+    this.resource = resource;
+    this.flags = flags;
+  }
+  get listener() {
+    return this.resource.listener;
+  }
+  get connection() {
+    return this.resource.connection;
+  }
+  read(length) {
+    return this.resource.read(length);
+  }
+  write(data) {
+    return this.resource.write(data);
+  }
+  readable() {
+    return this.resource.readable;
+  }
+  writable() {
+    return this.resource.writable;
+  }
+  whenReady() {
+    return this.resource.waitForChange();
+  }
+  stat() {
+    return {
+      ino: 0,
+      mode: 49663,
+      size: 0,
+      uid: 0,
+      gid: 0,
+      nlink: 1,
+      atimeMs: Date.now(),
+      mtimeMs: Date.now(),
+      ctimeMs: Date.now()
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.resource.close();
+  }
+  bind(address, port) {
+    this.resource.bind(address, port);
+  }
+  listen(backlog) {
+    this.resource.listen(backlog);
+  }
+  connect(address, port) {
+    this.resource.connect(port, address);
+  }
+  accept() {
+    return new _SocketDescription(this.resource.accept(), this.flags);
+  }
+  shutdown(read, write) {
+    this.resource.shutdown(read, write);
+  }
+  setOption(level, option, value) {
+    this.options.set(`${level}:${option}`, value.slice());
+  }
+  getOption(level, option) {
+    return this.options.get(`${level}:${option}`)?.slice() ?? new Uint8Array(4);
+  }
+  localAddress() {
+    return this.resource.local;
+  }
+  peerAddress() {
+    const peer = this.resource.remote;
+    if (!peer) throw new PosixError(Errno.ENOTCONN);
+    return peer;
+  }
+};
+
 // src/runtime/python/syscall-server.ts
 var MAX_TRANSFER = 8 * 1024 * 1024;
 function createHostAbiServer(proc) {
@@ -1325,12 +1511,76 @@ function createHostAbiServer(proc) {
         crypto.getRandomValues(bytes);
         return { status: length, payload: bytes };
       }
+      /* ----------------------------------------------------------- sockets */
+      case Op.socket: {
+        const family = r.u32();
+        const type = r.u32();
+        const protocol = r.i32();
+        if (family !== 2 || (type & 15) !== 1 || protocol !== 0) throw new PosixError(Errno.EAFNOSUPPORT);
+        if (!proc.sockets) throw new PosixError(Errno.ENOSYS);
+        return { status: proc.table.add(new SocketDescription(new VirtualTcpSocket(proc.sockets))) };
+      }
+      case Op.bind: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        description.bind(r.string(), r.u32());
+        return { status: 0 };
+      }
+      case Op.listen: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        description.listen(Math.max(1, Math.min(1024, r.u32())));
+        return { status: 0 };
+      }
+      case Op.accept: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        const accepted = await acceptBlocking(description);
+        const fd = proc.table.add(accepted);
+        const peer = accepted.peerAddress();
+        return { status: fd, payload: new Writer().string(peer.address).u32(peer.port).finish() };
+      }
+      case Op.connect: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        description.connect(r.string(), r.u32());
+        return { status: 0 };
+      }
+      case Op.send: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        return { status: await writeBlocking(description, r.bytes32()) };
+      }
+      case Op.recv: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        const data = await readBlocking(description, clamp(r.u32()));
+        return { status: data.length, payload: data };
+      }
+      case Op.shutdown: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        const how = r.u32();
+        if (how > 2) throw new PosixError(Errno.EINVAL);
+        description.shutdown(how === 0 || how === 2, how === 1 || how === 2);
+        return { status: 0 };
+      }
+      case Op.getsockname: {
+        const address = socketDescription(proc.table.get(r.i32())).localAddress();
+        return { status: 0, payload: new Writer().string(address.address).u32(address.port).finish() };
+      }
+      case Op.getpeername: {
+        const address = socketDescription(proc.table.get(r.i32())).peerAddress();
+        return { status: 0, payload: new Writer().string(address.address).u32(address.port).finish() };
+      }
+      case Op.setsockopt: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        description.setOption(r.u32(), r.u32(), r.bytes32());
+        return { status: 0 };
+      }
+      case Op.getsockopt: {
+        const description = socketDescription(proc.table.get(r.i32()));
+        return { status: 0, payload: new Writer().bytes32(description.getOption(r.u32(), r.u32())).finish() };
+      }
       default:
         return { status: failure(Errno.ENOSYS) };
     }
   }
   function implemented(capability) {
-    return ["files", "descriptors", "pipes", "readiness", "time", "identity", "entropy"].includes(capability);
+    return ["files", "descriptors", "pipes", "readiness", "time", "identity", "entropy"].includes(capability) || capability === "sockets" && proc.sockets !== void 0;
   }
   function resolve2(path) {
     if (path.startsWith("/")) return proc.vfs.resolvePath(path);
@@ -1339,6 +1589,22 @@ function createHostAbiServer(proc) {
   function clamp(length) {
     return Math.min(length, MAX_TRANSFER);
   }
+  function socketDescription(description) {
+    if (!(description instanceof SocketDescription)) throw new PosixError(Errno.ENOTSOCK, "descriptor is not a socket");
+    return description;
+  }
+  async function acceptBlocking(description) {
+    for (; ; ) {
+      try {
+        return description.accept();
+      } catch (error) {
+        const posix = toPosixError(error);
+        if (posix.errno !== Errno.EAGAIN || description.flags & O_NONBLOCK) throw posix;
+      }
+      await Promise.race([description.whenReady(), aborted()]);
+      if (proc.signal.aborted) throw new PosixError(Errno.EINTR);
+    }
+  }
   async function readBlocking(description, length) {
     for (; ; ) {
       try {
@@ -1559,6 +1825,37 @@ var HostAbiClient = class {
   getrandom(length) {
     return this.call(Op.getrandom, new Writer().u32(length).finish()).payload;
   }
+  socket(family, type, protocol = 0) {
+    return this.call(Op.socket, new Writer().u32(family).u32(type).i32(protocol).finish()).status;
+  }
+  bind(fd, address, port) {
+    this.call(Op.bind, new Writer().i32(fd).string(address).u32(port).finish());
+  }
+  listen(fd, backlog = 128) {
+    this.call(Op.listen, new Writer().i32(fd).u32(backlog).finish());
+  }
+  accept(fd) {
+    const result = this.call(Op.accept, new Writer().i32(fd).finish());
+    const r = new Reader(result.payload);
+    return { fd: result.status, address: r.string(), port: r.u32() };
+  }
+  connect(fd, address, port) {
+    this.call(Op.connect, new Writer().i32(fd).string(address).u32(port).finish());
+  }
+  send(fd, data) {
+    return this.call(Op.send, new Writer().i32(fd).bytes32(data).finish()).status;
+  }
+  recv(fd, length) {
+    return this.call(Op.recv, new Writer().i32(fd).u32(length).finish()).payload;
+  }
+  shutdown(fd, how) {
+    this.call(Op.shutdown, new Writer().i32(fd).u32(how).finish());
+  }
+  socketName(fd, peer = false) {
+    const payload = this.call(peer ? Op.getpeername : Op.getsockname, new Writer().i32(fd).finish()).payload;
+    const r = new Reader(payload);
+    return { address: r.string(), port: r.u32() };
+  }
 };
 function decodeStat(payload) {
   const r = new Reader(payload);