Class QUICSocket

Hierarchy

StartStop
- QUICSocket

Constructors

constructor

new QUICSocket(opts): QUICSocket
Constructs a QUIC socket.
Parameters
- opts: {
  logger?: Logger;
  resolveHostname?: ResolveHostname;
  }
  - Optional logger?: Logger
  - Optional resolveHostname?: ResolveHostname
    
    defaults to using OS DNS resolver
Returns QUICSocket
Inherited from StartStop.constructor
- Defined in src/QUICSocket.ts:168

Properties

`Readonly` [initLock]

[initLock]: RWLockWriter

`Protected` _closed

_closed: boolean = false

`Protected` _closedP

_closedP: Promise<void>

`Protected` _host

_host: Host

`Protected` _port

_port: Port

`Protected` _type

_type: "ipv4" | "ipv6" | "ipv4&ipv6"

`Protected` logger

logger: Logger

`Protected` resolveClosedP

resolveClosedP: (() => void)

Type declaration

- (): void
- Returns void

`Protected` resolveHostname

resolveHostname: ResolveHostname

Hostname resolver.

`Protected` `Optional` server

server?: QUICServer

Registered server for this socket. If a server is not registered for this socket, all packets for new connections will be dropped.

`Protected` socket

socket: Socket

`Protected` socketBind

socketBind: ((port, host) => Promise<void>)

Type declaration

- (port, host): Promise<void>
- Parameters
  - port: number
  - host: string
  Returns Promise<void>

`Protected` socketClose

socketClose: (() => Promise<void>)

Type declaration

- (): Promise<void>
- Returns Promise<void>

`Protected` socketSend

socketSend: ((...params) => Promise<number>)

Type declaration

- (...params): Promise<number>
- Parameters
  - Rest ...params: any[]
  Returns Promise<number>

Accessors

[eventHandled]

get [eventHandled](): ReadonlyWeakSet<Event>
Returns ReadonlyWeakSet<Event>
Inherited from StartStop.[eventHandled]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:7

[eventHandlers]

get [eventHandlers](): ReadonlyMap<string, Set<EventHandlerInfo>>
Returns ReadonlyMap<string, Set<EventHandlerInfo>>
Inherited from StartStop.[eventHandlers]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:6

[eventTarget]

get [eventTarget](): EventTarget
Returns EventTarget
Inherited from StartStop.[eventTarget]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:5

[handleEventError]

get [handleEventError](): ((evt) => void)
Returns ((evt) => void)
- - (evt): void
  - Parameters
    - evt: EventError
    Returns void
Inherited from StartStop.[handleEventError]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:8

[running]

get [running](): boolean
Returns boolean
Inherited from StartStop.[running]
- Defined in node_modules/@matrixai/async-init/dist/StartStop.d.ts:6

[statusP]

get [statusP](): Promise<Status>
Returns Promise<Status>
Inherited from StartStop.[statusP]
- Defined in node_modules/@matrixai/async-init/dist/StartStop.d.ts:8

[status]

get [status](): Status
Returns Status
Inherited from StartStop.[status]
- Defined in node_modules/@matrixai/async-init/dist/StartStop.d.ts:7

closed

get closed(): boolean
Returns boolean
- Defined in src/QUICSocket.ts:213

closedP

get closedP(): Promise<void>
Returns Promise<void>
- Defined in src/QUICSocket.ts:217

host

get host(): Host
Gets the bound resolved host IP (not hostname). This can be the IPv4 or IPv6 address. This could be a wildcard address which means all interfaces. Note that :: can mean all IPv4 and all IPv6. Whereas 0.0.0.0 means only all IPv4.

Returns Host
- Defined in src/QUICSocket.ts:189

port

get port(): Port
Gets the bound resolved port. This cannot be 0. Because 0 is always resolved to a specific port.

Returns Port
- Defined in src/QUICSocket.ts:199

type

get type(): "ipv4" | "ipv6" | "ipv4&ipv6"
Gets the type of socket It can be ipv4-only, ipv6-only or dual stack

Returns "ipv4" | "ipv6" | "ipv4&ipv6"
- Defined in src/QUICSocket.ts:208

Methods

addEventListener

addEventListener(type, callback, options?): void
Parameters
- type: string
- callback: null | EventListenerOrEventListenerObject
- Optional options: boolean | AddEventListenerOptions
Returns void
Inherited from StartStop.addEventListener
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:9

dispatchEvent

dispatchEvent(event): boolean
Parameters
- event: Event
Returns boolean
Inherited from StartStop.dispatchEvent
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:11

`Protected` handleEventQUICSocketClose

handleEventQUICSocketClose(): Promise<void>
Returns Promise<void>
- Defined in src/QUICSocket.ts:62

`Protected` handleEventQUICSocketError

handleEventQUICSocketError(evt): void
Parameters
- evt: EventQUICSocketError
Returns void
- Defined in src/QUICSocket.ts:57

`Protected` handleSocketMessage

handleSocketMessage(data, remoteInfo): Promise<void>
Handles UDP socket message.

The data buffer could be multiple coalesced QUIC packets. It could also be a non-QUIC packet data. If it is non-QUIC, we can discard the data. If there are multiple coalesced QUIC packets, it is expected that all packets are intended for the same connection. This means we only need to parse the first QUIC packet to determining what connection to route the data to.
Parameters
- data: Buffer
- remoteInfo: RemoteInfo
Returns Promise<void>
- Defined in src/QUICSocket.ts:82

