Update L7 APIs to be transport agnostic

.github/workflows/release.yml

@@ -84,6 +84,26 @@ jobs:
         if: ${{ steps.release.outputs.releases_created == 'true' }}
         run: pnpm build
 
+      - name: Publish @tcpip/transport
+        if: ${{ steps.release.outputs['packages/transport--release_created'] == 'true' }}
+        working-directory: packages/transport
+        run: |
+          set -euo pipefail
+          VERSION=$(node -p "require('./package.json').version")
+          NPM_VIEW_STDERR=$(mktemp)
+          EXISTING=$(npm view "@tcpip/transport@$VERSION" version 2>"$NPM_VIEW_STDERR") || STATUS=$?
+          if [ -n "$EXISTING" ]; then
+            echo "@tcpip/transport@$VERSION is already published, skipping."
+            rm -f "$NPM_VIEW_STDERR"
+            exit 0
+          elif [ "${STATUS:-0}" -ne 0 ] && ! grep -qiE 'E404|not found' "$NPM_VIEW_STDERR"; then
+            cat "$NPM_VIEW_STDERR"
+            rm -f "$NPM_VIEW_STDERR"
+            exit 1
+          fi
+          rm -f "$NPM_VIEW_STDERR"
+          pnpm publish --access public --no-git-checks --ignore-scripts --provenance
+
       - name: Publish @tcpip/wire
         if: ${{ steps.release.outputs['packages/wire--release_created'] == 'true' }}
         working-directory: packages/wire

.release-please-manifest.json

