@webvpn/dgram 0.0.1

package/src/index.ts

@@ -0,0 +1,701 @@
+import type { BindOptions, Socket as DgramSocket, RemoteInfo, SocketOptions, SocketType } from 'dgram'
+import type { AddressInfo } from 'net'
+
+import { DuplexOptions, Stream } from 'stream'
+import { EventEmitter, } from 'events'
+
+import { Packr } from 'msgpackr'
+import { makeWebVPNWebtransport, packPacket, unpackMultiplePackets, unpackPacket } from './utils'
+
+type TypedWebTransportStream = WebTransportBidirectionalStream & {
+  readable: ReadableStream<Uint8Array>
+  writable: WritableStream<Uint8Array>
+}
+
+export type WebVPNHandshakePacket =
+  {
+    type: 'udp-socket'
+    socketType: 'udp4' | 'udp6'
+    reuseAddr?: boolean
+    ipv6Only?: boolean
+    recvBufferSize?: number
+    sendBufferSize?: number
+    // lookup?:
+    //     | ((
+    //         hostname: string,
+    //         options: dns.LookupOneOptions,
+    //         callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
+    //     ) => void)
+  }
+
+export type SocketClientPacket =
+  {
+    type: 'addMembership'
+    multicastAddress: string
+    multicastInterface?: string
+  } |
+  {
+    type: 'addSourceSpecificMembership'
+    sourceAddress: string
+    groupAddress: string
+    multicastInterface?: string
+  } |
+  {
+    type: 'bind'
+    uuid?: string
+    port?: number
+    address?: string
+    exclusive?: boolean
+    // fd?: number
+  } |
+  {
+    type: 'close'
+    uuid?: string
+  } |
+  {
+    type: 'connect'
+    uuid?: string
+    port: number
+    address?: string
+  } |
+  {
+    type: 'disconnect'
+  } |
+  {
+    type: 'dropMembership'
+    multicastAddress: string
+    multicastInterface?: string
+  } |
+  {
+    type: 'dropSourceSpecificMembership'
+    sourceAddress: string
+    groupAddress: string
+    multicastInterface?: string
+  } |
+  {
+    type: 'send'
+    // uuid?: string
+    msg: string | readonly any[] | Uint8Array
+    offset?: number
+    length?: number
+    port?: number
+    address?: string
+  } |
+  {
+    type: 'setBroadcast'
+    flag: boolean
+  } |
+  {
+    type: 'setMulticastInterface'
+    multicastInterface: string
+  } |
+  {
+    type: 'setMulticastLoopback'
+    flag: boolean
+  } |
+  {
+    type: 'setMulticastTTL'
+    ttl: number
+  } |
+  {
+    type: 'setRecvBufferSize'
+    size: number
+  } |
+  {
+    type: 'setSendBufferSize'
+    size: number
+  } |
+  {
+    type: 'setTTL'
+    ttl: number
+  }
+
+export type SocketServerPacket =
+  {
+    type: 'event-close'
+  } |
+  {
+    type: 'event-connect'
+  } |
+  {
+    type: 'event-error'
+    exception: string
+  } |
+  {
+    type: 'event-listening'
+    address: {
+      address: string
+      port: number
+      family: 'IPv4' | 'IPv6'
+    }
+  } |
+  // handled by datagram stream
+  {
+    type: 'event-message'
+    message: Uint8Array
+    rinfo: {
+      address: string
+      family: 'IPv4' | 'IPv6'
+      port: number
+      size: number
+    }
+  } |
+  {
+    type: 'callback-bind'
+    uuid: string
+    address: {
+      address: string
+      port: number
+      family: 'IPv4' | 'IPv6'
+    }
+  } |
+  {
+    type: 'callback-close'
+    uuid: string
+  } |
+  {
+    type: 'callback-connect'
+    uuid: string
+    remoteAddress: {
+      address: string
+      port: number
+      family: 'IPv4' | 'IPv6'
+    }
+  } |
+  {
+    type: 'callback-send'
+    uuid: string
+  }
+
+const normalizeBindArgs = (
+  args:
+    [port: number, address: string, callback: () => void] |
+    [port: number, callback: () => void] |
+    [callback: () => void] |
+    [options: BindOptions, callback: () => void]
+) => {
+  if (args.length === 1) {
+    return {
+      port: undefined,
+      address: undefined,
+      callback: args[0]
+    }
+  } else if (args.length === 2) {
+    if (typeof args[0] === 'number') {
+      return {
+        port: args[0],
+        address: undefined,
+        callback: args[1]
+      }
+    }
+    if (args[0].fd !== undefined) {
+      throw new Error('FKN WebVPN does not support file descriptors')
+    }
+    return {
+      ...args[0],
+      callback: args[1]
+    }
+  }
+  return {
+    port: args[0],
+    address: args[1],
+    callback: args[2]
+  }
+}
+
+const normalizeConnectArgs = (
+  args:
+    [port: number, address?: string, callback?: () => void] |
+    [port: number, callback: () => void]
+) => {
+  if (args.length === 2) {
+    return {
+      port: args[0],
+      address: undefined,
+      callback: args[1] as () => void
+    }
+  } else {
+    return {
+      port: args[0],
+      address: args[1],
+      callback: args[2]
+    }
+  }
+}
+
+const normalizeSendArgs = (
+  args:
+    [msg: string | readonly any[] | Uint8Array, port: number, address: string, callback: (error: Error | null, bytes: number) => void] |
+    [msg: string | readonly any[] | Uint8Array, port: number, callback: (error: Error | null, bytes: number) => void] |
+    [msg: string | readonly any[] | Uint8Array, callback: (error: Error | null, bytes: number) => void] |
+    [msg: string | Uint8Array, offset: number, length: number, port: number, address: string, callback: (error: Error | null, bytes: number) => void] |
+    [msg: string | Uint8Array, offset: number, length: number, port: number, callback: (error: Error | null, bytes: number) => void] |
+    [msg: string | Uint8Array, offset: number, length: number, callback: (error: Error | null, bytes: number) => void]
+) => {
+  if (args.length === 6) {
+    return {
+      msg: args[0],
+      offset: args[1],
+      length: args[2],
+      port: args[3],
+      address: args[4],
+      callback: args[5]
+    }
+  } else if (args.length === 5) {
+    return {
+      msg: args[0],
+      offset: args[1],
+      length: args[2],
+      port: args[3],
+      address: undefined,
+      callback: args[4]
+    }
+  } else if (args.length === 4) {
+    if (typeof args[3] === 'string') {
+      return {
+        msg: args[0],
+        offset: undefined,
+        length: undefined,
+        port: args[1],
+        address: args[2] as string,
+        callback: args[3]
+      }
+    } else {
+      return {
+        msg: args[0],
+        offset: args[1],
+        length: undefined,
+        port: args[2] as number,
+        address: undefined,
+        callback: args[3]
+      }
+    }
+  } else if (args.length === 3) {
+    return {
+      msg: args[0],
+      offset: undefined,
+      length: undefined,
+      port: args[1],
+      address: undefined,
+      callback: args[2]
+    }
+  } else if (args.length === 2) {
+    return {
+      msg: args[0],
+      offset: undefined,
+      length: undefined,
+      port: undefined,
+      address: undefined,
+      callback: args[1]
+    }
+  } else {
+    return {
+      msg: args[0],
+      offset: undefined,
+      length: undefined,
+      port: undefined,
+      address: undefined,
+      callback: undefined
+    }
+  }
+}
+
+interface EventEmitterOptions {
+  /**
+   * Enables automatic capturing of promise rejection.
+   */
+  captureRejections?: boolean | undefined;
+}
+
+export class Socket extends EventEmitter implements DgramSocket {
+  _webVPN: Promise<{
+    webtransport: WebTransport
+    reader: ReadableStreamDefaultReader<Uint8Array>
+    writer: WritableStreamDefaultWriter<Uint8Array>
+    datagramReader: ReadableStreamDefaultReader<Uint8Array>
+    datagramWriter: WritableStreamDefaultWriter<Uint8Array>
+  }>
+  _type: 'udp4' | 'udp6'
+  _address: {
+    address: string,
+    port: number
+    family: string
+  } | undefined
+  _remoteAddress: {
+    address: string,
+    port: number
+    family: string
+  } | undefined
+
+  constructor(options: SocketOptions & EventEmitterOptions) {
+    // console.log('new socket')
+    super(options)
+    this._type = options.type
+    this._address = undefined
+    this._webVPN =
+      makeWebVPNWebtransport()
+        .then(async (webtransport) => {
+          const connectionDatagramReader = webtransport.datagrams.readable.getReader()
+          const connectionDatagramWriter = webtransport.datagrams.writable.getWriter()
+          await connectionDatagramWriter.ready
+          const webTransportBidirectionalStream = await webtransport.createBidirectionalStream()
+          const { readable, writable } = webTransportBidirectionalStream
+          const reader = readable.getReader()
+          const writer = writable.getWriter()
+          await writer.ready
+          await writer.write(packPacket({ type: 'udp-socket', socketType: options.type }))
+
+          const read = async () => {
+            const { done, value } = await reader.read()
+            if (done) return
+            try {
+              const packets = unpackMultiplePackets(value) as SocketServerPacket[]
+              for (const packet of packets) {
+                // console.log('socket recv packet', packet)
+                if (packet.type === 'event-close') {
+                  this.emit('close')
+                } else if (packet.type === 'event-connect') {
+                  this.emit('connect')
+                } else if (packet.type === 'event-error') {
+                  this.emit('error', new Error(packet.exception))
+                } else if (packet.type === 'event-listening') {
+                  this._address = packet.address
+                  this.emit('listening')
+                // handled by dgram stream
+                // } else if (packet.type === 'event-message') {
+                } else if (packet.type === 'callback-bind') {
+                  this._address = packet.address
+                  this.emit('callback-bind', { uuid: packet.uuid })
+                } else if (packet.type === 'callback-close') {
+                  this.emit('callback-close', { uuid: packet.uuid })
+                } else if (packet.type === 'callback-connect') {
+                  this._remoteAddress = packet.remoteAddress
+                  this.emit('callback-connect', { uuid: packet.uuid })
+                } else if (packet.type === 'callback-send') {
+                  this.emit('callback-send', { uuid: packet.uuid })
+                } else {
+                  console.error('unknown packet type', packet)
+                }
+              }
+            } catch (err) {
+              console.error(err)
+            } finally {
+              await read()
+            }
+          }
+          read()
+    
+          return {
+            webtransport: webtransport,
+            reader: reader,
+            writer: writer,
+            datagramReader: connectionDatagramReader,
+            datagramWriter: connectionDatagramWriter
+          }
+        })
+  }
+  addMembership(multicastAddress: string, multicastInterface?: string | undefined): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'addMembership',
+          multicastAddress,
+          multicastInterface
+        })
+      )
+    })
+  }
+  address(): AddressInfo {
+    if (!this._address) throw new Error('EBADF')
+    return this._address
+  }
+
+  bind(port?: number | undefined, address?: string | undefined, callback?: (() => void) | undefined): this
+  bind(port?: number | undefined, callback?: (() => void) | undefined): this
+  bind(callback?: (() => void) | undefined): this
+  bind(options: BindOptions, callback?: (() => void) | undefined): this
+  bind(
+    args:
+      [port: number, address: string, callback: () => void] |
+      [port: number, callback: () => void] |
+      [callback: () => void] |
+      [options: BindOptions, callback: () => void]
+  ): this {
+    // console.log('bind')
+    const normalizedOptions = normalizeBindArgs(args)
+    this._webVPN.then(webVPN => {
+      const uuid = normalizedOptions.callback ? self.crypto.randomUUID() : undefined
+      if (uuid && normalizedOptions.callback) {
+        this.on('callback-bind', function callbackBind({ uuid: _uuid }) {
+          if (_uuid !== uuid) return
+          this.off('callback-bind', callbackBind)
+          normalizedOptions.callback!()
+        })
+      }
+      webVPN.writer.write(
+        packPacket({
+          type: 'bind',
+          uuid,
+          port: normalizedOptions.port,
+          address: normalizedOptions.address,
+          exclusive: normalizedOptions.exclusive
+        })
+      )
+    })
+    return this
+  }
+  close(callback?: (() => void) | undefined): this {
+    this._webVPN.then(webVPN => {
+      const uuid = callback ? self.crypto.randomUUID() : undefined
+      if (uuid && callback) {
+        this.on('callback-close', function callbackClose({ uuid: _uuid }) {
+          if (_uuid !== uuid) return
+          this.off('callback-close', callbackClose)
+          callback()
+        })
+      }
+      webVPN.writer.write(
+        packPacket({
+          type: 'close',
+          uuid
+        })
+      )
+    })
+    return this
+  }
+
+  connect(port: number, address?: string, callback?: () => void): void;
+  connect(port: number, callback: () => void): void;
+  connect(
+    ...args:
+      [port: number, address?: string, callback?: () => void] |
+      [port: number, callback: () => void]
+  ): void {
+    const normalizedOptions = normalizeConnectArgs(args)
+    const address = normalizedOptions.address
+    const port = normalizedOptions.port
+
+    if (!address) throw new Error('port is required')
+    if (!port) throw new Error('address is required')
+
+    this._webVPN.then(webVPN => {
+      const uuid = normalizedOptions.callback ? self.crypto.randomUUID() : undefined
+      if (uuid && normalizedOptions.callback) {
+        this.on('callback-connect', function callbackConnect({ uuid: _uuid }) {
+          if (_uuid !== uuid) return
+          this.off('callback-connect', callbackConnect)
+          normalizedOptions.callback!()
+        })
+      }
+      webVPN.writer.write(
+        packPacket({
+          type: 'connect',
+          uuid,
+          address,
+          port
+        })
+      )
+    })
+  }
+  disconnect(): void {
+    if (!this._address) throw new Error('ERR_SOCKET_DGRAM_NOT_CONNECTED')
+    this._address = undefined
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(packPacket({ type: 'disconnect' }))
+    })
+  }
+  dropMembership(multicastAddress: string, multicastInterface?: string | undefined): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'dropMembership',
+          multicastAddress,
+          multicastInterface
+        })
+      )
+    })
+  }
+  getRecvBufferSize(): number {
+    return 0
+  }
+  getSendBufferSize(): number {
+    return 0
+  }
+  getSendQueueSize(): number {
+    return 0
+  }
+  getSendQueueCount(): number {
+    return 0
+  }
+  ref(): this {
+    return this
+  }
+  remoteAddress(): AddressInfo {
+    if (!this._remoteAddress) throw new Error('ERR_SOCKET_DGRAM_NOT_CONNECTED')
+    return {
+      address: this._remoteAddress.address,
+      family: this._remoteAddress.family,
+      port: this._remoteAddress.port
+    }
+  }
+
+  send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void
+  send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void
+  send(msg: string | readonly any[] | Uint8Array, callback?: ((error: Error | null, bytes: number) => void) | undefined): void
+  send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void
+  send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void
+  send(msg: string | Uint8Array, offset: number, length: number, callback?: ((error: Error | null, bytes: number) => void) | undefined): void
+  send(msg: unknown, offset?: unknown, length?: unknown, port?: unknown, address?: unknown, callback?: unknown): void
+  send(
+    ...args:
+      [msg: string | readonly any[] | Uint8Array, port: number, address: string, callback: (error: Error | null, bytes: number) => void] |
+      [msg: string | readonly any[] | Uint8Array, port: number, callback: (error: Error | null, bytes: number) => void] |
+      [msg: string | readonly any[] | Uint8Array, callback: (error: Error | null, bytes: number) => void] |
+      [msg: string | Uint8Array, offset: number, length: number, port: number, address: string, callback: (error: Error | null, bytes: number) => void] |
+      [msg: string | Uint8Array, offset: number, length: number, port: number, callback: (error: Error | null, bytes: number) => void] |
+      [msg: string | Uint8Array, offset: number, length: number, callback: (error: Error | null, bytes: number) => void]
+  ): void {
+    const { address, callback, length, msg, offset, port } = normalizeSendArgs(args)
+    this._webVPN.then(webVPN => {
+      // const uuid = callback ? self.crypto.randomUUID() : undefined
+      // if (uuid && callback) {
+      //   this.on('callback-send', function callbackSend({ uuid: _uuid }) {
+      //     if (_uuid !== uuid) return
+      //     this.off('callback-send', callbackSend)
+      //     callback(null, 0)
+      //   })
+      // }
+      // console.log('send', {
+      //   type: 'send',
+      //   msg,
+      //   offset,
+      //   length,
+      //   port,
+      //   address
+      // }, args)
+      webVPN.datagramWriter.write(
+        packPacket({
+          type: 'send',
+          msg,
+          offset,
+          length,
+          port,
+          address
+        })
+      )
+      if (typeof callback === 'function') {
+        callback(null, 0)
+      }
+    })
+  }
+  setBroadcast(flag: boolean): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'setBroadcast',
+          flag
+        })
+      )
+    })
+  }
+  setMulticastInterface(multicastInterface: string): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'setMulticastInterface',
+          multicastInterface
+        })
+      )
+    })
+  }
+  setMulticastLoopback(flag: boolean): boolean {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'setMulticastLoopback',
+          flag
+        })
+      )
+    })
+    return true
+  }
+  setMulticastTTL(ttl: number): number {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'setMulticastTTL',
+          ttl
+        })
+      )
+    })
+    return ttl
+  }
+  setRecvBufferSize(size: number): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'setRecvBufferSize',
+          size
+        })
+      )
+    })
+  }
+  setSendBufferSize(size: number): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'setSendBufferSize',
+          size
+        })
+      )
+    })
+  }
+  setTTL(ttl: number): number {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'setTTL',
+          ttl
+        })
+      )
+    })
+    return ttl
+  }
+  unref(): this {
+    return this
+  }
+  addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'addSourceSpecificMembership',
+          sourceAddress,
+          groupAddress,
+          multicastInterface
+        })
+      )
+    })
+  }
+  dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void {
+    this._webVPN.then(webVPN => {
+      webVPN.writer.write(
+        packPacket({
+          type: 'dropSourceSpecificMembership',
+          sourceAddress,
+          groupAddress,
+          multicastInterface
+        })
+      )
+    })
+  }
+}
+
+export const createSocket = (options: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void) => {
+  const socket = new Socket(
+    typeof options === 'string'
+      ? { type: options }
+      : options
+  )
+  if (callback) socket.on('message', callback)
+  return socket
+}