@streamr/dht 0.0.1-tatum.0

package/src/connection/WebRTC/WebRtcConnector.ts

@@ -0,0 +1,306 @@
+import {
+    IceCandidate,
+    PeerDescriptor,
+    RtcAnswer,
+    RtcOffer, WebRtcConnectionRequest
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { ITransport } from '../../transport/ITransport'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { NodeWebRtcConnection } from './NodeWebRtcConnection'
+import { RemoteWebrtcConnector } from './RemoteWebrtcConnector'
+import { WebRtcConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { PeerIDKey } from '../../helpers/PeerID'
+import { ManagedWebRtcConnection } from '../ManagedWebRtcConnection'
+import { Logger } from '@streamr/utils'
+import * as Err from '../../helpers/errors'
+import { IWebRtcConnectorService } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { ManagedConnection } from '../ManagedConnection'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import {
+    isSamePeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../../helpers/peerIdFromPeerDescriptor'
+import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
+
+const logger = new Logger(module)
+
+export interface WebRtcConnectorConfig {
+    rpcTransport: ITransport
+    protocolVersion: string
+    iceServers?: IceServer[]
+    allowPrivateAddresses?: boolean
+    bufferThresholdLow?: number
+    bufferThresholdHigh?: number
+    connectionTimeout?: number
+}
+
+export interface IceServer {
+    url: string
+    port: number
+    username?: string
+    password?: string
+    tcp?: boolean
+}
+
+export class WebRtcConnector implements IWebRtcConnectorService {
+    private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc_connector'
+    private readonly rpcCommunicator: ListeningRpcCommunicator
+    private readonly ongoingConnectAttempts: Map<PeerIDKey, ManagedWebRtcConnection> = new Map()
+    private ownPeerDescriptor?: PeerDescriptor
+    private stopped = false
+    private iceServers: IceServer[]
+    private allowPrivateAddresses: boolean
+    private config: WebRtcConnectorConfig
+    private incomingConnectionCallback: (connection: ManagedConnection) => boolean
+
+    constructor(
+        config: WebRtcConnectorConfig,
+        incomingConnectionCallback: (connection: ManagedConnection) => boolean
+    ) {
+        this.config = config
+        this.iceServers = config.iceServers || []
+        this.allowPrivateAddresses = config.allowPrivateAddresses || true
+        this.incomingConnectionCallback = incomingConnectionCallback
+
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.rpcTransport, {
+            rpcRequestTimeout: 15000
+        })
+        this.rpcCommunicator.registerRpcNotification(RtcOffer, 'rtcOffer',
+            (req: RtcOffer, context) => this.rtcOffer(req, context))
+        this.rpcCommunicator.registerRpcNotification(RtcAnswer, 'rtcAnswer',
+            (req: RtcAnswer, context) => this.rtcAnswer(req, context))
+        this.rpcCommunicator.registerRpcNotification(IceCandidate, 'iceCandidate',
+            (req: IceCandidate, context) => this.iceCandidate(req, context))
+        this.rpcCommunicator.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection',
+            (req: WebRtcConnectionRequest, context) => this.requestConnection(req, context))
+    }
+
+    connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+        if (isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+            throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
+        }
+
+        logger.trace(`Opening WebRTC connection to ${targetPeerDescriptor.kademliaId.toString()}`)
+
+        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.ongoingConnectAttempts.get(peerKey)
+        if (existingConnection) {
+            return existingConnection
+        }
+
+        const connection = new NodeWebRtcConnection({ 
+            remotePeerDescriptor: targetPeerDescriptor,
+            iceServers: this.iceServers,
+            bufferThresholdLow: this.config.bufferThresholdLow,
+            bufferThresholdHigh: this.config.bufferThresholdHigh,
+            connectingTimeout: this.config.connectionTimeout
+        })
+
+        const offering = this.isOffering(targetPeerDescriptor)
+        let managedConnection: ManagedWebRtcConnection
+
+        if (offering) {
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, connection)
+        } else {
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, undefined, connection)
+        }
+
+        managedConnection.setPeerDescriptor(targetPeerDescriptor)
+
+        this.ongoingConnectAttempts.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+
+        const delFunc = () => {
+            if (this.ongoingConnectAttempts.has(peerKey)) {
+                this.ongoingConnectAttempts.delete(peerKey)
+            }
+            connection.off('disconnected', delFunc)
+            managedConnection.off('handshakeCompleted', delFunc)
+        }
+        connection.on('disconnected', delFunc)
+        managedConnection.on('handshakeCompleted', delFunc)
+
+        const remoteConnector = new RemoteWebrtcConnector(
+            targetPeerDescriptor,
+            toProtoRpcClient(new WebRtcConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+        )
+
+        connection.on('localCandidate', (candidate: string, mid: string) => {
+            remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection.connectionId.toString())
+        })
+
+        if (offering) {
+            connection.once('localDescription', (description: string, _type: string) => {
+                remoteConnector.sendRtcOffer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
+            })
+        } else {
+            connection.once('localDescription', (description: string, _type: string) => {
+                remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
+            })
+        }
+
+        connection.start(offering)
+
+        if (!offering) {
+            remoteConnector.requestConnection(this.ownPeerDescriptor!, connection.connectionId.toString())
+        }
+
+        return managedConnection
+    }
+
+    setOwnPeerDescriptor(peerDescriptor: PeerDescriptor): void {
+        this.ownPeerDescriptor = peerDescriptor
+    }
+
+    isIceCandidateAllowed(candidate: string): boolean {
+        if (!this.allowPrivateAddresses) {
+            const address = getAddressFromIceCandidate(candidate)
+            if (address && isPrivateIPv4(address)) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private onRtcOffer(
+        remotePeer: PeerDescriptor,
+        targetPeer: PeerDescriptor,
+        description: string,
+        connectionId: string
+    ): void {
+        if (this.stopped || !isSamePeerDescriptor(targetPeer, this.ownPeerDescriptor!)) {
+            return
+        }
+        const peerKey = keyFromPeerDescriptor(remotePeer)
+        let managedConnection = this.ongoingConnectAttempts.get(peerKey)
+        let connection = managedConnection?.getWebRtcConnection()
+
+        if (!managedConnection) {
+            connection = new NodeWebRtcConnection({ remotePeerDescriptor: remotePeer })
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, undefined, connection)
+            
+            managedConnection.setPeerDescriptor(remotePeer)
+
+            this.ongoingConnectAttempts.set(peerKey, managedConnection)
+            this.incomingConnectionCallback(managedConnection)
+
+            const remoteConnector = new RemoteWebrtcConnector(
+                remotePeer,
+                toProtoRpcClient(new WebRtcConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+            )
+
+            connection.on('localCandidate', (candidate: string, mid: string) => {
+                remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection!.connectionId.toString())
+            })
+
+            connection.once('localDescription', (description: string, _type: string) => {
+                remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection!.connectionId.toString())
+            })
+
+            connection.start(false)
+
+        }
+
+        // Always use offerers connectionId
+        connection!.setConnectionId(connectionId)
+        connection!.setRemoteDescription(description, 'offer')
+        
+        managedConnection!.on('handshakeRequest', () => {
+            if (this.ongoingConnectAttempts.has(peerKey)) {
+                this.ongoingConnectAttempts.delete(peerKey)
+            }
+            managedConnection!.acceptHandshake()
+        })
+    }
+
+    private onRtcAnswer(
+        remotePeerDescriptor: PeerDescriptor,
+        targetPeerDescriptor: PeerDescriptor,
+        description: string,
+        connectionId: string
+    ): void {
+        if (this.stopped || !isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+            return
+        }
+        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.ongoingConnectAttempts.get(peerKey)?.getWebRtcConnection()
+        if (!connection) {
+            return
+        } else if (connection.connectionId.toString() !== connectionId) {
+            logger.trace(`Ignoring RTC answer due to connectionId mismatch`)
+            return
+        }
+        connection.setRemoteDescription(description, 'answer')
+    }
+
+    private onConnectionRequest(targetPeerDescriptor: PeerDescriptor): void {
+        if (this.stopped || this.ongoingConnectAttempts.has(keyFromPeerDescriptor(targetPeerDescriptor))) {
+            return
+        }
+        const managedConnection = this.connect(targetPeerDescriptor)
+        managedConnection.setPeerDescriptor(targetPeerDescriptor)
+
+        this.incomingConnectionCallback(managedConnection)
+    }
+    private onRemoteCandidate(
+        remotePeerDescriptor: PeerDescriptor,
+        targetPeerDescriptor: PeerDescriptor,
+        candidate: string,
+        mid: string,
+        connectionId: string
+    ): void {
+        if (this.stopped || !isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+            return
+        }
+        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.ongoingConnectAttempts.get(peerKey)?.getWebRtcConnection()
+
+        if (!connection) {
+            return
+        } else if (connection.connectionId.toString() !== connectionId) {
+            logger.trace(`Ignoring remote candidate due to connectionId mismatch`)
+            return
+        } else if (this.isIceCandidateAllowed(candidate)) {
+            connection.addRemoteCandidate(candidate, mid)
+        }
+    }
+
+    public async stop(): Promise<void> {
+        logger.trace('stop()')
+        this.stopped = true
+
+        const attempts = Array.from(this.ongoingConnectAttempts.values())
+        await Promise.allSettled(attempts.map((conn) => conn.close('OTHER')))
+       
+        this.rpcCommunicator.stop()
+    }
+
+    public isOffering(targetPeerDescriptor: PeerDescriptor): boolean {
+        const myId = peerIdFromPeerDescriptor(this.ownPeerDescriptor!)
+        const theirId = peerIdFromPeerDescriptor(targetPeerDescriptor)
+        return myId.hasSmallerHashThan(theirId)
+    }
+
+    // IWebRTCConnector implementation
+    async requestConnection(request: WebRtcConnectionRequest, _context: ServerCallContext): Promise<Empty> {
+        this.onConnectionRequest(request.requester!)
+        return {}
+    }
+
+    async rtcOffer(request: RtcOffer, _context: ServerCallContext): Promise<Empty> {
+        this.onRtcOffer(request.requester!, request.target!, request.description, request.connectionId)
+        return {}
+    }
+
+    async rtcAnswer(request: RtcAnswer, _context: ServerCallContext): Promise<Empty> {
+        this.onRtcAnswer(request.requester!, request.target!, request.description, request.connectionId)
+        return {}
+    }
+
+    async iceCandidate(request: IceCandidate, _context: ServerCallContext): Promise<Empty> {
+        this.onRemoteCandidate(request.requester!, request.target!, request.candidate, request.mid, request.connectionId)
+        return {}
+    }
+}

