hm-simulator 1.1.0 → 1.2.0

package/lib/servers.js

@@ -1,8 +1,11 @@
 'use strict';
 
 const {EventEmitter} = require('node:events');
+const net = require('node:net');
+const {Duplex, PassThrough} = require('node:stream');
 
 const binrpc = require('binrpc');
+const binrpcProtocol = require('binrpc/lib/protocol.js');
 const xmlrpc = require('homematic-xmlrpc');
 
 const {encodeResponse, encodeFault} = require('./binrpc-codec.js');
@@ -35,9 +38,16 @@ function createBinrpcServer({host, port, dispatch, onListening, onError}) {
             return;
         }
 
-        dispatch(method, params, (fault, result) => {
-            socket.write(fault ? encodeFault(fault) : encodeResponse(result));
-        });
+        dispatch(
+            method,
+            params,
+            (fault, result) => {
+                if (!socket.destroyed) {
+                    socket.write(fault ? encodeFault(fault) : encodeResponse(result));
+                }
+            },
+            {socket},
+        );
     };
 
     server.on('error', (error) => {
@@ -61,6 +71,22 @@ function unauthorized(response, realm) {
     response.end('Unauthorized');
 }
 
+const LATIN1 = /^(iso-?8859-1|latin-?1|l1|us-ascii|windows-1252|cp1252)$/i;
+
+/**
+ * An XML-RPC request body as UTF-8: converted from ISO-8859-1 when the Content-Type header or the
+ * XML declaration says so, as it is.
+ * @param {Buffer} body
+ * @param {string} [contentType]
+ * @returns {Buffer}
+ */
+function toUtf8(body, contentType) {
+    const header = /charset=["']?([\w-]+)/i.exec(contentType || '');
+    const prolog = /^\s*<\?xml[^>]*encoding=["']([\w-]+)["']/i.exec(body.subarray(0, 200).toString('latin1'));
+    const charset = (prolog && prolog[1]) || (header && header[1]);
+    return charset && LATIN1.test(charset) ? Buffer.from(body.toString('latin1'), 'utf8') : body;
+}
+
 /**
  * xmlrpc server, optionally with TLS and/or HTTP basic auth.
  *
@@ -79,7 +105,7 @@ function unauthorized(response, realm) {
  * @param {function} [options.onListening]
  * @returns {object} the homematic-xmlrpc Server instance
  */
-function createXmlrpcServer({host, port, dispatch, tls, auth, path, onListening, onError}) {
+function createXmlrpcServer({host, port, dispatch, tls, auth, path, onListening, onError, listen = true}) {
     const serverOptions = tls ? {host, port, ...tls} : {host, port};
     const listening = () => {
         if (typeof onListening === 'function') {
@@ -90,21 +116,64 @@ function createXmlrpcServer({host, port, dispatch, tls, auth, path, onListening,
         ? xmlrpc.createSecureServer(serverOptions, listening)
         : xmlrpc.createServer(serverOptions, listening);
 
+    if (!listen) {
+        // the connections come from createDualServer, see there; homematic-xmlrpc listens on the
+        // next tick, so this is in time
+        server.httpServer.listen = function () {
+            return this;
+        };
+    }
+
     server.listenerCount = function (eventName) {
         return INTERNAL_EVENTS.has(eventName) ? EventEmitter.prototype.listenerCount.call(this, eventName) : 1;
     };
 
+    // homematic-xmlrpc reads every request as UTF-8, but the interface processes speak ISO-8859-1
+    // and so do clients that talk to them (openccu-lite's lite-rpc proxy sends it declared in the
+    // prolog): the body is read here and handed on as UTF-8. It also emits the method call
+    // synchronously from the body's 'end'; a listener registered before its own runs first and
+    // tells the dispatch which connection the call came on.
+    let current = null;
+    const httpServer = server.httpServer;
+    const [handleRequest] = httpServer.listeners('request');
+    httpServer.removeAllListeners('request');
+    httpServer.on('request', (request, response) => {
+        const chunks = [];
+        request.on('data', (chunk) => chunks.push(chunk));
+        request.on('end', () => {
+            const body = new PassThrough();
+            Object.assign(body, {
+                headers: request.headers,
+                url: request.url,
+                method: request.method,
+                socket: request.socket,
+            });
+            body.once('end', () => {
+                current = {socket: request.socket};
+            });
+            handleRequest(body, response);
+            body.end(toUtf8(Buffer.concat(chunks), request.headers['content-type']));
+        });
+    });
+
     const originalEmit = server.emit;
     server.emit = function (eventName, ...args) {
         if (!INTERNAL_EVENTS.has(eventName) && args.length === 3 && typeof args[2] === 'function') {
             const [, params, callback] = args;
-            dispatch(eventName, params || [], (fault, result) => {
-                if (fault) {
-                    callback({faultCode: fault.faultCode, faultString: fault.faultString});
-                } else {
-                    callback(null, result === undefined ? '' : result);
-                }
-            });
+            const context = current || {};
+            current = null;
+            dispatch(
+                eventName,
+                params || [],
+                (fault, result) => {
+                    if (fault) {
+                        callback({faultCode: fault.faultCode, faultString: fault.faultString});
+                    } else {
+                        callback(null, result === undefined ? '' : result);
+                    }
+                },
+                context,
+            );
             return true;
         }
 
@@ -119,7 +188,6 @@ function createXmlrpcServer({host, port, dispatch, tls, auth, path, onListening,
     });
 
     if (auth || path) {
-        const httpServer = server.httpServer;
         const [handleMethodCall] = httpServer.listeners('request');
         httpServer.removeAllListeners('request');
         const expected = auth
@@ -147,4 +215,185 @@ function createXmlrpcServer({host, port, dispatch, tls, auth, path, onListening,
     return server;
 }
 
-module.exports = {createBinrpcServer, createXmlrpcServer};
+/**
+ * Reads BIN-RPC requests from one connection and answers them, as binrpc's server does, but with
+ * the simulator's own encoder so that a fault goes out as message type 0xff.
+ *
+ * @param {net.Socket} socket
+ * @param {function} dispatch (method, params, callback) - callback(fault, result)
+ * @param {Buffer} [first] bytes already read from the socket
+ */
+function serveBinrpc(socket, dispatch, first) {
+    let receiver = Buffer.alloc(0);
+
+    const receive = (data) => {
+        receiver = Buffer.concat([receiver, data]);
+        while (receiver.length >= 8) {
+            const length = receiver.readUInt32BE(4);
+            if (receiver.length < length + 8) {
+                return;
+            }
+            const message = receiver.subarray(0, length + 8);
+            receiver = receiver.subarray(length + 8);
+
+            let request;
+            try {
+                request = binrpcProtocol.decodeRequest(message);
+            } catch {
+                request = undefined;
+            }
+            const method = request && request.method;
+            if (typeof method !== 'string' || method === '') {
+                socket.write(encodeResponse(''));
+                continue;
+            }
+            dispatch(
+                method,
+                request.params || [],
+                (fault, result) => {
+                    if (!socket.destroyed) {
+                        socket.write(fault ? encodeFault(fault) : encodeResponse(result));
+                    }
+                },
+                {socket},
+            );
+        }
+    };
+
+    socket.on('data', receive);
+    if (first) {
+        receive(first);
+    }
+}
+
+/**
+ * A duplex stream over a socket that first yields `head`, the bytes already read from it.
+ * @param {net.Socket} socket
+ * @param {Buffer} head
+ * @returns {Duplex}
+ */
+function replay(socket, head) {
+    const stream = new Duplex({
+        read() {
+            socket.resume();
+        },
+        write(chunk, encoding, callback) {
+            socket.write(chunk, encoding, callback);
+        },
+        final(callback) {
+            socket.end();
+            callback();
+        },
+        destroy(error, callback) {
+            socket.destroy();
+            callback(error);
+        },
+    });
+    stream.push(head);
+    socket.on('data', (data) => {
+        if (!stream.push(data)) {
+            socket.pause();
+        }
+    });
+    socket.on('end', () => stream.push(null));
+    socket.on('close', () => stream.destroy());
+    return stream;
+}
+
+/** First bytes of a BIN-RPC message, and of a TLS handshake record. */
+const BIN = Buffer.from('Bin', 'ascii');
+const TLS_HANDSHAKE = 0x16;
+
+/**
+ * rfd's and hs485d's port: BIN-RPC and XML-RPC on the same port, as on a CCU.
+ *
+ * A connection whose first bytes are `Bin` is BIN-RPC; anything else is handed to an HTTP server
+ * running the XML-RPC dispatch - with `tls` an HTTPS server, and a connection that does not start
+ * with a TLS handshake is closed. BIN-RPC stays plain, and basic auth applies to the XML-RPC half
+ * only: BIN-RPC has no such thing.
+ *
+ * @param {object} options as createXmlrpcServer, plus
+ * @param {string[]} [options.protocols=['binrpc', 'xmlrpc']] what this port answers
+ * @returns {{server: net.Server, close: function(): Promise<void>, on: function}} an emitter with
+ *          `server` (the net server) and `close()`, like the other two server kinds
+ */
+function createDualServer({host, port, dispatch, tls, auth, onListening, onError, protocols}) {
+    const accepts = new Set(protocols || ['binrpc', 'xmlrpc']);
+    const emitter = new EventEmitter();
+    const connections = new Set();
+
+    const xmlrpcServer = (secure) =>
+        createXmlrpcServer({host, port: 0, dispatch, tls: secure ? tls : null, auth, listen: false});
+    // with tls the XML-RPC half is HTTPS only, as the simulator's xmlrpc servers are
+    const http = accepts.has('xmlrpc') && !tls ? xmlrpcServer(false) : null;
+    const https = accepts.has('xmlrpc') && tls ? xmlrpcServer(true) : null;
+
+    const server = net.createServer((socket) => {
+        connections.add(socket);
+        socket.on('close', () => connections.delete(socket));
+        socket.on('error', () => {});
+
+        let head = Buffer.alloc(0);
+        const sniff = (data) => {
+            head = Buffer.concat([head, data]);
+            if (head.length < BIN.length && BIN.subarray(0, head.length).equals(head)) {
+                // could still be "Bin": wait for more
+                return;
+            }
+            socket.removeListener('data', sniff);
+
+            if (head.subarray(0, BIN.length).equals(BIN)) {
+                if (accepts.has('binrpc')) {
+                    serveBinrpc(socket, dispatch, head);
+                } else {
+                    socket.destroy();
+                }
+                return;
+            }
+
+            if (head[0] === TLS_HANDSHAKE && https) {
+                // a TLS socket reads from the connection's handle, past anything unshifted: it
+                // gets a stream that starts with the bytes already read
+                https.httpServer.emit('connection', replay(socket, head));
+                return;
+            }
+            if (!http) {
+                socket.destroy();
+                return;
+            }
+            socket.pause();
+            socket.unshift(head);
+            http.httpServer.emit('connection', socket);
+            socket.resume();
+        };
+        socket.on('data', sniff);
+    });
+
+    server.on('error', (error) => {
+        if (emitter.listenerCount('error') > 0) {
+            emitter.emit('error', error);
+        }
+        if (typeof onError === 'function') {
+            onError(error);
+        }
+    });
+
+    server.listen(port, host, () => {
+        emitter.emit('listening');
+        if (typeof onListening === 'function') {
+            onListening(emitter);
+        }
+    });
+
+    emitter.server = server;
+    emitter.close = () =>
+        new Promise((resolve) => {
+            server.close(() => resolve());
+            for (const socket of connections) {
+                socket.destroy();
+            }
+        });
+    return emitter;
+}
+
+module.exports = {createBinrpcServer, createXmlrpcServer, createDualServer};