Source: components/room-link-validator.js

  1. /**
  2.  * The room link validator is used to determine if a room can be bridged.
  3.  */
  4. const ConfigValidator = require("./config-validator");
  5. const log = require("./logging").get("room-link-validator");
  6. const VALIDATION_CACHE_LIFETIME = 30 * 60 * 1000;
  7. const PASSED = "RLV_PASSED";
  8. const ERROR = "RVL_ERROR";
  9. const ERROR_USER_CONFLICT = "RVL_USER_CONFLICT";
  10. const ERROR_CACHED = "RVL_ERROR_CACHED";
  12. const RULE_SCHEMA = {
  13.     "$schema": "http://json-schema.org/draft-04/schema#",
  14.     type: "object",
  15.     properties: {
  16.         userIds: {
  17.             type: "object",
  18.             properties: {
  19.                 exempt: {
  20.                     type: "array",
  21.                     items: {
  22.                         type: "string"
  23.                     }
  24.                 },
  25.                 conflict: {
  26.                     type: "array",
  27.                     items: {
  28.                         type: "string"
  29.                     }
  30.                 }
  31.             }
  32.         }
  33.     }
  34. };
  36. /**
  37.  * The RoomLinkValidator checks if a room should be linked to a remote
  38.  * channel, given a set of rules supplied in a config. The ruleset is maintained
  39.  * in a seperate config from the bridge config. It can be reloaded by triggering
  40.  * an endpoint specified in the {@link Bridge} class.
  41.  */
  42. class RoomLinkValidator {
  43.     /**
  44.      * @param {string} config Config for the validator.
  45.      * @param {string} config.ruleFile Filename for the rule file.
  46.      * @param {string} config.rules Rules if not using a rule file, will be
  47.      *                              overwritten if both is set.
  48.      * @param {AppServiceBot} asBot The AS bot.
  49.      */
  50.     constructor (config, asBot) {
  51.         this.conflictCache = new Map(); // roomId => number
  52.         this.waitingRooms = new Map(); // roomId => Promise
  53.         this.asBot = asBot;
  55.         if (config.ruleFile) {
  56.             this.config = new ConfigValidator(RULE_SCHEMA);
  57.             this.ruleFile = config.ruleFile;
  58.             this.readRuleFile();
  59.         }
  60.         else if (config.rules) {
  61.             this.rules = this.evaulateRules(config.rules);
  62.         }
  63.         else {
  64.             throw new Error("Either config.ruleFile or config.rules must be set");
  65.         }
  66.     }
  68.     readRuleFile (filename) {
  69.         filename = filename || this.ruleFile;
  70.         if (!filename) {
  71.             throw new Error("No filename given and config is not using a file");
  72.         }
  73.         log.info(`Detected rule config change...`);
  74.         const rules = this.config.validate(filename);
  75.         if (rules === undefined) {
  76.             throw Error("Rule file contents was undefined");
  77.         }
  78.         log.info(`Rule file ok, checking rules...`);
  79.         this.rules = this.evaulateRules(rules);
  80.         log.info(`Applied new ruleset`);
  81.         this.conflictCache.clear();
  82.     }
  84.     evaulateRules (rules) {
  85.         let newRules = {userIds: {}};
  86.         if (!rules || !rules.userIds) {
  87.             rules = {userIds: {}};
  88.         }
  89.         if (!rules.userIds.conflict) {
  90.             rules.userIds.conflict = [];
  91.         }
  92.         if (!rules.userIds.exempt) {
  93.             rules.userIds.exempt = [];
  94.         }
  95.         newRules.userIds.conflict = rules.userIds.conflict.map(
  96.             (regexStr) => new RegExp(regexStr)
  97.         );
  98.         newRules.userIds.exempt = rules.userIds.exempt.map(
  99.             (regexStr) => new RegExp(regexStr)
  100.         );
  101.         return newRules;
  102.     }
  104.     validateRoom (roomId, cache=true) {
  105.         const status = cache ? this._checkConflictCache(roomId) : undefined;
  106.         if (status !== undefined) {
  107.             return Promise.reject(status);
  108.         }
  109.         // Get all users in the room.
  110.         return this.asBot.getJoinedMembers(roomId).then((joined) => {
  111.             for (const userId of Object.keys(joined)) {
  112.                 let rule;
  113.                 let ignoreUser = false;
  114.                 for (rule of this.rules.userIds.exempt) {
  115.                     if (rule.exec(userId) !== null) {
  116.                         ignoreUser = true;
  117.                         break;
  118.                     }
  119.                 }
  120.                 if (ignoreUser) {
  121.                     break;
  122.                 }
  123.                 for (rule of this.rules.userIds.conflict) {
  124.                     if (rule.exec(userId) !== null) {
  125.                         return false;
  126.                     }
  127.                 }
  128.             }
  129.             return true;
  130.         }).then((isValid) => {
  131.             if (isValid) {
  132.                 return PASSED;
  133.             }
  134.             this.conflictCache.set(roomId, Date.now());
  135.             throw ERROR_USER_CONFLICT;
  136.         });
  137.     }
  139.     _checkConflictCache (roomId) {
  140.         if (this.conflictCache.has(roomId)) {
  141.             if (
  142.                 this.conflictCache.get(roomId) > (Date.now() - VALIDATION_CACHE_LIFETIME)
  143.             ) {
  144.                 return ERROR_CACHED;
  145.             }
  146.             this.conflictCache.delete(roomId);
  147.         }
  148.         return undefined;
  149.     }
  150. }
  152. module.exports = {
  153.     validationStatuses: {
  154.         PASSED,
  155.         ERROR_USER_CONFLICT,
  156.         ERROR_CACHED,
  157.         ERROR,
  158.     },
  159.     RoomLinkValidator
  160. };