src/user.js

   1 var Server = require("./server");
   2 var util = require("./utilities");
   3 var db = require("./database");
   4 var Config = require("./config");
   5 var ACP = require("./acp");
   6 var Account = require("./account");
   7 var Flags = require("./flags");
   8 import { EventEmitter } from 'events';
   9 import Logger from './logger';
  10 import net from 'net';
  11
  12 const LOGGER = require('@calzoneman/jsli')('user');
  13
  14 function User(socket, ip, loginInfo) {
  15     this.flags = 0;
  16     this.socket = socket;
  17     // Expanding IPv6 addresses shouldn't really be necessary
  18     // At some point, the IPv6 related stuff should be revisited
  19     this.realip = net.isIPv6(ip) ? util.expandIPv6(ip) : ip;
  20     this.displayip = util.cloakIP(this.realip);
  21     this.channel = null;
  22     this.queueLimiter = util.newRateLimiter();
  23     this.chatLimiter = util.newRateLimiter();
  24     this.reqPlaylistLimiter = util.newRateLimiter();
  25     this.awaytimer = false;
  26
  27     if (loginInfo) {
  28         this.account = new Account.Account(this.realip, loginInfo, socket.context.aliases);
  29         this.registrationTime = new Date(this.account.user.time);
  30         this.setFlag(Flags.U_REGISTERED | Flags.U_LOGGED_IN | Flags.U_READY);
  31         socket.emit("login", {
  32             success: true,
  33             name: this.getName(),
  34             guest: false
  35         });
  36         socket.emit("rank", this.account.effectiveRank);
  37         if (this.account.globalRank >= 255) {
  38             this.initAdminCallbacks();
  39         }
  40         this.emit("login", this.account);
  41         LOGGER.info(ip + " logged in as " + this.getName());
  42     } else {
  43         this.account = new Account.Account(this.realip, null, socket.context.aliases);
  44         socket.emit("rank", -1);
  45         this.setFlag(Flags.U_READY);
  46         this.once("login", account => {
  47             if (account.globalRank >= 255) {
  48                 this.initAdminCallbacks();
  49             }
  50         });
  51     }
  52
  53     socket.once("joinChannel", data => this.handleJoinChannel(data));
  54     socket.once("initACP", () => this.handleInitACP());
  55     socket.on("login", data => this.handleLogin(data));
  56 }
  57
  58 User.prototype = Object.create(EventEmitter.prototype);
  59
  60 User.prototype.handleJoinChannel = function handleJoinChannel(data) {
  61     if (typeof data !== "object" || typeof data.name !== "string") {
  62         return;
  63     }
  64
  65     if (this.inChannel()) {
  66         return;
  67     }
  68
  69     if (!util.isValidChannelName(data.name)) {
  70         this.socket.emit("errorMsg", {
  71             msg: "Invalid channel name.  Channel names may consist of 1-30 " +
  72                  "characters in the set a-z, A-Z, 0-9, -, and _"
  73         });
  74         this.kick("Invalid channel name");
  75         return;
  76     }
  77
  78     data.name = data.name.toLowerCase();
  79     if (data.name in Config.get("channel-blacklist")) {
  80         this.kick("This channel is blacklisted.");
  81         return;
  82     }
  83
  84     this.waitFlag(Flags.U_READY, () => {
  85         var chan;
  86         try {
  87             chan = Server.getServer().getChannel(data.name);
  88         } catch (error) {
  89             if (error.code === 'EWRONGPART') {
  90                 this.socket.emit("errorMsg", {
  91                     msg: "Channel '" + data.name + "' is hosted on another server.  " +
  92                          "Try refreshing the page to update the connection URL."
  93                 });
  94             } else {
  95                 LOGGER.error("Unexpected error from getChannel(): %s", error.stack);
  96                 this.socket.emit("errorMsg", {
  97                     msg: "Unable to join channel due to an internal error"
  98                 });
  99             }
 100             return;
 101         }
 102
 103         if (!chan.is(Flags.C_READY)) {
 104             chan.once("loadFail", reason => {
 105                 this.socket.emit("errorMsg", {
 106                     msg: reason,
 107                     alert: true
 108                 });
 109                 this.kick(`Channel could not be loaded: ${reason}`);
 110             });
 111         }
 112         chan.joinUser(this, data);
 113     });
 114 };
 115
 116 User.prototype.handleInitACP = function handleInitACP() {
 117     this.waitFlag(Flags.U_LOGGED_IN, () => {
 118         if (this.account.globalRank >= 255) {
 119             ACP.init(this);
 120         } else {
 121             this.kick("Attempted initACP from non privileged user.  This incident " +
 122                       "will be reported.");
 123             Logger.eventlog.log("[acp] Attempted initACP from socket client " +
 124                                 this.getName() + "@" + this.realip);
 125         }
 126     });
 127 };
 128
 129 User.prototype.handleLogin = function handleLogin(data) {
 130     if (typeof data !== "object") {
 131         this.socket.emit("errorMsg", {
 132             msg: "Invalid login frame"
 133         });
 134         return;
 135     }
 136
 137     var name = data.name;
 138     if (typeof name !== "string") {
 139         return;
 140     }
 141
 142     var pw = data.pw || "";
 143     if (typeof pw !== "string") {
 144         pw = "";
 145     }
 146
 147     if (this.is(Flags.U_LOGGING_IN) || this.is(Flags.U_LOGGED_IN)) {
 148         return;
 149     }
 150
 151     if (!pw) {
 152         this.guestLogin(name);
 153     } else {
 154         this.login(name, pw);
 155     }
 156 };
 157
 158 User.prototype.die = function () {
 159     for (const key in this.socket._events) {
 160         delete this.socket._events[key];
 161     }
 162
 163     delete this.socket.typecheckedOn;
 164     delete this.socket.typecheckedOnce;
 165
 166     for (const key in this.__evHandlers) {
 167         delete this.__evHandlers[key];
 168     }
 169
 170     if (this.awaytimer) {
 171         clearTimeout(this.awaytimer);
 172     }
 173
 174     this.dead = true;
 175 };
 176
 177 User.prototype.is = function (flag) {
 178     return Boolean(this.flags & flag);
 179 };
 180
 181 User.prototype.setFlag = function (flag) {
 182     this.flags |= flag;
 183     this.emit("setFlag", flag);
 184 };
 185
 186 User.prototype.clearFlag = function (flag) {
 187     this.flags &= ~flag;
 188     this.emit("clearFlag", flag);
 189 };
 190
 191 User.prototype.waitFlag = function (flag, cb) {
 192     var self = this;
 193     if (self.is(flag)) {
 194         cb();
 195     } else {
 196         var wait = function (f) {
 197             if (f === flag) {
 198                 self.removeListener("setFlag", wait);
 199                 cb();
 200             }
 201         };
 202         self.on("setFlag", wait);
 203     }
 204 };
 205
 206 User.prototype.getName = function () {
 207     return this.account.name;
 208 };
 209
 210 User.prototype.getLowerName = function () {
 211     return this.account.lowername;
 212 };
 213
 214 User.prototype.inChannel = function () {
 215     return this.channel != null && !this.channel.dead;
 216 };
 217
 218 User.prototype.inRegisteredChannel = function () {
 219     return this.inChannel() && this.channel.is(Flags.C_REGISTERED);
 220 };
 221
 222 /* Called when a user's AFK status changes */
 223 User.prototype.setAFK = function (afk) {
 224     if (!this.inChannel()) {
 225         return;
 226     }
 227
 228     /* No change in AFK status, don't need to change anything */
 229     if (this.is(Flags.U_AFK) === afk) {
 230         this.autoAFK();
 231         return;
 232     }
 233
 234     if (afk) {
 235         this.setFlag(Flags.U_AFK);
 236         if (this.channel.modules.voteskip) {
 237             this.channel.modules.voteskip.unvote(this.realip);
 238             this.socket.emit("clearVoteskipVote");
 239         }
 240     } else {
 241         this.clearFlag(Flags.U_AFK);
 242         this.autoAFK();
 243     }
 244
 245     if (!this.inChannel()) {
 246         /*
 247          * In unusual circumstances, the above emit("clearVoteskipVote")
 248          * can cause the "disconnect" event to be fired synchronously,
 249          * which results in this user no longer being in the channel.
 250          */
 251         return;
 252     }
 253
 254     /* Number of AFK users changed, voteskip state changes */
 255     if (this.channel.modules.voteskip) {
 256         this.channel.modules.voteskip.update();
 257     }
 258
 259     this.emit('afk', afk);
 260 };
 261
 262 /* Automatically tag a user as AFK after a period of inactivity */
 263 User.prototype.autoAFK = function () {
 264     var self = this;
 265     if (self.awaytimer) {
 266         clearTimeout(self.awaytimer);
 267     }
 268
 269     if (!self.inChannel() || !self.channel.modules.options) {
 270         return;
 271     }
 272
 273     /* Don't set a timer if the duration is invalid */
 274     var timeout = parseFloat(self.channel.modules.options.get("afk_timeout"));
 275     if (isNaN(timeout) || timeout <= 0) {
 276         return;
 277     }
 278
 279     self.awaytimer = setTimeout(function () {
 280         self.setAFK(true);
 281     }, timeout * 1000);
 282 };
 283
 284 User.prototype.kick = function (reason) {
 285     this.socket.emit("kick", { reason: reason });
 286     this.socket.disconnect();
 287 };
 288
 289 User.prototype.isAnonymous = function(){
 290     var self = this;
 291     return !self.is(Flags.U_LOGGED_IN);
 292 };
 293
 294 User.prototype.initAdminCallbacks = function () {
 295     var self = this;
 296     self.socket.on("borrow-rank", function (rank) {
 297         if (self.inChannel()) {
 298             if (typeof rank !== "number") {
 299                 return;
 300             }
 301
 302             if (rank > self.account.globalRank) {
 303                 return;
 304             }
 305
 306             if (rank === 255 && self.account.globalRank > 255) {
 307                 rank = self.account.globalRank;
 308             }
 309
 310             self.account.channelRank = rank;
 311             self.account.effectiveRank = rank;
 312             self.socket.emit("rank", rank);
 313             self.channel.broadcastAll("setUserRank", {
 314                 name: self.getName(),
 315                 rank: rank
 316             });
 317         }
 318     });
 319 };
 320
 321 User.prototype.login = function (name, pw) {
 322     var self = this;
 323     self.setFlag(Flags.U_LOGGING_IN);
 324
 325     db.users.verifyLogin(name, pw, function (err, user) {
 326         if (err) {
 327             if (err === "Invalid username/password combination") {
 328                 Logger.eventlog.log("[loginfail] Login failed (bad password): " + name
 329                                   + "@" + self.realip);
 330             }
 331
 332             self.socket.emit("login", {
 333                 success: false,
 334                 error: err
 335             });
 336             self.clearFlag(Flags.U_LOGGING_IN);
 337             return;
 338         }
 339
 340         const oldRank = self.account.effectiveRank;
 341         self.account.user = user;
 342         self.account.update();
 343         self.socket.emit("rank", self.account.effectiveRank);
 344         self.emit("effectiveRankChange", self.account.effectiveRank, oldRank);
 345         self.registrationTime = new Date(user.time);
 346         self.setFlag(Flags.U_REGISTERED);
 347         self.socket.emit("login", {
 348             success: true,
 349             name: user.name
 350         });
 351         db.recordVisit(self.realip, self.getName());
 352         LOGGER.info(self.realip + " logged in as " + user.name);
 353         self.setFlag(Flags.U_LOGGED_IN);
 354         self.clearFlag(Flags.U_LOGGING_IN);
 355         self.emit("login", self.account);
 356     });
 357 };
 358
 359 var lastguestlogin = {};
 360 User.prototype.guestLogin = function (name) {
 361     var self = this;
 362
 363     if (!self.channel.modules.options.get("allow_anon_chat") && self.realip in lastguestlogin) {
 364         var diff = (Date.now() - lastguestlogin[self.realip]) / 1000;
 365         if (diff < Config.get("guest-login-delay")) {
 366             self.socket.emit("login", {
 367                 success: false,
 368                 error: "Guest logins are restricted to one per IP address per " +
 369                        Config.get("guest-login-delay") + " seconds."
 370             });
 371             return;
 372         }
 373     }
 374
 375     if (!util.isValidUserName(name)) {
 376         self.socket.emit("login", {
 377             success: false,
 378             error: "Invalid username.  Usernames must be 1-20 characters long and " +
 379                    "consist only of characters a-z, A-Z, 0-9, -, or _."
 380         });
 381         return;
 382     }
 383
 384     if (!self.channel.modules.options.get("allow_anon_chat") && name.match(Config.get("reserved-names.usernames"))) {
 385         LOGGER.warn(
 386             'Rejecting attempt by %s to use reserved username "%s"',
 387             self.realip,
 388             name
 389         );
 390         self.socket.emit("login", {
 391             success: false,
 392             error: "That username is reserved."
 393         });
 394         return;
 395     }
 396
 397     // Prevent duplicate logins
 398     self.setFlag(Flags.U_LOGGING_IN);
 399     db.users.isUsernameTaken(name, function (err, taken) {
 400         self.clearFlag(Flags.U_LOGGING_IN);
 401         if (err) {
 402             self.socket.emit("login", {
 403                 success: false,
 404                 error: err
 405             });
 406             return;
 407         }
 408
 409         if (taken) {
 410             self.socket.emit("login", {
 411                 success: false,
 412                 error: "That username is registered."
 413             });
 414             return;
 415         }
 416
 417         if (!self.channel.modules.options.get("allow_anon_chat") && self.inChannel()) {
 418             var nameLower = name.toLowerCase();
 419             for (var i = 0; i < self.channel.users.length; i++) {
 420                 if (self.channel.users[i].getLowerName() === nameLower) {
 421                     self.socket.emit("login", {
 422                         success: false,
 423                         error: "That name is already in use on this channel."
 424                     });
 425                     return;
 426                 }
 427             }
 428         }
 429         // Login succeeded
 430         lastguestlogin[self.realip] = Date.now();
 431
 432         const oldRank = self.account.effectiveRank;
 433         self.account.guestName = name;
 434         self.account.update();
 435         self.socket.emit("rank", self.account.effectiveRank);
 436         self.emit("effectiveRankChange", self.account.effectiveRank, oldRank);
 437         self.socket.emit("login", {
 438             success: true,
 439             name: name,
 440             guest: true
 441         });
 442         db.recordVisit(self.realip, self.getName());
 443         LOGGER.info(self.realip + " signed in as " + name);
 444         self.setFlag(Flags.U_LOGGED_IN);
 445         self.emit("login", self.account);
 446     });
 447 };
 448
 449 /* Clean out old login throttlers to save memory */
 450 setInterval(function () {
 451     var delay = Config.get("guest-login-delay");
 452     for (var ip in lastguestlogin) {
 453         var diff = (Date.now() - lastguestlogin[ip]) / 1000;
 454         if (diff > delay) {
 455             delete lastguestlogin[ip];
 456         }
 457     }
 458
 459     if (Config.get("aggressive-gc") && global && global.gc) {
 460         global.gc();
 461     }
 462 }, 5 * 60 * 1000);
 463
 464 User.prototype.getFirstSeenTime = function getFirstSeenTime() {
 465     if (this.registrationTime && this.socket.context.ipSessionFirstSeen) {
 466         return Math.min(
 467             this.registrationTime.getTime(),
 468             this.socket.context.ipSessionFirstSeen.getTime()
 469         );
 470     } else if (this.registrationTime) {
 471         return this.registrationTime.getTime();
 472     } else if (this.socket.context.ipSessionFirstSeen) {
 473         return this.socket.context.ipSessionFirstSeen.getTime();
 474     } else {
 475         LOGGER.error(`User "${this.getName()}" (IP: ${this.realip}) has neither ` +
 476                 "an IP session first seen time nor a registered account.");
 477         return Date.now();
 478     }
 479 };
 480
 481 User.prototype.setChannelRank = function setRank(rank) {
 482     const oldRank = this.account.effectiveRank;
 483     const changed = oldRank !== rank;
 484     this.account.channelRank = rank;
 485     this.account.update();
 486     this.socket.emit("rank", this.account.effectiveRank);
 487     if (changed) {
 488         this.emit("effectiveRankChange", this.account.effectiveRank, oldRank);
 489     }
 490 };
 491
 492 module.exports = User;