webrtc: fix google device access leaks?

Author: koush

plugins/webrtc/package-lock.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/webrtc",
-   "version": "0.2.24",
+   "version": "0.2.25",
    "scripts": {
       "scrypted-setup-project": "scrypted-setup-project",
       "prescrypted-setup-project": "scrypted-package-json",

plugins/webrtc/package.json

@@ -6,7 +6,7 @@ import { createBrowserSignalingSession } from "@scrypted/common/src/rtc-connect"
 import { legacyGetSignalingSessionOptions } from '@scrypted/common/src/rtc-signaling';
 import { SettingsMixinDeviceBase, SettingsMixinDeviceOptions } from '@scrypted/common/src/settings-mixin';
 import { createZygote } from '@scrypted/common/src/zygote';
-import sdk, { BufferConverter, ConnectOptions, DeviceCreator, DeviceCreatorSettings, DeviceProvider, FFmpegInput, HttpRequest, Intercom, MediaObject, MediaObjectOptions, MixinProvider, RTCSessionControl, RTCSignalingChannel, RTCSignalingClient, RTCSignalingOptions, RTCSignalingSession, RequestMediaStream, RequestMediaStreamOptions, ResponseMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, SettingValue, Settings, VideoCamera, WritableDeviceState } from '@scrypted/sdk';
+import sdk, { BufferConverter, ConnectOptions, DeviceCreator, DeviceCreatorSettings, DeviceProvider, FFmpegInput, HttpRequest, Intercom, MediaObject, MediaObjectOptions, MixinProvider, RTCSessionControl, RTCSignalingChannel, RTCSignalingClient, RTCSignalingOptions, RTCSignalingSession, RequestMediaStream, RequestMediaStreamOptions, ResponseMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, ScryptedNativeId, Setting, SettingValue, Settings, VideoCamera, WritableDeviceState } from '@scrypted/sdk';
 import { StorageSettings } from '@scrypted/sdk/storage-settings';
 import crypto from 'crypto';
 import ip from 'ip';
@@ -19,7 +19,7 @@ import { waitClosed } from './peerconnection-util';
 import { WebRTCCamera } from "./webrtc-camera";
 import { MediaStreamTrack, PeerConfig, RTCPeerConnection, defaultPeerConfig } from './werift';
 import { WeriftSignalingSession } from './werift-signaling-session';
-import { createRTCPeerConnectionSource, getRTCMediaStreamOptions } from './wrtc-to-rtsp';
+import { RTCPeerConnectionPipe, createRTCPeerConnectionSource, getRTCMediaStreamOptions } from './wrtc-to-rtsp';
 
 const { mediaManager, systemManager, deviceManager } = sdk;
 
@@ -154,15 +154,29 @@ class WebRTCMixin extends SettingsMixinDeviceBase<RTCSignalingClient & VideoCame
             return this.mixinDevice.getVideoStream(options);
         }
 
