2016-07-19 01:35:02 +00:00
|
|
|
"use strict";
|
|
|
|
|
2018-01-11 11:33:36 +00:00
|
|
|
const _ = require("lodash");
|
2018-06-15 20:31:06 +00:00
|
|
|
const log = require("./log");
|
2018-01-11 11:33:36 +00:00
|
|
|
const pkg = require("../package.json");
|
|
|
|
const Client = require("./client");
|
|
|
|
const ClientManager = require("./clientManager");
|
|
|
|
const express = require("express");
|
|
|
|
const fs = require("fs");
|
|
|
|
const path = require("path");
|
|
|
|
const io = require("socket.io");
|
|
|
|
const dns = require("dns");
|
2018-09-03 07:30:05 +00:00
|
|
|
const Uploader = require("./plugins/uploader");
|
2018-01-11 11:33:36 +00:00
|
|
|
const Helper = require("./helper");
|
2018-03-02 18:28:54 +00:00
|
|
|
const colors = require("chalk");
|
2017-06-11 19:33:04 +00:00
|
|
|
const net = require("net");
|
2016-12-17 09:51:33 +00:00
|
|
|
const Identification = require("./identification");
|
2017-07-13 18:32:18 +00:00
|
|
|
const changelog = require("./plugins/changelog");
|
2014-08-14 16:35:37 +00:00
|
|
|
|
2018-01-05 17:40:34 +00:00
|
|
|
const themes = require("./plugins/packages/themes");
|
|
|
|
themes.loadLocalThemes();
|
|
|
|
|
|
|
|
const packages = require("./plugins/packages/index");
|
|
|
|
packages.loadPackages();
|
|
|
|
|
2017-09-01 09:44:53 +00:00
|
|
|
// The order defined the priority: the first available plugin is used
|
|
|
|
// ALways keep local auth in the end, which should always be enabled.
|
|
|
|
const authPlugins = [
|
|
|
|
require("./plugins/auth/ldap"),
|
|
|
|
require("./plugins/auth/local"),
|
|
|
|
];
|
|
|
|
|
2017-08-28 09:18:31 +00:00
|
|
|
// A random number that will force clients to reload the page if it differs
|
|
|
|
const serverHash = Math.floor(Date.now() * Math.random());
|
|
|
|
|
2018-01-11 11:33:36 +00:00
|
|
|
let manager = null;
|
2014-08-14 16:35:37 +00:00
|
|
|
|
2016-06-08 09:26:24 +00:00
|
|
|
module.exports = function() {
|
2016-12-17 09:51:33 +00:00
|
|
|
log.info(`The Lounge ${colors.green(Helper.getVersion())} \
|
2017-11-18 18:52:31 +00:00
|
|
|
(Node.js ${colors.green(process.versions.node)} on ${colors.green(process.platform)} ${process.arch})`);
|
2017-12-07 03:54:54 +00:00
|
|
|
log.info(`Configuration file: ${colors.green(Helper.getConfigPath())}`);
|
2014-08-14 16:35:37 +00:00
|
|
|
|
2018-06-06 09:19:51 +00:00
|
|
|
const staticOptions = {
|
|
|
|
redirect: false,
|
|
|
|
maxAge: 86400 * 1000,
|
|
|
|
};
|
|
|
|
|
2018-01-11 11:33:36 +00:00
|
|
|
const app = express()
|
2018-10-13 21:23:32 +00:00
|
|
|
.set("env", "production")
|
2017-11-12 18:24:21 +00:00
|
|
|
.disable("x-powered-by")
|
2016-05-01 17:27:10 +00:00
|
|
|
.use(allRequests)
|
2014-08-14 16:35:37 +00:00
|
|
|
.use(index)
|
2018-06-06 09:19:51 +00:00
|
|
|
.use(express.static(path.join(__dirname, "..", "public"), staticOptions))
|
|
|
|
.use("/storage/", express.static(Helper.getStoragePath(), staticOptions));
|
2014-11-01 20:06:01 +00:00
|
|
|
|
2018-09-03 07:30:05 +00:00
|
|
|
if (Helper.config.fileUpload.enable) {
|
|
|
|
Uploader.router(app);
|
|
|
|
}
|
|
|
|
|
2018-01-12 05:46:55 +00:00
|
|
|
// This route serves *installed themes only*. Local themes are served directly
|
|
|
|
// from the `public/themes/` folder as static assets, without entering this
|
2018-09-03 07:30:05 +00:00
|
|
|
// handler. Remember this if you make changes to this function, serving of
|
2018-01-12 05:46:55 +00:00
|
|
|
// local themes will not get those changes.
|
2017-06-22 21:09:55 +00:00
|
|
|
app.get("/themes/:theme.css", (req, res) => {
|
|
|
|
const themeName = req.params.theme;
|
|
|
|
const theme = themes.getFilename(themeName);
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-06-22 21:09:55 +00:00
|
|
|
if (theme === undefined) {
|
|
|
|
return res.status(404).send("Not found");
|
|
|
|
}
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-06-22 21:09:55 +00:00
|
|
|
return res.sendFile(theme);
|
|
|
|
});
|
|
|
|
|
2018-01-05 17:40:34 +00:00
|
|
|
app.get("/packages/:package/:filename", (req, res) => {
|
|
|
|
const packageName = req.params.package;
|
|
|
|
const fileName = req.params.filename;
|
|
|
|
const packageFile = packages.getPackage(packageName);
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2018-01-05 17:40:34 +00:00
|
|
|
if (!packageFile || !packages.getStylesheets().includes(`${packageName}/${fileName}`)) {
|
|
|
|
return res.status(404).send("Not found");
|
|
|
|
}
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2018-01-05 17:40:34 +00:00
|
|
|
const packagePath = Helper.getPackageModulePath(packageName);
|
|
|
|
return res.sendFile(path.join(packagePath, fileName));
|
|
|
|
});
|
|
|
|
|
2018-01-11 11:33:36 +00:00
|
|
|
let server = null;
|
2014-09-26 23:26:21 +00:00
|
|
|
|
2018-01-11 11:33:36 +00:00
|
|
|
if (Helper.config.public && (Helper.config.ldap || {}).enable) {
|
2016-08-10 06:14:09 +00:00
|
|
|
log.warn("Server is public and set to use LDAP. Set to private mode if trying to use LDAP authentication.");
|
2016-07-30 01:20:38 +00:00
|
|
|
}
|
|
|
|
|
2018-01-11 11:33:36 +00:00
|
|
|
if (!Helper.config.https.enable) {
|
2014-09-26 23:26:21 +00:00
|
|
|
server = require("http");
|
2016-12-17 09:51:33 +00:00
|
|
|
server = server.createServer(app);
|
2014-09-26 23:26:21 +00:00
|
|
|
} else {
|
2018-01-11 11:33:36 +00:00
|
|
|
const keyPath = Helper.expandHome(Helper.config.https.key);
|
|
|
|
const certPath = Helper.expandHome(Helper.config.https.certificate);
|
|
|
|
const caPath = Helper.expandHome(Helper.config.https.ca);
|
2017-04-13 21:05:28 +00:00
|
|
|
|
|
|
|
if (!keyPath.length || !fs.existsSync(keyPath)) {
|
2016-10-04 22:35:04 +00:00
|
|
|
log.error("Path to SSL key is invalid. Stopping server...");
|
|
|
|
process.exit();
|
|
|
|
}
|
2017-04-13 21:05:28 +00:00
|
|
|
|
|
|
|
if (!certPath.length || !fs.existsSync(certPath)) {
|
2016-10-04 22:35:04 +00:00
|
|
|
log.error("Path to SSL certificate is invalid. Stopping server...");
|
|
|
|
process.exit();
|
|
|
|
}
|
2017-04-13 21:05:28 +00:00
|
|
|
|
2017-04-10 18:49:58 +00:00
|
|
|
if (caPath.length && !fs.existsSync(caPath)) {
|
|
|
|
log.error("Path to SSL ca bundle is invalid. Stopping server...");
|
|
|
|
process.exit();
|
|
|
|
}
|
|
|
|
|
2018-08-29 12:35:06 +00:00
|
|
|
server = require("https");
|
2014-09-26 23:26:21 +00:00
|
|
|
server = server.createServer({
|
2016-10-04 22:35:04 +00:00
|
|
|
key: fs.readFileSync(keyPath),
|
2017-04-10 18:49:58 +00:00
|
|
|
cert: fs.readFileSync(certPath),
|
2017-11-15 06:35:15 +00:00
|
|
|
ca: caPath ? fs.readFileSync(caPath) : undefined,
|
2016-12-17 09:51:33 +00:00
|
|
|
}, app);
|
2014-09-26 23:26:21 +00:00
|
|
|
}
|
|
|
|
|
2017-08-31 18:56:20 +00:00
|
|
|
let listenParams;
|
|
|
|
|
2018-01-11 11:33:36 +00:00
|
|
|
if (typeof Helper.config.host === "string" && Helper.config.host.startsWith("unix:")) {
|
|
|
|
listenParams = Helper.config.host.replace(/^unix:/, "");
|
2017-08-31 18:56:20 +00:00
|
|
|
} else {
|
|
|
|
listenParams = {
|
2018-01-11 11:33:36 +00:00
|
|
|
port: Helper.config.port,
|
|
|
|
host: Helper.config.host,
|
2017-08-31 18:56:20 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-09-03 12:13:56 +00:00
|
|
|
server.on("error", (err) => log.error(`${err}`));
|
|
|
|
|
2017-08-31 18:56:20 +00:00
|
|
|
server.listen(listenParams, () => {
|
|
|
|
if (typeof listenParams === "string") {
|
|
|
|
log.info("Available on socket " + colors.green(listenParams));
|
|
|
|
} else {
|
2018-01-11 11:33:36 +00:00
|
|
|
const protocol = Helper.config.https.enable ? "https" : "http";
|
2017-08-31 18:56:20 +00:00
|
|
|
const address = server.address();
|
|
|
|
|
|
|
|
log.info(
|
|
|
|
"Available at " +
|
|
|
|
colors.green(`${protocol}://${address.address}:${address.port}/`) +
|
2018-01-11 11:33:36 +00:00
|
|
|
` in ${colors.bold(Helper.config.public ? "public" : "private")} mode`
|
2017-08-31 18:56:20 +00:00
|
|
|
);
|
|
|
|
}
|
2017-08-23 05:19:50 +00:00
|
|
|
|
|
|
|
const sockets = io(server, {
|
2018-02-23 10:35:35 +00:00
|
|
|
wsEngine: "ws",
|
2017-08-23 05:19:50 +00:00
|
|
|
serveClient: false,
|
2018-01-11 11:33:36 +00:00
|
|
|
transports: Helper.config.transports,
|
2017-08-23 05:19:50 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
sockets.on("connect", (socket) => {
|
2018-01-11 11:33:36 +00:00
|
|
|
if (Helper.config.public) {
|
2017-08-23 05:19:50 +00:00
|
|
|
performAuthentication.call(socket, {});
|
|
|
|
} else {
|
2017-08-28 09:18:31 +00:00
|
|
|
socket.emit("auth", {
|
|
|
|
serverHash: serverHash,
|
|
|
|
success: true,
|
|
|
|
});
|
2017-08-23 05:19:50 +00:00
|
|
|
socket.on("auth", performAuthentication);
|
|
|
|
}
|
|
|
|
});
|
2014-08-14 16:35:37 +00:00
|
|
|
|
2017-08-23 05:19:50 +00:00
|
|
|
manager = new ClientManager();
|
2016-12-07 05:50:11 +00:00
|
|
|
|
2017-08-23 05:19:50 +00:00
|
|
|
new Identification((identHandler) => {
|
|
|
|
manager.init(identHandler, sockets);
|
|
|
|
});
|
2017-08-30 17:26:45 +00:00
|
|
|
|
|
|
|
// Handle ctrl+c and kill gracefully
|
|
|
|
let suicideTimeout = null;
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-08-30 17:26:45 +00:00
|
|
|
const exitGracefully = function() {
|
|
|
|
if (suicideTimeout !== null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-12-18 11:08:18 +00:00
|
|
|
log.info("Exiting...");
|
|
|
|
|
|
|
|
// Close all client and IRC connections
|
|
|
|
manager.clients.forEach((client) => client.quit());
|
|
|
|
|
2017-12-18 14:58:43 +00:00
|
|
|
if (Helper.config.prefetchStorage) {
|
|
|
|
log.info("Clearing prefetch storage folder, this might take a while...");
|
|
|
|
|
|
|
|
require("./plugins/storage").emptyDir();
|
|
|
|
}
|
|
|
|
|
2017-08-30 17:26:45 +00:00
|
|
|
// Forcefully exit after 3 seconds
|
|
|
|
suicideTimeout = setTimeout(() => process.exit(1), 3000);
|
|
|
|
|
|
|
|
// Close http server
|
|
|
|
server.close(() => {
|
|
|
|
clearTimeout(suicideTimeout);
|
|
|
|
process.exit(0);
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
process.on("SIGINT", exitGracefully);
|
|
|
|
process.on("SIGTERM", exitGracefully);
|
2017-12-18 14:58:43 +00:00
|
|
|
|
|
|
|
// Clear storage folder after server starts successfully
|
|
|
|
if (Helper.config.prefetchStorage) {
|
|
|
|
require("./plugins/storage").emptyDir();
|
|
|
|
}
|
2016-12-17 09:51:33 +00:00
|
|
|
});
|
2017-10-06 09:53:08 +00:00
|
|
|
|
|
|
|
return server;
|
2014-08-14 16:35:37 +00:00
|
|
|
};
|
|
|
|
|
2017-12-28 13:34:49 +00:00
|
|
|
function getClientLanguage(socket) {
|
|
|
|
const acceptLanguage = socket.handshake.headers["accept-language"];
|
|
|
|
|
|
|
|
if (typeof acceptLanguage === "string" && /^[\x00-\x7F]{1,50}$/.test(acceptLanguage)) {
|
|
|
|
// only allow ASCII strings between 1-50 characters in length
|
|
|
|
return acceptLanguage;
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2017-10-12 07:57:25 +00:00
|
|
|
function getClientIp(socket) {
|
2019-01-09 09:38:21 +00:00
|
|
|
let ip = socket.handshake.address || "127.0.0.1";
|
2016-07-31 00:54:09 +00:00
|
|
|
|
2017-06-11 19:33:04 +00:00
|
|
|
if (Helper.config.reverseProxy) {
|
2017-10-12 07:57:25 +00:00
|
|
|
const forwarded = (socket.request.headers["x-forwarded-for"] || "").split(/\s*,\s*/).filter(Boolean);
|
2017-06-11 19:33:04 +00:00
|
|
|
|
|
|
|
if (forwarded.length && net.isIP(forwarded[0])) {
|
|
|
|
ip = forwarded[0];
|
|
|
|
}
|
2016-04-03 05:12:49 +00:00
|
|
|
}
|
2016-07-31 00:54:09 +00:00
|
|
|
|
|
|
|
return ip.replace(/^::ffff:/, "");
|
2016-04-03 05:12:49 +00:00
|
|
|
}
|
|
|
|
|
2016-05-01 17:27:10 +00:00
|
|
|
function allRequests(req, res, next) {
|
|
|
|
res.setHeader("X-Content-Type-Options", "nosniff");
|
|
|
|
return next();
|
|
|
|
}
|
|
|
|
|
2014-08-14 16:35:37 +00:00
|
|
|
function index(req, res, next) {
|
2016-05-01 09:41:17 +00:00
|
|
|
if (req.url.split("?")[0] !== "/") {
|
|
|
|
return next();
|
|
|
|
}
|
|
|
|
|
2017-07-06 15:33:09 +00:00
|
|
|
const policies = [
|
2017-12-07 18:45:45 +00:00
|
|
|
"default-src 'none'", // default to nothing
|
2018-09-02 17:34:47 +00:00
|
|
|
"form-action 'self'", // 'self' to fix saving passwords in Firefox, even though login is handled in javascript
|
2017-12-07 18:45:45 +00:00
|
|
|
"connect-src 'self' ws: wss:", // allow self for polling; websockets
|
2018-01-30 09:23:34 +00:00
|
|
|
"style-src 'self' https: 'unsafe-inline'", // allow inline due to use in irc hex colors
|
2017-12-07 18:45:45 +00:00
|
|
|
"script-src 'self'", // javascript
|
|
|
|
"worker-src 'self'", // service worker
|
2018-01-12 10:04:04 +00:00
|
|
|
"child-src 'self'", // deprecated fall back for workers, Firefox <58, see #1902
|
2017-12-07 18:45:45 +00:00
|
|
|
"manifest-src 'self'", // manifest.json
|
|
|
|
"font-src 'self' https:", // allow loading fonts from secure sites (e.g. google fonts)
|
|
|
|
"media-src 'self' https:", // self for notification sound; allow https media (audio previews)
|
2017-07-06 15:33:09 +00:00
|
|
|
];
|
|
|
|
|
|
|
|
// If prefetch is enabled, but storage is not, we have to allow mixed content
|
2017-12-27 18:56:38 +00:00
|
|
|
// - https://user-images.githubusercontent.com is where we currently push our changelog screenshots
|
|
|
|
// - data: is required for the HTML5 video player
|
2017-07-06 15:33:09 +00:00
|
|
|
if (Helper.config.prefetchStorage || !Helper.config.prefetch) {
|
2017-12-27 18:56:38 +00:00
|
|
|
policies.push("img-src 'self' data: https://user-images.githubusercontent.com");
|
2017-07-06 15:33:09 +00:00
|
|
|
policies.unshift("block-all-mixed-content");
|
2017-12-07 18:45:45 +00:00
|
|
|
} else {
|
2017-12-27 18:56:38 +00:00
|
|
|
policies.push("img-src http: https: data:");
|
2017-07-06 15:33:09 +00:00
|
|
|
}
|
|
|
|
|
2017-11-12 18:24:21 +00:00
|
|
|
res.setHeader("Content-Type", "text/html");
|
2017-07-06 15:33:09 +00:00
|
|
|
res.setHeader("Content-Security-Policy", policies.join("; "));
|
2017-04-20 10:17:25 +00:00
|
|
|
res.setHeader("Referrer-Policy", "no-referrer");
|
2017-11-12 18:24:21 +00:00
|
|
|
|
2018-01-14 00:46:59 +00:00
|
|
|
return fs.readFile(path.join(__dirname, "..", "client", "index.html.tpl"), "utf-8", (err, file) => {
|
2017-11-12 18:24:21 +00:00
|
|
|
if (err) {
|
|
|
|
throw err;
|
|
|
|
}
|
|
|
|
|
2018-01-05 17:40:34 +00:00
|
|
|
res.send(_.template(file)(getServerConfiguration()));
|
2017-11-12 18:24:21 +00:00
|
|
|
});
|
2014-08-14 16:35:37 +00:00
|
|
|
}
|
|
|
|
|
2017-08-28 20:14:01 +00:00
|
|
|
function initializeClient(socket, client, token, lastMessage) {
|
2017-08-13 18:37:12 +00:00
|
|
|
socket.emit("authorized");
|
2016-09-25 06:52:16 +00:00
|
|
|
|
2017-10-17 09:45:18 +00:00
|
|
|
client.clientAttach(socket.id, token);
|
|
|
|
|
2018-09-03 07:30:05 +00:00
|
|
|
if (Helper.config.fileUpload.enable) {
|
2018-09-04 09:08:30 +00:00
|
|
|
new Uploader(socket);
|
2018-09-03 07:30:05 +00:00
|
|
|
}
|
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
socket.on("disconnect", function() {
|
2018-10-21 08:05:05 +00:00
|
|
|
process.nextTick(() => client.clientDetach(socket.id));
|
2017-08-13 18:37:12 +00:00
|
|
|
});
|
2016-11-19 20:34:05 +00:00
|
|
|
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("input", (data) => {
|
|
|
|
if (typeof data === "object") {
|
2017-08-13 18:37:12 +00:00
|
|
|
client.input(data);
|
|
|
|
}
|
2018-02-21 11:17:56 +00:00
|
|
|
});
|
2016-09-25 06:41:10 +00:00
|
|
|
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("more", (data) => {
|
|
|
|
if (typeof data === "object") {
|
2018-01-07 13:04:37 +00:00
|
|
|
const history = client.more(data);
|
|
|
|
|
|
|
|
if (history !== null) {
|
|
|
|
socket.emit("more", history);
|
|
|
|
}
|
2017-08-13 18:37:12 +00:00
|
|
|
}
|
2018-02-21 11:17:56 +00:00
|
|
|
});
|
2017-08-13 18:37:12 +00:00
|
|
|
|
2018-03-15 08:37:32 +00:00
|
|
|
socket.on("network:new", (data) => {
|
2018-02-21 11:17:56 +00:00
|
|
|
if (typeof data === "object") {
|
2017-08-13 18:37:12 +00:00
|
|
|
// prevent people from overriding webirc settings
|
|
|
|
data.ip = null;
|
|
|
|
data.hostname = null;
|
2017-11-28 17:25:15 +00:00
|
|
|
data.uuid = null;
|
2018-03-15 08:37:05 +00:00
|
|
|
data.commands = null;
|
2018-07-11 07:57:02 +00:00
|
|
|
data.ignoreList = null;
|
2017-08-13 18:37:12 +00:00
|
|
|
|
|
|
|
client.connect(data);
|
|
|
|
}
|
2018-02-21 11:17:56 +00:00
|
|
|
});
|
2017-08-13 18:37:12 +00:00
|
|
|
|
2018-03-15 08:37:05 +00:00
|
|
|
socket.on("network:get", (data) => {
|
|
|
|
if (typeof data !== "string") {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const network = _.find(client.networks, {uuid: data});
|
|
|
|
|
|
|
|
if (!network) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
socket.emit("network:info", getClientConfiguration(network.export()));
|
|
|
|
});
|
|
|
|
|
|
|
|
socket.on("network:edit", (data) => {
|
|
|
|
if (typeof data !== "object") {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const network = _.find(client.networks, {uuid: data.uuid});
|
|
|
|
|
|
|
|
if (!network) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
network.edit(client, data);
|
|
|
|
});
|
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
if (!Helper.config.public && !Helper.config.ldap.enable) {
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("change-password", (data) => {
|
|
|
|
if (typeof data === "object") {
|
2018-01-11 11:33:36 +00:00
|
|
|
const old = data.old_password;
|
|
|
|
const p1 = data.new_password;
|
|
|
|
const p2 = data.verify_password;
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
if (typeof p1 === "undefined" || p1 === "") {
|
|
|
|
socket.emit("change-password", {
|
2017-11-15 06:35:15 +00:00
|
|
|
error: "Please enter a new password",
|
2017-08-13 18:37:12 +00:00
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
if (p1 !== p2) {
|
|
|
|
socket.emit("change-password", {
|
2017-11-15 06:35:15 +00:00
|
|
|
error: "Both new password fields must match",
|
2017-08-13 18:37:12 +00:00
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
2016-05-31 21:28:31 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
Helper.password
|
|
|
|
.compare(old || "", client.config.password)
|
|
|
|
.then((matching) => {
|
|
|
|
if (!matching) {
|
|
|
|
socket.emit("change-password", {
|
2017-11-15 06:35:15 +00:00
|
|
|
error: "The current password field does not match your account password",
|
2017-08-13 18:37:12 +00:00
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
const hash = Helper.password.hash(p1);
|
2017-03-23 07:47:51 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
client.setPassword(hash, (success) => {
|
|
|
|
const obj = {};
|
2017-03-23 07:47:51 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
if (success) {
|
|
|
|
obj.success = "Successfully updated your password";
|
|
|
|
} else {
|
|
|
|
obj.error = "Failed to update your password";
|
|
|
|
}
|
2017-03-23 07:47:51 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
socket.emit("change-password", obj);
|
2017-03-23 07:47:51 +00:00
|
|
|
});
|
2017-08-13 18:37:12 +00:00
|
|
|
}).catch((error) => {
|
|
|
|
log.error(`Error while checking users password. Error: ${error}`);
|
|
|
|
});
|
2016-02-17 02:29:44 +00:00
|
|
|
}
|
2018-02-21 11:17:56 +00:00
|
|
|
});
|
2017-08-13 18:37:12 +00:00
|
|
|
}
|
2017-07-24 06:01:25 +00:00
|
|
|
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("open", (data) => {
|
|
|
|
client.open(socket.id, data);
|
|
|
|
});
|
2017-07-24 06:01:25 +00:00
|
|
|
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("sort", (data) => {
|
|
|
|
if (typeof data === "object") {
|
2017-08-13 18:37:12 +00:00
|
|
|
client.sort(data);
|
|
|
|
}
|
2018-02-21 11:17:56 +00:00
|
|
|
});
|
2017-07-24 06:01:25 +00:00
|
|
|
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("names", (data) => {
|
|
|
|
if (typeof data === "object") {
|
2017-08-13 18:37:12 +00:00
|
|
|
client.names(data);
|
|
|
|
}
|
2018-02-21 11:17:56 +00:00
|
|
|
});
|
2017-08-13 18:37:12 +00:00
|
|
|
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("changelog", () => {
|
Improve UI of the About section and changelog viewer
- Keep consistent width between the Help page and Changelog (which is already different from other windows 😠)
- Add icons to the About links
- Make sure `li` elements (i.e. all the lists in changelogs) are consistent in size with rest of the client
- Display version and release notes link on the "About The Lounge" header line, smaller, pushed to the right
- Check new releases when opening the Help window in order to display it without having to open the release notes. Release notes are being fed to the Changelog page at that moment to avoid fetching twice.
- Re-check version/fetch release notes after 24h. Since The Lounge can now run 24/7, reconnect when losing the network, we have to assume an "always-on" usage.
- Change icon, animate background color when getting response from GitHub to avoid flashing.
- Combine click handlers with our wonderful window management. These were the same handler, even with similar checks (`target` exists, etc.), just in 2 different places. This is necessary for the next item.
- Combine "Open release notes" and "Go back to Help" button behaviors with window management handlers. The window management code is gross as ever, and is in desperate need of a refactor, but at least there is no duplicated code for the same behavior + history management. This fixes the "Next" history behavior (however reloading the app while viewing the notes does not load on the notes, but this is a bug for a different PR!).
- Added a rule in the history management thingy: if a link we want to add history handling to has an `id`, store that in the state
- Added a button to go back to the Help window
- Fixed links to releases
- Send user to the GitHub issues *list* instead of *new issue form* because if they do not have a GitHub account, they will be redirected to the login page, which is a rather unpleasant experience when you are already confused...
- Fixed a bug that would return data about a new release in `latest` even though it is already the `current`. It was showing the current version as "The Lounge v... is now available".
- Added https://user-images.githubusercontent.com to the CSP rule when prefetch storage is enabled, because that is where we have stored screenshots in the changelog so far. Meh (we can improve that later if we decide to have a dedicated place for screenshots).
- Fetch changelog info even in public mode because users in public mode can access the release notes. They do not see the result of the version checker however.
2017-12-23 03:40:41 +00:00
|
|
|
changelog.fetch((data) => {
|
|
|
|
socket.emit("changelog", data);
|
2017-07-13 18:32:18 +00:00
|
|
|
});
|
Improve UI of the About section and changelog viewer
- Keep consistent width between the Help page and Changelog (which is already different from other windows 😠)
- Add icons to the About links
- Make sure `li` elements (i.e. all the lists in changelogs) are consistent in size with rest of the client
- Display version and release notes link on the "About The Lounge" header line, smaller, pushed to the right
- Check new releases when opening the Help window in order to display it without having to open the release notes. Release notes are being fed to the Changelog page at that moment to avoid fetching twice.
- Re-check version/fetch release notes after 24h. Since The Lounge can now run 24/7, reconnect when losing the network, we have to assume an "always-on" usage.
- Change icon, animate background color when getting response from GitHub to avoid flashing.
- Combine click handlers with our wonderful window management. These were the same handler, even with similar checks (`target` exists, etc.), just in 2 different places. This is necessary for the next item.
- Combine "Open release notes" and "Go back to Help" button behaviors with window management handlers. The window management code is gross as ever, and is in desperate need of a refactor, but at least there is no duplicated code for the same behavior + history management. This fixes the "Next" history behavior (however reloading the app while viewing the notes does not load on the notes, but this is a bug for a different PR!).
- Added a rule in the history management thingy: if a link we want to add history handling to has an `id`, store that in the state
- Added a button to go back to the Help window
- Fixed links to releases
- Send user to the GitHub issues *list* instead of *new issue form* because if they do not have a GitHub account, they will be redirected to the login page, which is a rather unpleasant experience when you are already confused...
- Fixed a bug that would return data about a new release in `latest` even though it is already the `current`. It was showing the current version as "The Lounge v... is now available".
- Added https://user-images.githubusercontent.com to the CSP rule when prefetch storage is enabled, because that is where we have stored screenshots in the changelog so far. Meh (we can improve that later if we decide to have a dedicated place for screenshots).
- Fetch changelog info even in public mode because users in public mode can access the release notes. They do not see the result of the version checker however.
2017-12-23 03:40:41 +00:00
|
|
|
});
|
2017-07-13 18:32:18 +00:00
|
|
|
|
2018-02-21 11:17:56 +00:00
|
|
|
socket.on("msg:preview:toggle", (data) => {
|
|
|
|
if (typeof data !== "object") {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
const networkAndChan = client.find(data.target);
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
if (!networkAndChan) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const message = networkAndChan.chan.findMessage(data.msgId);
|
|
|
|
|
|
|
|
if (!message) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const preview = message.findPreview(data.link);
|
|
|
|
|
|
|
|
if (preview) {
|
|
|
|
preview.shown = data.shown;
|
|
|
|
}
|
|
|
|
});
|
2017-07-24 06:01:25 +00:00
|
|
|
|
2018-02-20 11:24:46 +00:00
|
|
|
if (!Helper.config.public) {
|
|
|
|
socket.on("push:register", (subscription) => {
|
|
|
|
if (!client.config.sessions.hasOwnProperty(token)) {
|
|
|
|
return;
|
|
|
|
}
|
2017-07-10 19:47:03 +00:00
|
|
|
|
2018-02-20 11:24:46 +00:00
|
|
|
const registration = client.registerPushSubscription(client.config.sessions[token], subscription);
|
2017-07-10 19:47:03 +00:00
|
|
|
|
2018-02-20 11:24:46 +00:00
|
|
|
if (registration) {
|
|
|
|
client.manager.webPush.pushSingle(client, registration, {
|
|
|
|
type: "notification",
|
|
|
|
timestamp: Date.now(),
|
|
|
|
title: "The Lounge",
|
|
|
|
body: "🚀 Push notifications have been enabled",
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2017-07-10 19:47:03 +00:00
|
|
|
|
2018-02-20 11:24:46 +00:00
|
|
|
socket.on("push:unregister", () => client.unregisterPushSubscription(token));
|
|
|
|
}
|
2017-07-10 19:47:03 +00:00
|
|
|
|
2017-08-15 09:44:29 +00:00
|
|
|
const sendSessionList = () => {
|
|
|
|
const sessions = _.map(client.config.sessions, (session, sessionToken) => ({
|
|
|
|
current: sessionToken === token,
|
|
|
|
active: _.find(client.attachedClients, (u) => u.token === sessionToken) !== undefined,
|
|
|
|
lastUse: session.lastUse,
|
|
|
|
ip: session.ip,
|
|
|
|
agent: session.agent,
|
|
|
|
token: sessionToken, // TODO: Ideally don't expose actual tokens to the client
|
|
|
|
}));
|
|
|
|
|
|
|
|
socket.emit("sessions:list", sessions);
|
|
|
|
};
|
|
|
|
|
|
|
|
socket.on("sessions:get", sendSessionList);
|
|
|
|
|
2017-12-11 19:01:15 +00:00
|
|
|
if (!Helper.config.public) {
|
|
|
|
socket.on("setting:set", (newSetting) => {
|
|
|
|
if (!newSetting || typeof newSetting !== "object") {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-01-16 08:59:52 +00:00
|
|
|
if (typeof newSetting.value === "object" || typeof newSetting.name !== "string" || newSetting.name[0] === "_") {
|
2019-01-16 08:52:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-12-11 19:01:15 +00:00
|
|
|
// We do not need to do write operations and emit events if nothing changed.
|
|
|
|
if (client.config.clientSettings[newSetting.name] !== newSetting.value) {
|
|
|
|
client.config.clientSettings[newSetting.name] = newSetting.value;
|
|
|
|
|
|
|
|
// Pass the setting to all clients.
|
|
|
|
client.emit("setting:new", {
|
|
|
|
name: newSetting.name,
|
|
|
|
value: newSetting.value,
|
|
|
|
});
|
|
|
|
|
|
|
|
client.manager.updateUser(client.name, {
|
|
|
|
clientSettings: client.config.clientSettings,
|
|
|
|
});
|
2019-01-16 09:23:12 +00:00
|
|
|
|
|
|
|
if (newSetting.name === "highlights") {
|
|
|
|
client.compileCustomHighlights();
|
|
|
|
}
|
2017-12-11 19:01:15 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
socket.on("setting:get", () => {
|
|
|
|
if (!client.config.hasOwnProperty("clientSettings")) {
|
|
|
|
socket.emit("setting:all", {});
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const clientSettings = client.config.clientSettings;
|
|
|
|
socket.emit("setting:all", clientSettings);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-08-15 09:44:29 +00:00
|
|
|
socket.on("sign-out", (tokenToSignOut) => {
|
|
|
|
// If no token provided, sign same client out
|
|
|
|
if (!tokenToSignOut) {
|
|
|
|
tokenToSignOut = token;
|
|
|
|
}
|
|
|
|
|
2018-01-05 13:26:12 +00:00
|
|
|
if (!client.config.sessions.hasOwnProperty(tokenToSignOut)) {
|
2017-08-15 09:44:29 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete client.config.sessions[tokenToSignOut];
|
2017-07-24 06:01:25 +00:00
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
client.manager.updateUser(client.name, {
|
2017-11-15 06:35:15 +00:00
|
|
|
sessions: client.config.sessions,
|
2017-07-24 06:01:25 +00:00
|
|
|
});
|
|
|
|
|
2017-08-15 09:44:29 +00:00
|
|
|
_.map(client.attachedClients, (attachedClient, socketId) => {
|
|
|
|
if (attachedClient.token !== tokenToSignOut) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const socketToRemove = manager.sockets.of("/").connected[socketId];
|
|
|
|
|
|
|
|
socketToRemove.emit("sign-out");
|
|
|
|
socketToRemove.disconnect();
|
|
|
|
});
|
|
|
|
|
|
|
|
// Do not send updated session list if user simply logs out
|
|
|
|
if (tokenToSignOut !== token) {
|
|
|
|
sendSessionList();
|
|
|
|
}
|
2017-08-13 18:37:12 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
socket.join(client.id);
|
|
|
|
|
|
|
|
const sendInitEvent = (tokenToSend) => {
|
|
|
|
socket.emit("init", {
|
2017-07-10 19:47:03 +00:00
|
|
|
applicationServerKey: manager.webPush.vapidKeys.publicKey,
|
|
|
|
pushSubscription: client.config.sessions[token],
|
2017-08-13 18:37:12 +00:00
|
|
|
active: client.lastActiveChannel,
|
2017-11-29 19:54:09 +00:00
|
|
|
networks: client.networks.map((network) => network.getFilteredClone(client.lastActiveChannel, lastMessage)),
|
2017-11-15 06:35:15 +00:00
|
|
|
token: tokenToSend,
|
2017-08-13 18:37:12 +00:00
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2017-08-26 16:37:56 +00:00
|
|
|
if (!Helper.config.public && token === null) {
|
2017-08-13 18:37:12 +00:00
|
|
|
client.generateToken((newToken) => {
|
2018-01-05 13:26:12 +00:00
|
|
|
client.attachedClients[socket.id].token = token = client.calculateTokenHash(newToken);
|
2017-08-13 18:37:12 +00:00
|
|
|
|
2017-10-12 07:57:25 +00:00
|
|
|
client.updateSession(token, getClientIp(socket), socket.request);
|
2017-06-21 07:58:29 +00:00
|
|
|
|
2018-01-05 13:26:12 +00:00
|
|
|
sendInitEvent(newToken);
|
2014-08-14 16:35:37 +00:00
|
|
|
});
|
2017-08-13 18:37:12 +00:00
|
|
|
} else {
|
|
|
|
sendInitEvent(null);
|
2014-08-14 16:35:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-15 08:37:05 +00:00
|
|
|
function getClientConfiguration(network) {
|
2017-11-04 17:32:18 +00:00
|
|
|
const config = _.pick(Helper.config, [
|
|
|
|
"public",
|
|
|
|
"lockNetwork",
|
|
|
|
"displayNetwork",
|
|
|
|
"useHexIp",
|
|
|
|
"prefetch",
|
|
|
|
]);
|
|
|
|
|
2018-09-03 07:30:05 +00:00
|
|
|
config.fileUpload = Helper.config.fileUpload.enable;
|
2017-11-04 17:32:18 +00:00
|
|
|
config.ldapEnabled = Helper.config.ldap.enable;
|
|
|
|
|
2017-11-15 18:43:38 +00:00
|
|
|
if (config.displayNetwork) {
|
2018-03-15 08:37:05 +00:00
|
|
|
config.defaults = _.clone(network || Helper.config.defaults);
|
2018-01-31 21:14:26 +00:00
|
|
|
} else {
|
|
|
|
// Only send defaults that are visible on the client
|
2018-03-15 08:37:05 +00:00
|
|
|
config.defaults = _.pick(network || Helper.config.defaults, [
|
2018-08-11 22:10:13 +00:00
|
|
|
"name",
|
2018-01-31 21:14:26 +00:00
|
|
|
"nick",
|
|
|
|
"username",
|
2018-02-15 20:26:19 +00:00
|
|
|
"password",
|
2018-01-31 21:14:26 +00:00
|
|
|
"realname",
|
|
|
|
"join",
|
|
|
|
]);
|
2017-11-15 18:43:38 +00:00
|
|
|
}
|
|
|
|
|
2018-03-15 08:37:05 +00:00
|
|
|
if (!network) {
|
|
|
|
config.version = pkg.version;
|
|
|
|
config.gitCommit = Helper.getGitCommit();
|
|
|
|
config.themes = themes.getAll();
|
|
|
|
config.defaultTheme = Helper.config.theme;
|
2018-04-03 14:49:22 +00:00
|
|
|
config.defaults.nick = Helper.getDefaultNick();
|
2018-03-15 08:37:05 +00:00
|
|
|
}
|
2018-02-21 15:29:22 +00:00
|
|
|
|
2018-09-03 07:30:05 +00:00
|
|
|
if (Uploader) {
|
|
|
|
config.fileUploadMaxFileSize = Uploader.getMaxFileSize();
|
|
|
|
}
|
|
|
|
|
2017-11-04 17:32:18 +00:00
|
|
|
return config;
|
|
|
|
}
|
|
|
|
|
2018-01-05 17:40:34 +00:00
|
|
|
function getServerConfiguration() {
|
|
|
|
const config = _.clone(Helper.config);
|
|
|
|
|
|
|
|
config.stylesheets = packages.getStylesheets();
|
|
|
|
|
|
|
|
return config;
|
|
|
|
}
|
|
|
|
|
2017-08-13 18:37:12 +00:00
|
|
|
function performAuthentication(data) {
|
2018-08-29 10:55:30 +00:00
|
|
|
if (typeof data !== "object") {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-21 07:58:29 +00:00
|
|
|
const socket = this;
|
|
|
|
let client;
|
2018-01-05 13:26:12 +00:00
|
|
|
let token = null;
|
2017-06-21 07:58:29 +00:00
|
|
|
|
2018-01-05 13:26:12 +00:00
|
|
|
const finalInit = () => initializeClient(socket, client, token, data.lastMessage || -1);
|
2017-08-13 18:37:12 +00:00
|
|
|
|
2017-06-21 07:58:29 +00:00
|
|
|
const initClient = () => {
|
2017-11-04 17:32:18 +00:00
|
|
|
socket.emit("configuration", getClientConfiguration());
|
|
|
|
|
2017-10-12 07:57:25 +00:00
|
|
|
client.ip = getClientIp(socket);
|
2017-12-28 13:34:49 +00:00
|
|
|
client.language = getClientLanguage(socket);
|
2017-08-13 18:37:12 +00:00
|
|
|
|
|
|
|
// If webirc is enabled perform reverse dns lookup
|
|
|
|
if (Helper.config.webirc === null) {
|
|
|
|
return finalInit();
|
2017-06-21 07:58:29 +00:00
|
|
|
}
|
2017-08-13 18:37:12 +00:00
|
|
|
|
|
|
|
reverseDnsLookup(client.ip, (hostname) => {
|
|
|
|
client.hostname = hostname;
|
|
|
|
|
|
|
|
finalInit();
|
|
|
|
});
|
2017-06-21 07:58:29 +00:00
|
|
|
};
|
|
|
|
|
2016-06-08 09:26:24 +00:00
|
|
|
if (Helper.config.public) {
|
2016-07-30 01:20:38 +00:00
|
|
|
client = new Client(manager);
|
2014-08-14 16:35:37 +00:00
|
|
|
manager.clients.push(client);
|
2017-06-21 07:58:29 +00:00
|
|
|
|
2014-08-14 16:35:37 +00:00
|
|
|
socket.on("disconnect", function() {
|
|
|
|
manager.clients = _.without(manager.clients, client);
|
|
|
|
client.quit();
|
|
|
|
});
|
2017-06-21 07:58:29 +00:00
|
|
|
|
|
|
|
initClient();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const authCallback = (success) => {
|
|
|
|
// Authorization failed
|
|
|
|
if (!success) {
|
2018-03-17 08:09:59 +00:00
|
|
|
if (!client) {
|
|
|
|
log.warn(`Authentication for non existing user attempted from ${colors.bold(getClientIp(socket))}`);
|
|
|
|
} else {
|
|
|
|
log.warn(`Authentication failed for user ${colors.bold(data.user)} from ${colors.bold(getClientIp(socket))}`);
|
|
|
|
}
|
|
|
|
|
2017-06-21 07:58:29 +00:00
|
|
|
socket.emit("auth", {success: false});
|
|
|
|
return;
|
2016-04-03 05:12:49 +00:00
|
|
|
}
|
2016-07-30 01:20:38 +00:00
|
|
|
|
2017-06-21 07:58:29 +00:00
|
|
|
// If authorization succeeded but there is no loaded user,
|
|
|
|
// load it and find the user again (this happens with LDAP)
|
|
|
|
if (!client) {
|
2017-10-15 16:05:19 +00:00
|
|
|
client = manager.loadUser(data.user);
|
2016-07-30 01:20:38 +00:00
|
|
|
}
|
|
|
|
|
2017-06-21 07:58:29 +00:00
|
|
|
initClient();
|
|
|
|
};
|
2016-07-30 01:20:38 +00:00
|
|
|
|
2017-06-21 07:58:29 +00:00
|
|
|
client = manager.findClient(data.user);
|
|
|
|
|
|
|
|
// We have found an existing user and client has provided a token
|
2018-01-05 13:26:12 +00:00
|
|
|
if (client && data.token) {
|
|
|
|
const providedToken = client.calculateTokenHash(data.token);
|
2017-06-21 07:58:29 +00:00
|
|
|
|
2018-01-05 13:26:12 +00:00
|
|
|
if (client.config.sessions.hasOwnProperty(providedToken)) {
|
|
|
|
token = providedToken;
|
|
|
|
|
|
|
|
client.updateSession(providedToken, getClientIp(socket), socket.request);
|
|
|
|
|
|
|
|
return authCallback(true);
|
|
|
|
}
|
2017-06-21 07:58:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Perform password checking
|
2017-09-01 09:44:53 +00:00
|
|
|
let auth = () => {
|
|
|
|
log.error("None of the auth plugins is enabled");
|
|
|
|
};
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-09-01 09:44:53 +00:00
|
|
|
for (let i = 0; i < authPlugins.length; ++i) {
|
|
|
|
if (authPlugins[i].isEnabled()) {
|
|
|
|
auth = authPlugins[i].auth;
|
|
|
|
break;
|
|
|
|
}
|
2014-08-14 16:35:37 +00:00
|
|
|
}
|
2018-02-20 07:28:04 +00:00
|
|
|
|
2017-08-29 16:05:06 +00:00
|
|
|
auth(manager, client, data.user, data.password, authCallback);
|
2014-08-14 16:35:37 +00:00
|
|
|
}
|
2017-08-13 18:37:12 +00:00
|
|
|
|
|
|
|
function reverseDnsLookup(ip, callback) {
|
|
|
|
dns.reverse(ip, (err, hostnames) => {
|
|
|
|
if (!err && hostnames.length) {
|
|
|
|
return callback(hostnames[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
callback(ip);
|
|
|
|
});
|
|
|
|
}
|