package/src/connection/WebRTC/iceServerAsString.ts

@@ -0,0 +1,15 @@
+import { IceServer } from './WebRtcConnector'
+
+export function iceServerAsString({ url, port, username, password, tcp }: IceServer): string {
+    const [protocol, hostname] = url.split(':')
+    if (hostname === undefined) {
+        throw new Error(`invalid stun/turn format: ${url}`)
+    }
+    if (username === undefined && password === undefined) {
+        return `${protocol}:${hostname}:${port}`
+    }
+    if (username !== undefined && password !== undefined) {
+        return `${protocol}:${username}:${password}@${hostname}:${port}${tcp ? '?transport=tcp' : ''}`
+    }
+    throw new Error(`username (${username}) and password (${password}) must be supplied together`)
+}

package/src/connection/WebSocket/ClientWebSocket.ts

@@ -0,0 +1,118 @@
+import { IConnection, ConnectionID, ConnectionType, ConnectionEvents } from '../IConnection'
+import { w3cwebsocket as WebSocket, ICloseEvent, IMessageEvent } from 'websocket'
+import EventEmitter from 'eventemitter3'
+import { Logger } from '@streamr/utils'
+import { DisconnectionType } from '../../transport/ITransport'
+
+const logger = new Logger(module)
+
+const BINARY_TYPE = 'arraybuffer'
+
+export class ClientWebSocket extends EventEmitter<ConnectionEvents> implements IConnection {
+    public readonly connectionId: ConnectionID
+    private socket?: WebSocket
+    public connectionType = ConnectionType.WEBSOCKET_CLIENT
+
+    private stopped = false
+
+    constructor() {
+        super()
+        this.connectionId = new ConnectionID()
+    }
+
+    public connect(address: string): void {
+        if (!this.stopped) {
+            this.socket = new WebSocket(address)
+            this.socket.binaryType = BINARY_TYPE
+
+            this.socket.onerror = (error: Error) => {
+                if (!this.stopped) {
+                    logger.trace('WebSocket Client error: ' + error)
+                    this.emit('error', error.name)
+                }
+            }
+
+            this.socket.onopen = () => {
+                if (!this.stopped) {
+                    logger.trace('WebSocket Client Connected')
+                    if (this.socket && this.socket.readyState === this.socket.OPEN) {
+                        this.emit('connected')
+                    }
+                }
+            }
+
+            this.socket.onclose = (event: ICloseEvent) => {
+                if (!this.stopped) {
+                    logger.trace('Websocket Closed')
+                    this.doDisconnect('OTHER', event.code, event.reason)
+                }
+            }
+
+            this.socket.onmessage = (message: IMessageEvent) => {
+                if (!this.stopped) {
+                    if (typeof message.data === 'string') {
+                        logger.debug('Received string: \'' + message.data + '\'')
+                    } else {
+                        this.emit('data', new Uint8Array(message.data))
+                    }
+                }
+            }
+        } else {
+            logger.debug('Tried to connect() a stopped connection')
+        }
+    }
+
+    private doDisconnect(disconnectionType: DisconnectionType, code?: number, reason?: string) {
+        this.stopped = true
+        this.stopListening()
+        this.socket = undefined
+
+        this.emit('disconnected', disconnectionType, code, reason)
+        this.removeAllListeners()
+    }
+
+    public send(data: Uint8Array): void {
+        if (!this.stopped) {
+            if (this.socket && this.socket.readyState === this.socket.OPEN) {
+                logger.trace(`Sending data with size ${data.byteLength}`)
+                this.socket?.send(data.buffer)
+            } else {
+                logger.warn('Tried to send data on a non-open connection')
+            }
+        } else {
+            logger.debug('Tried to send() on stopped connection')
+        }
+    }
+
+    public async close(): Promise<void> {
+        if (!this.stopped) {
+            logger.trace(`Closing socket for connection ${this.connectionId.toString()}`)
+            this.socket?.close()
+        } else {
+            logger.debug('Tried to close() a stopped connection')
+        }
+    }
+
+    private stopListening(): void {
+        if (this.socket) {
+            this.socket.onopen = undefined as unknown as (() => void)
+            this.socket.onclose = undefined as unknown as (() => void)
+            this.socket.onerror = undefined as unknown as (() => void)
+            this.socket.onmessage = undefined as unknown as (() => void)
+        }
+    }
+
+    public destroy(): void {
+        if (!this.stopped) {
+            this.removeAllListeners()
+            if (this.socket) {
+                this.stopListening()
+                this.socket.close()
+                this.socket = undefined
+            }
+            this.stopped = true
+        } else {
+            logger.debug('Tried to destroy() a stopped connection')
+        }
+    }
+}

