2013-07-19 20:27:21 +00:00
|
|
|
var path = require("path");
|
2013-07-28 23:47:55 +00:00
|
|
|
var fs = require("fs");
|
2013-09-09 22:16:41 +00:00
|
|
|
var http = require("http");
|
|
|
|
var https = require("https");
|
2013-04-17 18:42:29 +00:00
|
|
|
var express = require("express");
|
2013-07-15 22:57:33 +00:00
|
|
|
var Config = require("./config");
|
|
|
|
var Logger = require("./logger");
|
|
|
|
var Channel = require("./channel");
|
|
|
|
var User = require("./user");
|
2013-10-09 23:10:26 +00:00
|
|
|
var $util = require("./utilities");
|
2013-04-22 19:42:39 +00:00
|
|
|
|
2013-10-02 04:02:31 +00:00
|
|
|
const VERSION = "2.4.3";
|
2013-04-25 16:00:06 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
|
|
|
|
var Server = function (cfg) {
|
|
|
|
var self = this;
|
|
|
|
|
|
|
|
self.cfg = cfg;
|
|
|
|
self.channels = [],
|
|
|
|
self.express = null;
|
|
|
|
self.http = null;
|
|
|
|
self.https = null;
|
|
|
|
self.io = null;
|
|
|
|
self.ioWeb = null;
|
|
|
|
self.ioSecure = null;
|
|
|
|
self.ipCount = {};
|
|
|
|
self.db = null;
|
|
|
|
self.acp = null;
|
|
|
|
self.api = null;
|
|
|
|
self.announcement = null;
|
|
|
|
self.httplog = null;
|
|
|
|
self.actionlog = null;
|
|
|
|
self.infogetter = null;
|
|
|
|
|
|
|
|
// database init ------------------------------------------------------
|
|
|
|
var Database = require("./database");
|
|
|
|
self.db = new Database(self.cfg);
|
|
|
|
// TODO self.db.init();
|
|
|
|
self.actionlog = require("./actionlog")(self);
|
|
|
|
self.httplog = new Logger.Logger(path.join(__dirname,
|
|
|
|
"../httpaccess.log"));
|
|
|
|
// webserver init -----------------------------------------------------
|
|
|
|
self.express = express();
|
|
|
|
self.express.use(express.bodyParser());
|
|
|
|
|
|
|
|
// channel route
|
|
|
|
self.express.get("/r/:channel(*)", function (req, res, next) {
|
|
|
|
var c = req.params.channel;
|
|
|
|
if (!$util.isValidChannelName(c)) {
|
|
|
|
res.redirect("/" + c);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
self.logHTTP(req);
|
|
|
|
res.sendfile("channel.html", {
|
|
|
|
root: path.join(__dirname, "../www")
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
// api route
|
|
|
|
self.api = require("./api")(self);
|
|
|
|
|
|
|
|
// default route
|
|
|
|
self.express.get("/:thing(*)", function (req, res, next) {
|
|
|
|
var opts = {
|
|
|
|
root: path.join(__dirname, "../www"),
|
|
|
|
maxAge: self.cfg["asset-cache-ttl"]
|
|
|
|
};
|
|
|
|
|
|
|
|
res.sendfile(req.params.thing, opts, function (e) {
|
|
|
|
if (e) {
|
|
|
|
self.logHTTP(req, e.status);
|
|
|
|
if (req.params.thing.match(/\.\.|(%25)?%2e(%25)?%2e/)) {
|
|
|
|
res.send("Don't try that again.");
|
|
|
|
Logger.syslog.log("WARNING: Attempted path traversal "+
|
|
|
|
"from IP " + self.getHTTPIP(req));
|
|
|
|
Logger.syslog.log("Path was: " + req.url);
|
|
|
|
self.actionlog.record(self.getHTTPIP(req), "",
|
|
|
|
"path-traversal",
|
|
|
|
req.url);
|
|
|
|
} else if (e.status >= 500) {
|
|
|
|
Logger.errlog.log(err);
|
|
|
|
}
|
|
|
|
res.send(e.status);
|
|
|
|
} else {
|
|
|
|
self.logHTTP(req);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
// fallback route
|
|
|
|
self.express.use(function (err, req, res, next) {
|
|
|
|
self.logHTTP(req, err.status);
|
|
|
|
if (err.status === 404) {
|
|
|
|
res.send(404);
|
|
|
|
} else {
|
|
|
|
next(err);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
// http/https/sio server init -----------------------------------------
|
|
|
|
if (self.cfg["enable-ssl"]) {
|
|
|
|
var key = fs.readFileSync(path.resolve(__dirname, "..",
|
|
|
|
self.cfg["ssl-keyfile"]));
|
|
|
|
var cert = fs.readFileSync(path.resolve(__dirname, "..",
|
|
|
|
self.cfg["ssl-certfile"]));
|
|
|
|
var opts = {
|
|
|
|
key: key,
|
|
|
|
cert: cert,
|
|
|
|
passphrase: self.cfg["ssl-passphrase"]
|
|
|
|
};
|
|
|
|
|
|
|
|
self.https = https.createServer(opts, self.express)
|
|
|
|
.listen(self.cfg["ssl-port"]);
|
|
|
|
self.ioSecure = require("socket.io").listen(self.https);
|
|
|
|
self.ioSecure.set("log level", 1);
|
|
|
|
self.ioSecure.on("connection", function (sock) {
|
|
|
|
self.handleSocketConnection(sock);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
self.http = self.express.listen(self.cfg["web-port"],
|
|
|
|
self.cfg["express-host"]);
|
|
|
|
self.ioWeb = express().listen(self.cfg["io-port"], self.cfg["io-host"]);
|
|
|
|
self.io = require("socket.io").listen(self.ioWeb);
|
|
|
|
self.io.set("log level", 1);
|
|
|
|
self.io.sockets.on("connection", function (sock) {
|
|
|
|
self.handleSocketConnection(sock);
|
|
|
|
});
|
|
|
|
|
|
|
|
// acp init -----------------------------------------------------------
|
|
|
|
self.acp = require("./acp")(self);
|
|
|
|
|
|
|
|
// background tasks init ----------------------------------------------
|
|
|
|
require("./bgtask")(self);
|
|
|
|
|
|
|
|
// media metadata retriever init --------------------------------------
|
|
|
|
// TODO make the constructor just accept cfg?
|
|
|
|
self.infogetter = require("./get-info")(self);
|
|
|
|
};
|
|
|
|
|
|
|
|
Server.prototype.getHTTPIP = function (req) {
|
2013-07-06 17:00:02 +00:00
|
|
|
var raw = req.connection.remoteAddress;
|
2013-06-04 03:56:06 +00:00
|
|
|
var forward = req.header("x-forwarded-for");
|
2013-10-09 23:10:26 +00:00
|
|
|
if((this.cfg["trust-x-forward"] || raw === "127.0.0.1") && forward) {
|
2013-07-15 22:57:33 +00:00
|
|
|
var ip = forward.split(",")[0];
|
|
|
|
Logger.syslog.log("REVPROXY " + raw + " => " + ip);
|
2013-07-06 17:00:02 +00:00
|
|
|
return ip;
|
2013-06-04 03:56:06 +00:00
|
|
|
}
|
2013-07-06 17:00:02 +00:00
|
|
|
return raw;
|
2013-10-09 23:10:26 +00:00
|
|
|
};
|
2013-06-04 03:56:06 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Server.prototype.getSocketIP = function (socket) {
|
2013-07-06 17:00:02 +00:00
|
|
|
var raw = socket.handshake.address.address;
|
2013-10-09 23:10:26 +00:00
|
|
|
if(this.cfg["trust-x-forward"] || raw === "127.0.0.1") {
|
2013-07-06 17:00:02 +00:00
|
|
|
if(typeof socket.handshake.headers["x-forwarded-for"] == "string") {
|
2013-07-15 22:57:33 +00:00
|
|
|
var ip = socket.handshake.headers["x-forwarded-for"]
|
|
|
|
.split(",")[0];
|
|
|
|
Logger.syslog.log("REVPROXY " + raw + " => " + ip);
|
2013-07-06 17:00:02 +00:00
|
|
|
return ip;
|
|
|
|
}
|
|
|
|
}
|
2013-07-15 22:57:33 +00:00
|
|
|
return raw;
|
2013-10-09 23:10:26 +00:00
|
|
|
};
|
2013-07-15 22:57:33 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Server.prototype.isChannelLoaded = function (name) {
|
|
|
|
name = name.toLowerCase();
|
|
|
|
for (var i = 0; i < this.channels.length; i++) {
|
|
|
|
if (this.channels[i].canonical_name == name)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
};
|
2013-09-09 22:16:41 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Server.prototype.getChannel = function (name) {
|
|
|
|
var cname = name.toLowerCase();
|
|
|
|
for (var i = 0; i < this.channels.length; i++) {
|
|
|
|
if (this.channels[i].canonical_name == name)
|
|
|
|
return this.channels[i];
|
|
|
|
}
|
2013-09-09 22:16:41 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
var c = new Channel(name, this);
|
|
|
|
this.channels.push(c);
|
|
|
|
return c;
|
|
|
|
};
|
2013-09-09 22:16:41 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Server.prototype.unloadChannel = function (chan) {
|
|
|
|
if (chan.registered)
|
|
|
|
chan.saveDump();
|
2013-09-09 22:16:41 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
chan.playlist.die();
|
|
|
|
chan.logger.close();
|
|
|
|
for (var i = 0; i < this.channels.length; i++) {
|
|
|
|
if (this.channels[i].canonical_name === chan.canonical_name) {
|
|
|
|
this.channels.splice(i, 1);
|
|
|
|
i--;
|
|
|
|
}
|
|
|
|
}
|
2013-03-28 23:51:08 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
// Empty all outward references from the channel
|
|
|
|
var keys = Object.keys(chan);
|
|
|
|
for (var i in keys) {
|
|
|
|
delete chan[keys[i]];
|
|
|
|
}
|
|
|
|
chan.dead = true;
|
|
|
|
};
|
2013-08-20 04:53:33 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Server.prototype.logHTTP = function (req, status) {
|
|
|
|
if (status === undefined)
|
|
|
|
status = 200;
|
2013-07-20 01:59:39 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
var ip = req.connection.remoteAddress;
|
|
|
|
var ip2 = req.header("x-forwarded-for") ||
|
|
|
|
req.header("cf-connecting-ip");
|
|
|
|
var ipstr = !ip2 ? ip : ip + " (X-Forwarded-For " + ip2 + ")";
|
|
|
|
var url = req.url;
|
|
|
|
// Remove query
|
|
|
|
if(url.indexOf("?") != -1)
|
|
|
|
url = url.substring(0, url.lastIndexOf("?"));
|
|
|
|
this.httplog.log([
|
|
|
|
ipstr,
|
|
|
|
req.method,
|
|
|
|
url,
|
|
|
|
status,
|
|
|
|
req.header("user-agent")
|
|
|
|
].join(" "));
|
|
|
|
};
|
2013-03-28 23:51:08 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Server.prototype.handleSocketConnection = function (socket) {
|
|
|
|
var self = this;
|
|
|
|
var ip = self.getSocketIP(socket);
|
|
|
|
socket._ip = ip;
|
2013-05-03 18:15:05 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
// Check for global ban on the IP
|
|
|
|
self.db.isGlobalIPBanned(ip, function (err, banned) {
|
|
|
|
if (banned) {
|
|
|
|
Logger.syslog.log("Disconnecting " + ip + " - global banned");
|
|
|
|
socket.emit("kick", { reason: "Your IP is globally banned." });
|
|
|
|
socket.disconnect(true);
|
2013-09-09 22:16:41 +00:00
|
|
|
}
|
2013-10-09 23:10:26 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
socket.on("disconnect", function () {
|
|
|
|
self.ipCount[ip]--;
|
|
|
|
});
|
|
|
|
|
|
|
|
if (!(ip in self.ipCount))
|
|
|
|
self.ipCount[ip] = 0;
|
|
|
|
|
|
|
|
self.ipCount[ip]++;
|
|
|
|
if (self.ipCount[ip] > self.cfg["ip-connection-limit"]) {
|
|
|
|
socket.emit("kick", {
|
|
|
|
reason: "Too many connections from your IP address"
|
2013-09-09 22:16:41 +00:00
|
|
|
});
|
2013-10-09 23:10:26 +00:00
|
|
|
socket.disconnect(true);
|
|
|
|
return;
|
|
|
|
}
|
2013-07-14 02:19:47 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Logger.syslog.log("Accepted socket from " + ip);
|
|
|
|
new User(socket, self);
|
|
|
|
};
|
2013-07-16 03:01:12 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
Server.prototype.shutdown = function () {
|
|
|
|
Logger.syslog.log("Unloading channels");
|
|
|
|
for (var i = 0; i < this.channels.length; i++) {
|
|
|
|
if (this.channels[i].registered) {
|
|
|
|
Logger.syslog.log("Saving /r/" + this.channels[i].name);
|
|
|
|
this.channels[i].saveDump();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Logger.syslog.log("Goodbye");
|
|
|
|
process.exit(0);
|
|
|
|
};
|
2013-07-16 18:57:34 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
var singleton = null;
|
2013-08-03 14:52:24 +00:00
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
module.exports = {
|
|
|
|
init: function (cfg) {
|
|
|
|
singleton = new Server(cfg);
|
|
|
|
return singleton;
|
2013-07-15 22:57:33 +00:00
|
|
|
},
|
2013-10-09 23:10:26 +00:00
|
|
|
|
|
|
|
getServer: function () {
|
|
|
|
return singleton;
|
2013-07-15 22:57:33 +00:00
|
|
|
}
|
|
|
|
};
|
2013-07-14 02:19:47 +00:00
|
|
|
|
2013-07-15 22:57:33 +00:00
|
|
|
Logger.syslog.log("Starting CyTube v" + VERSION);
|
2013-09-05 18:48:05 +00:00
|
|
|
var chanlogpath = path.join(__dirname, "../chanlogs");
|
|
|
|
fs.exists(chanlogpath, function (exists) {
|
|
|
|
exists || fs.mkdir(chanlogpath);
|
2013-07-28 23:47:13 +00:00
|
|
|
});
|
|
|
|
|
2013-09-05 18:48:05 +00:00
|
|
|
var chandumppath = path.join(__dirname, "../chandump");
|
|
|
|
fs.exists(chandumppath, function (exists) {
|
|
|
|
exists || fs.mkdir(chandumppath);
|
2013-07-28 23:47:13 +00:00
|
|
|
});
|
|
|
|
|
2013-10-09 23:10:26 +00:00
|
|
|
var x = {};
|
|
|
|
Config.load(x, path.join(__dirname, "../cfg.json"), function () {
|
|
|
|
module.exports.init(x.cfg);
|
|
|
|
if(!singleton.cfg["debug"]) {
|
2013-07-28 15:49:29 +00:00
|
|
|
process.on("uncaughtException", function (err) {
|
|
|
|
Logger.errlog.log("[SEVERE] Uncaught Exception: " + err);
|
|
|
|
Logger.errlog.log(err.stack);
|
|
|
|
});
|
2013-07-14 02:19:47 +00:00
|
|
|
|
2013-07-28 15:49:29 +00:00
|
|
|
process.on("SIGINT", function () {
|
2013-10-09 23:10:26 +00:00
|
|
|
singleton.shutdown();
|
2013-07-28 15:49:29 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|