603 lines
25 KiB
TypeScript
603 lines
25 KiB
TypeScript
/**
|
|
* Node RTC factory (webrtc-implementation-plan.md §6.2).
|
|
*
|
|
* Native libwebrtc is preferred when present because its ICE behavior matches
|
|
* browser Remote Web. werift remains the pure-TypeScript fallback for systems
|
|
* without a loadable native addon. Both backends are loaded lazily so DSH
|
|
* startup remains unaffected when WebRTC is unused or `forceRelay` is enabled.
|
|
*/
|
|
|
|
import { createSocket } from 'node:dgram'
|
|
import { networkInterfaces, type NetworkInterfaceInfo } from 'node:os'
|
|
import type {
|
|
RtcCandidateSummary,
|
|
RtcDataChannel,
|
|
RtcDataChannelInit,
|
|
RtcIceCandidateInit,
|
|
RtcIceServer,
|
|
RtcPeerConnection,
|
|
RtcPeerConnectionFactory,
|
|
RtcSessionDescriptionInit,
|
|
RtcStats,
|
|
} from '@dsh-remote/webrtc'
|
|
import { summarizeAddress, summarizeIceCandidate } from '@dsh-remote/webrtc'
|
|
|
|
interface WeriftModule {
|
|
RTCPeerConnection: new (config?: WeriftConfig) => WeriftPeerConnection
|
|
}
|
|
|
|
interface WeriftConfig {
|
|
iceServers?: Array<{ urls: string | string[]; username?: string; credential?: string }>
|
|
iceAdditionalHostAddresses?: string[]
|
|
iceFilterCandidatePair?: (pair: WeriftCandidatePair) => boolean
|
|
iceUseIpv4?: boolean
|
|
iceUseIpv6?: boolean
|
|
iceUseLinkLocalAddress?: boolean
|
|
iceInterfaceAddresses?: { udp4?: string; udp6?: string }
|
|
}
|
|
|
|
interface WeriftCandidate {
|
|
host?: string
|
|
type?: string
|
|
relatedAddress?: string
|
|
}
|
|
|
|
interface WeriftCandidatePair {
|
|
localCandidate?: WeriftCandidate
|
|
}
|
|
|
|
interface WeriftPeerConnection {
|
|
connectionState: string
|
|
iceConnectionState: string
|
|
iceGatheringState: string
|
|
signalingState: string
|
|
onconnectionstatechange: (() => void) | null
|
|
oniceconnectionstatechange: (() => void) | null
|
|
onicegatheringstatechange: (() => void) | null
|
|
onicecandidate: ((event: { candidate?: { toJSON(): RtcIceCandidateInit } }) => void) | null
|
|
ondatachannel: ((event: { channel: WeriftDataChannel }) => void) | null
|
|
createDataChannel(label: string, options: { ordered: boolean }): WeriftDataChannel
|
|
createOffer(): Promise<{ type: 'offer' | 'answer'; sdp: string }>
|
|
createAnswer(): Promise<{ type: 'offer' | 'answer'; sdp: string }>
|
|
setLocalDescription(description?: { type: string; sdp?: string }): Promise<unknown>
|
|
setRemoteDescription(description: { type: string; sdp?: string }): Promise<void>
|
|
addIceCandidate(candidate?: RtcIceCandidateInit | null): Promise<void>
|
|
getStats(): Promise<RtcStats>
|
|
close(): Promise<void>
|
|
}
|
|
|
|
interface WeriftDataChannel {
|
|
readonly label: string
|
|
readonly ordered: boolean
|
|
readyState: string
|
|
bufferedAmount: number
|
|
onopen: (() => void) | null
|
|
onclose: (() => void) | null
|
|
onerror: (() => void) | null
|
|
onmessage: ((event: { data: string | Uint8Array }) => void) | null
|
|
send(data: Buffer | string): void
|
|
close(): void
|
|
}
|
|
|
|
let cachedFactory: RtcPeerConnectionFactory | undefined
|
|
let cachedWerift: WeriftModule | undefined
|
|
let cachedNativeFactory: RtcPeerConnectionFactory | undefined
|
|
|
|
interface NativeRtcModule {
|
|
RTCPeerConnection?: new (config?: { iceServers?: RtcIceServer[] }) => NativePeerConnection
|
|
default?: {
|
|
RTCPeerConnection?: new (config?: { iceServers?: RtcIceServer[] }) => NativePeerConnection
|
|
}
|
|
}
|
|
|
|
interface NativePeerConnection {
|
|
connectionState: string
|
|
iceConnectionState: string
|
|
iceGatheringState: string
|
|
signalingState: string
|
|
onconnectionstatechange: (() => void) | null
|
|
oniceconnectionstatechange: (() => void) | null
|
|
onicegatheringstatechange: (() => void) | null
|
|
onicecandidate: ((event: { candidate: NativeIceCandidate | null }) => void) | null
|
|
ondatachannel: ((event: { channel: NativeDataChannel }) => void) | null
|
|
createDataChannel(label: string, options?: RtcDataChannelInit): NativeDataChannel
|
|
createOffer(): Promise<RtcSessionDescriptionInit>
|
|
createAnswer(): Promise<RtcSessionDescriptionInit>
|
|
setLocalDescription(description?: RtcSessionDescriptionInit): Promise<void>
|
|
setRemoteDescription(description: RtcSessionDescriptionInit): Promise<void>
|
|
addIceCandidate(candidate?: RtcIceCandidateInit | null): Promise<void>
|
|
getStats(): Promise<RtcStats>
|
|
close(): void
|
|
}
|
|
|
|
interface NativeIceCandidate extends RtcIceCandidateInit {
|
|
toJSON?: () => RtcIceCandidateInit
|
|
}
|
|
|
|
interface NativeDataChannel {
|
|
readonly label: string
|
|
readonly ordered: boolean
|
|
readyState: string
|
|
bufferedAmount: number
|
|
binaryType: string
|
|
onopen: (() => void) | null
|
|
onclose: (() => void) | null
|
|
onerror: (() => void) | null
|
|
onmessage: ((event: { data: unknown }) => void) | null
|
|
onbufferedamountlow: (() => void) | null
|
|
send(data: Buffer | ArrayBuffer | string): void
|
|
close(): void
|
|
}
|
|
|
|
/**
|
|
* Node RTC factory used by the Plugin/VS Code clients and Host. Native
|
|
* libwebrtc is preferred because its ICE behavior matches browser Remote Web;
|
|
* werift remains the no-native fallback for environments that cannot load it.
|
|
*/
|
|
export async function loadNodeRtcFactory(options: WeriftFactoryOptions = {}): Promise<RtcPeerConnectionFactory | undefined> {
|
|
return await loadNativeRtcFactory().catch(() => undefined) ?? await loadWeriftFactory(options)
|
|
}
|
|
|
|
/** Load (once) a werift-backed factory, or `undefined` when it cannot be loaded. */
|
|
export async function loadWeriftFactory(options: WeriftFactoryOptions = {}): Promise<RtcPeerConnectionFactory | undefined> {
|
|
const cacheable = isCacheableFactoryOptions(options)
|
|
if (cacheable && cachedFactory !== undefined) return cachedFactory
|
|
try {
|
|
const werift = cachedWerift ?? ((await import('werift')) as unknown as WeriftModule)
|
|
cachedWerift = werift
|
|
const routeCandidates = options.preferredHostIpv4Candidates
|
|
?? await detectRouteHostIpv4Candidates(options.routeTargets ?? [], options.routeProbeTimeoutMs)
|
|
const factory = buildWeriftFactory(werift, { ...options, preferredHostIpv4Candidates: routeCandidates })
|
|
if (cacheable) cachedFactory = factory
|
|
return factory
|
|
} catch {
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
async function loadNativeRtcFactory(): Promise<RtcPeerConnectionFactory | undefined> {
|
|
if (cachedNativeFactory !== undefined) return cachedNativeFactory
|
|
try {
|
|
const wrtc = (await import('@roamhq/wrtc')) as unknown as NativeRtcModule
|
|
const RTCPeerConnection = wrtc.RTCPeerConnection ?? wrtc.default?.RTCPeerConnection
|
|
if (RTCPeerConnection === undefined) return undefined
|
|
cachedNativeFactory = buildNativeRtcFactory(RTCPeerConnection)
|
|
return cachedNativeFactory
|
|
} catch {
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
function buildNativeRtcFactory(
|
|
RTCPeerConnection: new (config?: { iceServers?: RtcIceServer[] }) => NativePeerConnection,
|
|
): RtcPeerConnectionFactory {
|
|
return {
|
|
create(configuration) {
|
|
const raw = new RTCPeerConnection({ iceServers: configuration.iceServers })
|
|
return {
|
|
get connectionState(): string { return raw.connectionState },
|
|
get iceConnectionState(): string { return raw.iceConnectionState },
|
|
get iceGatheringState(): string { return raw.iceGatheringState },
|
|
get signalingState(): string { return raw.signalingState },
|
|
set onconnectionstatechange(value) { raw.onconnectionstatechange = value },
|
|
get onconnectionstatechange() { return raw.onconnectionstatechange },
|
|
set oniceconnectionstatechange(value) { raw.oniceconnectionstatechange = value },
|
|
get oniceconnectionstatechange() { return raw.oniceconnectionstatechange },
|
|
set onicegatheringstatechange(value) { raw.onicegatheringstatechange = value },
|
|
get onicegatheringstatechange() { return raw.onicegatheringstatechange },
|
|
set onicecandidate(value) {
|
|
raw.onicecandidate = value === null ? null : event => value({
|
|
candidate: event.candidate === null ? null : normalizeNativeCandidate(event.candidate),
|
|
})
|
|
},
|
|
get onicecandidate() { return raw.onicecandidate as ((event: { candidate: RtcIceCandidateInit | null }) => void) | null },
|
|
set ondatachannel(value) {
|
|
raw.ondatachannel = value === null ? null : event => value({ channel: adaptNativeDataChannel(event.channel) })
|
|
},
|
|
get ondatachannel() { return raw.ondatachannel as ((event: { channel: RtcDataChannel }) => void) | null },
|
|
createDataChannel(label, options) { return adaptNativeDataChannel(raw.createDataChannel(label, options)) },
|
|
createOffer() { return raw.createOffer() },
|
|
createAnswer() { return raw.createAnswer() },
|
|
setLocalDescription(description) { return raw.setLocalDescription(description) },
|
|
setRemoteDescription(description) { return raw.setRemoteDescription(description) },
|
|
addIceCandidate(candidate) { return raw.addIceCandidate(candidate) },
|
|
getStats() { return raw.getStats() },
|
|
close() { raw.close() },
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
export interface WeriftFactoryOptions {
|
|
interfaces?: NodeJS.Dict<NetworkInterfaceInfo[] | undefined>
|
|
preferredHostIpv4Candidates?: readonly string[]
|
|
routeTargets?: readonly string[]
|
|
routeProbeTimeoutMs?: number
|
|
}
|
|
|
|
/** Synchronous factory for tests and callers that already resolved werift. */
|
|
export function buildWeriftFactory(werift: WeriftModule, options: WeriftFactoryOptions = {}): RtcPeerConnectionFactory {
|
|
return {
|
|
create(configuration) {
|
|
const hostIpv4Candidates = detectHostIpv4Candidates(
|
|
options.interfaces ?? networkInterfaces(),
|
|
options.preferredHostIpv4Candidates,
|
|
)
|
|
const allowedHostIpv4 = new Set(hostIpv4Candidates)
|
|
const raw = new werift.RTCPeerConnection({
|
|
iceServers: orderIceServersForWerift(configuration.iceServers ?? []) as RtcIceServer[],
|
|
iceUseIpv4: true,
|
|
iceUseIpv6: false,
|
|
iceUseLinkLocalAddress: false,
|
|
...(hostIpv4Candidates.length === 0
|
|
? {}
|
|
: {
|
|
iceAdditionalHostAddresses: hostIpv4Candidates,
|
|
iceFilterCandidatePair: pair => {
|
|
const allowed = shouldUseCandidatePair(pair, allowedHostIpv4)
|
|
if (!allowed) {
|
|
configuration.onDiagnostic?.({
|
|
type: 'candidate-pair-filtered',
|
|
localCandidate: summarizeWeriftCandidate(localCandidate(pair)),
|
|
reason: 'local-host-not-allowed',
|
|
})
|
|
}
|
|
return allowed
|
|
},
|
|
}),
|
|
})
|
|
|
|
let onIceCandidate: ((event: { candidate: RtcIceCandidateInit | null }) => void) | null = null
|
|
let onDataChannel: ((event: { channel: RtcDataChannel }) => void) | null = null
|
|
raw.onicecandidate = event => {
|
|
if (onIceCandidate === null) return
|
|
const candidate = event.candidate === undefined ? null : event.candidate.toJSON()
|
|
if (candidate !== null && !shouldAdvertiseCandidate(candidate, allowedHostIpv4)) {
|
|
configuration.onDiagnostic?.({
|
|
type: 'local-candidate-filtered',
|
|
candidate: summarizeIceCandidate(candidate),
|
|
reason: 'local-host-not-allowed',
|
|
})
|
|
return
|
|
}
|
|
onIceCandidate({ candidate })
|
|
}
|
|
raw.ondatachannel = event => {
|
|
if (onDataChannel === null) return
|
|
onDataChannel({ channel: adaptDataChannel(event.channel) })
|
|
}
|
|
|
|
const pc: RtcPeerConnection = {
|
|
get connectionState(): string { return raw.connectionState },
|
|
get iceConnectionState(): string { return raw.iceConnectionState },
|
|
get iceGatheringState(): string { return raw.iceGatheringState },
|
|
get signalingState(): string { return raw.signalingState },
|
|
set onconnectionstatechange(value) { raw.onconnectionstatechange = value },
|
|
get onconnectionstatechange() { return raw.onconnectionstatechange },
|
|
set oniceconnectionstatechange(value) { raw.oniceconnectionstatechange = value },
|
|
get oniceconnectionstatechange() { return raw.oniceconnectionstatechange },
|
|
set onicegatheringstatechange(value) { raw.onicegatheringstatechange = value },
|
|
get onicegatheringstatechange() { return raw.onicegatheringstatechange },
|
|
set onicecandidate(value) { onIceCandidate = value },
|
|
get onicecandidate() { return onIceCandidate },
|
|
set ondatachannel(value) { onDataChannel = value },
|
|
get ondatachannel() { return onDataChannel },
|
|
createDataChannel(label, options) {
|
|
return adaptDataChannel(raw.createDataChannel(label, { ordered: options?.ordered ?? true }))
|
|
},
|
|
createOffer() { return raw.createOffer() },
|
|
createAnswer() { return raw.createAnswer() },
|
|
setLocalDescription(description) { return raw.setLocalDescription(description).then(() => undefined) },
|
|
setRemoteDescription(description) { return raw.setRemoteDescription(description) },
|
|
addIceCandidate(candidate) { return raw.addIceCandidate(candidate) },
|
|
getStats() { return raw.getStats() },
|
|
close() { void raw.close().catch(() => undefined) },
|
|
}
|
|
return pc
|
|
},
|
|
}
|
|
}
|
|
|
|
function adaptDataChannel(raw: WeriftDataChannel): RtcDataChannel {
|
|
return {
|
|
get label(): string { return raw.label },
|
|
get ordered(): boolean { return raw.ordered },
|
|
get readyState() { return raw.readyState as RtcDataChannel['readyState'] },
|
|
get bufferedAmount(): number { return raw.bufferedAmount },
|
|
binaryType: 'arraybuffer',
|
|
set onopen(value: (() => void) | null) { raw.onopen = value },
|
|
get onopen(): (() => void) | null { return raw.onopen },
|
|
set onmessage(value: ((event: { data: ArrayBuffer | string }) => void) | null) {
|
|
raw.onmessage = value === null ? null : event => value({ data: toArrayBuffer(event.data) })
|
|
},
|
|
get onmessage(): ((event: { data: ArrayBuffer | string }) => void) | null { return null },
|
|
set onclose(value: (() => void) | null) { raw.onclose = value },
|
|
get onclose(): (() => void) | null { return raw.onclose },
|
|
set onerror(value: (() => void) | null) { raw.onerror = value },
|
|
get onerror(): (() => void) | null { return raw.onerror },
|
|
onbufferedamountlow: null,
|
|
send(data: ArrayBuffer | string) {
|
|
const bytes = typeof data === 'string' ? Buffer.byteLength(data) : data.byteLength
|
|
try {
|
|
raw.send(typeof data === 'string' ? data : Buffer.from(data))
|
|
} catch (error) {
|
|
console.error('[werift-send-error] bytes=' + bytes, error instanceof Error ? error.message : error)
|
|
throw error
|
|
}
|
|
},
|
|
close() { raw.close() },
|
|
}
|
|
}
|
|
|
|
function adaptNativeDataChannel(raw: NativeDataChannel): RtcDataChannel {
|
|
let onmessage: ((event: { data: ArrayBuffer | string }) => void) | null = null
|
|
return {
|
|
get label(): string { return raw.label },
|
|
get ordered(): boolean { return raw.ordered },
|
|
get readyState() { return raw.readyState as RtcDataChannel['readyState'] },
|
|
get bufferedAmount(): number { return raw.bufferedAmount },
|
|
get binaryType(): string { return raw.binaryType },
|
|
set binaryType(value: string) { raw.binaryType = value },
|
|
set onopen(value: (() => void) | null) { raw.onopen = value },
|
|
get onopen(): (() => void) | null { return raw.onopen },
|
|
set onmessage(value: ((event: { data: ArrayBuffer | string }) => void) | null) {
|
|
onmessage = value
|
|
raw.onmessage = value === null ? null : event => value({ data: normalizeNativeMessageData(event.data) })
|
|
},
|
|
get onmessage(): ((event: { data: ArrayBuffer | string }) => void) | null { return onmessage },
|
|
set onclose(value: (() => void) | null) { raw.onclose = value },
|
|
get onclose(): (() => void) | null { return raw.onclose },
|
|
set onerror(value: (() => void) | null) { raw.onerror = value },
|
|
get onerror(): (() => void) | null { return raw.onerror },
|
|
set onbufferedamountlow(value: (() => void) | null) { raw.onbufferedamountlow = value },
|
|
get onbufferedamountlow(): (() => void) | null { return raw.onbufferedamountlow },
|
|
send(data: ArrayBuffer | string) {
|
|
raw.send(typeof data === 'string' ? data : Buffer.from(data))
|
|
},
|
|
close() { raw.close() },
|
|
}
|
|
}
|
|
|
|
function toArrayBuffer(data: string | Uint8Array): ArrayBuffer | string {
|
|
if (typeof data === 'string') return data
|
|
// `Buffer.prototype.slice()` (unlike `Uint8Array.prototype.slice()`) returns a
|
|
// *view* over the pooled 8 KiB receive buffer, so slicing the underlying
|
|
// ArrayBuffer by byte offset/length is required to extract just the message.
|
|
return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer
|
|
}
|
|
|
|
function normalizeNativeCandidate(candidate: NativeIceCandidate): RtcIceCandidateInit {
|
|
if (typeof candidate.toJSON === 'function') return candidate.toJSON()
|
|
return {
|
|
candidate: candidate.candidate,
|
|
sdpMid: candidate.sdpMid,
|
|
sdpMLineIndex: candidate.sdpMLineIndex,
|
|
usernameFragment: candidate.usernameFragment,
|
|
}
|
|
}
|
|
|
|
function normalizeNativeMessageData(data: unknown): ArrayBuffer | string {
|
|
if (typeof data === 'string') return data
|
|
if (data instanceof ArrayBuffer) return data
|
|
if (ArrayBuffer.isView(data)) {
|
|
return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer
|
|
}
|
|
return new Uint8Array().buffer
|
|
}
|
|
|
|
/**
|
|
* Pick the safe IPv4 host addresses for ICE gathering.
|
|
*
|
|
* On macOS a host exposes many interfaces (WiFi `en0`, Thunderbolt `en1-4`,
|
|
* `bridge*`, Apple Wireless Direct Link `awdl0`/`llw0`, and several VPN `utun*`
|
|
* tunnels whose small MTUs drop large SCTP packets). Let werift/ICE compare
|
|
* real physical interfaces, but filter virtual and link-local Host candidates
|
|
* before they can become nominated paths.
|
|
*/
|
|
export function detectHostIpv4Candidates(
|
|
interfaces: NodeJS.Dict<NetworkInterfaceInfo[] | undefined>,
|
|
preferredHostIpv4Candidates: readonly string[] = [],
|
|
): string[] {
|
|
const candidates: Array<{ name: string; ip: string; score: number }> = []
|
|
const routePreference = new Map(preferredHostIpv4Candidates.map((ip, index) => [ip, 10_000 - index]))
|
|
for (const [name, addresses] of Object.entries(interfaces)) {
|
|
const interfaceScore = physicalInterfaceScore(name)
|
|
if (interfaceScore === undefined) continue
|
|
for (const address of addresses ?? []) {
|
|
if (address.internal || !isIpv4Family(address.family)) continue
|
|
const ip = address.address
|
|
if (!isUsableIpv4(ip)) continue
|
|
candidates.push({
|
|
name,
|
|
ip,
|
|
score: interfaceScore + (isPrivate(ip) ? 1_000 : 0) + (routePreference.get(ip) ?? 0),
|
|
})
|
|
}
|
|
}
|
|
candidates.sort((left, right) => {
|
|
const score = right.score - left.score
|
|
if (score !== 0) return score
|
|
const name = left.name.localeCompare(right.name, 'en')
|
|
return name === 0 ? left.ip.localeCompare(right.ip, 'en', { numeric: true }) : name
|
|
})
|
|
return [...new Set(candidates.map(candidate => candidate.ip))]
|
|
}
|
|
|
|
export async function detectRouteHostIpv4Candidates(
|
|
targets: readonly string[],
|
|
timeoutMs = 500,
|
|
): Promise<string[]> {
|
|
const detected = await Promise.all(targets.map(async target => {
|
|
const routeTarget = parseRouteTarget(target)
|
|
return routeTarget === undefined ? undefined : await detectRouteHostIpv4(routeTarget, timeoutMs).catch(() => undefined)
|
|
}))
|
|
return [...new Set(detected.filter((ip): ip is string => ip !== undefined && isUsableIpv4(ip)))]
|
|
}
|
|
|
|
function shouldUseCandidatePair(pair: WeriftCandidatePair, allowedHostIpv4: ReadonlySet<string>): boolean {
|
|
if (allowedHostIpv4.size === 0) return true
|
|
const candidate = localCandidate(pair)
|
|
if (candidate === undefined) return true
|
|
return shouldUseLocalCandidate(candidate, allowedHostIpv4)
|
|
}
|
|
|
|
export function shouldAdvertiseCandidate(candidate: RtcIceCandidateInit, allowedHostIpv4: ReadonlySet<string>): boolean {
|
|
if (allowedHostIpv4.size === 0) return true
|
|
const parsed = parseIceCandidate(candidate)
|
|
if (parsed === undefined) return true
|
|
return shouldUseLocalCandidate(parsed, allowedHostIpv4)
|
|
}
|
|
|
|
function shouldUseLocalCandidate(candidate: WeriftCandidate, allowedHostIpv4: ReadonlySet<string>): boolean {
|
|
if (candidate.type === 'host') return candidate.host !== undefined && allowedHostIpv4.has(candidate.host)
|
|
if (candidate.type === 'srflx' && candidate.relatedAddress !== undefined) {
|
|
return allowedHostIpv4.has(candidate.relatedAddress)
|
|
}
|
|
return true
|
|
}
|
|
|
|
function localCandidate(pair: WeriftCandidatePair): WeriftCandidate | undefined {
|
|
try {
|
|
return pair.localCandidate
|
|
} catch {
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
function summarizeWeriftCandidate(candidate: WeriftCandidate | undefined): RtcCandidateSummary | undefined {
|
|
if (candidate === undefined) return undefined
|
|
const address = summarizeAddress(candidate.host)
|
|
const related = summarizeAddress(candidate.relatedAddress)
|
|
return {
|
|
candidateType: candidate.type === 'host' || candidate.type === 'srflx' || candidate.type === 'prflx' || candidate.type === 'relay'
|
|
? candidate.type
|
|
: 'unknown',
|
|
...address,
|
|
...(candidate.relatedAddress === undefined
|
|
? {}
|
|
: { relatedAddressFamily: related.addressFamily, relatedAddressScope: related.addressScope }),
|
|
}
|
|
}
|
|
|
|
export function orderIceServersForWerift(iceServers: readonly RtcIceServer[]): RtcIceServer[] {
|
|
return iceServers.map(server => {
|
|
const urls = Array.isArray(server.urls) ? [...server.urls] : [server.urls]
|
|
urls.sort((left, right) => iceUrlScore(left) - iceUrlScore(right))
|
|
return { ...server, urls: Array.isArray(server.urls) ? urls : urls[0] ?? server.urls }
|
|
})
|
|
}
|
|
|
|
function iceUrlScore(url: string): number {
|
|
const value = url.trim().toLowerCase()
|
|
if (value.startsWith('stun:') || value.startsWith('stuns:')) return 0
|
|
if (value.startsWith('turn:') && value.includes('transport=tcp')) return 10
|
|
if (value.startsWith('turns:') && value.includes('transport=tcp')) return 20
|
|
if (value.startsWith('turn:') && value.includes('transport=udp')) return 30
|
|
if (value.startsWith('turns:')) return 40
|
|
if (value.startsWith('turn:')) return 50
|
|
return 100
|
|
}
|
|
|
|
interface ParsedRouteTarget {
|
|
host: string
|
|
port: number
|
|
}
|
|
|
|
function parseRouteTarget(value: string): ParsedRouteTarget | undefined {
|
|
try {
|
|
const url = new URL(value)
|
|
const port = Number(url.port || (url.protocol === 'http:' ? '80' : '443'))
|
|
if (!Number.isSafeInteger(port) || port <= 0 || port > 65_535 || url.hostname.length === 0) return undefined
|
|
return { host: url.hostname, port }
|
|
} catch {
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
async function detectRouteHostIpv4(target: ParsedRouteTarget, timeoutMs: number): Promise<string | undefined> {
|
|
const socket = createSocket('udp4')
|
|
try {
|
|
return await new Promise<string | undefined>((resolve, reject) => {
|
|
const timer = setTimeout(() => {
|
|
cleanup()
|
|
resolve(undefined)
|
|
}, timeoutMs)
|
|
const cleanup = () => {
|
|
clearTimeout(timer)
|
|
socket.off('error', onError)
|
|
}
|
|
const onError = (error: Error) => {
|
|
cleanup()
|
|
reject(error)
|
|
}
|
|
socket.once('error', onError)
|
|
socket.connect(target.port, target.host, () => {
|
|
cleanup()
|
|
const address = socket.address()
|
|
resolve(typeof address === 'string' ? undefined : address.address)
|
|
})
|
|
})
|
|
} finally {
|
|
socket.close()
|
|
}
|
|
}
|
|
|
|
function isCacheableFactoryOptions(options: WeriftFactoryOptions): boolean {
|
|
return options.interfaces === undefined
|
|
&& options.preferredHostIpv4Candidates === undefined
|
|
&& options.routeTargets === undefined
|
|
}
|
|
|
|
function parseIceCandidate(candidate: RtcIceCandidateInit): WeriftCandidate | undefined {
|
|
const value = candidate.candidate?.trim()
|
|
if (value === undefined || value.length === 0) return undefined
|
|
const parts = value.replace(/^candidate:/, '').split(/\s+/)
|
|
const typeIndex = parts.indexOf('typ')
|
|
if (typeIndex < 0) return undefined
|
|
const host = parts[4]
|
|
const type = parts[typeIndex + 1]
|
|
const relatedAddressIndex = parts.indexOf('raddr')
|
|
return {
|
|
...(host === undefined ? {} : { host }),
|
|
...(type === undefined ? {} : { type }),
|
|
...(relatedAddressIndex < 0 || parts[relatedAddressIndex + 1] === undefined
|
|
? {}
|
|
: { relatedAddress: parts[relatedAddressIndex + 1] }),
|
|
}
|
|
}
|
|
|
|
function physicalInterfaceScore(name: string): number | undefined {
|
|
const value = name.toLowerCase()
|
|
if (/^(utun|tun|tap|ppp|bridge|awdl|llw|gif|stf|anpi|ap\d|vmnet|veth|docker|br-|vboxnet|lo)/.test(value)) {
|
|
return undefined
|
|
}
|
|
if (/^(eth|eno|ens|enp)/.test(value)) return 500
|
|
if (/^(en|wlan|wl|wifi|wi-fi)/.test(value)) return 450
|
|
return 300
|
|
}
|
|
|
|
function isIpv4Family(family: string | number): boolean {
|
|
return family === 'IPv4' || family === 4
|
|
}
|
|
|
|
function isUsableIpv4(ip: string): boolean {
|
|
const parts = ip.split('.').map(Number)
|
|
if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255)) return false
|
|
if (parts[0] === 0 || parts[0] === 127 || parts[0] >= 224) return false
|
|
if (parts[0] === 169 && parts[1] === 254) return false
|
|
return !isCgnat(ip)
|
|
}
|
|
|
|
function isCgnat(ip: string): boolean {
|
|
const parts = ip.split('.').map(Number)
|
|
return parts.length === 4 && parts[0] === 100 && parts[1] >= 64 && parts[1] <= 127
|
|
}
|
|
|
|
function isPrivate(ip: string): boolean {
|
|
const parts = ip.split('.').map(Number)
|
|
if (parts.length !== 4) return false
|
|
if (parts[0] === 10) return true
|
|
if (parts[0] === 192 && parts[1] === 168) return true
|
|
return parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31
|
|
}
|