@webvpn/dgram 0.0.1 → 0.2.0

package/src/index.ts

@@ -1,701 +1,8 @@
-import type { BindOptions, Socket as DgramSocket, RemoteInfo, SocketOptions, SocketType } from 'dgram'
-import type { AddressInfo } from 'net'
+import type * as DgramTypes from 'dgram'
 
-import { DuplexOptions, Stream } from 'stream'
-import { EventEmitter, } from 'events'
+import { dgram } from '@fkn/lib'
 
-import { Packr } from 'msgpackr'
-import { makeWebVPNWebtransport, packPacket, unpackMultiplePackets, unpackPacket } from './utils'
+export const Socket = dgram.Socket as typeof DgramTypes.Socket
+export const createSocket = dgram.createSocket as typeof DgramTypes.createSocket
 
-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
-}
+export default dgram