@@ -1,5 +1,6 @@
 {
   "packages/tcpip": "0.3.6",
+  "packages/transport": "0.0.0",
   "packages/wire": "0.1.4",
   "packages/http": "0.1.0",
   "packages/dns": "0.2.2",

packages/dhcp/README.md

@@ -22,11 +22,11 @@ import { createStack } from 'tcpip';
 
 const stack = await createStack();
 
-const tapInterface = await stack.createTapInterface({
+const tapInterface = await stack.interfaces.createTap({
   ip: '192.168.1.1/24',
 });
 
-const dhcp = await createDhcp(stack);
+const dhcp = await createDhcp(stack.udp);
 const server = await dhcp.serve({
   leaseRange: {
     start: '192.168.1.100',
@@ -43,7 +43,7 @@ Then connect `tapInterface` to another virtual device. For example, with `@tcpip
 
 ```ts
 import { createV86NetworkStream } from '@tcpip/v86';
-import { connectStreams } from 'tcpip';
+import { connectStreams } from '@tcpip/transport';
 
 const vmNic = createV86NetworkStream(emulator);
 

packages/dhcp/package.json

@@ -25,11 +25,9 @@
     }
   },
   "dependencies": {
+    "@tcpip/transport": "workspace:*",
     "@tcpip/wire": "workspace:*"
   },
-  "peerDependencies": {
-    "tcpip": "workspace:*"
-  },
   "devDependencies": {
     "@total-typescript/tsconfig": "catalog:",
     "tcpip": "workspace:*",

packages/dhcp/src/dhcp-server.test.ts

@@ -1,4 +1,8 @@
-import type { NetworkStack, UdpDatagram, UdpSocket } from 'tcpip/types';
+import type {
+  Datagram,
+  DatagramSocket,
+  DatagramTransport,
+} from '@tcpip/transport';
 import { describe, expect, it } from 'vitest';
 import {
   DHCP_SERVER_PORT,
@@ -55,19 +59,23 @@ class AsyncQueue<T> implements AsyncIterable<T> {
   }
 }
 
-class TestUdpSocket implements UdpSocket, AsyncIterable<UdpDatagram> {
-  #incoming = new AsyncQueue<UdpDatagram>();
-  #outgoing = new AsyncQueue<UdpDatagram>();
+class TestUdpSocket implements DatagramSocket {
+  #outgoing = new AsyncQueue<Datagram>();
+  #readableController?: ReadableStreamDefaultController<Datagram>;
 
-  readable = new ReadableStream<UdpDatagram>();
-  writable = new WritableStream<UdpDatagram>({
+  readable = new ReadableStream<Datagram>({
+    start: (controller) => {
+      this.#readableController = controller;
+    },
+  });
+  writable = new WritableStream<Datagram>({
     write: async (datagram) => {
       this.#outgoing.push(datagram);
     },
   });
 
   receive(data: Uint8Array) {
-    this.#incoming.push({
+    this.#readableController?.enqueue({
       host: '0.0.0.0',
       port: 68,
       data,
@@ -96,19 +104,15 @@ class TestUdpSocket implements UdpSocket, AsyncIterable<UdpDatagram> {
   }
 
   async close() {
-    this.#incoming.close();
     this.#outgoing.close();
-  }
-
-  [Symbol.asyncIterator](): AsyncIterator<UdpDatagram> {
-    return this.#incoming[Symbol.asyncIterator]();
+    this.#readableController?.close();
   }
 }
 
-class TestNetworkStack implements Partial<NetworkStack> {
+class TestDatagramTransport implements DatagramTransport {
   socket = new TestUdpSocket();
 
-  async openUdp(options = {}) {
+  async open(options = {}) {
     expect(options).toEqual({ port: DHCP_SERVER_PORT });
     return this.socket;
   }
@@ -166,10 +170,10 @@ function createClientMessage({
 }
 
 async function createTestServer(options = defaultOptions) {
-  const stack = new TestNetworkStack();
-  const server = new DhcpServer(stack as unknown as NetworkStack, options);
+  const transport = new TestDatagramTransport();
+  const server = new DhcpServer(transport, options);
   await server.listen();
-  return { server, socket: stack.socket };
+  return { server, socket: transport.socket };
 }
 
 describe('DhcpServer', () => {

packages/dhcp/src/dhcp-server.ts

@@ -1,4 +1,9 @@
-import type { NetworkStack, UdpDatagram, UdpSocket } from 'tcpip/types';
+import { fromReadable } from '@tcpip/transport';
+import type {
+  Datagram,
+  DatagramSocket,
+  DatagramTransport,
+} from '@tcpip/transport';
 import {
   DHCP_CLIENT_PORT,
   DHCP_SERVER_PORT,
@@ -61,39 +66,39 @@ export type DhcpServerOptions = {
 };
 
 export class DhcpServer {
-  #stack: NetworkStack;
+  #transport: DatagramTransport;
   #options: DhcpServerOptions;
 
   leases = new Map<string, DhcpLease>();
   #offers = new Map<string, DhcpLease>();
 
-  constructor(stack: NetworkStack, options: DhcpServerOptions) {
-    this.#stack = stack;
+  constructor(transport: DatagramTransport, options: DhcpServerOptions) {
+    this.#transport = transport;
     this.#options = {
       leaseDuration: 86400,
       ...options,
     };
   }
 
   async listen() {
-    const socket = await this.#stack.openUdp({
+    const socket = await this.#transport.open({
       port: DHCP_SERVER_PORT,
     });
     this.#processDhcpMessages(socket);
   }
 
-  async #processDhcpMessages(socket: UdpSocket) {
+  async #processDhcpMessages(socket: DatagramSocket) {
     const writer = socket.writable.getWriter();
 
-    for await (const datagram of socket) {
+    for await (const datagram of fromReadable(socket.readable)) {
       // Process each message without blocking
       this.#processDhcpMessage(datagram, writer);
     }
   }
 
   async #processDhcpMessage(
-    datagram: UdpDatagram,
-    writer: WritableStreamDefaultWriter<UdpDatagram>
+    datagram: Datagram,
+    writer: WritableStreamDefaultWriter<Datagram>
   ) {
     try {
       const reply = this.#handleDhcpMessage(datagram.data);
@@ -152,7 +157,7 @@ export class DhcpServer {
     }
   }
 
-  #handleDiscover(message: DhcpMessage): UdpDatagram | undefined {
+  #handleDiscover(message: DhcpMessage): Datagram | undefined {
     const ip = this.#findAvailableIP(message.mac);
     if (!ip) {
       return;
@@ -182,7 +187,7 @@ export class DhcpServer {
     };
   }
 
-  #handleRequest(message: DhcpMessage): UdpDatagram | undefined {
+  #handleRequest(message: DhcpMessage): Datagram | undefined {
     this.#deleteExpiredAllocations();
 
     if (
@@ -236,7 +241,7 @@ export class DhcpServer {
     this.#offers.delete(message.mac);
   }
 
-  #createNak(message: DhcpMessage): UdpDatagram {
+  #createNak(message: DhcpMessage): Datagram {
     const nak = serializeDhcpMessage(
       {
         op: 2,

packages/dhcp/src/dhcp-stack.test.ts

@@ -140,11 +140,11 @@ async function waitForDhcpReply(iterator: AsyncIterator<Uint8Array>) {
 describe('DhcpServer with tcpip stack', () => {
   it('should complete discover/request over UDP broadcast', async () => {
     const stack = await createStack();
-    const tapInterface = await stack.createTapInterface({
+    const tapInterface = await stack.interfaces.createTap({
       ip: '192.168.1.1/24',
       mac: '02:00:00:00:00:01',
     });
-    const dhcp = await createDhcp(stack);
+    const dhcp = await createDhcp(stack.udp);
     const dhcpServer = await dhcp.serve({
       leaseRange: { start: '192.168.1.100', end: '192.168.1.110' },
       leaseDuration: 3600,
@@ -186,11 +186,11 @@ describe('DhcpServer with tcpip stack', () => {
 
   it('should advertise configured DNS servers', async () => {
     const stack = await createStack();
-    const tapInterface = await stack.createTapInterface({
+    const tapInterface = await stack.interfaces.createTap({
       ip: '192.168.1.1/24',
       mac: '02:00:00:00:00:01',
     });
-    const dhcp = await createDhcp(stack);
+    const dhcp = await createDhcp(stack.udp);
     await dhcp.serve({
       leaseRange: { start: '192.168.1.100', end: '192.168.1.110' },
       leaseDuration: 3600,

packages/dhcp/src/index.ts

@@ -1,21 +1,21 @@
-import type { NetworkStack } from 'tcpip/types';
+import type { DatagramTransport } from '@tcpip/transport';
 import { DhcpServer, type DhcpServerOptions } from './dhcp-server.js';
 
 export * from './dhcp-server.js';
 export type { DhcpLease } from './types.js';
 
 /**
- * Creates a DHCP server function on top of a `tcpip` network stack.
+ * Creates a DHCP server function on top of a datagram transport.
  *
  * @example
  * const stack = await createStack();
- * const { serve } = await createDhcp(stack);
+ * const { serve } = await createDhcp(stack.udp);
  * const dhcpServer = await serve({ ... });
  */
-export async function createDhcp(stack: NetworkStack) {
+export async function createDhcp(transport: DatagramTransport) {
   return {
     serve: async (options: DhcpServerOptions) => {
-      const server = new DhcpServer(stack, options);
+      const server = new DhcpServer(transport, options);
       await server.listen();
       return server;
     },

packages/dhcp/tsconfig.json

@@ -5,8 +5,8 @@
     "lib": ["es2022", "dom", "dom.iterable", "esnext.disposable"],
     "paths": {
       "tcpip": ["../tcpip/src/index.js"],
-      "tcpip/types": ["../tcpip/src/types.js"],
       "@tcpip/dns": ["../dns/src/index.js"],
+      "@tcpip/transport": ["../transport/src/index.js"],
       "@tcpip/wire": ["../wire/src/index.js"]
     }
   }

packages/dns/package.json

@@ -25,6 +25,7 @@
     }
   },
   "dependencies": {
+    "@tcpip/transport": "workspace:*",
     "@tcpip/wire": "workspace:*"
   },
   "devDependencies": {

packages/dns/src/dns-client.ts

@@ -1,4 +1,5 @@
-import type { NetworkStack } from 'tcpip/types';
+import { fromReadable } from '@tcpip/transport';
+import type { DatagramTransport } from '@tcpip/transport';
 import type { DnsMessage, DnsQuery, DnsRecord, NameServer } from './types.js';
 import { ipToPtrName } from './util.js';
 import { parseDnsMessage, serializeDnsMessage } from './wire.js';
@@ -12,12 +13,12 @@ export type DnsClientOptions = {
 };
 
 export class DnsClient {
-  #stack: NetworkStack;
+  #transport: DatagramTransport;
   #nameServer: NameServer;
   #messageId = 0;
 
-  constructor(stack: NetworkStack, options: DnsClientOptions = {}) {
-    this.#stack = stack;
+  constructor(transport: DatagramTransport, options: DnsClientOptions = {}) {
+    this.#transport = transport;
     this.#nameServer = options.nameServer ?? { ip: '127.0.0.1', port: 53 };
   }
 
@@ -50,7 +51,7 @@ export class DnsClient {
       ],
     };
 
-    const socket = await this.#stack.openUdp();
+    const socket = await this.#transport.open();
 
     // Serialize and send the message
     const data = serializeDnsMessage(message);
@@ -63,7 +64,7 @@ export class DnsClient {
     });
 
     // Wait for and parse the response
-    for await (const datagram of socket) {
+    for await (const datagram of fromReadable(socket.readable)) {
       const response = parseDnsMessage(datagram.data);
 
       // Verify this is the response to our query