@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.7

package/src/connection/WebRTC/NodeWebRtcConnection.ts

@@ -13,8 +13,6 @@ import { PortRange } from '../ConnectionManager'
 
 const logger = new Logger(module)
 
-const MAX_MESSAGE_SIZE = 1048576
-
 export const WEB_RTC_CLEANUP = new class {
     // eslint-disable-next-line class-methods-use-this
     cleanUp(): void {
@@ -27,6 +25,7 @@ export interface Params {
     bufferThresholdHigh?: number
     bufferThresholdLow?: number
     connectingTimeout?: number
+    maxMessageSize?: number
     iceServers?: IceServer[]
     portRange?: PortRange
 }
@@ -65,27 +64,29 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
     private readonly connectingTimeout: number
     private readonly remotePeerDescriptor: PeerDescriptor
     private readonly portRange?: PortRange
+    private readonly maxMessageSize?: number
     private closed = false
 
     constructor(params: Params) {
         super()
         this.connectionId = new ConnectionID()
-        this.iceServers = params.iceServers || []
+        this.iceServers = params.iceServers ?? []
         // eslint-disable-next-line no-underscore-dangle
-        this._bufferThresholdHigh = params.bufferThresholdHigh || 2 ** 17
-        this.bufferThresholdLow = params.bufferThresholdLow || 2 ** 15
-        this.connectingTimeout = params.connectingTimeout || 20000
+        this._bufferThresholdHigh = params.bufferThresholdHigh ?? 2 ** 17
+        this.bufferThresholdLow = params.bufferThresholdLow ?? 2 ** 15
+        this.connectingTimeout = params.connectingTimeout ?? 20000
         this.remotePeerDescriptor = params.remotePeerDescriptor
+        this.maxMessageSize = params.maxMessageSize ?? 1048576
         this.portRange = params.portRange
     }
 
     public start(isOffering: boolean): void {
-        logger.trace(`Staring new connection for peer: ${this.remotePeerDescriptor.kademliaId.toString()}`)
-        const hexId = keyFromPeerDescriptor(this.remotePeerDescriptor)
-        logger.trace(`Staring new connection for peer: ${hexId} offering: ${isOffering}`)
-        this.connection = new PeerConnection(hexId, {
+        logger.trace(`Staring new connection for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+        const peerIdKey = keyFromPeerDescriptor(this.remotePeerDescriptor)
+        logger.trace(`Staring new connection for peer: ${peerIdKey} offering: ${isOffering}`)
+        this.connection = new PeerConnection(peerIdKey, {
             iceServers: this.iceServers.map(iceServerAsString),
-            maxMessageSize: MAX_MESSAGE_SIZE,
+            maxMessageSize: this.maxMessageSize,
             portRangeBegin: this.portRange?.min,
             portRangeEnd: this.portRange?.max,
         })
@@ -96,7 +97,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
         }, this.connectingTimeout)
 
         this.connection.onStateChange((state: string) => this.onStateChange(state))
-        this.connection.onGatheringStateChange((_state: string) => {})
+        this.connection.onGatheringStateChange(() => {})
 
         this.connection.onLocalDescription((description: string, type: DescriptionType) => {
             this.emit('localDescription', description, type.toString())
@@ -232,7 +233,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
             clearTimeout(this.connectingTimeoutRef)
         }
         this.dataChannel = dataChannel
-        logger.trace(`DataChannel opened for peer ${this.remotePeerDescriptor.kademliaId.toString()}`)
+        logger.trace(`DataChannel opened for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
         this.emit('connected')
     }
 

package/src/connection/WebRTC/WebRtcConnector.ts

@@ -15,11 +15,10 @@ 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,
+    areEqualPeerDescriptors,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
@@ -38,12 +37,13 @@ export const replaceInternalIpWithExternalIp = (candidate: string, ip: string):
 }
 
 export interface WebRtcConnectorConfig {
-    rpcTransport: ITransport
+    transport: ITransport
     protocolVersion: string
     iceServers?: IceServer[]
     allowPrivateAddresses?: boolean
     bufferThresholdLow?: number
     bufferThresholdHigh?: number
+    maxMessageSize?: number
     connectionTimeout?: number
     externalIp?: string
     portRange?: PortRange
@@ -58,7 +58,7 @@ export interface IceServer {
 }
 
 export class WebRtcConnector implements IWebRtcConnectorService {
-    private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc_connector'
+    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
@@ -66,36 +66,36 @@ export class WebRtcConnector implements IWebRtcConnectorService {
     private iceServers: IceServer[]
     private allowPrivateAddresses: boolean
     private config: WebRtcConnectorConfig
-    private incomingConnectionCallback: (connection: ManagedConnection) => boolean
+    private onIncomingConnection: (connection: ManagedConnection) => boolean
 
     constructor(
         config: WebRtcConnectorConfig,
-        incomingConnectionCallback: (connection: ManagedConnection) => boolean
+        onIncomingConnection: (connection: ManagedConnection) => boolean
     ) {
         this.config = config
         this.iceServers = config.iceServers || []
         this.allowPrivateAddresses = config.allowPrivateAddresses || true
-        this.incomingConnectionCallback = incomingConnectionCallback
+        this.onIncomingConnection = onIncomingConnection
 
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.rpcTransport, {
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
             rpcRequestTimeout: 15000
         })
         this.rpcCommunicator.registerRpcNotification(RtcOffer, 'rtcOffer',
-            (req: RtcOffer, context) => this.rtcOffer(req, context))
+            (req: RtcOffer) => this.rtcOffer(req))
         this.rpcCommunicator.registerRpcNotification(RtcAnswer, 'rtcAnswer',
-            (req: RtcAnswer, context) => this.rtcAnswer(req, context))
+            (req: RtcAnswer) => this.rtcAnswer(req))
         this.rpcCommunicator.registerRpcNotification(IceCandidate, 'iceCandidate',
-            (req: IceCandidate, context) => this.iceCandidate(req, context))
+            (req: IceCandidate) => this.iceCandidate(req))
         this.rpcCommunicator.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection',
-            (req: WebRtcConnectionRequest, context) => this.requestConnection(req, context))
+            (req: WebRtcConnectionRequest) => this.requestConnection(req))
     }
 
     connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        if (isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+        if (areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
             throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
         }
 
-        logger.trace(`Opening WebRTC connection to ${targetPeerDescriptor.kademliaId.toString()}`)
+        logger.trace(`Opening WebRTC connection to ${keyFromPeerDescriptor(targetPeerDescriptor)}`)
 
         const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.ongoingConnectAttempts.get(peerKey)
@@ -103,7 +103,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
             return existingConnection
         }
 
-        const connection = new NodeWebRtcConnection({ 
+        const connection = new NodeWebRtcConnection({
             remotePeerDescriptor: targetPeerDescriptor,
             iceServers: this.iceServers,
             bufferThresholdLow: this.config.bufferThresholdLow,
@@ -149,11 +149,11 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         })
 
         if (offering) {
-            connection.once('localDescription', (description: string, _type: string) => {
+            connection.once('localDescription', (description: string) => {
                 remoteConnector.sendRtcOffer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
             })
         } else {
-            connection.once('localDescription', (description: string, _type: string) => {
+            connection.once('localDescription', (description: string) => {
                 remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
             })
         }
@@ -171,7 +171,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         this.ownPeerDescriptor = peerDescriptor
     }
 
-    isIceCandidateAllowed(candidate: string): boolean {
+    private isIceCandidateAllowed(candidate: string): boolean {
         if (!this.allowPrivateAddresses) {
             const address = getAddressFromIceCandidate(candidate)
             if (address && isPrivateIPv4(address)) {
@@ -187,7 +187,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         description: string,
         connectionId: string
     ): void {
-        if (this.stopped || !isSamePeerDescriptor(targetPeer, this.ownPeerDescriptor!)) {
+        if (this.stopped || !areEqualPeerDescriptors(targetPeer, this.ownPeerDescriptor!)) {
             return
         }
         const peerKey = keyFromPeerDescriptor(remotePeer)
@@ -197,11 +197,11 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         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)
+            this.onIncomingConnection(managedConnection)
 
             const remoteConnector = new RemoteWebrtcConnector(
                 remotePeer,
@@ -212,7 +212,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
                 remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection!.connectionId.toString())
             })
 
-            connection.once('localDescription', (description: string, _type: string) => {
+            connection.once('localDescription', (description: string) => {
                 remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection!.connectionId.toString())
             })
 
@@ -223,7 +223,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         // Always use offerers connectionId
         connection!.setConnectionId(connectionId)
         connection!.setRemoteDescription(description, 'offer')
-        
+
         managedConnection.on('handshakeRequest', () => {
             if (this.ongoingConnectAttempts.has(peerKey)) {
                 this.ongoingConnectAttempts.delete(peerKey)
@@ -238,7 +238,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         description: string,
         connectionId: string
     ): void {
-        if (this.stopped || !isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+        if (this.stopped || !areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
             return
         }
         const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
@@ -259,7 +259,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         const managedConnection = this.connect(targetPeerDescriptor)
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
 
-        this.incomingConnectionCallback(managedConnection)
+        this.onIncomingConnection(managedConnection)
     }
     private onRemoteCandidate(
         remotePeerDescriptor: PeerDescriptor,
@@ -268,7 +268,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         mid: string,
         connectionId: string
     ): void {
-        if (this.stopped || !isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+        if (this.stopped || !areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
             return
         }
         const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
@@ -290,7 +290,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
 
         const attempts = Array.from(this.ongoingConnectAttempts.values())
         await Promise.allSettled(attempts.map((conn) => conn.close('OTHER')))
-       
+
         this.rpcCommunicator.stop()
     }
 
@@ -301,22 +301,22 @@ export class WebRtcConnector implements IWebRtcConnectorService {
     }
 
     // IWebRTCConnector implementation
-    async requestConnection(request: WebRtcConnectionRequest, _context: ServerCallContext): Promise<Empty> {
+    async requestConnection(request: WebRtcConnectionRequest): Promise<Empty> {
         this.onConnectionRequest(request.requester!)
         return {}
     }
 
-    async rtcOffer(request: RtcOffer, _context: ServerCallContext): Promise<Empty> {
+    async rtcOffer(request: RtcOffer): Promise<Empty> {
         this.onRtcOffer(request.requester!, request.target!, request.description, request.connectionId)
         return {}
     }
 
-    async rtcAnswer(request: RtcAnswer, _context: ServerCallContext): Promise<Empty> {
+    async rtcAnswer(request: RtcAnswer): Promise<Empty> {
         this.onRtcAnswer(request.requester!, request.target!, request.description, request.connectionId)
         return {}
     }
 
-    async iceCandidate(request: IceCandidate, _context: ServerCallContext): Promise<Empty> {
+    async iceCandidate(request: IceCandidate): Promise<Empty> {
         this.onRemoteCandidate(request.requester!, request.target!, request.candidate, request.mid, request.connectionId)
         return {}
     }

package/src/connection/WebSocket/RemoteWebSocketConnector.ts

@@ -7,6 +7,7 @@ import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -21,7 +22,7 @@ export class RemoteWebSocketConnector {
     }
 
     async requestConnection(sourceDescriptor: PeerDescriptor, ip: string, port: number): Promise<boolean> {
-        logger.trace(`Requesting WebSocket connection from ${this.peerDescriptor.kademliaId.toString()}`)
+        logger.trace(`Requesting WebSocket connection from ${keyFromPeerDescriptor(this.peerDescriptor)}`)
         const request: WebSocketConnectionRequest = {
             target: this.peerDescriptor,
             requester: sourceDescriptor,

package/src/connection/WebSocket/WebSocketConnector.ts

@@ -6,14 +6,14 @@ import { RemoteWebSocketConnector } from './RemoteWebSocketConnector'
 import {
     ConnectivityMethod,
     ConnectivityResponse,
+    NodeType,
     PeerDescriptor,
     WebSocketConnectionRequest,
     WebSocketConnectionResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { WebSocketConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { Logger, wait } from '@streamr/utils'
+import { Logger, binaryToHex, wait } from '@streamr/utils'
 import { IWebSocketConnectorService } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ManagedConnection } from '../ManagedConnection'
 import { WebSocketServer } from './WebSocketServer'
 import { ConnectivityChecker } from '../ConnectivityChecker'
@@ -24,7 +24,8 @@ import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Handshaker } from '../Handshaker'
 import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ParsedUrlQuery } from 'querystring'
-import { sample } from 'lodash'
+import { range, sample } from 'lodash'
+import { isPrivateIPv4 } from '../../helpers/AddressTools'
 
 const logger = new Logger(module)
 
@@ -32,19 +33,35 @@ export const connectivityMethodToWebSocketUrl = (ws: ConnectivityMethod): string
     return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port
 }
 
+const canOpenConnectionFromBrowser = (websocketServer: ConnectivityMethod) => {
+    const hasPrivateAddress = ((websocketServer.host === 'localhost') || isPrivateIPv4(websocketServer.host))
+    return websocketServer.tls || hasPrivateAddress
+}
+
 const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 
+interface WebSocketConnectorConfig {
+    protocolVersion: string
+    transport: ITransport
+    canConnect: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
+    onIncomingConnection: (connection: ManagedConnection) => boolean
+    portRange?: PortRange
+    maxMessageSize?: number
+    host?: string
+    entrypoints?: PeerDescriptor[]
+    tlsCertificate?: TlsCertificate
+}
+
 export class WebSocketConnector implements IWebSocketConnectorService {
-    private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocketconnector'
+    private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly canConnectFunction: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
     private readonly webSocketServer?: WebSocketServer
     private connectivityChecker?: ConnectivityChecker
     private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
-    private incomingConnectionCallback: (connection: ManagedConnection) => boolean
-    private portRange?: PortRange
+    private onIncomingConnection: (connection: ManagedConnection) => boolean
     private host?: string
-    private entrypoints?: PeerDescriptor[]
+    private readonly entrypoints?: PeerDescriptor[]
     private readonly tlsCertificate?: TlsCertificate
     private selectedPort?: number
     private readonly protocolVersion: string
@@ -52,27 +69,21 @@ export class WebSocketConnector implements IWebSocketConnectorService {
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
     private destroyed = false
 
-    constructor(
-        protocolVersion: string,
-        rpcTransport: ITransport,
-        fnCanConnect: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean,
-        incomingConnectionCallback: (connection: ManagedConnection) => boolean,
-        portRange?: PortRange,
-        host?: string,
-        entrypoints?: PeerDescriptor[],
-        tlsCertificate?: TlsCertificate
-    ) {
-        this.protocolVersion = protocolVersion
-        this.webSocketServer = portRange ? new WebSocketServer() : undefined
-        this.incomingConnectionCallback = incomingConnectionCallback
-        this.portRange = portRange
-        this.host = host
-        this.entrypoints = entrypoints
-        this.tlsCertificate = tlsCertificate
-
-        this.canConnectFunction = fnCanConnect.bind(this)
-
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebSocketConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, rpcTransport, {
+    constructor(config: WebSocketConnectorConfig) {
+        this.protocolVersion = config.protocolVersion
+        this.webSocketServer = config.portRange ? new WebSocketServer({
+            portRange: config.portRange!,
+            tlsCertificate: config.tlsCertificate,
+            maxMessageSize: config.maxMessageSize
+        }) : undefined
+        this.onIncomingConnection = config.onIncomingConnection
+        this.host = config.host
+        this.entrypoints = config.entrypoints
+        this.tlsCertificate = config.tlsCertificate
+
+        this.canConnectFunction = config.canConnect.bind(this)
+
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebSocketConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
             rpcRequestTimeout: 15000
         })
 
@@ -80,7 +91,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
             WebSocketConnectionRequest,
             WebSocketConnectionResponse,
             'requestConnection',
-            (req: WebSocketConnectionRequest, context) => this.requestConnection(req, context)
+            (req: WebSocketConnectionRequest) => this.requestConnection(req)
         )
     }
 
@@ -100,10 +111,10 @@ export class WebSocketConnector implements IWebSocketConnectorService {
                     serverSocket.resourceURL.query) {
                     const query = serverSocket.resourceURL.query as unknown as ParsedUrlQuery
                     if (query.connectivityRequest) {
-                        logger.trace('Received connectivity request connection')
+                        logger.trace('Received connectivity request connection from ' + serverSocket.getRemoteAddress())
                         this.connectivityChecker!.listenToIncomingConnectivityRequests(serverSocket)
                     } else if (query.connectivityProbe) {
-                        logger.trace('Received connectivity probe connection')
+                        logger.trace('Received connectivity probe connection from ' + serverSocket.getRemoteAddress())
                     } else {
                         this.attachHandshaker(connection)
                     }
@@ -111,13 +122,13 @@ export class WebSocketConnector implements IWebSocketConnectorService {
                     this.attachHandshaker(connection)
                 }
             })
-            const port = await this.webSocketServer.start(this.portRange!, this.tlsCertificate)
+            const port = await this.webSocketServer.start()
             this.selectedPort = port
             this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.tlsCertificate !== undefined, this.host)
         }
     }
 
-    public async checkConnectivity(reattempt = 0): Promise<ConnectivityResponse> {
+    public async checkConnectivity(): Promise<ConnectivityResponse> {
         // TODO: this could throw if the server is not running
         const noServerConnectivityResponse: ConnectivityResponse = {
             openInternet: false,
@@ -127,35 +138,47 @@ export class WebSocketConnector implements IWebSocketConnectorService {
         if (this.destroyed) {
             return noServerConnectivityResponse
         }
-        try {
-            if (!this.webSocketServer) {
-                // If no websocket server, return openInternet: false
-                return noServerConnectivityResponse
-            } else {
-                if (!this.entrypoints || this.entrypoints.length < 1) {
-                    // return connectivity info given in config
-                    const preconfiguredConnectivityResponse: ConnectivityResponse = {
-                        openInternet: true,
-                        host: this.host!,
-                        natType: NatType.OPEN_INTERNET,
-                        websocket: { host: this.host!, port: this.selectedPort!, tls: this.tlsCertificate !== undefined }
-                    }
-                    return preconfiguredConnectivityResponse
+        for (const reattempt of range(ENTRY_POINT_CONNECTION_ATTEMPTS)) {
+            const entryPoint = sample(this.entrypoints)!
+            try {
+                if (!this.webSocketServer) {
+                    // If no websocket server, return openInternet: false
+                    return noServerConnectivityResponse
                 } else {
-                    // Do real connectivity checking     
-                    return await this.connectivityChecker!.sendConnectivityRequest(sample(this.entrypoints)!)
+                    if (!this.entrypoints || this.entrypoints.length < 1) {
+                        // return connectivity info given in config
+                        const preconfiguredConnectivityResponse: ConnectivityResponse = {
+                            openInternet: true,
+                            host: this.host!,
+                            natType: NatType.OPEN_INTERNET,
+                            websocket: { host: this.host!, port: this.selectedPort!, tls: this.tlsCertificate !== undefined }
+                        }
+                        return preconfiguredConnectivityResponse
+                    } else {
+                        // Do real connectivity checking     
+                        return await this.connectivityChecker!.sendConnectivityRequest(entryPoint)
+                    }
+                }
+            } catch (err) {
+                if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
+                    const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.kademliaId)} ` 
+                        + `and URL ${connectivityMethodToWebSocketUrl(entryPoint.websocket!)}`
+                    logger.error(error, { error: err })
+                    await wait(2000)
                 }
-            }
-        } catch (err) {
-            if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
-                logger.error('Failed to connect to the entrypoint', { error: err })
-                await wait(2000)
-                return this.checkConnectivity(reattempt + 1)
-            } else {
-                throw err
             }
         }
+        throw Error(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
+    }
 
+    public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
+        if (this.ownPeerDescriptor!.websocket !== undefined) {
+            return (targetPeerDescriptor.type !== NodeType.BROWSER) || canOpenConnectionFromBrowser(this.ownPeerDescriptor!.websocket)
+        } else if (targetPeerDescriptor.websocket !== undefined) {
+            return (this.ownPeerDescriptor!.type !== NodeType.BROWSER) || canOpenConnectionFromBrowser(targetPeerDescriptor.websocket)
+        } else {
+            return false
+        }
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
@@ -194,7 +217,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
         }
     }
 
-    public requestConnectionFromPeer(ownPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+    private requestConnectionFromPeer(ownPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
         setImmediate(() => {
             const remoteConnector = new RemoteWebSocketConnector(
                 targetPeerDescriptor,
@@ -215,7 +238,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
 
         if (this.ongoingConnectRequests.has(peerId.toKey())) {
             const ongoingConnectReguest = this.ongoingConnectRequests.get(peerId.toKey())!
-            ongoingConnectReguest.attachImplementation(serverWebSocket, peerDescriptor)
+            ongoingConnectReguest.attachImplementation(serverWebSocket)
             ongoingConnectReguest.acceptHandshake()
             this.ongoingConnectRequests.delete(peerId.toKey())
         } else {
@@ -224,7 +247,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
 
             managedConnection.setPeerDescriptor(peerDescriptor)
 
-            if (this.incomingConnectionCallback(managedConnection)) {
+            if (this.onIncomingConnection(managedConnection)) {
                 managedConnection.acceptHandshake()
             } else {
                 managedConnection.rejectHandshake('Duplicate connection')
@@ -251,14 +274,14 @@ export class WebSocketConnector implements IWebSocketConnectorService {
     }
 
     // IWebSocketConnectorService implementation
-    public async requestConnection(request: WebSocketConnectionRequest, _context: ServerCallContext): Promise<WebSocketConnectionResponse> {
+    public async requestConnection(request: WebSocketConnectionRequest): Promise<WebSocketConnectionResponse> {
         if (!this.destroyed && this.canConnectFunction(request.requester!, request.ip, request.port)) {
             setImmediate(() => {
                 if (this.destroyed) {
                     return
                 }
                 const connection = this.connect(request.requester!)
-                this.incomingConnectionCallback(connection)
+                this.onIncomingConnection(connection)
             })
             const res: WebSocketConnectionResponse = {
                 accepted: true

package/src/connection/WebSocket/WebSocketServer.ts

@@ -22,17 +22,33 @@ const logger = new Logger(module)
 
 declare class NodeJsWsServer extends WsServer { }
 
+interface WebSocketServerConfig {
+    portRange: PortRange
+    tlsCertificate?: TlsCertificate
+    maxMessageSize?: number
+}
+
 export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
 
     private httpServer?: HttpServer | HttpsServer
     private wsServer?: WsServer
     private readonly abortController = new AbortController()
+    private readonly portRange: PortRange
+    private readonly tlsCertificate?: TlsCertificate
+    private readonly maxMessageSize: number
+
+    constructor(config: WebSocketServerConfig) {
+        super()
+        this.portRange = config.portRange
+        this.tlsCertificate = config.tlsCertificate
+        this.maxMessageSize = config.maxMessageSize ?? 1048576
+    }
 
-    public async start(portRange: PortRange, tlsCertificate?: TlsCertificate): Promise<number> {
-        const ports = range(portRange.min, portRange.max + 1)
+    public async start(): Promise<number> {
+        const ports = range(this.portRange.min, this.portRange.max + 1)
         for (const port of ports) {
             try {
-                await asAbortable(this.startServer(port, tlsCertificate), this.abortController.signal)
+                await asAbortable(this.startServer(port, this.tlsCertificate), this.abortController.signal)
                 return port
             } catch (err) {
                 if (err.originalError?.code === 'EADDRINUSE') {
@@ -42,7 +58,7 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
                 }
             }
         }
-        throw new WebSocketServerStartError(`Failed to start WebSocket server on any port in range: ${portRange.min}-${portRange.min}`)
+        throw new WebSocketServerStartError(`Failed to start WebSocket server on any port in range: ${this.portRange.min}-${this.portRange.min}`)
     }
 
     private startServer(port: number, tlsCertificate?: TlsCertificate): Promise<void> {
@@ -60,14 +76,14 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
                 : 
                 createHttpServer(requestListener)
 
-            function originIsAllowed(_uorigin: string) {
+            function originIsAllowed() {
                 return true
             }
 
             this.wsServer = this.createWsServer(this.httpServer)
             
             this.wsServer.on('request', (request) => {
-                if (!originIsAllowed(request.origin)) {
+                if (!originIsAllowed()) {
                     // Make sure we only accept requests from an allowed origin
                     request.reject()
                     logger.trace('IConnection from origin ' + request.origin + ' rejected.')
@@ -115,12 +131,14 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
         if (typeof NodeJsWsServer !== 'undefined') {
             return new NodeJsWsServer({
                 httpServer,
-                autoAcceptConnections: false
+                autoAcceptConnections: false,
+                maxReceivedMessageSize: this.maxMessageSize
             })
         } else {
             return this.wsServer = new WsServer({
                 httpServer,
-                autoAcceptConnections: false
+                autoAcceptConnections: false,
+                maxReceivedMessageSize: this.maxMessageSize
             })
         }
     }