-        const { intercom, mediaObject, pcClose } = await createRTCPeerConnectionSource({
-            console: this.console,
+        const result = zygote();
+        this.plugin.activeConnections++;
+        result.worker.on('exit', () => {
+            this.plugin.activeConnections--;
+        });
+
+        const fork = await result.result;
+
+        const { getIntercom, mediaObject, pcClose } = await fork.createRTCPeerConnectionSource({
+            __json_copy_serialize_children: true,
+            nativeId: this.nativeId,
+            mixinId: this.id,
             mediaStreamOptions: this.createVideoStreamOptions(),
-            channel: this.mixinDevice,
+            startRTCSignalingSession: (session) => this.mixinDevice.startRTCSignalingSession(session),
             maximumCompatibilityMode: this.plugin.storageSettings.values.maximumCompatibilityMode,
         });
 
-        this.webrtcIntercom = intercom;
-        pcClose.finally(() => this.webrtcIntercom = undefined);
+        this.webrtcIntercom = getIntercom();
+        const pcc = pcClose();
+        pcc.finally(() => {
+            this.webrtcIntercom = undefined;
+            result.worker.terminate();
+        });
 
         return mediaObject;
     }
@@ -594,6 +608,23 @@ function handleCleanupConnection(cleanup: Deferred<string>, connection: WebRTCCo
 
 export async function fork() {
     return {
+        async createRTCPeerConnectionSource(options: {
+            __json_copy_serialize_children: true,
+            mixinId: string,
+            nativeId: ScryptedNativeId,
+            mediaStreamOptions: ResponseMediaStreamOptions,
+            startRTCSignalingSession: (session: RTCSignalingSession) => Promise<RTCSessionControl | undefined>,
+            maximumCompatibilityMode: boolean,
+        }): Promise<RTCPeerConnectionPipe> {
+            return createRTCPeerConnectionSource({
+                nativeId: this.nativeId,
+                mixinId: options.mixinId,
+                mediaStreamOptions: options.mediaStreamOptions,
+                startRTCSignalingSession: (session) => options.startRTCSignalingSession(session),
+                maximumCompatibilityMode: options.maximumCompatibilityMode,
+            });
+        },
+
         async createConnection(message: any,
             port: number,
             clientSession: RTCSignalingSession,

plugins/webrtc/src/main.ts

@@ -29,15 +29,17 @@ export class WebRTCCamera extends ScryptedDeviceBase implements VideoCamera, RTC
     async getVideoStream(options?: RequestMediaStreamOptions): Promise<MediaObject> {
         const mediaStreamOptions = getRTCMediaStreamOptions('webrtc', 'WebRTC');
 
-        const { mediaObject, intercom } = await createRTCPeerConnectionSource({
-            console: this.console,
+        // todo: sdk.fork
+        const { mediaObject, getIntercom } = await createRTCPeerConnectionSource({
+            mixinId: undefined,
+            nativeId: this.nativeId,
             mediaStreamOptions,
-            channel: this,
+            startRTCSignalingSession: session => this.startRTCSignalingSession(session),
             maximumCompatibilityMode: this.plugin.storageSettings.values.maximumCompatibilityMode,
         });
 
         this.intercom?.then(intercom => intercom.stopIntercom());
-        this.intercom = intercom;
+        this.intercom = getIntercom();
 
         return mediaObject;
     }

plugins/webrtc/src/webrtc-camera.ts

@@ -2,7 +2,7 @@ import { Deferred } from "@scrypted/common/src/deferred";
 import { listenZeroSingleClient } from "@scrypted/common/src/listen-cluster";
 import { getNaluTypesInNalu, RtspServer } from "@scrypted/common/src/rtsp-server";
 import { createSdpInput, parseSdp } from '@scrypted/common/src/sdp-utils';
-import sdk, { FFmpegInput, Intercom, MediaObject, MediaStreamUrl, ResponseMediaStreamOptions, RTCAVSignalingSetup, RTCSessionControl, RTCSignalingChannel, RTCSignalingOptions, RTCSignalingSendIceCandidate, RTCSignalingSession, ScryptedMimeTypes } from "@scrypted/sdk";
+import sdk, { FFmpegInput, Intercom, MediaObject, MediaStreamUrl, ResponseMediaStreamOptions, RTCAVSignalingSetup, RTCSessionControl, RTCSignalingChannel, RTCSignalingOptions, RTCSignalingSendIceCandidate, RTCSignalingSession, ScryptedMimeTypes, ScryptedNativeId } from "@scrypted/sdk";
 import { FullIntraRequest } from "../../../external/werift/packages/rtp/src/rtcp/psfb/fullIntraRequest";
 import { logConnectionState, waitClosed, waitConnected, waitIceConnected } from "./peerconnection-util";
 import { startRtpForwarderProcess } from "./rtp-forwarders";
@@ -13,9 +13,10 @@ import { createRawResponse, getWeriftIceServers, isPeerConnectionAlive, logIsLoc
 const { mediaManager } = sdk;
 
 export interface RTCPeerConnectionPipe {
+    __json_copy_serialize_children: true,
     mediaObject: MediaObject;
-    intercom: Promise<Intercom>;
-    pcClose: Promise<unknown>;
+    getIntercom(): Promise<Intercom>;
+    pcClose(): Promise<unknown>;
 }
 
 function ignoreDeferred(...d: Deferred<any>[]) {
@@ -27,12 +28,14 @@ function ignorePromise(...p: Promise<any>[]) {
 }
 
 export async function createRTCPeerConnectionSource(options: {
-    console: Console,
+    mixinId: string,
+    nativeId: ScryptedNativeId,
     mediaStreamOptions: ResponseMediaStreamOptions,
-    channel: RTCSignalingChannel,
+    startRTCSignalingSession: (session: RTCSignalingSession) => Promise<RTCSessionControl | undefined>,
     maximumCompatibilityMode: boolean,
 }): Promise<RTCPeerConnectionPipe> {
-    const { mediaStreamOptions, channel, console, maximumCompatibilityMode } = options;
+    const { mediaStreamOptions, startRTCSignalingSession, mixinId, nativeId, maximumCompatibilityMode } = options;
+    const console = mixinId ? sdk.deviceManager.getMixinConsole(mixinId, nativeId) : sdk.deviceManager.getDeviceConsole(nativeId);
 
     const { clientPromise, port } = await listenZeroSingleClient();
 
@@ -45,9 +48,9 @@ export async function createRTCPeerConnectionSource(options: {
 
     const cleanup = () => {
         console.log('webrtc/rtsp cleaning up');
-        clientPromise.then(client => client.destroy()).catch(() => {});
-        sessionControl.promise.then(sc => sc.endSession()).catch(() => {});
-        peerConnection.promise.then(pc => pc.close()).catch(() => {});
+        clientPromise.then(client => client.destroy()).catch(() => { });
+        sessionControl.promise.then(sc => sc.endSession()).catch(() => { });
+        peerConnection.promise.then(pc => pc.close()).catch(() => { });
         ignorePromise(intercom.promise.then(intercom => intercom.stopIntercom()));
     };
 
@@ -74,6 +77,8 @@ export async function createRTCPeerConnectionSource(options: {
                 iceServers: getWeriftIceServers(setup.configuration),
             });
 
+            waitClosed(ret).then(() => cleanup());
+
             logConnectionState(console, ret);
             peerConnection.resolve(ret);
 
@@ -101,6 +106,8 @@ export async function createRTCPeerConnectionSource(options: {
             let gotVideo = false;
 
             const pc = await peerConnection.promise;
+            const timeout = setTimeout(() => cleanup(), 2 * 60 * 1000);
+            waitClosed(pc).then(() => clearTimeout(timeout));
 
             const setupAudioTranscevier = (transciever: RTCRtpTransceiver) => {
                 audioTransceiver = transciever;
@@ -135,6 +142,7 @@ export async function createRTCPeerConnectionSource(options: {
                     track.onReceiveRtcp.subscribe(rtp => rtspServer.sendTrack(videoTrack, rtp.serialize(), true));
 
                     track.onReceiveRtp.once(() => {
+                        clearTimeout(timeout);
                         let firSequenceNumber = 0;
                         const pictureLossInterval = setInterval(() => {
                             // i think this is necessary for older clients like ring
@@ -266,7 +274,7 @@ export async function createRTCPeerConnectionSource(options: {
         }
 
         const session = new SignalingSession();
-        const sc = await channel.startRTCSignalingSession(session);
+        const sc = await startRTCSignalingSession(session);
         sessionControl.resolve(sc);
         console.log('waiting for peer connection');
         const pc = await peerConnection.promise;
@@ -351,9 +359,10 @@ export async function createRTCPeerConnectionSource(options: {
     };
 
     return {
+        __json_copy_serialize_children: true,
         mediaObject: await mediaManager.createMediaObject(mediaStreamUrl, ScryptedMimeTypes.MediaStreamUrl),
-        intercom: intercom.promise,
-        pcClose,
+        getIntercom: () => intercom.promise,
+        pcClose: () => pcClose,
     };
 }