@scrypted/server 0.56.0 → 0.58.0

package/src/runtime.ts

@@ -1,3 +1,4 @@
+import net from 'net';
 import { Device, DeviceInformation, DeviceProvider, EngineIOHandler, HttpRequest, HttpRequestHandler, ScryptedDevice, ScryptedInterface, ScryptedInterfaceMethod, ScryptedInterfaceProperty, ScryptedNativeId, ScryptedUser as SU } from '@scrypted/types';
 import AdmZip from 'adm-zip';
 import crypto from 'crypto';
@@ -34,6 +35,7 @@ import { getPluginVolume } from './plugin/plugin-volume';
 import { NodeForkWorker } from './plugin/runtime/node-fork-worker';
 import { PythonRuntimeWorker } from './plugin/runtime/python-worker';
 import { RuntimeWorker, RuntimeWorkerOptions } from './plugin/runtime/runtime-worker';
+import { ClusterObject } from './cluster/connect-rpc-object';
 import { getIpAddress, SCRYPTED_INSECURE_PORT, SCRYPTED_SECURE_PORT } from './server-settings';
 import { AddressSettings } from './services/addresses';
 import { Alerts } from './services/alerts';
@@ -43,6 +45,7 @@ import { PluginComponent } from './services/plugin';
 import { ServiceControl } from './services/service-control';
 import { UsersService } from './services/users';
 import { getState, ScryptedStateManager, setState } from './state';
+import { computeClusterObjectHash } from './cluster/cluster-hash';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
@@ -82,6 +85,17 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
             })
         },
     });
+    connectRPCObjectIO: IOServer = new io.Server({
+        pingTimeout: 120000,
+        perMessageDeflate: true,
+        cors: (req, callback) => {
+            const header = this.getAccessControlAllowOrigin(req.headers);
+            callback(undefined, {
+                origin: header,
+                credentials: true,
+            })
+        },
+    });
     pluginComponent = new PluginComponent(this);
     serviceControl = new ServiceControl(this);
     alerts = new Alerts(this);
@@ -120,14 +134,71 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
                 const cp = spawn(process.env.SHELL, [], {
                 });
                 cp.onData(data => connection.send(data));
-                connection.on('message', message => cp.write(message.toString()));
+                connection.on('message', message => {
+                    if (Buffer.isBuffer(message)) {
+                        cp.write(message.toString());
+                        return;
+                    }
+
+                    try {
+                        const parsed = JSON.parse(message.toString());
+                        if (parsed.dim) {
+                            cp.resize(parsed.dim.cols, parsed.dim.rows);
+                        }
+                    } catch (e) {
+                        // we should only get here if an outdated core plugin
+                        // is sending us string data instead of buffer data
+                        cp.write(message.toString());
+                    }
+                });
                 connection.on('close', () => cp.kill());
+                cp.onExit(() => connection.close());
             }
             catch (e) {
                 connection.close();
             }
         });
 
+        app.all('/engine.io/connectRPCObject', (req, res) => this.connectRPCObjectHandler(req, res));
+
+        /*
+        * Handle incoming connections that will be
+        * proxied to a connectRPCObject socket.
+        *
+        * Note that the clusterObject hash must be
+        * verified before connecting to the target port.
+        */
+        this.connectRPCObjectIO.on('connection', connection => {
+            try {
+                const clusterObject: ClusterObject = JSON.parse((connection.request as Request).query.clusterObject as string);
+                const sha256 = computeClusterObjectHash(clusterObject, this.clusterSecret);
+                if (sha256 != clusterObject.sha256) {
+                    connection.send({
+                        error: 'invalid signature'
+                    });
+                    connection.close();
+                    return;
+                }
+
+                const socket = net.connect(clusterObject.port, '127.0.0.1');
+                socket.on('error', () => connection.close());
+                socket.on('close', () => connection.close());
+                socket.on('data', data => connection.send(data));
+                connection.on('close', () => socket.destroy());
+                connection.on('message', message => {
+                    if (typeof message !== 'string') {
+                        socket.write(message);
+                    }
+                    else {
+                        console.warn('unexpected string data on engine.io rpc connection. terminating.')
+                        connection.close();
+                    }
+                });
+            } catch {
+                connection.close();
+            }
+        });
+
         insecure.on('upgrade', (req, socket, upgradeHead) => {
             (req as any).upgradeHead = upgradeHead;
             (app as any).handle(req, {
@@ -262,6 +333,33 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
             this.shellio.handleRequest(req, res);
     }
 
+    async connectRPCObjectHandler(req: Request, res: Response) {
+        const isUpgrade = isConnectionUpgrade(req.headers);
+
+        const end = (code: number, message: string) => {
+            if (isUpgrade) {
+                const socket = res.socket;
+                socket.write(`HTTP/1.1 ${code} ${message}\r\n` +
+                    '\r\n');
+                socket.destroy();
+            }
+            else {
+                res.status(code);
+                res.send(message);
+            }
+        };
+
+        if (!res.locals.username) {
+            end(401, 'Not Authorized');
+            return;
+        }
+
+        if ((req as any).upgradeHead)
+            this.connectRPCObjectIO.handleUpgrade(req, res.socket, (req as any).upgradeHead)
+        else
+            this.connectRPCObjectIO.handleRequest(req, res);
+    }
+
     async getEndpointPluginData(req: Request, endpoint: string, isUpgrade: boolean, isEngineIOEndpoint: boolean): Promise<HttpPluginData> {
         const ret = await this.getPluginForEndpoint(endpoint);
         if (req.url.indexOf('/engine.io/api') !== -1)