removeEventListener

removeEventListener(type, callback, options?): void
Parameters
- type: string
- callback: null | EventListenerOrEventListenerObject
- Optional options: boolean | EventListenerOptions
Returns void
Inherited from StartStop.removeEventListener
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:10

send

send(msg, port, address): Promise<number>
Sends UDP datagram. Because UDP socket is connectionless, the port and address are required. This call is used internally by the rest of the library, but it is not internal because it can be used for hole punching, which is an application concern. Therefore if this method throws an exception, it does necessarily mean that this QUICSocket is an error state. It could be the caller's fault.
Parameters
- msg: string | readonly any[] | Uint8Array
- port: number
- address: string
Returns Promise<number>
- Defined in src/QUICSocket.ts:367
send(msg, offset, length, port, address): Promise<number>
Parameters
- msg: string | Uint8Array
- offset: number
- length: number
- port: number
- address: string
Returns Promise<number>
- Defined in src/QUICSocket.ts:372

send_

send_(msg, offset, length, port, address): Promise<number>
Parameters
- msg: string | Uint8Array
- offset: number
- length: number
- port: number
- address: string
Returns Promise<number>
- Defined in src/QUICSocket.ts:418

setServer

setServer(server): void
Parameters
- server: QUICServer
Returns void
- Defined in src/QUICSocket.ts:430

start

start(opts?): Promise<void>
Starts this QUICSocket. This supports hostnames and IPv4 and IPv6 addresses. If the host is ::, this will also bind to 0.0.0.0.
Parameters
- opts: {
      host?: string;
      ipv6Only?: boolean;
      port?: number;
      reuseAddr?: boolean;
  } = {}
  - Optional host?: string
    
    The host to bind to. Default is ::.
  - Optional ipv6Only?: boolean
    
    Whether to only bind to IPv6. Default is false.
  - Optional port?: number
    
    The port to bind to. Default is 0.
  - Optional reuseAddr?: boolean
    
    Whether to reuse the address. Default is false.
Returns Promise<void>

Throws
If bind failed due to EINVAL or ENOTFOUND. EINVAL is due to using IPv4 host when creating a udp6 socket. ENOTFOUND is when the hostname does not resolve or does not resolve to IPv6 when creating a udp6 socket or does not resolve to IPv4 when creating a udp4 socket.
Inherited from StartStop.start
- Defined in src/QUICSocket.ts:238

stop

stop(opts?): Promise<void>
Stop this QUICSocket.
Parameters
- opts: {
  force?: boolean;
  } = {}
  - Optional force?: boolean
    
    Stop the socket even if the connection map is not empty.
Returns Promise<void>

Throws
Inherited from StartStop.stop
- Defined in src/QUICSocket.ts:328

unsetServer

unsetServer(): void
Returns void
- Defined in src/QUICSocket.ts:434

Class QUICSocket

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

opts: { logger?: Logger; resolveHostname?: ResolveHostname; }

Optional logger?: Logger

Optional resolveHostname?: ResolveHostname

Returns QUICSocket

Properties

Readonly [initLock]

Protected _closed

Protected _closedP

Protected _host

Protected _port

Protected _type

Protected logger

Protected resolveClosedP

Type declaration

Returns void

Protected resolveHostname

Protected Optional server

Protected socket

Protected socketBind

Type declaration

Parameters

port: number

host: string

Returns Promise<void>

Protected socketClose

Type declaration

Returns Promise<void>

Protected socketSend

Type declaration

Parameters

Rest ...params: any[]

Returns Promise<number>

Accessors

[eventHandled]

Returns ReadonlyWeakSet<Event>

[eventHandlers]

Returns ReadonlyMap<string, Set<EventHandlerInfo>>

[eventTarget]

Returns EventTarget

[handleEventError]

Returns ((evt) => void)

Parameters

evt: EventError

Returns void

[running]

Returns boolean

[statusP]

Returns Promise<Status>

[status]

Returns Status

closed

Returns boolean

closedP

Returns Promise<void>

host

Returns Host

port

Returns Port

type

Returns "ipv4" | "ipv6" | "ipv4&ipv6"

Methods

addEventListener

Parameters

type: string

callback: null | EventListenerOrEventListenerObject

Optional options: boolean | AddEventListenerOptions

Returns void

dispatchEvent

Parameters

event: Event

opts: {
logger?: Logger;
resolveHostname?: ResolveHostname;
}

`Optional` logger?: Logger

`Optional` resolveHostname?: ResolveHostname

`Readonly` [initLock]

`Protected` _closed

`Protected` _closedP

`Protected` _host

`Protected` _port

`Protected` _type

`Protected` logger

`Protected` resolveClosedP

`Protected` resolveHostname

`Protected` `Optional` server

`Protected` socket

`Protected` socketBind

`Protected` socketClose

`Protected` socketSend

`Rest` ...params: any[]

`Optional` options: boolean | AddEventListenerOptions

`Protected` handleEventQUICSocketClose

`Protected` handleEventQUICSocketError

`Protected` handleSocketMessage

`Optional` options: boolean | EventListenerOptions

opts: {
host?: string;
ipv6Only?: boolean;
port?: number;
reuseAddr?: boolean;
} = {}

`Optional` host?: string

`Optional` ipv6Only?: boolean

`Optional` port?: number

`Optional` reuseAddr?: boolean

opts: {
force?: boolean;
} = {}

`Optional` force?: boolean