teleportxr 1.0.48 → 1.0.50

package/client/client.js

@@ -11,6 +11,11 @@ const resources= require("../scene/resources.js");
 const { BackgroundMode } = require("../core/core.js");
 
 
+// Maximum number of times an unacknowledged origin/lighting command will be
+// resent before we give up and log a disconnect. With a 3s ack timeout this
+// gives roughly MAX_ACK_RESENDS*3 seconds before we stop trying.
+const MAX_ACK_RESENDS = 5;
+
 class OriginState
 {
     constructor() {
@@ -20,6 +25,8 @@ class OriginState
 		this.acknowledged=false;
 		this.serverTimeSentUs=BigInt(0);
 		this.valid_counter=BigInt(0);
+		this.resendCount=0;
+		this.givenUp=false;
 	}
 };
 
@@ -30,6 +37,8 @@ class LightingState
 		this.acknowledged=false;
 		this.serverTimeSentUs=BigInt(0);
 		this.clientDynamicLighting=new core.ClientDynamicLighting();
+		this.resendCount=0;
+		this.givenUp=false;
 	}
 };
 
@@ -64,9 +73,24 @@ class Client {
 			this.webRtcConnected=false;
 		}
     }
-	receivedMessageReliable(id,data)
+	receivedMessageReliable(id,pkt)
 	{
-		console.log('Client receivedMessage reliable ch.'+id+' received: '+data+'.');
+        var dataView=new DataView(pkt.data,0,1);
+        const messageType=dataView.getUint8(0);
+        switch(messageType){
+            case message.MessagePayloadType.ReceivedResources:
+                this.receiveReceivedResourcesMessage(pkt.data);
+                return;
+			case message.MessagePayloadType.Acknowledgement:
+				this.ReceiveAcknowledgement(pkt.data);
+				return;
+			case message.MessagePayloadType.ControllerPoses:
+				this.ReceiveNodePoses(pkt.data);
+				return;
+            default:
+				console.log('Client receivedMessageReliable ch.'+id+' unknown messageType '+messageType+'.');
+                break;
+        }
 	}
 	// Is the Buffer bf too small to contain a type tp?
 	checkTooSmall(tp,bf) {
@@ -131,8 +155,14 @@ class Client {
 		this.currentOriginState.acknowledged = false;
 		this.currentOriginState.serverTimeSentUs = BigInt(0);
 		this.currentOriginState.ackId = 0;
+		this.currentOriginState.resendCount = 0;
+		this.currentOriginState.givenUp = false;
 		this.currentLightingState = new LightingState();
 		this.setupCommand.float32_draw_distance=10.0;
+		// The C++ client uses startTimestamp_utc_unix_us as the session epoch
+		// against which subsequent message timestamps are measured. Without it
+		// some message handlers will not progress.
+		this.setupCommand.int64_startTimestamp_utc_unix_us = BigInt(core.getStartTimeUnixUs());
 		if(this.scene)
 		{
 			if(this.scene.backgroundTexturePath&&this.scene.backgroundTexturePath!="")
@@ -182,7 +212,14 @@ class Client {
     SendCommand(command){
         let array=core.encodeToUint8Array(command);
         console.log("SendCommand: encoded to", array.length, "bytes, expected", command.size(), "bytes");
-        this.signalingSend(array);
+        // Once the WebRTC reliable data channel is open, route commands through it
+        // (matches the C++ server's sendCommand path). Bootstrap commands sent
+        // before the channel is open (SetupCommand, AcknowledgeHandshakeCommand)
+        // fall back to the signaling WebSocket.
+        if(this.webRtcConnection && this.webRtcConnection.isReliableOpen())
+            this.webRtcConnection.sendReliable(array);
+        else
+            this.signalingSend(array);
     }
     // We call StartStreaming once the SetupCommand has been acknowledged.
     StartStreaming()
@@ -220,10 +257,12 @@ class Client {
 		if(msg.uint64_ackId==this.currentOriginState.ackId)
 		{
 			this.currentOriginState.acknowledged=true;
+			this.currentOriginState.resendCount=0;
 		}
 		if(msg.uint64_ackId==this.currentLightingState.ackId)
 		{
 			this.currentLightingState.acknowledged=true;
+			this.currentLightingState.resendCount=0;
 		}
 	}
 	ReceiveNodePoses(data)
@@ -298,16 +337,16 @@ class Client {
 		{
 			this.SendTexture(uid);
 		}
-		if(!this.currentOriginState.acknowledged)
+		if(!this.currentOriginState.acknowledged && !this.currentOriginState.givenUp)
 			this.SendOrigin();
-		if(!this.currentLightingState.acknowledged)
+		if(!this.currentLightingState.acknowledged && !this.currentLightingState.givenUp)
 			this.SendLighting();
 	}
 	SendOrigin()
 	{
 		let time_now_us=core.getTimestampUs();
 		let originAckWaitTimeUs=BigInt(3000000);// three seconds
-		if(this.setupCommand.startTimestamp_utc_unix_us==0)
+		if(this.setupCommand.int64_startTimestamp_utc_unix_us==BigInt(0))
 		{
 			console.log("Start timestamp is not set, so not sending origin.");
 			return ;
@@ -329,6 +368,18 @@ class Client {
 			console.log("Origin client has is 0, so not sending origin.");
 			return;
 		}
+		// A previous send timed out without an ack. Bound the resend loop so
+		// we don't spam the client forever if it never acknowledges.
+		if(this.currentOriginState.serverTimeSentUs!=BigInt(0))
+		{
+			this.currentOriginState.resendCount++;
+			if(this.currentOriginState.resendCount>MAX_ACK_RESENDS)
+			{
+				console.log("Client "+this.clientID+": gave up resending SetOriginNodeCommand after "+this.currentOriginState.resendCount+" attempts; treating client as disconnected for origin.");
+				this.currentOriginState.givenUp=true;
+				return;
+			}
+		}
 		this.currentOriginState.valid_counter++;
 		this.geometryService.SetOriginNode(this.currentOriginState.originClientHas);
 		var setp=new command.SetOriginNodeCommand();
@@ -350,7 +401,7 @@ class Client {
 	{
 		let time_now_us=core.getTimestampUs();
 		let ackWaitTimeUs=BigInt(3000000);// three seconds
-		if(this.setupCommand.startTimestamp_utc_unix_us==0)
+		if(this.setupCommand.int64_startTimestamp_utc_unix_us==BigInt(0))
 		{
 			console.log("Start timestamp is not set, so not sending lighting.");
 			return;
@@ -367,6 +418,18 @@ class Client {
 			console.log("WebRTC connection is not established, so not sending lighting.");
 			return;
 		}
+		// A previous send timed out without an ack. Bound the resend loop so
+		// we don't spam the client forever if it never acknowledges.
+		if(this.currentLightingState.serverTimeSentUs!=BigInt(0))
+		{
+			this.currentLightingState.resendCount++;
+			if(this.currentLightingState.resendCount>MAX_ACK_RESENDS)
+			{
+				console.log("Client "+this.clientID+": gave up resending SetLightingCommand after "+this.currentLightingState.resendCount+" attempts; treating client as disconnected for lighting.");
+				this.currentLightingState.givenUp=true;
+				return;
+			}
+		}
 
 		var setl					=new command.SetLightingCommand();
 		setl.uint64_ackId			=this.next_ack_id++;

package/connections/webrtcconnection.js

@@ -208,7 +208,13 @@ class WebRtcConnection extends EventEmitter
 				if (this.peerConnection !== pc) return;
 				await pc.setLocalDescription(offer);
 				if (this.peerConnection !== pc) return;
-				var message = '{"teleport-signal-type":"offer","sdp":"'+offer.sdp+'"}'; //
+				// Use pc.localDescription.sdp rather than the createOffer() result: the
+				// ICE ufrag/pwd in the SDP returned by createOffer() are provisional and
+				// libwebrtc may activate a transport with different credentials in
+				// setLocalDescription(), which would cause STUN ufrag check failures on
+				// the remote peer.
+				const localSdp = (pc.localDescription && pc.localDescription.sdp) || offer.sdp;
+				var message = '{"teleport-signal-type":"offer","sdp":"'+localSdp+'"}';
 				this.sendConfigMessage(this.id,message);
 				await this.waitUntilIceGatheringStateComplete(pc, this.options);
 			} catch (error)
@@ -343,12 +349,23 @@ class WebRtcConnection extends EventEmitter
 		this.emit('closed');
 	};
     sendGeometry(buffer) {
-		try {	
+		try {
         	this.geometryDataChannel.send(buffer);
 		}
 		catch(exception) {
             console.error('datachannel.sendGeometry exception: '+exception.message);
 		}
+    }
+	isReliableOpen() {
+		return !!(this.reliableDataChannel && this.reliableDataChannel.readyState === 'open');
+	}
+    sendReliable(buffer) {
+		try {
+			this.reliableDataChannel.send(buffer);
+		}
+		catch(exception) {
+            console.error('datachannel.sendReliable exception: '+exception.message);
+		}
     }
     beforeOffer() {
           

package/package.json

@@ -15,7 +15,7 @@
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"

package/signaling.js

@@ -53,6 +53,7 @@ var webRtcConnectionManager = null;
 var newClient=null;
 var disconnectClient=null;
 var clientHostHeader = ""; // Store the first client's host header for resource URLs
+var clientProtoHeader = ""; // Store the first client's X-Forwarded-Proto header
 function startStreaming(signalingClient) {
     signalingClient.ChangeSignalingState(SignalingState.ACCEPTED);
 	// And we send the WebSockets connect-response.
@@ -185,20 +186,20 @@ function OnWebSocket(ws, req) {
 			signalingClient.ip_addr_port.toString()
 	);
 
-	// Capture the Host header from the first client connection for resource URLs
-	// This allows us to auto-detect the server's public address
+	// Capture the Host and X-Forwarded-Proto headers from the first client connection
+	// for resource URL auto-detection.
 	if (!clientHostHeader && req.headers) {
-		// Try to get the host from headers, preferring X-Forwarded-Host (for reverse proxies)
-		const xForwardedHost = req.headers['x-forwarded-host'];
-		const hostHeader = req.headers['host'];
-		clientHostHeader = xForwardedHost || hostHeader || '';
+		// Prefer X-Forwarded-Host / X-Forwarded-Proto set by a reverse proxy.
+		const xForwardedHost  = req.headers['x-forwarded-host'];
+		const xForwardedProto = req.headers['x-forwarded-proto'];
+		const hostHeader      = req.headers['host'];
+		clientHostHeader  = xForwardedHost  || hostHeader || '';
+		clientProtoHeader = xForwardedProto || '';
 		if (clientHostHeader) {
 			console.log("Auto-detected resource server host from client connection: " + clientHostHeader);
-			if (xForwardedHost) {
-				console.log("  (from X-Forwarded-Host: " + xForwardedHost + ")");
-			} else if (hostHeader) {
-				console.log("  (from Host: " + hostHeader + ")");
-			}
+			if (xForwardedHost)  console.log("  (from X-Forwarded-Host: "  + xForwardedHost  + ")");
+			else                  console.log("  (from Host: "              + hostHeader       + ")");
+			if (xForwardedProto) console.log("  (from X-Forwarded-Proto: " + xForwardedProto + ")");
 		} else {
 			console.log("WARNING: Could not auto-detect host from request headers");
 			console.log("  Available headers: " + JSON.stringify(req.headers));
@@ -300,3 +301,8 @@ exports.signalingClients = signalingClients;
 exports.getClientHostHeader = function () {
 	return clientHostHeader;
 };
+
+// Export function to retrieve the auto-detected X-Forwarded-Proto header
+exports.getClientProtoHeader = function () {
+	return clientProtoHeader;
+};