@iobroker/socket-classes 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-2022 bluefox <dogafox@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# @iobroker/socket-classes
+
+This library is used for following adapters:
+- [iobroker.admin](https://github.com/ioBroker/ioBroker.admin)
+- [iobroker.cloud](https://github.com/ioBroker/ioBroker.cloud)
+- [iobroker.socketio](https://github.com/ioBroker/ioBroker.socketio)
+- [iobroker.ws](https://github.com/ioBroker/ioBroker.ws)
+- [iobroker.rest-api](https://github.com/ioBroker/ioBroker.rest-api)
+- [iobroker.iot](https://github.com/ioBroker/ioBroker.iot)
+
+## Usage as admin
+```
+const TTL_SEC      = 3600;
+
+const SocketAdmin  = require('./lib/socketAdmin');
+const ws           = require('@iobroker/ws-server');
+const session      = require('express-session');
+const utils 	   = require('@iobroker/adapter-core'); // Get common adapter utils
+const AdapterStore = require(utils.controllerDir + '/lib/session.js')(session, TTL_SEC);
+
+const store = new AdapterStore({adapter});
+
+const io = new SocketAdmin(adapter.config, adapter, objects);
+io.start(
+    server,
+    ws,
+    {
+        userKey: 'connect.sid',
+        store,
+        secret: adapter.config.secret
+    }
+);
+
+// subscribe on all object changes
+io.subscribe('objectChange', '*');
+
+
+// later
+io.close();
+```
+
+## Usage as socket (ws or socketio)
+```
+const TTL_SEC      = 3600;
+
+const ws           = require('@iobroker/ws-server');
+const SocketWS     = require('./lib/socketWS.js');
+const session      = require('express-session');
+const utils 	   = require('@iobroker/adapter-core'); // Get common adapter utils
+const AdapterStore = require(utils.controllerDir + '/lib/session.js')(session, TTL_SEC);
+
+const store = new AdapterStore({adapter});
+
+const settings = adapter.config;
+settings.crossDomain = true;
+settings.ttl = settings.ttl || TTL_SEC;
+
+const io = new SocketWS(settings, adapter);
+io.start(server.server, ws, {userKey: 'connect.sid', checkUser, store, secret: adapter.config.secret});
+
+
+// later
+io.close();
+```
+
+<!--
+	Placeholder for the next version (at the beginning of the line):
+	### **WORK IN PROGRESS**
+-->
+
+## Changelog
+### 0.1.2 (2022-04-24)
+* (bluefox) initial commit
+
+## License
+The MIT License (MIT)
+
+Copyright (c) 2020-2022 Bluefox <dogafox@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/index.js

@@ -0,0 +1,11 @@
+const SocketAdmin = require('./lib/socketAdmin');
+const SocketCommon = require('./lib/socketCommon');
+const SocketCommands = require('./lib/socketCommands');
+const SocketCommandsAdmin = require('./lib/socketCommandsAdmin');
+
+module.exports = {
+    SocketAdmin,
+    SocketCommon,
+    SocketCommands,
+    SocketCommandsAdmin
+};

package/lib/passportSocket.js

@@ -0,0 +1,100 @@
+// Originally taken from here: https://github.com/jfromaniello/passport.socketio/blob/master/lib/index.js
+// Copyright Licensed under the MIT-License. 2012-2013 José F. Romaniello.
+
+function parseCookie(auth, cookieHeader) {
+    const cookieParser = auth.cookieParser(auth.secret);
+    const req = {
+        headers: {
+            cookie: cookieHeader
+        }
+    };
+
+    let result;
+
+    cookieParser(req, {}, err => {
+        if (err) {
+            throw err;
+        }
+        result = req.signedCookies || req.cookies;
+    });
+
+    return result;
+}
+
+function getQuery(url) {
+    const query = url.split('?')[1] || '';
+    const parts = query.split('&');
+    const result = {};
+    for (let p = 0; p < parts.length; p++) {
+        const parts1 = parts[p].split('=');
+        result[parts1[0]] = parts1[1];
+    }
+    return result;
+}
+
+function authorize(options) {
+    const defaults = {
+        key:          'connect.sid',
+        secret:       null,
+        store:        null,
+        userProperty: 'user'
+    };
+
+    const auth = Object.assign({}, defaults, options);
+
+    if (!auth.passport) {
+        throw new Error('passport is required to use require(\'passport\'), please install passport');
+    }
+
+    if (!auth.cookieParser) {
+        throw new Error('cookieParser is required use require(\'cookie-parser\'), connect.cookieParser or express.cookieParser');
+    }
+
+    return function (data, accept) {
+        data.query = getQuery(data.url);
+
+        if (options.checkUser && data.query.user && data.query.pass) {
+            return options.checkUser(data.query.user, data.query.pass, (error, result) => {
+                if (error) {
+                    return auth.fail(data, 'Cannot check user', false, accept);
+                } else if (!result) {
+                    return auth.fail(data, 'User not found', false, accept);
+                } else {
+                    data[auth.userProperty] = result;
+                    data[auth.userProperty].logged_in = true;
+                    auth.success(data, accept);
+                }
+            });
+        }
+
+        data.cookie = parseCookie(auth, data.headers.cookie || '');
+        data.sessionID = data.cookie[auth.key] || '';
+        data[auth.userProperty] = {
+            logged_in: false
+        };
+
+        auth.store.get(data.sessionID, (err, session) => {
+            if (err) {
+                return auth.fail(data, 'Error in session store:\n' + err.message, true, accept);
+            } else
+            if (!session) {
+                return auth.fail(data, 'No session found', false, accept);
+            } else
+            if (!session[auth.passport._key]) {
+                return auth.fail(data, 'Passport was not initialized', true, accept);
+            }
+
+            const userKey = session[auth.passport._key].user;
+
+            if (typeof userKey === 'undefined') {
+                return auth.fail(data, 'User not authorized through passport. (User Property not found)', false, accept);
+            }
+
+            data[auth.userProperty] = userKey;
+            data[auth.userProperty].logged_in = true;
+            auth.success(data, accept);
+        });
+    };
+}
+
+exports.authorize = authorize;

package/lib/socketAdmin.js

@@ -0,0 +1,178 @@
+/**
+ *      Class Socket
+ *
+ *      Copyright 2014-2022 bluefox <dogafox@gmail.com>,
+ *      MIT License
+ *
+ */
+const SocketCommon = require('./socketCommon');
+const SocketCommandsAdmin = require('./socketCommandsAdmin');
+let passport; // require('passport') - only if auth is activated
+let cookieParser; // require('cookie-parser') - only if auth is activated
+let passportSocketIo; // require('./passportSocket') - only if auth is activated
+
+class SocketAdmin extends SocketCommon {
+    constructor(settings, adapter, objects) {
+        super(settings, adapter);
+
+        // user another set of commands for admin
+        this.commands = new SocketCommandsAdmin(adapter, socket => this.__updateSession(socket), objects);
+    }
+
+    __getIsNoDisconnect() {
+        // ws does not require disconnect
+        return true;
+    }
+
+    _onAuthorizeSuccess = (data, accept) => {
+        this.adapter.log.debug(`successful connection to socket.io from ${data.connection.remoteAddress}`);
+        accept();
+    }
+
+    _onAuthorizeFail = (data, message, error, accept) => {
+        setTimeout(() => data.socket.emit(SocketCommon.COMMAND_RE_AUTHENTICATE), 100);
+
+        error && this.adapter.log.info(`failed connection to socket.io from ${data.connection.remoteAddress}: ${message}`);
+
+        if (error) {
+            accept(new Error(message));
+        } else {
+            accept(new Error(`failed connection to socket.io: ${message}`));//null, false);
+        }
+        // this error will be sent to the user as a special error-package
+        // see: http://socket.io/docs/client-api/#socket > error-object
+    }
+
+    __initAuthentication(authOptions) {
+        passportSocketIo = passportSocketIo || require('./passportSocket');
+        passport = passport || require('passport');
+        cookieParser = cookieParser || require('cookie-parser');
+
+        this.store = authOptions.store;
+
+        this.server.use(passportSocketIo.authorize({
+            passport,
+            cookieParser,
+            key:     authOptions.userKey,         // the name of the cookie where express/connect stores its session_id
+            secret:  authOptions.secret,          // the session_secret to parse the cookie
+            store:   authOptions.store,           // we NEED to use a sessionstore. no memorystore please
+            success: this._onAuthorizeSuccess,    // *optional* callback on success - read more below
+            fail:    this._onAuthorizeFail        // *optional* callback on fail/error - read more below
+        }));
+    }
+
+    // Extract username from socket
+    __getUserFromSocket(socket, callback) {
+        if (socket.conn.request.sessionID) {
+            socket._secure = true;
+            socket._sessionID = socket.conn.request.sessionID;
+            // Get user for session
+            return this.adapter.getSession(socket.conn.request.sessionID, obj => {
+                if (!obj || !obj.passport) {
+                    socket._acl.user = '';
+                    socket.emit(SocketCommon.COMMAND_RE_AUTHENTICATE);
+                    callback('Cannot detect user');
+                } else {
+                    callback(null, obj.passport.user ? `system.user.${obj.passport.user}` : '');
+                }
+            });
+        }
+        callback('Cannot detect user');
+    }
+
+    __getClientAddress(socket) {
+        let address;
+        if (socket.connection) {
+            address = socket.connection && socket.connection.remoteAddress;
+        } else {
+            address = socket.ws._socket.remoteAddress;
+        }
+
+        if (!address && socket.handshake) {
+            address = socket.handshake.address;
+        }
+        if (!address && socket.conn.request && socket.conn.request.connection) {
+            address = socket.conn.request.connection.remoteAddress;
+        }
+        return address;
+    }
+
+    // update session ID, but not ofter than 60 seconds
+    __updateSession(socket) {
+        if (socket._sessionID) {
+            const time = Date.now();
+            if (socket._lastActivity && time - socket._lastActivity > this.settings.ttl * 1000) {
+                this.adapter.log.warn('REAUTHENTICATE!');
+                socket.emit(SocketCommon.COMMAND_RE_AUTHENTICATE);
+                return false;
+            }
+            socket._lastActivity = time;
+            socket._sessionTimer = socket._sessionTimer || setTimeout(() => {
+                socket._sessionTimer = null;
+                this.adapter.getSession(socket._sessionID, obj => {
+                    if (obj) {
+                        this.adapter.setSession(socket._sessionID, this.settings.ttl, obj);
+                    } else {
+                        this.adapter.log.warn('REAUTHENTICATE!');
+                        socket.emit(SocketCommon.COMMAND_RE_AUTHENTICATE);
+                    }
+                });
+            }, 60000);
+        }
+
+        return true;
+    }
+
+    __getSessionID(socket) {
+        return this.settings.auth && socket.conn.request.sessionID;
+    }
+
+    start(server, socketClass, authOptions, socketOptions) {
+        super.start(server, socketClass, authOptions, socketOptions);
+
+        this.commands.start(thresholdEnabled => this.onThresholdChanged(thresholdEnabled));
+    }
+
+    onThresholdChanged(enabled) {
+        this.server && this.server.sockets && this.server.sockets.emit('eventsThreshold', enabled);
+    }
+
+    stateChange(id, state) {
+        this.commands.stateChange(id, state);
+
+        this.server.sockets.connected.forEach(socket =>
+            this.__updateSession(socket));
+
+        this.server.sockets.emit('stateChange', id, state);
+    }
+
+    repoUpdated() {
+        if (this.server && this.server.sockets) {
+            this.server.sockets.emit('repoUpdated');
+        }
+    }
+
+    objectChange(id, obj) {
+        const clients = this.server.sockets.connected;
+
+        for (const i in clients) {
+            if (clients.hasOwnProperty(i)) {
+                this.__updateSession(clients[i]);
+            }
+        }
+
+        this.server.sockets.emit('objectChange', id, obj);
+    }
+
+    subscribe(type, pattern) {
+        this.commands.subscribe(null, type, pattern);
+    }
+
+    sendCommand(obj) {
+        if (this.commands.sendCommand(obj) && this.server) {
+            this.server.sockets.emit(obj.command, obj.message.id, obj.message.data);
+        }
+    }
+}
+
+module.exports = SocketAdmin;