Connecting to server on emulator from JavaScript

[matan-h]

I have a server (for example http or websoket on port 3000) running on the emulator and I'm trying to establish a connection to it from the JavaScript API.
can someone please provide help on the steps required to make this work? Any help or pointers would be greatly appreciated.

[SuperMaxusa]

#783, probably the easiest solution is opening a port tunneling on guest OS (for example, with https://github.com/fatedier/frp) then you will have access via Fetch/XHR API or WebSocket.

[matan-h]

Thank you, #783 answers a similar question, but it doesn't specifically talk about JavaScript API. One of the suggestions is to run another vm and connect from there. Is it possible to do it in JavaScript API without another vm?

[SuperMaxusa]

Is it possible to do it in JavaScript API without another vm?

Probably no, #711 (comment), v86 uses a ethernet frame, and a way is create a "middleware" to decode/encode it (#994). The most closer to your case are https://github.com/oldweb-today/oldweb-today (uses an own network stack) and https://github.com/pixeltris/ww32vmt (uses an own proxy implementation) but they mostly work like:

VM [GET request] -> Browser

[progrium]

The network stack I'm working on compiles to WASM and can be used from JS (getting a WebSocket-like object after connecting to an IP on the virtual network). It's how VSCode here is talking to the guest service in v86 here:

This could be wrapped with a service worker to allow iframes to serve content from the VM.

[SuperMaxusa]

Nice, recently I became interested in the Direct Sockets API that can open TCP listener from browser and this would be cool have access to connect outside the virtual network to VM, but it works only in IWA at the moment.

[progrium]

Yea I'm keeping an eye on Direct Sockets / IWA too

[gregnr]

I had this same use case and built tcpip.js to solve it - a virtual network stack that can run in the browser. It's built on top of lwIP compiled to WASM with bindings to hook into each layer of the network stack (L2, L3, L4).

Example

(same example from #1197)

Set up plumbing that pipes ethernet packets between v86 and the virtual network stack.

import { createStack } from 'tcpip';
import { createV86NetworkStream } from '@tcpip/v86';

const stack = await createStack();

// Tap interfaces hook into ethernet (L2) frames
const tapInterface = await stack.createTapInterface({
  mac: '01:23:45:67:89:ab',
  ip: '192.168.1.1/24',
});

const emulator = new V86();

// Adds net0 listener and exposes as readable/writable streams
const vmNic = createV86NetworkStream(emulator);

// Forward frames between the tap interface and the VM's NIC
tapInterface.readable.pipeTo(vmNic.writable);
vmNic.readable.pipeTo(tapInterface.writable);

Now we can establish a TCP connection to the emulator from JS (assuming VM has IP 192.168.1.2 and a server listening on port 80):

const connection = await stack.connectTcp({
  host: '192.168.1.2',
  port: 80,
});

// connection.writable is a standard WritableStream
const writer = connection.writable.getWriter();

// Send data
await writer.write(new TextEncoder().encode('Hello, world!'));
await writer.close();

// Listen for incoming data
for await (const chunk of connection) {
  console.log(new TextDecoder().decode(chunk));
}

Or we can create a TCP server and listen for inbound connections:

const listener = await stack.listenTcp({
  port: 80,
});

// TcpListener is an async iterable that yields TcpConnections
for await (const connection of listener) {
  const writer = connection.writable.getWriter();

  // Send data
  await writer.write(new TextEncoder().encode('Hello, world!'));
  await writer.close();

  // Listen for incoming data
  for await (const chunk of connection) {
    console.log(new TextDecoder().decode(chunk));
  }
}

Protocol support

Right now it supports outbound and inbound TCP connections. I'm in the middle of adding HTTP client/server support and will be exposing it using the same API as fetch. I haven't started WebSocket support, but could be nice to add. If you are willing to switch to a TCP client/server for now that should solve your use case.

UDP, DNS, ICMP, etc support is also on the roadmap.