@epicgames-ps/lib-pixelstreamingsignalling-ue5.8 0.2.0 → 0.2.1

package/src/StreamerConnection.ts

@@ -179,7 +179,13 @@ export class StreamerConnection extends EventEmitter implements IStreamer, LogUt
             }
             const player = this.server.playerRegistry.get(message.playerId);
             if (player) {
-                player.protocol.disconnect(1011, message.reason);
+                // ws throws on a reason over 123 bytes or one that is not a string, which would crash the
+                // server. Such a reason is dropped; the player is still closed.
+                const reason =
+                    typeof message.reason === 'string' && Buffer.byteLength(message.reason) <= 123
+                        ? message.reason
+                        : undefined;
+                player.protocol.disconnect(1011, reason);
             }
         }
     }

package/src/StreamerRegistry.test.ts

@@ -0,0 +1,27 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type WebSocket from 'ws';
+import { Messages } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { StreamerConnection } from './StreamerConnection';
+import { StreamerRegistry } from './StreamerRegistry';
+import { SignallingServer } from './SignallingServer';
+
+// A streamer the registry can add and talk to, with no socket behind it.
+function unconnectedStreamer(): StreamerConnection {
+    return new StreamerConnection({} as unknown as SignallingServer, {} as unknown as WebSocket);
+}
+
+describe('StreamerRegistry endpointId handling', () => {
+    it('treats a non-string id as no id, so a later registration still works', () => {
+        const registry = new StreamerRegistry();
+        const first = unconnectedStreamer();
+        registry.add(first);
+
+        // The id arrives as any JSON value; a number here used to be stored as the streamer id.
+        first.protocol.emit(Messages.endpointId.typeName, { type: Messages.endpointId.typeName, id: 5 });
+        expect(typeof first.streamerId).toBe('string');
+
+        const second = unconnectedStreamer();
+        expect(() => registry.add(second)).not.toThrow();
+        expect(second.streamerId).not.toBe(first.streamerId);
+    });
+});

package/src/StreamerRegistry.ts

@@ -176,8 +176,12 @@ export class StreamerRegistry extends EventEmitter {
     private onEndpointId(streamer: IStreamer, message: Messages.endpointId): void {
         const oldId = streamer.streamerId;
 
+        // The id arrives as any JSON value. A non-string one is treated as no id, because sanitizing it
+        // would store a value that later lookups cannot handle.
+        const requestedId = typeof message.id === 'string' ? message.id : '';
+
         // id might conflict or be invalid so here we sanitize it
-        const sanitizedId = this.sanitizeStreamerId(message.id);
+        const sanitizedId = this.sanitizeStreamerId(requestedId);
 
         let committedId: string | null = sanitizedId;
         if (this.authorizeStreamerId) {
@@ -185,9 +189,9 @@ export class StreamerRegistry extends EventEmitter {
             // reject the registration entirely. This is where anti-squatting policy lives.
             committedId = this.authorizeStreamerId({
                 streamer,
-                requestedId: message.id,
+                requestedId,
                 sanitizedId,
-                collided: !!message.id && sanitizedId !== message.id
+                collided: !!requestedId && sanitizedId !== requestedId
             });
 
             if (committedId === null) {

package/src/Utils.test.ts

@@ -0,0 +1,31 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import { MAX_LOGGED_LENGTH, limitLogText, limitLoggedMessage } from './Utils';
+
+describe('limitLogText', () => {
+    it('returns text up to the limit unchanged', () => {
+        const text = 'a'.repeat(MAX_LOGGED_LENGTH);
+        expect(limitLogText(text)).toBe(text);
+    });
+
+    it('cuts longer text to the limit and gives its full length', () => {
+        const text = 'a'.repeat(MAX_LOGGED_LENGTH + 1);
+        expect(limitLogText(text)).toBe(
+            `${'a'.repeat(MAX_LOGGED_LENGTH)}... (${MAX_LOGGED_LENGTH + 1} characters)`
+        );
+    });
+});
+
+describe('limitLoggedMessage', () => {
+    it('returns a message whose JSON fits as the message itself', () => {
+        const message = { type: 'ping', time: 1 };
+        expect(limitLoggedMessage(message)).toBe(message);
+    });
+
+    it('returns a message whose JSON is too long as its JSON text, cut', () => {
+        const message = { type: 'ping', pad: 'a'.repeat(MAX_LOGGED_LENGTH) };
+        const json = JSON.stringify(message);
+        expect(limitLoggedMessage(message)).toBe(
+            `${json.slice(0, MAX_LOGGED_LENGTH)}... (${json.length} characters)`
+        );
+    });
+});

package/src/Utils.ts

@@ -14,3 +14,28 @@ export function stringify(obj: any): string {
 export function beautify(obj: any): string {
     return jsonc.stringify(obj, undefined, '\t');
 }
+
+/**
+ * The longest text, or protocol message as JSON, that the logger writes whole. A client chooses the
+ * size of what it sends, so anything longer is cut rather than written to the log in full.
+ */
+export const MAX_LOGGED_LENGTH = 16 * 1024;
+
+/**
+ * Returns the text, or if it is longer than MAX_LOGGED_LENGTH, its start and its full length.
+ */
+export function limitLogText(text: string): string {
+    if (text.length <= MAX_LOGGED_LENGTH) {
+        return text;
+    }
+    return `${text.slice(0, MAX_LOGGED_LENGTH)}... (${text.length} characters)`;
+}
+
+/**
+ * Returns a protocol message as the log file should hold it: the message itself while its JSON fits in
+ * MAX_LOGGED_LENGTH, otherwise its JSON text cut by limitLogText.
+ */
+export function limitLoggedMessage(message: object): object | string {
+    const text = JSON.stringify(message);
+    return text.length <= MAX_LOGGED_LENGTH ? message : limitLogText(text);
+}