package/src/connection/WebSocket/RemoteWebSocketConnector.ts

@@ -0,0 +1,49 @@
+import {
+    PeerDescriptor,
+    WebSocketConnectionRequest
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { IWebSocketConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
+import { Logger } from '@streamr/utils'
+import * as Err from '../../helpers/errors'
+import { ProtoRpcClient } from '@streamr/proto-rpc'
+
+const logger = new Logger(module)
+
+export class RemoteWebSocketConnector {
+
+    private peerDescriptor: PeerDescriptor
+    private client: ProtoRpcClient<IWebSocketConnectorServiceClient>
+
+    constructor(peerDescriptor: PeerDescriptor, client: ProtoRpcClient<IWebSocketConnectorServiceClient>) {
+        this.peerDescriptor = peerDescriptor
+        this.client = client
+    }
+
+    async requestConnection(sourceDescriptor: PeerDescriptor, ip: string, port: number): Promise<boolean> {
+        logger.trace(`Requesting WebSocket connection from ${this.peerDescriptor.kademliaId.toString()}`)
+        const request: WebSocketConnectionRequest = {
+            target: this.peerDescriptor,
+            requester: sourceDescriptor,
+            ip,
+            port
+        }
+        const options: DhtRpcOptions = {
+            sourceDescriptor: sourceDescriptor as PeerDescriptor,
+            targetDescriptor: this.peerDescriptor as PeerDescriptor
+        }
+        try {
+            const res = await this.client.requestConnection(request, options)
+            
+            if (res.reason) {
+                logger.debug('WebSocketConnectionRequest Rejected', {
+                    stack: new Err.WebSocketConnectionRequestRejected(res.reason).stack
+                })
+            }
+            return res.accepted
+        } catch (err) {
+            logger.debug(new Err.WebSocketConnectionRequestRejected('WebSocketConnectionRequest rejected', err).stack!)
+            return false
+        }
+    }
+}

package/src/connection/WebSocket/ServerWebSocket.ts

@@ -0,0 +1,119 @@
+import EventEmitter from 'eventemitter3'
+import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
+import { connection as WsConnection } from 'websocket'
+import { Logger } from '@streamr/utils'
+import { DisconnectionType } from '../../transport/ITransport'
+import { Url } from 'url'
+
+const logger = new Logger(module)
+
+// NodeJsBuffer is global defined in preload.js of Karma
+// It is used to make Karma/Electron tests to use the NodeJS
+// implementation of Buffer instead of the browser polyfill
+
+declare let NodeJsBuffer: BufferConstructor
+
+enum MessageType {
+    UTF8 = 'utf8',
+    BINARY = 'binary'
+}
+
+export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements IConnection {
+
+    public readonly connectionId: ConnectionID
+    public readonly connectionType = ConnectionType.WEBSOCKET_SERVER
+    public readonly resourceURL: Url
+    private socket?: WsConnection
+    private stopped = false
+
+    constructor(socket: WsConnection, resourceURL: Url) {
+        super()
+
+        this.resourceURL = resourceURL
+        this.connectionId = new ConnectionID()
+
+        socket.on('message', (message) => {
+            if (!this.stopped) {
+                logger.trace('ServerWebSocket::onMessage')
+                if (message.type === MessageType.UTF8) {
+                    logger.debug('Received string Message: ' + message.utf8Data)
+                } else if (message.type === MessageType.BINARY) {
+                    logger.trace('Received Binary Message of ' + message.binaryData.length + ' bytes')
+                    this.emit('data',
+                        new Uint8Array(message.binaryData.buffer, message.binaryData.byteOffset,
+                            message.binaryData.byteLength / Uint8Array.BYTES_PER_ELEMENT))
+                }
+            }
+        })
+        socket.on('close', (reasonCode, description) => {
+            if (!this.stopped) {
+                logger.trace(' Peer ' + socket.remoteAddress + ' disconnected.')
+                this.doDisconnect('OTHER', reasonCode, description)
+            }
+        })
+
+        socket.on('error', (error) => {
+            if (!this.stopped) {
+                this.emit('error', error.name)
+            }
+        })
+
+        this.socket = socket
+    }
+
+    private doDisconnect(disconnectionType: DisconnectionType, reasonCode: number, description: string): void {
+        this.stopped = true
+        this.socket?.removeAllListeners()
+        this.socket = undefined
+
+        this.emit('disconnected', disconnectionType, reasonCode, description)
+        this.removeAllListeners()
+    }
+
+    public send(data: Uint8Array): void {
+        // If in an Karma / Electron test, use the NodeJS implementation
+        // of Buffer instead of the browser polyfill
+
+        if (!this.stopped && this.socket) {
+            if (typeof NodeJsBuffer !== 'undefined') {
+                this.socket.sendBytes(NodeJsBuffer.from(data))
+            } else {
+                this.socket.sendBytes(Buffer.from(data))
+            }
+        } else {
+            logger.error('Tried to call send() on a stopped socket')
+        }
+
+    }
+
+    public async close(): Promise<void> {
+        if (!this.stopped) {
+            this.socket?.close()
+        } else {
+            logger.error('Tried to close a stopped connection')
+        }
+    }
+
+    public destroy(): void {
+        if (!this.stopped) {
+            this.removeAllListeners()
+            if (this.socket) {
+                this.socket.removeAllListeners()
+                this.socket.close()
+                this.socket = undefined
+            }
+            this.stopped = true
+        } else {
+            logger.error('Tried to destroy() a stopped connection')
+        }
+    }
+
+    public getRemoteAddress(): string {
+        if (!this.stopped && this.socket) {
+            return this.socket.remoteAddress
+        } else {
+            logger.error('Tried to get the remoteAddress of a stopped connection')
+            return ''
+        }
+    }
+}