2712 lines
148 KiB
JavaScript
2712 lines
148 KiB
JavaScript
'use strict';
|
|
const path = require('path');
|
|
const classPath = path.resolve(__dirname + path.sep + "includes" + path.sep + "classes" + path.sep) + path.sep;
|
|
require(classPath + "Prototypes.js");
|
|
const { WTVShared, clientShowAlert } = require(classPath + "WTVShared.js");
|
|
const wtvshared = new WTVShared(); // creates minisrv_config
|
|
|
|
const fs = wtvshared.fs;
|
|
const zlib = wtvshared.zlib;
|
|
const process = wtvshared.process;
|
|
const util = wtvshared.util;
|
|
const nunjucks = require('nunjucks');
|
|
const {serialize, unserialize} = require('php-serialize');
|
|
const {spawn, spawnSync} = require('child_process');
|
|
const http = require('follow-redirects').http;
|
|
const httpx = require(classPath + "/HTTPX.js");
|
|
const { URL } = require('url');
|
|
const net = require('net');
|
|
const crypto = require('crypto')
|
|
const CryptoJS = require('crypto-js');
|
|
const sharp = require('sharp')
|
|
const WTVSec = require(classPath + "/WTVSec.js");
|
|
const WTVSSL = require(classPath + "/WTVSSL.js");
|
|
const LZPF = require(classPath + "/LZPF.js");
|
|
const WTVClientCapabilities = require(classPath + "/WTVClientCapabilities.js");
|
|
const WTVClientSessionData = require(classPath + "/WTVClientSessionData.js");
|
|
const WTVMime = require(classPath + "/WTVMime.js");
|
|
const WTVFlashrom = require(classPath + "/WTVFlashrom.js");
|
|
const WTVImage = require(classPath + "/WTVImage.js");
|
|
const WTVAudioProxy = require(classPath + "/WTVAudioProxy.js");
|
|
const vm = require('vm');
|
|
const debug = require('debug')('app');
|
|
const express = require('express');
|
|
let handlerModules = [];
|
|
|
|
let wtvnewsserver = null;
|
|
const protocolServers = [];
|
|
|
|
const minisrv_config = wtvshared.getMiniSrvConfig(); // snatches minisrv_config
|
|
const wtvmime = new WTVMime(minisrv_config);
|
|
const wtvAudioProxy = new WTVAudioProxy(minisrv_config);
|
|
|
|
function validateAudioProxy() {
|
|
if (!wtvAudioProxy || !wtvAudioProxy.isEnabled()) return;
|
|
|
|
try {
|
|
const check = spawnSync(wtvAudioProxy.config.ffmpegPath, ['-hide_banner', '-version'], {
|
|
stdio: ['ignore', 'ignore', 'ignore'],
|
|
timeout: 5000
|
|
});
|
|
|
|
if (check.error || check.status !== 0) {
|
|
console.warn(` # AudioProxy disabled: ffmpeg not found or failed to execute at '${wtvAudioProxy.config.ffmpegPath}'.`);
|
|
if (check.error) console.warn(` # AudioProxy ffmpeg error: ${check.error.message}`);
|
|
wtvAudioProxy.config.enabled = false;
|
|
return;
|
|
}
|
|
|
|
console.log(` * AudioProxy enabled: transcoding audio to ${wtvAudioProxy.config.bitrate} ${wtvAudioProxy.config.sampleRate}Hz mono MP3.`);
|
|
} catch (error) {
|
|
console.warn(` # AudioProxy disabled: ffmpeg validation failed: ${error.message}`);
|
|
wtvAudioProxy.config.enabled = false;
|
|
}
|
|
}
|
|
|
|
process
|
|
.on('SIGTERM', shutdown('SIGTERM'))
|
|
.on('SIGINT', shutdown('SIGINT'))
|
|
.on('uncaughtException', function (err) {
|
|
console.error((err && err.stack) ? err.stack : err);
|
|
});
|
|
|
|
|
|
function shutdown(signal = 'SIGTERM') {
|
|
return (err) => {
|
|
console.log("Received signal", signal);
|
|
if (err) console.error(err.stack || err);
|
|
process.exit(err ? 1 : 0);
|
|
};
|
|
}
|
|
|
|
function getServiceEnabled(service) {
|
|
if (minisrv_config.services[service]) {
|
|
if (minisrv_config.services[service].disabled) return false;
|
|
else return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function getServiceByPort(port) {
|
|
let service_name;
|
|
Object.keys(minisrv_config.services).forEach((k) => {
|
|
if (service_name) return;
|
|
if (minisrv_config.services[k].port) {
|
|
if (port === parseInt(minisrv_config.services[k].port) && getServiceEnabled(k))
|
|
service_name = k;
|
|
}
|
|
})
|
|
return service_name;
|
|
}
|
|
|
|
function getServiceByVHost(vhost) {
|
|
let service_name;
|
|
Object.keys(minisrv_config.services).forEach((k) => {
|
|
if (service_name) return;
|
|
if (minisrv_config.services[k].vhost) {
|
|
if (vhost.toLowerCase() === minisrv_config.services[k].vhost.toLowerCase())
|
|
service_name = k;
|
|
}
|
|
})
|
|
return service_name;
|
|
}
|
|
|
|
function getPortByService(service) {
|
|
if (minisrv_config.services[service]) return minisrv_config.services[service].port;
|
|
else return null;
|
|
}
|
|
|
|
function getSocketServer(socket) {
|
|
let server;
|
|
if (socket._server) {
|
|
if (socket._server._connectionKey) server = socket._server;
|
|
} else if (socket._parent) {
|
|
if (socket._parent._server) {
|
|
if (socket._parent._server._connectionKey) server = socket._parent._server;
|
|
}
|
|
}
|
|
return server;
|
|
}
|
|
|
|
function getSocketDestinationPort(socket) {
|
|
return getServerDestinationPort(getSocketServer(socket));
|
|
}
|
|
|
|
function getServerDestinationPort(server) {
|
|
return parseInt(server._connectionKey.split(':')[2]);
|
|
}
|
|
|
|
function verifyServicePort(service_name, socket) {
|
|
if (!minisrv_config.config.enable_port_isolation) return service_name;
|
|
const server = getSocketServer(socket);
|
|
if (server) {
|
|
const socketPort = getServerDestinationPort(server);
|
|
if (minisrv_config.services[service_name]) {
|
|
if (minisrv_config.services[service_name].port === socketPort) {
|
|
if (minisrv_config.services[service_name].servicevault_dir)
|
|
return minisrv_config.services[service_name].servicevault_dir;
|
|
else
|
|
return service_name;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function getServiceByVaultDir(vault_dir) {
|
|
let res = vault_dir;
|
|
Object.keys(minisrv_config.services).forEach((k) => {
|
|
if (res !== vault_dir) return;
|
|
if (minisrv_config.services[k].servicevault_dir) {
|
|
if (minisrv_config.services[k].servicevault_dir === vault_dir) {
|
|
res = k;
|
|
return false;
|
|
}
|
|
} else {
|
|
if (k === vault_dir) {
|
|
res = k;
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
return res;
|
|
}
|
|
|
|
function configureService(service_name, service_obj, initial = false) {
|
|
if (service_obj.disabled) return false;
|
|
|
|
service_obj.service_name = service_name;
|
|
if (!service_obj.host) {
|
|
service_obj.host = minisrv_config.config.service_ip;
|
|
}
|
|
if (service_obj.port && !service_obj.nobind && initial) {
|
|
if (service_obj.pc_services) pc_ports.push(service_obj.port);
|
|
else ports.push(service_obj.port);
|
|
}
|
|
|
|
// Exclude protocols that handle their own ports
|
|
if (service_obj.handler_handles_port) {
|
|
return true;
|
|
}
|
|
|
|
// minisrv_config service toString
|
|
service_obj.toString = function (overrides) {
|
|
const self = Object.assign({}, this);
|
|
if (overrides !== null) {
|
|
if (typeof (overrides) === 'object') {
|
|
Object.keys(overrides).forEach(function (k) {
|
|
if (k !== "exceptions") self[k] = overrides[k];
|
|
});
|
|
}
|
|
}
|
|
let outstr = '';
|
|
if ((service_name === "wtv-star" && self.no_star_word !== true) || service_name !== "wtv-star") {
|
|
outstr = `wtv-service: name=${self.service_name} host=${self.host} port=${self.port}`;
|
|
if (self.flags) outstr += ` flags=${self.flags}`;
|
|
if (self.connections) outstr += ` connections=${self.connections}`;
|
|
}
|
|
if (service_name === "wtv-star") {
|
|
outstr += `\nwtv-service: name=wtv-* host=${self.host} port=${self.port}`;
|
|
if (self.flags) outstr += ` flags=${self.flags}`;
|
|
if (self.connections) outstr += ` connections=${self.connections}`;
|
|
}
|
|
return outstr;
|
|
}
|
|
minisrv_config.services[service_name] = service_obj;
|
|
return true;
|
|
}
|
|
|
|
// Where we store our session information
|
|
let ssid_sessions = [];
|
|
let socket_sessions = [];
|
|
|
|
const ports = [];
|
|
const pc_ports = [];
|
|
|
|
function getServiceString(service_name, overrides = {}) {
|
|
wtvshared.getServiceString(service_name, overrides);
|
|
}
|
|
|
|
|
|
const DEPRECIATED_CONFIG_PATH = path.join(__dirname, 'includes', 'depreciated.json');
|
|
|
|
function loadDepreciatedPatterns() {
|
|
try {
|
|
if (!fs.existsSync(DEPRECIATED_CONFIG_PATH)) {
|
|
return {};
|
|
}
|
|
|
|
const raw = fs.readFileSync(DEPRECIATED_CONFIG_PATH, 'utf8');
|
|
const parsed = JSON.parse(raw);
|
|
|
|
if (!Array.isArray(parsed) || parsed.length === 0) {
|
|
return {};
|
|
}
|
|
|
|
const mapped = parsed
|
|
.filter((entry) => entry && typeof entry.pattern === 'string')
|
|
.map((entry) => ({
|
|
id: entry.id || entry.pattern,
|
|
pattern: new RegExp(entry.pattern, entry.flags || 'g'),
|
|
message: entry.message || 'Deprecated API usage found',
|
|
removeVersion: entry.removeVersion || 'unknown',
|
|
replacement: entry.replacement || null
|
|
}));
|
|
|
|
return mapped.length > 0 ? mapped : {};
|
|
} catch (error) {
|
|
console.warn('Failed to load includes/depreciated.json, using fallback deprecation patterns:', error.message);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
|
|
// Deprecation warnings configuration
|
|
const deprecationWarnings = {
|
|
// Array of deprecated patterns with their details
|
|
patterns: loadDepreciatedPatterns(),
|
|
|
|
// Enable/disable deprecation warnings globally
|
|
enabled: true,
|
|
|
|
// Log level for deprecation warnings (console.warn, console.log, etc.)
|
|
logLevel: 'warn'
|
|
};
|
|
|
|
function checkDeprecationWarnings(script_data, filename = null, debug_name = null) {
|
|
if (!deprecationWarnings.enabled || !script_data) return;
|
|
|
|
const scriptSource = filename || debug_name || 'unknown script';
|
|
const foundDeprecations = [];
|
|
|
|
deprecationWarnings.patterns.forEach(deprecation => {
|
|
const matches = script_data.match(deprecation.pattern);
|
|
if (matches) {
|
|
const uniqueMatches = [...new Set(matches)]; // Remove duplicates
|
|
uniqueMatches.forEach(match => {
|
|
foundDeprecations.push({
|
|
pattern: match.trim(),
|
|
message: deprecation.message,
|
|
removeVersion: deprecation.removeVersion,
|
|
replacement: deprecation.replacement
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
if (foundDeprecations.length > 0) {
|
|
const logFunction = console[deprecationWarnings.logLevel] || console.warn;
|
|
|
|
logFunction(`\n⚠️ DEPRECATION WARNING(S) in ${scriptSource}:`);
|
|
foundDeprecations.forEach((dep, index) => {
|
|
logFunction(` ${index + 1}. ${dep.pattern}: ${dep.message} in version ${dep.removeVersion}`);
|
|
if (dep.replacement) {
|
|
logFunction(` → ${dep.replacement}`);
|
|
}
|
|
});
|
|
logFunction(''); // Empty line for readability
|
|
}
|
|
}
|
|
|
|
async function sendRawFile(socket, path) {
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Found " + path + " to handle request (Direct File Mode) [Socket " + socket.id + "]");
|
|
const contypes = wtvmime.getContentType(path);
|
|
let headers = "200 OK\n"
|
|
headers += "Content-Type: " + contypes[0] + "\n";
|
|
headers += "wtv-modern-content-type: " + contypes[1];
|
|
fs.readFile(path, null, function (err, data) {
|
|
sendToClient(socket, headers, data);
|
|
});
|
|
}
|
|
|
|
const runScriptInVM = function (script_data, user_contextObj = {}, privileged = false, filename = null, debug_name = null) {
|
|
// Check for deprecation warnings before execution
|
|
checkDeprecationWarnings(script_data, filename, debug_name);
|
|
|
|
// Here we define the ServiceVault Script Context Object
|
|
// The ServiceVault scripts will only be allowed to access the following functions/variables.
|
|
// Furthermore, only modifications to variables in `updateFromVM` will be saved.
|
|
// Example: an attempt to change "minisrv_config" from a ServiceVault script would be discarded
|
|
|
|
// try to build a name for the script's debug() calls
|
|
if (!debug_name) {
|
|
// try to make the debug name
|
|
let debug_name = (filename) ? filename.split(path.sep) : null;
|
|
if (debug_name) {
|
|
if (wtvshared.isConfiguredService(debug_name[debug_name.length - 2]))
|
|
// service:/filename
|
|
debug_name = debug_name[debug_name.length - 2] + ":/" + debug_name[debug_name.length - 1];
|
|
else
|
|
// filename
|
|
debug_name = debug_name[debug_name.length - 1];
|
|
}
|
|
}
|
|
|
|
// create global context object
|
|
const contextObj = {
|
|
// node core variables and functions
|
|
"console": console, // needed for per-script debugging
|
|
"__dirname": __dirname, // needed by services such as wtv-flashrom and wtv-disk
|
|
"__filename": (filename) ? filename : null, // path to the script file
|
|
|
|
// Our modules
|
|
"wtvmime": wtvmime,
|
|
"http": require('follow-redirects').http,
|
|
"https": require('follow-redirects').https,
|
|
"util": util,
|
|
"sharp": sharp,
|
|
"nunjucks": nunjucks,
|
|
"URL": URL,
|
|
"URLSearchParams": URLSearchParams,
|
|
"wtvshared": wtvshared,
|
|
"zlib": zlib,
|
|
"clientShowAlert": clientShowAlert,
|
|
"WTVClientSessionData": WTVClientSessionData,
|
|
"WTVClientCapabilities": WTVClientCapabilities,
|
|
"strftime": require('strftime'),
|
|
"CryptoJS": CryptoJS,
|
|
"crypto": crypto,
|
|
"fs": fs,
|
|
"path": path,
|
|
|
|
// Our variables and functions
|
|
"debug": require('debug')((debug_name) ? debug_name : 'service_script'),
|
|
"minisrv_config": minisrv_config,
|
|
"socket": null,
|
|
"headers": null,
|
|
"data": null,
|
|
"request_is_async": false,
|
|
"minisrv_version_string": z_title,
|
|
"getServiceString": getServiceString, // deprecated - use wtvshared.getServiceString() instead
|
|
"sendToClient": sendToClient,
|
|
"service_vaults": service_vaults,
|
|
"service_deps": service_deps,
|
|
"ssid_sessions": ssid_sessions,
|
|
"moveArrayKey": wtvshared.moveArrayKey,
|
|
"cwd": (filename) ? path.dirname(filename) : __dirname, // current working directory
|
|
|
|
// Our prototype overrides
|
|
"Buffer": Buffer,
|
|
"String": String,
|
|
"Object": Object,
|
|
"Array": Array,
|
|
|
|
// add any additional context objects provided with function call
|
|
...user_contextObj
|
|
}
|
|
|
|
// per service overrides
|
|
const modules_loaded = [];
|
|
if (minisrv_config.services[contextObj.service_name]) {
|
|
if (minisrv_config.services[contextObj.service_name].modules) {
|
|
const vm_modules = minisrv_config.services[contextObj.service_name].modules;
|
|
Object.keys(vm_modules).forEach(function (k) {
|
|
const module_file = classPath + path.sep + vm_modules[k] + ".js"
|
|
try {
|
|
contextObj[vm_modules[k]] = require(module_file);
|
|
modules_loaded.push(module_file)
|
|
} catch (e) {
|
|
console.error(" *!* Could not load module", module_file, "requested by service", contextObj.service_name, e)
|
|
}
|
|
// Special case for WTVNews services which require a reference to the server for its functionality
|
|
if (vm_modules[k] === "WTVNews") contextObj['wtvnewsserver'] = wtvnewsserver;
|
|
})
|
|
}
|
|
// Provide flashrom class to any service that is reported as a flashrom service in the config
|
|
if (minisrv_config.services[contextObj.service_name].is_flashrom_service) {
|
|
contextObj["WTVFlashrom"] = WTVFlashrom;
|
|
}
|
|
}
|
|
|
|
switch (contextObj.service_name) {
|
|
case "wtv-guide":
|
|
// wtv-guide is a special case due to needing this function
|
|
contextObj.wtvguide = new contextObj["WTVGuide"](minisrv_config, ssid_sessions[contextObj.socket.ssid], contextObj.socket, runScriptInVM);
|
|
break;
|
|
case "wtv-1800":
|
|
// special case for bf0app (wtv-1800:/noflash)
|
|
contextObj["WTVFlashrom"] = WTVFlashrom;
|
|
break;
|
|
}
|
|
|
|
if (contextObj.socket) {
|
|
if(contextObj.socket.id) {
|
|
if (socket_sessions[contextObj.socket.id]) {
|
|
contextObj.wtv_encrypted = (socket_sessions[contextObj.socket.id].secure === true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (privileged) {
|
|
// Grant the service additional access to global variables, such as the session stores.
|
|
// This is needed for privileged services such as wtv-1800, wtv-setup, wtv-head-waiter, etc. but should be avoided for regular services for security.
|
|
contextObj["privileged"] = true;
|
|
contextObj["require"] = require; // this is dangerous but needed for some scripts at this time
|
|
contextObj["SessionStore"] = SessionStore;
|
|
contextObj["socket_sessions"] = socket_sessions;
|
|
contextObj["reloadConfig"] = reloadConfig;
|
|
contextObj["classPath"] = classPath;
|
|
}
|
|
|
|
const options = {};
|
|
if (filename) options["filename"] = filename;
|
|
const eval_ctx = new vm.Script(script_data, options)
|
|
try {
|
|
eval_ctx.runInNewContext(contextObj, {
|
|
"breakOnSigint": true
|
|
});
|
|
} catch (e) {
|
|
throw e;
|
|
}
|
|
return contextObj; // updated context object with whatever global varibles the script set
|
|
}
|
|
|
|
async function handleCGI(executable, cgi_file, socket, request_headers, vault, service_name, session_data = null, extra_path = "")
|
|
{
|
|
const SAFE_ROOT = path.resolve(__dirname);
|
|
vault = path.resolve(vault);
|
|
if (!vault.startsWith(SAFE_ROOT)) {
|
|
console.error("Invalid vault path:", vault);
|
|
const errpage = wtvshared.doErrorPage(403);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
const env = wtvshared.cloneObj(process.env);
|
|
env.QUERY_STRING = "";
|
|
const request_data = [];
|
|
const split_req = request_headers.request.split(' ');
|
|
request_data.method = split_req[0];
|
|
let request_type = (request_headers.request_url.indexOf(":/")) ? request_headers.request_url.split(":/")[0] : 'http';
|
|
if (request_type !== "http" && request_type !== "https") {
|
|
request_type = "wtvp";
|
|
request_data.host = minisrv_config.config.service_ip;
|
|
request_data.port = minisrv_config.services[service_name].port;
|
|
} else {
|
|
request_data.host = request_headers.host;
|
|
if (request_data.host.indexOf(':') > 0) {
|
|
request_data.port = request_data.host.split(':')[1];
|
|
request_data.host = request_data.host.split(':')[0];
|
|
} else {
|
|
if (request_type === "https") request_data.port = 443;
|
|
else request_data.port = 80;
|
|
}
|
|
}
|
|
// CGI/1.1 stuff
|
|
env.SCRIPT_NAME = cgi_file.replace(vault,"");
|
|
env.REQUEST_URI = request_headers.request_url;
|
|
Object.keys(request_headers.query).forEach(function (k) {
|
|
env.QUERY_STRING += k + "=" + request_headers.query[k] + "&";
|
|
});
|
|
env.QUERY_STRING = env.QUERY_STRING.slice(0, -1);
|
|
env.REQUEST_METHOD = request_data.method;
|
|
env.SERVER_PROTOCOL = (split_req.length >= 3) ? request_headers.request.split(' ')[2] : "HTTP/1.0";
|
|
env.GATEWAY_INTERFACE = "CGI/1.1";
|
|
env.REMOTE_PORT = socket.remotePort;
|
|
env.SCRIPT_FILENAME = cgi_file;
|
|
env.SERVER_ADMIN = minisrv_config.config.service_owner_contact;
|
|
env.CONTEXT_DOCUMENT_ROOT = vault;
|
|
env.CONTEXT_PREFIX = "";
|
|
env.REQUEST_SCHEME = request_type;
|
|
env.DOCUMENT_ROOT = vault;
|
|
env.REMOTE_ADDR = socket.remoteAddress;
|
|
env.SERVER_PORT = request_data.port;
|
|
env.SERVER_ADDR = request_data.host;
|
|
env.SERVER_NAME = request_data.host;
|
|
if (minisrv_config.config.hide_minisrv_version) {
|
|
env.SERVER_SOFTWARE = "NodeJS; minisrv";
|
|
} else {
|
|
// Full version
|
|
env.SERVER_SOFTWARE = "NodeJS/"+process.version+"; " + z_cgiver;
|
|
}
|
|
env.SERVER_SIGNATURE = env.SERVER_SOFTWARE;
|
|
env.ALL_RAW = request_headers.raw_headers;
|
|
const raw_header_split = env.ALL_RAW.split("\r\n");
|
|
raw_header_split.forEach(function (header) {
|
|
if (header) {
|
|
header = header.split(": ");
|
|
if (header[0] === "Request") return;
|
|
if (header[1]) {
|
|
env["HTTP_"+header[0].toUpperCase().replaceAll("-","_")] = header[1];
|
|
}
|
|
}
|
|
});
|
|
env.SCRIPT_URI = request_type + "://" + request_data.host;
|
|
if (request_data.port !== 80 && request_data.port !== 443) env.SCRIPT_URI += ":" + request_data.port;
|
|
env.SCRIPT_URI += env.SCRIPT_NAME;
|
|
env.SCRIPT_URL = env.SCRIPT_NAME;
|
|
env.PHP_SELF = env.SCRIPT_NAME;
|
|
env.REQUEST_TIME_FLOAT = Math.floor(new Date().getTime() / 1000);
|
|
env.REQUEST_TIME = parseInt(env.REQUEST_TIME_FLOAT);
|
|
|
|
env.REDIRECT_STATUS = true;
|
|
if (request_headers['content-type']) env.CONTENT_TYPE = request_headers['content-type'];
|
|
else delete env['CONTENT_TYPE'];
|
|
if (request_headers['content-length']) env.CONTENT_LENGTH = request_headers['content-length'];
|
|
else delete env['CONTENT_LENGTH'];
|
|
|
|
const post_data = (request_headers['post_data']) ? request_headers['post_data'] : "";
|
|
env.MINISRV_SESSION_STORE = serialize((session_data) ? session_data.getSessionData() : null);
|
|
env.MINISRV_DATA_STORE = serialize((session_data) ? session_data.get() : null);
|
|
|
|
if (extra_path) {
|
|
env.PATH_INFO = extra_path;
|
|
env.PATH_TRANSLATED = extra_path ? vault + extra_path : "";
|
|
} else {
|
|
delete env['PATH_INFO'];
|
|
delete env['PATH_TRANSLATED'];
|
|
}
|
|
|
|
const isWindows = process.platform === 'win32';
|
|
let options = { 'cwd': vault, 'env': env, 'timeout': 120000, windowsHide: true, 'stdio': 'overlapped' };
|
|
if (!isWindows) {
|
|
options.uid = process.getuid();
|
|
options.gid = process.getgid();
|
|
}
|
|
|
|
if (!minisrv_config.config.debug_flags.quiet) (executable === cgi_file) ? console.debug(" * Executing CGI:", executable) : console.debug(" * Executing CGI:", executable, cgi_file);
|
|
const cgi = (executable === cgi_file) ? spawn(cgi_file, options=options) : spawn(executable, [cgi_file], options)
|
|
let data = "";
|
|
let error = "";
|
|
|
|
if (request_headers['content-length'] && post_data) {
|
|
cgi.stdin.write(post_data);
|
|
cgi.stdin.end();
|
|
}
|
|
|
|
cgi.stdout.on('data', function (dat) {
|
|
data += dat;
|
|
});
|
|
cgi.stderr.on('data', function (dat) {
|
|
error += dat;
|
|
});
|
|
cgi.on('close', function (code) {
|
|
if (code === 0) {
|
|
const stdout = data.split("\r\n\r\n", 2);
|
|
let headers = stdout[0];
|
|
data = stdout[1];
|
|
headers = wtvshared.headerStringToObj(headers, true);
|
|
if (!headers.Status) headers.Status = "200 OK";
|
|
headers['Connection'] = 'keep-alive';
|
|
sendToClient(socket, headers, data);
|
|
}
|
|
});
|
|
cgi.on('error', function (err) {
|
|
console.error("CGI exec error", err);
|
|
const errpage = wtvshared.doErrorPage(500);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
});
|
|
}
|
|
|
|
async function handlePHP(socket, request_headers, php_file, vault, service_name, session_data = null, extra_path = "") {
|
|
await handleCGI(minisrv_config.config.php_binpath, php_file, socket, request_headers, vault, service_name, session_data, extra_path);
|
|
}
|
|
|
|
async function processPath(socket, service_vault_file_path, request_headers = [], service_name, shared_romcache = null, pc_services = false) {
|
|
let headers, data = null;
|
|
let request_is_async = false;
|
|
let service_vault_found = false;
|
|
let service_path = decodeURIComponent(service_vault_file_path);
|
|
let pc_service_name = null;
|
|
let vaults_to_scan = service_vaults;
|
|
let usingSharedROMCache = false;
|
|
const contextObj = {
|
|
"privileged": false,
|
|
"socket": socket,
|
|
"session_data": ssid_sessions[socket.ssid],
|
|
"request_headers": request_headers,
|
|
"service_name": service_name,
|
|
"cwd": __dirname // current working directory, updated below in function
|
|
}
|
|
|
|
// Define the variables that we want to assign from the evaluated script.
|
|
// Normally any changes in the VM are discarded, but the rest of this function
|
|
// requires reading some of the data back into the main application.
|
|
// Here we define which ones to read back.
|
|
const updateFromVM = [
|
|
// format: [ ourvarname, scriptsvarname ]
|
|
["headers", "headers"], // we need to be able to read the script's response headers
|
|
["data", "data"], // we need to be able to read the script's response data
|
|
["request_is_async", "request_is_async"] // we need to know if the script is async or not
|
|
]
|
|
|
|
if (pc_services) {
|
|
pc_service_name = getServiceByVaultDir(service_name)
|
|
contextObj.pc_service_name = pc_service_name;
|
|
if (minisrv_config.services[pc_service_name].service_vaults) {
|
|
vaults_to_scan = vaults_to_scan.concat(minisrv_config.services[pc_service_name].service_vaults);
|
|
}
|
|
} else {
|
|
updateFromVM.push([`ssid_sessions['${socket.ssid}']`, "session_data"]); // user-specific session data from unprivileged scripts
|
|
}
|
|
let privileged = false;
|
|
if (minisrv_config.services[service_name]) privileged = (minisrv_config.services[service_name].privileged) ? true : false;
|
|
else if (pc_services) privileged = (minisrv_config.services[pc_service_name].privileged) ? true : false;
|
|
|
|
if (privileged) {
|
|
updateFromVM.push(["ssid_sessions", "ssid_sessions"]); // global ssid_sessions object for privileged service scripts, such as wtv-setup, wtv-head-waiter, etc
|
|
updateFromVM.push(["socket_sessions", "socket_sessions"]); // global socket_sessions object for privileged service scripts, such as wtv-1800, etc
|
|
}
|
|
|
|
if (request_headers['User-Agent'] === "Artemis/0.0" && minisrv_config.config.enable_prealpha_workaround === true) {
|
|
socket_sessions[socket.id].prealpha = true;
|
|
}
|
|
|
|
try {
|
|
vaults_to_scan.forEach(function (service_vault_dir) {
|
|
if (service_vault_found) return;
|
|
if (!usingSharedROMCache) {
|
|
if (minisrv_config.config.SharedROMCache && shared_romcache) {
|
|
if (shared_romcache.includes(minisrv_config.config.SharedROMCache)) {
|
|
const service_path_presplit = shared_romcache.split(path.sep);
|
|
service_path_presplit.splice(service_path_presplit.findIndex((element) => element === 'ROMCache'), 1);
|
|
const service_path_romcache = service_vault_dir + path.sep + service_path_presplit.join(path.sep);
|
|
const service_vault_file_path_romcache = wtvshared.returnAbsolutePath(wtvshared.makeSafePath(service_path_romcache));
|
|
if (fs.existsSync(service_vault_file_path_romcache)) {
|
|
service_path = service_path.replace(wtvshared.fixPathSlashes(minisrv_config.config.SharedROMCache), 'ROMCache');
|
|
service_vault_file_path = service_vault_file_path_romcache;
|
|
usingSharedROMCache = true;
|
|
} else {
|
|
service_vault_file_path = wtvshared.makeSafePath(service_vault_dir, service_path);
|
|
}
|
|
} else {
|
|
service_vault_file_path = wtvshared.makeSafePath(service_vault_dir, service_path);
|
|
}
|
|
} else {
|
|
service_vault_file_path = wtvshared.makeSafePath(service_vault_dir, service_path);
|
|
}
|
|
|
|
// deny access to catchall file name directly
|
|
const service_path_split = service_path.split("/");
|
|
const service_path_request_file = service_path_split[service_path_split.length - 1];
|
|
if (minisrv_config.config.catchall_file_name) {
|
|
let minisrv_catchall = null;
|
|
if (minisrv_config.services[service_name]) minisrv_catchall = minisrv_config.services[service_name].catchall_file_name || minisrv_config.config.catchall_file_name || null;
|
|
else minisrv_catchall = minisrv_config.config.catchall_file_name || null;
|
|
if (minisrv_catchall) {
|
|
if (service_path_request_file === minisrv_catchall) {
|
|
request_is_async = true;
|
|
const errpage = wtvshared.doErrorPage(401, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (service_vault_file_path.endsWith("/index")) {
|
|
service_vault_file_path = getDirectoryIndex(service_vault_file_path.slice(0, -6));
|
|
}
|
|
let is_dir = false;
|
|
let file_exists = false;
|
|
|
|
if (fs.existsSync(service_vault_file_path)) {
|
|
file_exists = true;
|
|
is_dir = fs.lstatSync(service_vault_file_path).isDirectory()
|
|
contextObj.cwd = service_vault_file_path
|
|
} else {
|
|
contextObj.cwd = service_vault_file_path.slice(0, service_vault_file_path.lastIndexOf(path.sep));
|
|
}
|
|
|
|
if (fs.existsSync(service_vault_file_path + ".txt")) {
|
|
// raw text format, entire payload expected (headers and content)
|
|
service_vault_found = true;
|
|
request_is_async = true;
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Found " + service_vault_file_path + ".txt to handle request (Raw TXT Mode) [Socket " + socket.id + "]");
|
|
request_headers.service_file_path = service_vault_file_path + ".txt";
|
|
fs.readFile(service_vault_file_path + ".txt", 'Utf-8', function (err, file_raw) {
|
|
if (file_raw.indexOf("\n\n") > 0) {
|
|
// split headers and data by newline (unix format)
|
|
const file_raw_split = file_raw.split("\n\n");
|
|
headers = file_raw_split[0];
|
|
file_raw_split.shift();
|
|
data = file_raw_split.join("\n");
|
|
} else if (file_raw.indexOf("\r\n\r\n") > 0) {
|
|
// split headers and data by carrage return + newline (windows format)
|
|
const file_raw_split = file_raw.split("\r\n\r\n");
|
|
headers = file_raw_split[0].replace(/\r/g, "");
|
|
file_raw_split.shift();
|
|
data = file_raw_split.join("\r\n");
|
|
} else {
|
|
// couldn't find two line breaks, assume entire file is just headers
|
|
headers = file_raw;
|
|
data = '';
|
|
}
|
|
sendToClient(socket, headers, data);
|
|
});
|
|
} else if (fs.existsSync(service_vault_file_path + ".js")) {
|
|
// synchronous js scripting, process with vars, must set 'headers' and 'data' appropriately.
|
|
// loaded script will have r/w access to any JavaScript vars this function does.
|
|
// request headers are in an array named `request_headers`.
|
|
// Query arguments in `request_headers.query`
|
|
// Can upgrade to asynchronous by setting `request_is_async` to `true`
|
|
// In Asynchronous mode, you are expected to call sendToClient(socket,headers,data) by the end of your script
|
|
// `socket` is already defined and should be passed-through.
|
|
service_vault_found = true;
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Found " + service_vault_file_path + ".js to handle request (JS Interpreter mode) [Socket " + socket.id + "]");
|
|
request_headers.service_file_path = service_vault_file_path + ".js";
|
|
// expose var service_dir for script path to the root of the wtv-service
|
|
socket_sessions[socket.id].starttime = Math.floor(new Date().getTime() / 1000);
|
|
const script_data = fs.readFileSync(service_vault_file_path + ".js").toString();
|
|
|
|
const vmResults = runScriptInVM(script_data, contextObj, privileged, service_vault_file_path + ".js");
|
|
// Here we read back certain data from the ServiceVault Script Context Object
|
|
updateFromVM.forEach((item) => {
|
|
try {
|
|
if (typeof vmResults[item[1]] !== "undefined") {
|
|
// Safely assign without eval
|
|
if (item[0] === `ssid_sessions['${socket.ssid}']`) {
|
|
ssid_sessions[socket.ssid] = vmResults[item[1]];
|
|
} else if (item[0] === 'ssid_sessions' && privileged) {
|
|
ssid_sessions = vmResults[item[1]];
|
|
} else if (item[0] === 'headers') {
|
|
headers = vmResults[item[1]];
|
|
} else if (item[0] === 'data') {
|
|
data = vmResults[item[1]];
|
|
} else if (item[0] === 'request_is_async') {
|
|
request_is_async = vmResults[item[1]];
|
|
} else if (item[0] === 'socket_sessions' && privileged) {
|
|
socket_sessions = vmResults[item[1]];
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.error("vm readback error", e, item[0] + ' = vmResults[' + item[1] + ']');
|
|
}
|
|
})
|
|
|
|
if (request_is_async && !minisrv_config.config.debug_flags.quiet) console.debug(" * Script requested Asynchronous mode");
|
|
} else if (fs.existsSync(service_vault_file_path + ".php") || (service_vault_file_path.endsWith(".php") && fs.existsSync(service_vault_file_path)) || service_vault_file_path.indexOf(".php") > 0) {
|
|
request_is_async = true;
|
|
if (minisrv_config.config.php_enabled && minisrv_config.config.php_binpath) {
|
|
if (fs.existsSync(service_vault_file_path + ".php") || fs.existsSync(service_vault_file_path)) {
|
|
if (fs.existsSync(service_vault_file_path + ".php")) service_vault_file_path += ".php";
|
|
service_vault_found = true;
|
|
handlePHP(socket, request_headers, service_vault_file_path, service_vault_dir + path.sep + service_name, (pc_services) ? pc_service_name : service_name, (pc_services) ? null : ssid_sessions[socket.ssid])
|
|
return;
|
|
} else {
|
|
const extra_path = service_vault_file_path.includes(".php") ? service_vault_file_path.slice(service_vault_file_path.lastIndexOf(".php") + 4) : "";
|
|
service_vault_file_path = service_vault_file_path.slice(0, service_vault_file_path.indexOf(".php") + 4);
|
|
if (fs.existsSync(service_vault_file_path)) {
|
|
service_vault_found = true;
|
|
handlePHP(socket, request_headers, service_vault_file_path, service_vault_dir + path.sep + service_name, (pc_services) ? pc_service_name : service_name, (pc_services) ? null : ssid_sessions[socket.ssid], extra_path)
|
|
return;
|
|
} else if (service_vault_dir === vaults_to_scan[vaults_to_scan.length - 1]) {
|
|
const errpage = wtvshared.doErrorPage(404, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
// php is not enabled, don't expose source code
|
|
service_vault_found = true;
|
|
const errpage = wtvshared.doErrorPage(403, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
} else if (fs.existsSync(service_vault_file_path + ".cgi") || (service_vault_file_path.endsWith(".cgi") && fs.existsSync(service_vault_file_path)) || service_vault_file_path.indexOf(".cgi") > 0) {
|
|
request_is_async = true;
|
|
if (minisrv_config.config.php_enabled && minisrv_config.config.php_binpath) {
|
|
if (fs.existsSync(service_vault_file_path + ".cgi") || fs.existsSync(service_vault_file_path)) {
|
|
if (fs.existsSync(service_vault_file_path + ".cgi")) service_vault_file_path += ".cgi";
|
|
service_vault_found = true;
|
|
handleCGI(service_vault_file_path, service_vault_file_path, socket, request_headers, service_vault_dir + path.sep + service_name, (pc_services) ? pc_service_name : service_name, (pc_services) ? null : ssid_sessions[socket.ssid])
|
|
return;
|
|
} else {
|
|
const extra_path = service_vault_file_path.includes(".cgi") ? service_vault_file_path.slice(service_vault_file_path.lastIndexOf(".cgi") + 4) : "";
|
|
service_vault_file_path = service_vault_file_path.slice(0, service_vault_file_path.indexOf(".cgi") + 4);
|
|
if (fs.existsSync(service_vault_file_path)) {
|
|
service_vault_found = true;
|
|
handleCGI(service_vault_file_path, service_vault_file_path, socket, request_headers, service_vault_dir + path.sep + service_name, (pc_services) ? pc_service_name : service_name, (pc_services) ? null : ssid_sessions[socket.ssid], extra_path)
|
|
return;
|
|
} else if (service_vault_dir === vaults_to_scan[vaults_to_scan.length - 1]) {
|
|
const errpage = wtvshared.doErrorPage(404, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
// cgi is not enabled, don't expose source code
|
|
service_vault_found = true;
|
|
const errpage = wtvshared.doErrorPage(403, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
} else if (fs.existsSync(service_vault_file_path + ".html")) {
|
|
// Standard HTML with no headers, WTV Style
|
|
service_vault_found = true;
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Found " + service_vault_file_path + ".html to handle request (HTML Mode) [Socket " + socket.id + "]");
|
|
request_headers.service_file_path = service_vault_file_path + ".html";
|
|
request_is_async = true;
|
|
headers = "200 OK\n"
|
|
headers += "Content-Type: text/html"
|
|
fs.readFile(service_vault_file_path + ".html", null, function (err, data) {
|
|
sendToClient(socket, headers, data);
|
|
});
|
|
} else if (file_exists && !is_dir) {
|
|
// file exists, read it and return it
|
|
service_vault_found = true;
|
|
request_is_async = true;
|
|
request_headers.service_file_path = service_vault_file_path;
|
|
request_headers.raw_file = true;
|
|
// process flashroms
|
|
if (minisrv_config.services[(pc_service_name || service_name)].is_flashrom_service && (wtvshared.getFileExt(service_vault_file_path).toLowerCase() === "rom" || wtvshared.getFileExt(service_vault_file_path).toLowerCase() === "brom")) {
|
|
let bf0app_update = false;
|
|
const request_path = request_headers.request_url.replace(service_name + ":/", "");
|
|
const romtype = ssid_sessions[socket.ssid].get("wtv-client-rom-type");
|
|
const bootver = ssid_sessions[socket.ssid].get("wtv-client-bootrom-version")
|
|
|
|
if ((romtype === "bf0app" || !romtype) && (bootver === "105" || !bootver)) {
|
|
// assume old classic in flash mode, override user setting and send tellyscript
|
|
// because it is required to proceed in flash mode
|
|
bf0app_update = true;
|
|
ssid_sessions[socket.ssid].set("bf0app_update", bf0app_update);
|
|
}
|
|
|
|
if (!ssid_sessions[socket.ssid].data_store.WTVFlashrom) {
|
|
ssid_sessions[socket.ssid].data_store.WTVFlashrom = new WTVFlashrom(minisrv_config, vaults_to_scan, service_name, minisrv_config.services[service_name].use_zefie_server, bf0app_update);
|
|
}
|
|
|
|
ssid_sessions[socket.ssid].data_store.WTVFlashrom.getFlashRom(request_path, function (data, headers) {
|
|
sendToClient(socket, headers, data);
|
|
});
|
|
|
|
// service parsed files, we might not want to expose our service source files so we can protect them with a flag on the first line
|
|
} else if (wtvshared.getFileExt(service_vault_file_path).toLowerCase() === "js" || wtvshared.getFileExt(service_vault_file_path).toLowerCase() === "txt") {
|
|
if (wtvshared.getFileExt(service_vault_file_path).toLowerCase() === "js") {
|
|
wtvshared.getLineFromFile(service_vault_file_path, 0, function (status, line) {
|
|
if (!status) {
|
|
if (line.match(/minisrv\_service\_file.*true/i)) {
|
|
request_is_async = true;
|
|
const errpage = wtvshared.doErrorPage(403, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
} else {
|
|
sendRawFile(socket, service_vault_file_path);
|
|
}
|
|
} else {
|
|
request_is_async = true;
|
|
const errpage = wtvshared.doErrorPage(400, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (wtvshared.getFileExt(service_vault_file_path).toLowerCase() === "txt") {
|
|
wtvshared.getLineFromFile(service_vault_file_path, 0, function (status, line) {
|
|
if (!status) {
|
|
if (line.match(/^#!minisrv/i)) {
|
|
request_is_async = true;
|
|
const errpage = wtvshared.doErrorPage(403, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
} else {
|
|
sendRawFile(socket, service_vault_file_path);
|
|
}
|
|
} else {
|
|
request_is_async = true;
|
|
const errpage = wtvshared.doErrorPage(400, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
// not a potential service file, so safe to send
|
|
sendRawFile(socket, service_vault_file_path);
|
|
}
|
|
} else {
|
|
// look for a catchall in the current path and all parent paths up until the service root
|
|
const service_config = ((pc_services) ? minisrv_config.services[pc_service_name] : minisrv_config.services[service_name]) || {};
|
|
if (minisrv_config.config.catchall_file_name || service_config['catchall_file_name']) {
|
|
const minisrv_catchall_file_name = service_config['catchall_file_name'] || minisrv_config.config.catchall_file_name || null;
|
|
if (minisrv_catchall_file_name) {
|
|
const service_check_dir = service_vault_file_path.split(path.sep);
|
|
service_check_dir.pop(); // pop filename
|
|
|
|
while (service_check_dir.join(path.sep) !== service_vault_dir && service_check_dir.length > 0) {
|
|
const catchall_file = service_check_dir.join(path.sep) + path.sep + minisrv_catchall_file_name;
|
|
if (fs.existsSync(catchall_file)) {
|
|
|
|
service_vault_found = true;
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Found catchall at " + catchall_file + " to handle request (JS Interpreter Mode) [Socket " + socket.id + "]");
|
|
request_headers.service_file_path = catchall_file;
|
|
if (catchall_file.endsWith(".js")) {
|
|
const script_data = fs.readFileSync(catchall_file).toString();
|
|
const vmResults = runScriptInVM(script_data, contextObj, privileged, catchall_file);
|
|
updateFromVM.forEach((item) => {
|
|
// Here we read back certain data from the ServiceVault Script Context Object
|
|
try {
|
|
if (typeof vmResults[item[1]] !== "undefined") {
|
|
// Safely assign without eval
|
|
if (item[0] === `ssid_sessions['${socket.ssid}']`) {
|
|
ssid_sessions[socket.ssid] = vmResults[item[1]];
|
|
} else if (item[0] === 'ssid_sessions' && privileged) {
|
|
ssid_sessions = vmResults[item[1]];
|
|
} else if (item[0] === 'headers') {
|
|
headers = vmResults[item[1]];
|
|
} else if (item[0] === 'data') {
|
|
data = vmResults[item[1]];
|
|
} else if (item[0] === 'request_is_async') {
|
|
request_is_async = vmResults[item[1]];
|
|
} else if (item[0] === 'socket_sessions' && privileged) {
|
|
socket_sessions = vmResults[item[1]];
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.error("vm readback error", e, item[0] + ' = vmResults[' + item[1] + ']');
|
|
}
|
|
});
|
|
} else if (catchall_file.endsWith(".php")) {
|
|
if (minisrv_config.config.php_enabled && minisrv_config.config.php_binpath) {
|
|
request_is_async = true;
|
|
const extra_path = service_check_dir.join(path.sep) + path.sep + request_headers.request_url.replace(service_name + ":/", "");
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Found catchall at " + catchall_file + " to handle request (CGI Interpreter Mode) [Socket " + socket.id + "]");
|
|
handlePHP(socket, request_headers, catchall_file, service_vault_dir + path.sep + service_name, (pc_services) ? pc_service_name : service_name, (pc_services) ? null : ssid_sessions[socket.ssid], extra_path)
|
|
} else {
|
|
// php is not enabled, don't expose source code
|
|
const errpage = wtvshared.doErrorPage(403, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
} else if (catchall_file.endsWith(".cgi")) {
|
|
if (minisrv_config.config.cgi_enabled) {
|
|
request_is_async = true;
|
|
const extra_path = service_check_dir.join(path.sep) + path.sep + request_headers.request_url.replace(service_name + ":/", "");
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Found catchall at " + catchall_file + " to handle request (CGI Interpreter Mode) [Socket " + socket.id + "]");
|
|
handleCGI(catchall_file, catchall_file, socket, request_headers, service_vault_dir + path.sep + service_name, (pc_services) ? pc_service_name : service_name, (pc_services) ? null : ssid_sessions[socket.ssid], extra_path)
|
|
} else {
|
|
// cgi is not enabled, don't expose source code
|
|
const errpage = wtvshared.doErrorPage(403, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (request_is_async && !minisrv_config.config.debug_flags.quiet) console.debug(" * Script requested Asynchronous mode");
|
|
break;
|
|
} else {
|
|
service_check_dir.pop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// either `request_is_async`, or `headers` and `data` MUST be defined by this point!
|
|
});
|
|
} catch (e) {
|
|
const errpage = wtvshared.doErrorPage(400, null, null, pc_services);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
if (pc_services) {
|
|
if (minisrv_config.services[pc_service_name].show_verbose_errors)
|
|
data += "<br><br>The interpreter said:<br><pre>" + e.stack + "</pre>";
|
|
}
|
|
console.error(" * Scripting error:", e);
|
|
}
|
|
if (!request_is_async) {
|
|
if (!service_vault_found) {
|
|
console.error(" * Could not find a Service Vault for " + service_name + ":/" + service_path.replace(service_name + path.sep, "").replace(path.sep, '/'));
|
|
const errpage = wtvshared.doErrorPage(404, null, null, pc_services);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
}
|
|
if (headers === null && !request_is_async) {
|
|
const errpage = wtvshared.doErrorPage(400, null, null, pc_services);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
console.error(" * Scripting or Data error: Headers were not defined. (headers,data) as follows:")
|
|
console.error(socket.id, headers, data)
|
|
}
|
|
if (data === null) {
|
|
data = '';
|
|
}
|
|
sendToClient(socket, headers, data);
|
|
}
|
|
}
|
|
|
|
function getDirectoryIndex(svpath) {
|
|
if (fs.existsSync(svpath + path.sep + "index.js")) return svpath + path.sep + "index";
|
|
else if (fs.existsSync(svpath + path.sep + "index.html")) return svpath + path.sep + "index.html";
|
|
else if (fs.existsSync(svpath + path.sep + "index.htm")) return svpath + path.sep + "index.htm";
|
|
else if (fs.existsSync(svpath + path.sep + "index.txt")) return svpath + path.sep + "index.txt";
|
|
else if (fs.existsSync(svpath + path.sep + "index.php")) return svpath + path.sep + "index.php";
|
|
else if (fs.existsSync(svpath + path.sep + "index.cgi")) return svpath + path.sep + "index.cgi";
|
|
else return svpath;
|
|
}
|
|
|
|
async function processURL(socket, request_headers, pc_services = false) {
|
|
let shortURL, headers, data, service_name;
|
|
let original_service_name = "";
|
|
let shared_romcache = null;
|
|
let allow_double_slash = false;
|
|
let enable_multi_query = false;
|
|
let use_external_proxy = false;
|
|
let disallow_no_slash = false;
|
|
let uses_service_vault = true;
|
|
request_headers.query = {};
|
|
|
|
if (request_headers.request_url) {
|
|
try {
|
|
// wtv-log handling
|
|
request_headers.request_url = request_headers.request_url.replaceAll(/\%\+/g, "%20"); // sanitize parentheses for logging
|
|
service_name = socket.service_name || verifyServicePort(decodeURIComponent(request_headers.request_url).split(':')[0], socket);
|
|
} catch (err) {
|
|
console.log(" * Invalid URI: %s", request_headers.request_url);
|
|
console.error((err && err.stack) ? err.stack : err);
|
|
const errpage = wtvshared.doErrorPage(400, null, null, pc_services);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
if (minisrv_config.services[service_name]) {
|
|
allow_double_slash = minisrv_config.services[service_name].allow_double_slash || false;
|
|
enable_multi_query = minisrv_config.services[service_name].enable_multi_query || false;
|
|
use_external_proxy = minisrv_config.services[service_name].use_external_proxy || false;
|
|
disallow_no_slash = minisrv_config.services[service_name].disallow_no_slash || false;
|
|
uses_service_vault = (minisrv_config.services[service_name].uses_service_vault === false) ? false : true;
|
|
}
|
|
if (pc_services) {
|
|
original_service_name = socket.service_name; // store service name
|
|
service_name = verifyServicePort(socket.service_name, socket); // get the actual ServiceVault path
|
|
}
|
|
if (request_headers.request_url.includes('?')) {
|
|
shortURL = request_headers.request_url.split('?')[0];
|
|
const qraw = request_headers.request_url.split('?')[1];
|
|
if (qraw) {
|
|
qraw.split("&").forEach(param => {
|
|
const qraw_split = param.split("=");
|
|
if (qraw_split.length === 2) {
|
|
const k = qraw_split[0];
|
|
const value = decodeURIComponent(qraw_split[1].replace(/\+/g, "%20"));
|
|
if (request_headers.query[k] && enable_multi_query) {
|
|
if (typeof request_headers.query[k] === 'string') {
|
|
request_headers.query[k] = [request_headers.query[k]];
|
|
}
|
|
request_headers.query[k].push(value);
|
|
} else {
|
|
request_headers.query[k] = value;
|
|
}
|
|
} else if (param.length === 1) {
|
|
request_headers.query[param] = null;
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
shortURL = decodeURIComponent(request_headers.request_url);
|
|
}
|
|
|
|
if (request_headers['wtv-request-type']) socket_sessions[socket.id].wtv_request_type = request_headers['wtv-request-type'];
|
|
|
|
if (request_headers.post_data) {
|
|
let post_data_string = null;
|
|
try {
|
|
post_data_string = request_headers.post_data.toString(CryptoJS.enc.Utf8); // if not text this will probably throw an exception
|
|
if (post_data_string) {
|
|
if (post_data_string.indexOf('=')) {
|
|
if (post_data_string.indexOf('&')) {
|
|
const qraw = post_data_string.split('&');
|
|
if (qraw.length) {
|
|
for (let i = 0; i < qraw.length; i++) {
|
|
const qraw_split = qraw[i].split("=");
|
|
if (qraw_split.length === 2) {
|
|
const k = qraw_split[0];
|
|
data = wtvshared.unescape(qraw[i].split("=")[1]);
|
|
if (request_headers.query[k]) {
|
|
if (typeof request_headers.query[k] === 'string') {
|
|
const keyarray = [request_headers.query[k]];
|
|
request_headers.query[k] = keyarray;
|
|
}
|
|
if (wtvshared.isASCII(data)) request_headers.query[k].push(data);
|
|
else request_headers.query[k].push(wtvshared.urlDecodeBytes(wtvshared.unescape(qraw[i].split("=")[1])));
|
|
} else {
|
|
if (wtvshared.isASCII(data)) request_headers.query[k] = data;
|
|
else request_headers.query[k] = wtvshared.urlDecodeBytes(wtvshared.unescape(qraw[i].split("=")[1]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const qraw_split = post_data_string.split("=");
|
|
if (qraw_split.length === 2) {
|
|
const k = qraw_split[0];
|
|
data = wtvshared.unescape(qraw_split[1]);
|
|
if (request_headers.query[k]) {
|
|
if (typeof request_headers.query[k] === 'string') {
|
|
const keyarray = [request_headers.query[k]];
|
|
request_headers.query[k] = keyarray;
|
|
}
|
|
if (wtvshared.isASCII(data)) request_headers.query[k].push(data);
|
|
else request_headers.query[k].push(wtvshared.urlDecodeBytes(wtvshared.unescape(qraw_split[1])));
|
|
} else {
|
|
if (wtvshared.isASCII(data)) request_headers.query[k] = data;
|
|
else request_headers.query[k] = wtvshared.urlDecodeBytes(wtvshared.unescape(qraw_split[1]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
|
|
}
|
|
}
|
|
if ((!disallow_no_slash && shortURL.includes(":") && !shortURL.includes(":/"))) {
|
|
// Apparently it is within WTVP spec to accept urls without a slash (eg wtv-home:home)
|
|
// Here, we just reassemble the request URL as if it was a proper URL (eg wtv-home:/home)
|
|
// we will allow this on any service except http(s) and ftp
|
|
const shortURL_split = shortURL.split(':');
|
|
const shortURL_service_name = shortURL_split[0];
|
|
shortURL_split.shift();
|
|
const shortURL_service_path = shortURL_split.join(":");
|
|
shortURL = shortURL_service_name + ":/" + shortURL_service_path;
|
|
}
|
|
|
|
if (socket.ssid) {
|
|
// skip box auth tests for pc mode
|
|
|
|
// check security
|
|
if (!ssid_sessions[socket.ssid].isAuthorized(shortURL)) {
|
|
// lockdown mode and URL not authorized
|
|
headers = "300 Unauthorized\n";
|
|
headers += "Location: " + minisrv_config.config.unauthorized_url + "\n";
|
|
headers += "minisrv-no-mail-count: true\n";
|
|
data = "";
|
|
sendToClient(socket, headers, data);
|
|
console.warn(" * Lockdown rejected request for %s on socket ID %d", shortURL, socket.id);
|
|
return;
|
|
}
|
|
|
|
if (ssid_sessions[socket.ssid].isRegistered() && !ssid_sessions[socket.ssid].isUserLoggedIn()) {
|
|
if (!ssid_sessions[socket.ssid].isAuthorized(shortURL, 'login')) {
|
|
// user is not fully logged in, and URL not authorized
|
|
headers = "300 Unauthorized\n";
|
|
headers += "Location: client:relogin\n";
|
|
headers += "minisrv-no-mail-count: true\n";
|
|
data = "";
|
|
sendToClient(socket, headers, data);
|
|
console.warn(" * Incomplete login rejected request for %s on socket ID %d", shortURL, socket.id);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (ssid_sessions[socket.ssid].get("wtv-my-disk-sucks-sucks-sucks") && !ssid_sessions[socket.ssid].get("bad_disk_shown")) {
|
|
if (!ssid_sessions[socket.ssid].baddisk) {
|
|
// psuedo lockdown, will unlock on the disk warning page, but prevents minisrv access until they read the error
|
|
ssid_sessions[socket.ssid].lockdown = true;
|
|
ssid_sessions[socket.ssid].baddisk = true;
|
|
}
|
|
}
|
|
|
|
if (!ssid_sessions[socket.ssid].isUserLoggedIn() && !ssid_sessions[socket.ssid].isAuthorized(shortURL, 'login')) {
|
|
// lockdown mode and URL not authorized
|
|
headers = `300 Unauthorized
|
|
Location: ${minisrv_config.config.unauthorized_url}
|
|
minisrv-no-mail-count: true`;
|
|
data = "";
|
|
sendToClient(socket, headers, data);
|
|
console.warn(" * Rejected login bypass request for %s on socket ID %d", shortURL, socket.id);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (pc_services) {
|
|
const ssl = (socket.ssl) ? true : false;
|
|
if (original_service_name === service_name) console.log(" * PC" + ((ssl) ? "SSL " : "") + "PC request on service %s for %s on %d", service_name, request_headers.request_url, socket.id);
|
|
else console.log(" * " + ((ssl) ? "SSL " : "") + "PC request on service %s (Service Vault %s) for %s on %d", original_service_name, service_name, request_headers.request_url, socket.id);
|
|
}
|
|
|
|
if ((shortURL.includes(':/')) && (!shortURL.includes('://') || (shortURL.includes('://') && allow_double_slash) && uses_service_vault)) {
|
|
let ssid = socket.ssid;
|
|
if (ssid === null) {
|
|
// prevent possible injection attacks via malformed SSID and filesystem SessionStore
|
|
ssid = wtvshared.makeSafeSSID(request_headers["wtv-client-serial-number"]);
|
|
if (ssid === "") ssid = null;
|
|
}
|
|
if (!pc_services) {
|
|
let reqverb = "Request";
|
|
if (request_headers.encrypted || request_headers.secure) reqverb = "Encrypted " + reqverb;
|
|
if (ssid !== null) {
|
|
console.log(" * " + reqverb + " for %s from WebTV SSID %s on socket ID %d", request_headers.request_url, await wtvshared.filterSSID(ssid), socket.id);
|
|
} else {
|
|
console.log(" * " + reqverb + " for %s on socket ID %d", request_headers.request_url, socket.id);
|
|
}
|
|
|
|
if (!service_name) {
|
|
// detect if client is trying to load wtv-star due to client-perceived error
|
|
if (getSocketDestinationPort(socket) === getPortByService("wtv-star")) {
|
|
// is wtv-star
|
|
if (minisrv_config.config.debug_flags.debug) console.debug(" * client requested %s on wtv-star port %d", shortURL, getSocketDestinationPort(socket));
|
|
shortURL = "wtv-star:/star";
|
|
service_name = "wtv-star";
|
|
} else {
|
|
// is actually a request on then wrong port
|
|
const errpage = wtvshared.doErrorPage(500, null, null, pc_services);
|
|
socket_sessions[socket.id].close_me = true;
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return
|
|
}
|
|
}
|
|
}
|
|
const urlToPath = wtvshared.fixPathSlashes(service_name + path.sep + shortURL.split(':/')[1]);
|
|
|
|
if ((shortURL.includes(":/ROMCache/") || shortURL.includes("://ROMCache/")) && minisrv_config.config.enable_shared_romcache) {
|
|
shared_romcache = wtvshared.fixPathSlashes(minisrv_config.config.SharedROMCache + path.sep + shortURL.split(':/')[1]);
|
|
}
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * ["+socket.remoteAddress+"] Incoming", (pc_services) ? "HTTP" : "WTVP", "headers on", (pc_services) ? "HTTP" : "WTVP", "socket ID", socket.id, await wtvshared.decodePostData(await wtvshared.filterRequestLog(await wtvshared.filterSSID(request_headers))));
|
|
else debug(" * ["+socket.remoteAddress+"] Incoming", (pc_services) ? "HTTP" : "WTVP", "headers on", (pc_services) ? "HTTP" : "WTVP", "socket ID", socket.id, await wtvshared.decodePostData(await wtvshared.filterRequestLog(await wtvshared.filterSSID(request_headers))));
|
|
|
|
socket_sessions[socket.id].request_headers = request_headers;
|
|
processPath(socket, urlToPath, request_headers, service_name, shared_romcache, pc_services);
|
|
} else if (handlerModules["wtvhttp"] && ((shortURL.includes('http://') || shortURL.includes('https://')) || (use_external_proxy === true && shortURL.includes(service_name + "://")) && !pc_services)) {
|
|
handlerModules["wtvhttp"].doHTTPProxy(socket, request_headers);
|
|
} else if (handlerModules["wtvgopher"] && shortURL.startsWith("gopher://")) {
|
|
handlerModules["wtvgopher"].handleGopherRequest(socket, request_headers);
|
|
} else if (handlerModules["wtvftp"] &&shortURL.startsWith('ftp://')) {
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * Incoming FTP request on WTVP socket ID", socket.id, await wtvshared.decodePostData(await wtvshared.filterRequestLog(await wtvshared.filterSSID(request_headers))));
|
|
handlerModules["wtvftp"].handleFTPRequest(socket, request_headers);
|
|
} else if (shortURL.indexOf('file://') >= 0) {
|
|
shortURL = shortURL.replace("file://",'').replace("romcache", "ROMCache");
|
|
service_name = "wtv-star";
|
|
const urlToPath = wtvshared.fixPathSlashes(service_name + path.sep + shortURL);
|
|
processPath(socket, urlToPath, request_headers, service_name, shared_romcache, pc_services);
|
|
} else if (pc_services) {
|
|
// if a directory, request index
|
|
if (shortURL.indexOf("/ROMCache/") === 0 && minisrv_config.config.enable_shared_romcache) {
|
|
shared_romcache = wtvshared.fixPathSlashes(minisrv_config.config.SharedROMCache + path.sep + shortURL.split('/')[1] + '/' + shortURL.split('/')[2]);
|
|
}
|
|
if (shortURL.endsWith("/")) shortURL += "index";
|
|
const urlToPath = wtvshared.fixPathSlashes(service_name + path.sep + shortURL);
|
|
processPath(socket, urlToPath, request_headers, service_name, shared_romcache, pc_services);
|
|
} else {
|
|
if (request_headers.request.indexOf("HTTP/1.0") > 0) {
|
|
// webtv in HTTP/1.0 mode, try to kick it back to WTVP
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * Incoming HTTP/1.0 headers on WTVP socket ID", socket.id, await wtvshared.decodePostData(await wtvshared.filterRequestLog(await wtvshared.filterSSID(request_headers))));
|
|
else debug(" * Incoming HTTP/1.0 headers on WTVP socket ID", socket.id, await wtvshared.decodePostData(await wtvshared.filterRequestLog(await wtvshared.filterSSID(request_headers))));
|
|
|
|
const errpage = wtvshared.doErrorPage(500, null, null, false, true);
|
|
headers = errpage[0];
|
|
data = ''
|
|
socket_sessions[socket.id].close_me = true;
|
|
sendToClient(socket, headers, data);
|
|
} else {
|
|
// error reading headers (no request_url provided, or PC on WTVP port)
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * Incoming Invalid headers on WTVP socket ID", socket.id, await wtvshared.decodePostData(await wtvshared.filterRequestLog(await wtvshared.filterSSID(request_headers))));
|
|
else debug(" * Incoming Invalid headers on WTVP socket ID", socket.id, await wtvshared.decodePostData(await wtvshared.filterRequestLog(await wtvshared.filterSSID(request_headers))));
|
|
|
|
const errpage = wtvshared.doErrorPage(500, null, null, true, false);
|
|
headers = errpage[0];
|
|
data = ''
|
|
socket_sessions[socket.id].close_me = true;
|
|
sendToClient(socket, headers, data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async function sendToClient(socket, headers_obj, data = null, throttle = 0) {
|
|
let headers = "";
|
|
let content_length = 0;
|
|
const eol = "\n";
|
|
let timezone = "-0000";
|
|
let wtv_connection_close = false;
|
|
|
|
if (typeof (data) === 'undefined' || data === null) data = '';
|
|
if (typeof (headers_obj) === 'string') {
|
|
// string to header object
|
|
headers_obj = wtvshared.headerStringToObj(headers_obj, true);
|
|
}
|
|
if (!socket_sessions[socket.id]) {
|
|
if (socket.destroy) socket.destroy();
|
|
return;
|
|
}
|
|
const isWebTVClient = Boolean(socket.ssid && ssid_sessions[socket.ssid]);
|
|
if (!socket.res) {
|
|
wtv_connection_close = (headers_obj["wtv-connection-close"]) ? true : false;
|
|
if (typeof (headers_obj["wtv-connection-close"]) !== 'undefined') delete headers_obj["wtv-connection-close"];
|
|
|
|
if (!headers_obj['minisrv-no-mail-count']) {
|
|
if (ssid_sessions[socket.ssid]) {
|
|
if (ssid_sessions[socket.ssid].isRegistered()) {
|
|
if (!ssid_sessions[socket.ssid].isUserLoggedIn()) {
|
|
// not logged in probe all users
|
|
headers_obj['wtv-mail-count'] = ssid_sessions[socket.ssid].getAccountTotalUnreadMessages();
|
|
} else if (ssid_sessions[socket.ssid].mailstore) {
|
|
// logged in
|
|
headers_obj['wtv-mail-count'] = ssid_sessions[socket.ssid].mailstore.countUnreadMessages(0);
|
|
}
|
|
timezone = ssid_sessions[socket.ssid].getSessionData("timezone") || "-0000"
|
|
}
|
|
}
|
|
} else {
|
|
if (headers_obj['wtv-mail-count']) delete headers_obj['wtv-mail-count'];
|
|
delete headers_obj['minisrv-no-mail-count'];
|
|
}
|
|
}
|
|
|
|
// add Connection header if missing, default to Keep-Alive
|
|
if (!headers_obj.Connection) {
|
|
headers_obj.Connection = "Keep-Alive";
|
|
headers_obj = wtvshared.moveObjectKey('Connection', 'Status', headers_obj);
|
|
}
|
|
|
|
if (typeof data.length !== 'undefined') {
|
|
content_length = data.length;
|
|
} else if (typeof data.byteLength !== 'undefined') {
|
|
content_length = data.byteLength;
|
|
}
|
|
|
|
// fix captialization
|
|
if (headers_obj["raw_headers"]) {
|
|
delete headers_obj["raw_headers"];
|
|
}
|
|
const contype_key = wtvshared.getCaseInsensitiveKey('content-type', headers_obj);
|
|
if (contype_key) {
|
|
if (socket.ssid && headers_obj[contype_key].indexOf(";") > 0) {
|
|
// WebTV client
|
|
headers_obj[contype_key] = headers_obj[contype_key].split(";")[0];
|
|
}
|
|
if (contype_key !== "Content-type") {
|
|
headers_obj["Content-type"] = headers_obj[contype_key];
|
|
delete headers_obj[contype_key];
|
|
}
|
|
}
|
|
|
|
|
|
let imageArtemisType = minisrv_config.config.image_decoder.gif_type || 'ALP';
|
|
// Add last modified if not a dynamic script
|
|
if (socket_sessions[socket.id]) {
|
|
if (socket_sessions[socket.id].request_headers) {
|
|
if (socket_sessions[socket.id].request_headers.query) {
|
|
if (socket_sessions[socket.id].request_headers.query.type === "ALF" ||
|
|
socket_sessions[socket.id].request_headers.query.type === "ALP"
|
|
)
|
|
{
|
|
imageArtemisType = socket_sessions[socket.id].request_headers.query.type;
|
|
}
|
|
}
|
|
if (socket_sessions[socket.id].request_headers.service_file_path) {
|
|
// Don't change Last-modified header if provided already
|
|
if (!headers['Last-Modified'] && !headers['minisrv-no-last-modified']) {
|
|
// Only add the header if not a js, php, or cgi file
|
|
if (wtvshared.getFileExt(socket_sessions[socket.id].request_headers.service_file_path).toLowerCase() !== "js" ||
|
|
wtvshared.getFileExt(socket_sessions[socket.id].request_headers.service_file_path).toLowerCase() !== "php" ||
|
|
wtvshared.getFileExt(socket_sessions[socket.id].request_headers.service_file_path).toLowerCase() !== "cgi" ||
|
|
socket_sessions[socket.id].request_headers.raw_file === true) {
|
|
let last_modified_formatted = null;
|
|
if (socket.res) {
|
|
last_modified_formatted = wtvshared.getFileLastModifiedUTCString(socket_sessions[socket.id].request_headers.service_file_path);
|
|
} else {
|
|
const last_modified = wtvshared.getFileLastModifiedUTCObj(socket_sessions[socket.id].request_headers.service_file_path);
|
|
const strftime = require('strftime');
|
|
const strf = strftime.timezone(timezone);
|
|
last_modified_formatted = strf("%a, %d %b %Y %H:%M:%S", last_modified);
|
|
}
|
|
if (last_modified_formatted) headers_obj["Last-Modified"] = last_modified_formatted;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (headers_obj['minisrv-no-last-modified']) {
|
|
if (headers_obj['Last-Modified']) {
|
|
delete headers_obj['Last-Modified'];
|
|
}
|
|
delete headers_obj['minisrv-no-last-modified'];
|
|
}
|
|
|
|
if (isWebTVClient && minisrv_config.config.image_decoder && minisrv_config.config.image_decoder.enabled) {
|
|
const contype_key = wtvshared.getCaseInsensitiveKey('content-type', headers_obj);
|
|
if (contype_key) {
|
|
if (minisrv_config.config.image_decoder.image_formats && minisrv_config.config.image_decoder.image_formats.includes(headers_obj[contype_key].toLowerCase())) {
|
|
const convertOpts = {
|
|
jpegQuality: minisrv_config.config.image_decoder.jpg_quality,
|
|
type: imageArtemisType,
|
|
imgopts: minisrv_config.config.image_decoder.image_options || null
|
|
};
|
|
|
|
if (minisrv_config.config.image_decoder.max_height > 0) convertOpts.maxHeight = minisrv_config.config.image_decoder.max_height;
|
|
if (minisrv_config.config.image_decoder.max_width > 0) convertOpts.maxWidth = minisrv_config.config.image_decoder.max_width;
|
|
|
|
const sourceData = Buffer.isBuffer(data) ? data : Buffer.from(data);
|
|
try {
|
|
const converted = await WTVImage.ImageToWebTV(sourceData, convertOpts);
|
|
data = converted.data;
|
|
content_length = data.length;
|
|
var i=0;
|
|
while (content_length > minisrv_config.config.image_decoder.max_size && converted.mime === 'image/jpeg') {
|
|
// Image is too big, try to reduce quality
|
|
if (i < minisrv_config.config.image_decoder.max_quality_tries) {
|
|
convertOpts.jpegQuality -= minisrv_config.config.image_decoder.jpeg_interval;
|
|
var converted2 = await WTVImage.ImageToWebTV(sourceData, convertOpts, pngOpts);
|
|
data = converted2.data;
|
|
content_length = data.length;
|
|
i++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (content_length > minisrv_config.config.image_decoder.max_size) {
|
|
headers_obj = {
|
|
"Status": `400 ${minisrv_config.config.service_name} ran into a technical problem. (Image too large)`,
|
|
"Content-type": "text/html"
|
|
}
|
|
data = "";
|
|
} else {
|
|
headers_obj[contype_key] = (converted.mime === 'image/jpeg') ? 'image/jpeg' : 'image/gif';
|
|
}
|
|
} catch (e) {
|
|
console.error("Error converting image for client:", e);
|
|
headers_obj = {
|
|
"Status": `400 ${minisrv_config.config.service_name} ran into a technical problem. (Image not supported by backend, it may be corrupt)`,
|
|
"Content-type": "text/html"
|
|
}
|
|
data = "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isWebTVClient && wtvAudioProxy && wtvAudioProxy.isEnabled()) {
|
|
const contype_key = wtvshared.getCaseInsensitiveKey('content-type', headers_obj);
|
|
if (contype_key && wtvAudioProxy.shouldProxy(headers_obj[contype_key])) {
|
|
try {
|
|
const transformResult = await wtvAudioProxy.transformIfNeeded(headers_obj, data);
|
|
headers_obj = transformResult.headers;
|
|
data = transformResult.data;
|
|
content_length = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data || '');
|
|
} catch (e) {
|
|
console.error('Audio proxy error:', e.message);
|
|
headers_obj = {
|
|
"Status": "413 Audio Too Long",
|
|
"Content-type": "text/plain"
|
|
};
|
|
data = (e.code === 'AUDIO_TOO_LONG') ?
|
|
`Audio exceeds maximum allowed duration of ${wtvAudioProxy.config.maxDurationSeconds} seconds.` :
|
|
`Audio proxy failure: ${e.message}`;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// if client can do compression, see if its worth enabling
|
|
// small files actually get larger, so don't compress them
|
|
let compression_type = 0;
|
|
if (content_length >= 256) compression_type = wtvmime.shouldWeCompress(ssid_sessions[socket.ssid], headers_obj);
|
|
if (socket_sessions[socket.id].request_headers) {
|
|
if (socket_sessions[socket.id].request_headers.query) {
|
|
if (socket_sessions[socket.id].wtv_request_type === "download") {
|
|
if (socket_sessions[socket.id].request_headers.query.dont_compress) {
|
|
compression_type = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// webtvism
|
|
if (headers_obj["minisrv-force-compression"]) {
|
|
compression_type = parseInt(headers_obj["minisrv-force-compression"]);
|
|
delete headers_obj["minisrv-force-compression"];
|
|
}
|
|
|
|
if (headers_obj["wtv-modern-content-type"]) {
|
|
delete headers_obj["wtv-modern-content-type"];
|
|
}
|
|
|
|
if (socket.res) { // pc mode with response object available
|
|
if (compression_type === 1) compression_type = 2; // wtv-lzpf not supported in pc mode
|
|
}
|
|
|
|
// compress if needed
|
|
if (compression_type > 0 && content_length > 0 && headers_obj['Status'].startsWith("200")) {
|
|
const uncompressed_content_length = content_length;
|
|
switch (compression_type) {
|
|
case 1:
|
|
// wtv-lzpf implementation
|
|
headers_obj["wtv-lzpf"] = 0;
|
|
const wtvcomp = new LZPF();
|
|
data = wtvcomp.compress(data);
|
|
break;
|
|
|
|
case 2:
|
|
// zlib DEFLATE implementation
|
|
const zlib_options = { 'level': 9 };
|
|
if (uncompressed_content_length > 4194304) zlib_options.strategy = 2;
|
|
headers_obj['Content-Encoding'] = 'deflate';
|
|
data = zlib.deflateSync(data, zlib_options);
|
|
break;
|
|
}
|
|
|
|
let compressed_content_length = 0;
|
|
if (content_length === 0 || compression_type !== 1) {
|
|
// ultimately send compressed content length
|
|
compressed_content_length = data.byteLength;
|
|
content_length = compressed_content_length;
|
|
} else {
|
|
// ultimately send original content length if lzpf
|
|
compressed_content_length = data.byteLength;
|
|
}
|
|
const compression_ratio = (uncompressed_content_length / compressed_content_length).toFixed(2);
|
|
const compression_percentage = ((1 - (compressed_content_length / uncompressed_content_length)) * 100).toFixed(1);
|
|
if (uncompressed_content_length !== compressed_content_length) if (minisrv_config.config.debug_flags.debug) console.debug(" # Compression stats: Orig Size:", uncompressed_content_length, "~ Comp Size:", compressed_content_length, "~ Ratio:", compression_ratio, "~ Saved:", compression_percentage.toString() + "%");
|
|
}
|
|
|
|
if (!socket.res) {
|
|
// encrypt if needed
|
|
if (socket_sessions[socket.id].secure === true && !socket_sessions[socket.id].do_not_encrypt && !socket_sessions[socket.id].prealpha) {
|
|
headers_obj["wtv-encrypted"] = 'true';
|
|
headers_obj = wtvshared.moveObjectKey('wtv-encrypted', 'Connection', headers_obj);
|
|
if (content_length > 0 && socket_sessions[socket.id].wtvsec) {
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Encrypting response to client ...")
|
|
data = socket_sessions[socket.id].wtvsec.Encrypt(1, data);
|
|
}
|
|
}
|
|
|
|
if (socket_sessions[socket.id].do_not_encrypt) {
|
|
if (headers_obj["wtv-encrypted"]) delete headers_obj["wtv-encrypted"];
|
|
if (headers_obj["secure"]) delete headers_obj["secure"];
|
|
}
|
|
}
|
|
|
|
if (socket_sessions[socket.id].prealpha === true && !socket_sessions[socket.id].secure) {
|
|
if (headers_obj["wtv-encrypted"]) delete headers_obj["wtv-encrypted"];
|
|
}
|
|
|
|
// calculate content length
|
|
// make sure we are using our Content-length and not one set in a script.
|
|
if (headers_obj["Content-Length"]) delete headers_obj["Content-Length"];
|
|
if (headers_obj["Content-length"]) delete headers_obj["Content-length"];
|
|
|
|
|
|
headers_obj["Content-length"] = content_length;
|
|
|
|
// if force-content-length is defined, use it for webtvisms
|
|
if (headers_obj["minisrv-force-content-length"]) {
|
|
headers_obj["Content-length"] = headers_obj["minisrv-force-content-length"];
|
|
delete headers_obj["minisrv-force-content-length"];
|
|
}
|
|
|
|
if (!socket.res) {
|
|
// Send wtv-ticket if it has been flagged as updated
|
|
if (ssid_sessions[socket.ssid]) {
|
|
if (ssid_sessions[socket.ssid].data_store.wtvsec_login) {
|
|
if (ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_b64) {
|
|
if (ssid_sessions[socket.ssid].data_store.wtvsec_login.update_ticket) {
|
|
headers_obj["wtv-ticket"] = ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_b64;
|
|
headers_obj = wtvshared.moveObjectKey("wtv-ticket", "Connection", headers_obj);
|
|
ssid_sessions[socket.ssid].data_store.wtvsec_login.update_ticket = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// rearranges headers for WebTV (and zefie's OCD)
|
|
headers_obj = wtvshared.moveObjectKey("Status", 0, headers_obj); // move Status to top
|
|
headers_obj = wtvshared.moveObjectKey("Connection", 1, headers_obj); // move Connection to second
|
|
headers_obj = wtvshared.moveObjectKey("Content-type", -1, headers_obj); // move Content-type to last
|
|
headers_obj = wtvshared.moveObjectKey("Content-length", "Content-type", headers_obj); // move Content-length to before Content-type
|
|
|
|
// remove x-powered-by header if client is WebTV
|
|
let xpower = wtvshared.getCaseInsensitiveKey("x-powered-by", headers_obj);
|
|
if (!xpower && socket.service_name) {
|
|
// add X-Powered-By header if not WebTV and not already set
|
|
xpower = 'X-Powered-By';
|
|
if (minisrv_config.config.hide_minisrv_version) {
|
|
// Don't report version
|
|
if (!socket.ssid) headers_obj[xpower] = "NodeJS; minisrv";
|
|
} else {
|
|
// Full version
|
|
if (!socket.ssid) headers_obj[xpower] = "NodeJS/"+process.version+"; " + z_cgiver;
|
|
}
|
|
} else {
|
|
// delete if webtv
|
|
if (socket.ssid) delete headers_obj[xpower];
|
|
if (socket.service_name) {
|
|
if (minisrv_config.config.hide_minisrv_version) {
|
|
// Don't report version
|
|
if (!socket.ssid) headers_obj[xpower] = headers_obj[xpower] + "; NodeJS; minisrv";
|
|
} else {
|
|
// Full version
|
|
if (!socket.ssid) headers_obj[xpower] = headers_obj[xpower] + "; NodeJS/"+process.version+"; " + z_cgiver;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (headers_obj[xpower]) headers_obj = wtvshared.moveObjectKey(xpower, -2, headers_obj, true) // move x-powered-by before Content-type
|
|
|
|
if (!socket.res) {
|
|
// header object to string
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * ["+socket.remoteAddress+"] Outgoing Status "+headers_obj.Status+" headers on socket ID", socket.id, headers_obj);
|
|
else debug(" * ["+socket.remoteAddress+"] Outgoing Status "+headers_obj.Status+" headers on socket ID", socket.id, headers_obj);
|
|
|
|
Object.keys(headers_obj).forEach(function (k) {
|
|
if (k === "Status") {
|
|
headers += headers_obj[k] + eol;
|
|
} else {
|
|
if (typeof headers_obj[k] === 'object') {
|
|
headers_obj[k].forEach(function (v) {
|
|
headers += k + ": " + v + eol;
|
|
});
|
|
} else {
|
|
headers += k + ": " + headers_obj[k] + eol;
|
|
}
|
|
}
|
|
});
|
|
|
|
if (headers_obj["Connection"]) {
|
|
if (headers_obj["Connection"].toLowerCase() === "close" && wtv_connection_close) {
|
|
socket_sessions[socket.id].destroy_me = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Delete any other stray minisrv headers (we process them all before this)
|
|
Object.keys(headers_obj).forEach(function (k) {
|
|
if (k.startsWith("minisrv-")) {
|
|
delete headers_obj[k];
|
|
}
|
|
});
|
|
|
|
// send to client
|
|
if (socket.res) {
|
|
const resCode = parseInt(headers_obj.Status.slice(0, 3)) || 500;
|
|
socket.res.writeHead(resCode, headers_obj);
|
|
socket.res.end(data);
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * ["+socket.remoteAddress+"] Outgoing Status "+headers_obj.Status+" PC headers on " + socket.service_name + " socket ID", socket.id, headers_obj);
|
|
else debug(" * ["+socket.remoteAddress+"] Outgoing Status "+headers_obj.Status+" PC headers on " + socket.service_name + " socket ID", socket.id, headers_obj);
|
|
|
|
if (minisrv_config.config.debug_flags.quiet) console.debug(" * Sent response " + headers_obj.Status + " to PC client (Content-Type:", headers_obj['Content-type'], "~", headers_obj['Content-length'], "bytes)");
|
|
} else {
|
|
let toClient = null;
|
|
if (typeof data === 'string') {
|
|
toClient = headers + eol + data;
|
|
sendToSocket(socket, Buffer.from(toClient), throttle);
|
|
} else if (typeof data === 'object') {
|
|
let verbosity_mod = (headers_obj["wtv-encrypted"] === 'true') ? " encrypted response" : "";
|
|
if (socket_sessions[socket.id].secure_headers === true) {
|
|
// encrypt headers
|
|
if (minisrv_config.config.debug_flags.quiet) verbosity_mod += " with encrypted headers";
|
|
const enc_headers = socket_sessions[socket.id].wtvsec.Encrypt(1, headers + eol);
|
|
sendToSocket(socket, new Buffer.from(concatArrayBuffer(enc_headers, data)), throttle);
|
|
} else {
|
|
sendToSocket(socket, new Buffer.from(concatArrayBuffer(Buffer.from(headers + eol), data)), throttle);
|
|
}
|
|
if (minisrv_config.config.debug_flags.quiet) console.debug(" * Sent" + verbosity_mod + " " + headers_obj.Status + " to client (Content-Type:", headers_obj['Content-type'], "~", headers_obj['Content-length'], "bytes)");
|
|
}
|
|
}
|
|
}
|
|
|
|
async function sendToSocket(socket, data, throttle = 0) {
|
|
const chunk_size = 16384;
|
|
if (!throttle || throttle <= 0) {
|
|
let can_write = true;
|
|
let close_socket = false;
|
|
let expected_data_out = 0;
|
|
while ((socket.bytesWritten === 0 || socket.bytesWritten !== expected_data_out) && can_write) {
|
|
if (expected_data_out === 0) expected_data_out = data.byteLength + (socket_sessions[socket.id].socket_total_written || 0);
|
|
if (socket.bytesWritten === expected_data_out) break;
|
|
|
|
const data_left = (expected_data_out - socket.bytesWritten);
|
|
// buffer size = lesser of chunk_size or size remaining
|
|
const buffer_size = (data_left >= chunk_size) ? chunk_size : data_left;
|
|
if (buffer_size < 0) {
|
|
socket.destroy();
|
|
close_socket = true;
|
|
break;
|
|
}
|
|
const offset = (data.byteLength - data_left);
|
|
const chunk = new Buffer.alloc(buffer_size);
|
|
data.copy(chunk, 0, offset, (offset + buffer_size));
|
|
can_write = socket.write(chunk);
|
|
if (!can_write) {
|
|
socket.once('drain', function () {
|
|
sendToSocket(socket, data, throttle);
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
if (socket.bytesWritten === expected_data_out || close_socket) {
|
|
socket_sessions[socket.id].socket_total_written = socket.bytesWritten;
|
|
if (socket_sessions[socket.id].expecting_post_data) delete socket_sessions[socket.id].expecting_post_data;
|
|
if (socket_sessions[socket.id].header_buffer) delete socket_sessions[socket.id].header_buffer;
|
|
if (socket_sessions[socket.id].secure_buffer) delete socket_sessions[socket.id].secure_buffer;
|
|
if (socket_sessions[socket.id].buffer) delete socket_sessions[socket.id].buffer;
|
|
if (socket_sessions[socket.id].headers) delete socket_sessions[socket.id].headers;
|
|
if (socket_sessions[socket.id].post_data) delete socket_sessions[socket.id].post_data;
|
|
if (socket_sessions[socket.id].post_data_length) delete socket_sessions[socket.id].post_data_length;
|
|
if (socket_sessions[socket.id].post_data_percents_shown) delete socket_sessions[socket.id].post_data_percents_shown;
|
|
socket.setTimeout(minisrv_config.config.socket_timeout * 1000);
|
|
if (socket_sessions[socket.id] && socket_sessions[socket.id].close_me) socket.end();
|
|
if (socket_sessions[socket.id].destroy_me) socket.destroy();
|
|
}
|
|
return;
|
|
}
|
|
|
|
let offset = 0;
|
|
while (offset < data.byteLength) {
|
|
const buffer_size = Math.min(chunk_size, data.byteLength - offset);
|
|
const chunk = Buffer.alloc(buffer_size);
|
|
data.copy(chunk, 0, offset, offset + buffer_size);
|
|
offset += buffer_size;
|
|
|
|
const can_write = socket.write(chunk);
|
|
if (!can_write) {
|
|
await new Promise(resolve => socket.once('drain', resolve));
|
|
}
|
|
|
|
if (offset < data.byteLength) {
|
|
const delay_ms = Math.max(1, Math.round((buffer_size * 8) / throttle * 1000));
|
|
await new Promise(resolve => setTimeout(resolve, delay_ms));
|
|
}
|
|
}
|
|
|
|
socket_sessions[socket.id].socket_total_written = socket.bytesWritten;
|
|
if (socket_sessions[socket.id].expecting_post_data) delete socket_sessions[socket.id].expecting_post_data;
|
|
if (socket_sessions[socket.id].header_buffer) delete socket_sessions[socket.id].header_buffer;
|
|
if (socket_sessions[socket.id].secure_buffer) delete socket_sessions[socket.id].secure_buffer;
|
|
if (socket_sessions[socket.id].buffer) delete socket_sessions[socket.id].buffer;
|
|
if (socket_sessions[socket.id].headers) delete socket_sessions[socket.id].headers;
|
|
if (socket_sessions[socket.id].post_data) delete socket_sessions[socket.id].post_data;
|
|
if (socket_sessions[socket.id].post_data_length) delete socket_sessions[socket.id].post_data_length;
|
|
if (socket_sessions[socket.id].post_data_percents_shown) delete socket_sessions[socket.id].post_data_percents_shown;
|
|
socket.setTimeout(minisrv_config.config.socket_timeout * 1000);
|
|
if (socket_sessions[socket.id] && socket_sessions[socket.id].close_me) socket.end();
|
|
if (socket_sessions[socket.id].destroy_me) socket.destroy();
|
|
}
|
|
|
|
function concatArrayBuffer(buffer1, buffer2) {
|
|
if (!buffer1) return buffer2;
|
|
if (!buffer2) return buffer1;
|
|
const tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
|
|
tmp.set(new Uint8Array(buffer1), 0);
|
|
tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
|
|
return tmp.buffer;
|
|
}
|
|
|
|
function isUnencryptedString(string) {
|
|
// a generic "isAscii" check is not sufficient, as the test will see the binary
|
|
// compressed / encrypted data as ASCII. This function checks for characters expected
|
|
// in unencrypted headers, and returns true only if every character in the string matches
|
|
// the regex. Once we know the string is binary, we can better process it with the
|
|
// raw base64 or hex data in processRequest() below.
|
|
return /^([A-Za-z0-9\+\/\=\-\.\,\ \"\;\:\?\&\r\n\(\)\%\<\>\_\~\*\@\#\\\!]{8,})$/.test(string);
|
|
}
|
|
|
|
async function processRequest(socket, data_hex, skipSecure = false, encryptedRequest = false) {
|
|
|
|
// This function sucks and needs to be rewritten
|
|
|
|
let headers = [];
|
|
let header_length = 0;
|
|
if (socket_sessions[socket.id]) {
|
|
if (socket_sessions[socket.id].headers) {
|
|
headers = socket_sessions[socket.id].headers;
|
|
delete socket_sessions[socket.id].headers;
|
|
}
|
|
}
|
|
let data = Buffer.from(data_hex, 'hex').toString('ascii');
|
|
if (typeof data === "string") {
|
|
if ((data.includes("\r\n\r\n") || data.includes("\n\n") || data.includes("\n\r\n")) && typeof socket_sessions[socket.id].post_data === "undefined") {
|
|
if (data.includes("\r\n\r\n")) {
|
|
data = data.split("\r\n\r\n")[0];
|
|
} else if (data.includes("\n\r\n")) {
|
|
// early builds
|
|
data = data.split("\n\r\n")[0];
|
|
} else {
|
|
data = data.split("\n\n")[0];
|
|
}
|
|
if (isUnencryptedString(data)) {
|
|
if (headers.length !== 0) {
|
|
const new_header_obj = wtvshared.headerStringToObj(data);
|
|
Object.keys(new_header_obj).forEach(function (k, v) {
|
|
headers[k] = new_header_obj[k];
|
|
});
|
|
} else {
|
|
headers = wtvshared.headerStringToObj(data);
|
|
}
|
|
} else if (!skipSecure) {
|
|
// if its a POST request, assume its a binary blob and not encrypted (dangerous)
|
|
if (!encryptedRequest) {
|
|
// its not a POST and it failed the isUnencryptedString test, so we think this is an encrypted blob
|
|
if (socket_sessions[socket.id].secure !== true) {
|
|
// first time so reroll sessions
|
|
socket_sessions[socket.id].wtvsec = new WTVSec(minisrv_config);
|
|
socket_sessions[socket.id].wtvsec.IssueChallenge();
|
|
socket_sessions[socket.id].wtvsec.SecureOn();
|
|
socket_sessions[socket.id].secure = true;
|
|
}
|
|
const enc_data = CryptoJS.enc.Hex.parse(data_hex.slice(header_length * 2));
|
|
if (enc_data.sigBytes > 0) {
|
|
if (!socket_sessions[socket.id].wtvsec) {
|
|
const errpage = wtvshared.doErrorPage(400);
|
|
sendToClient(socket, errpage[0] + "wtv-visit: client:relog\n", errpage[1]);
|
|
return;
|
|
}
|
|
const dec_data = CryptoJS.lib.WordArray.create(socket_sessions[socket.id].wtvsec.Decrypt(0, enc_data));
|
|
const secure_headers = await processRequest(socket, dec_data.toString(CryptoJS.enc.Hex), true, true);
|
|
if (secure_headers) {
|
|
headers = [];
|
|
headers.encrypted = true;
|
|
Object.keys(secure_headers).forEach(function (k, v) {
|
|
headers[k] = secure_headers[k];
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!headers) return;
|
|
|
|
if (headers["wtv-client-serial-number"] !== null && socket.ssid === null) {
|
|
socket.ssid = wtvshared.makeSafeSSID(headers["wtv-client-serial-number"]);
|
|
if (minisrv_config.config.require_valid_ssid) {
|
|
if (!wtvshared.checkSSID(socket.ssid)) {
|
|
if (!socket.ssid.startsWith("1SEGA") && !socket.ssid.startsWith("MSTVSIMU")) {
|
|
// reject invalid SSIDs, but let Dreamcast and MSTV Sim through for now until we figure out their checksumming method.
|
|
const errpage = wtvshared.doErrorPage(400, `${minisrv_config.config.service_name} ran into a technical problem. Reason: Your SSID is not valid.`);
|
|
socket.close_me = true;
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (socket.ssid !== null) {
|
|
if (!ssid_sessions[socket.ssid]) {
|
|
ssid_sessions[socket.ssid] = new WTVClientSessionData(minisrv_config, socket.ssid);
|
|
ssid_sessions[socket.ssid].SaveIfRegistered();
|
|
}
|
|
if (!ssid_sessions[socket.ssid].data_store.sockets) ssid_sessions[socket.ssid].data_store.sockets = new Set();
|
|
ssid_sessions[socket.ssid].data_store.sockets.add(socket);
|
|
}
|
|
}
|
|
|
|
if (socket.ssid) {
|
|
if (!ssid_sessions[socket.ssid] || !socket.ssid) return headers;
|
|
if (!ssid_sessions[socket.ssid].getClientAddress()) ssid_sessions[socket.ssid].setClientAddress(socket.remoteAddress);
|
|
if (ssid_sessions[socket.ssid]) ssid_sessions[socket.ssid].checkSecurity();
|
|
|
|
if (headers["wtv-capability-flags"] !== null) {
|
|
if (!ssid_sessions[socket.ssid]) {
|
|
ssid_sessions[socket.ssid] = new WTVClientSessionData(minisrv_config, socket.ssid);
|
|
ssid_sessions[socket.ssid].SaveIfRegistered();
|
|
}
|
|
if (!ssid_sessions[socket.ssid].capabilities) ssid_sessions[socket.ssid].capabilities = new WTVClientCapabilities(headers["wtv-capability-flags"]);
|
|
}
|
|
// log all client wtv- headers to the SessionData for that SSID
|
|
// this way we can pull up client info such as wtv-client-rom-type or wtv-system-sysconfig
|
|
Object.keys(headers).forEach(function (k) {
|
|
if (k.slice(0, 4) === "wtv-") {
|
|
if (k === "wtv-incarnation" && socket_sessions[socket.id].wtvsec) {
|
|
socket_sessions[socket.id].wtvsec.set_incarnation(headers[k]);
|
|
}
|
|
ssid_sessions[socket.ssid].set(k, headers[k]);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (ssid_sessions[socket.ssid]) {
|
|
if (headers["wtv-ticket"]) {
|
|
if (!ssid_sessions[socket.ssid].data_store.wtvsec_login) {
|
|
ssid_sessions[socket.ssid].data_store.wtvsec_login = new WTVSec(minisrv_config);
|
|
ssid_sessions[socket.ssid].data_store.wtvsec_login.IssueChallenge();
|
|
if (headers["wtv-incarnation"]) ssid_sessions[socket.ssid].data_store.wtvsec_login.set_incarnation(headers["wtv-incarnation"]);
|
|
ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_b64 = headers["wtv-ticket"];
|
|
ssid_sessions[socket.ssid].data_store.wtvsec_login.DecodeTicket(ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_b64);
|
|
if (ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_store.user_id !== null) {
|
|
if (ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_store.user_id >= 0) {
|
|
ssid_sessions[socket.ssid].switchUserID(ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_store.user_id, true, false);
|
|
ssid_sessions[socket.ssid].setUserLoggedIn(true);
|
|
}
|
|
}
|
|
} else {
|
|
if (ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_b64 !== headers["wtv-ticket"]) {
|
|
if (!ssid_sessions[socket.ssid].data_store.wtvsec_login.update_ticket) {
|
|
if (minisrv_config.config.debug_flags.debug) console.debug(" # New ticket from client");
|
|
ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_b64 = headers["wtv-ticket"];
|
|
ssid_sessions[socket.ssid].data_store.wtvsec_login.DecodeTicket(ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_b64);
|
|
if (headers["wtv-incarnation"]) ssid_sessions[socket.ssid].data_store.wtvsec_login.set_incarnation(headers["wtv-incarnation"]);
|
|
if (ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_store.user_id >= 0) {
|
|
if (ssid_sessions[socket.ssid].user_id !== ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_store.user_id) {
|
|
ssid_sessions[socket.ssid].switchUserID(ssid_sessions[socket.ssid].data_store.wtvsec_login.ticket_store.user_id, true, false);
|
|
ssid_sessions[socket.ssid].setUserLoggedIn(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if ((headers.secure === true || headers.encrypted === true) && !skipSecure) {
|
|
if (!socket_sessions[socket.id].wtvsec) {
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * Starting new WTVSec instance on socket", socket.id);
|
|
if (ssid_sessions[socket.ssid].get("wtv-incarnation")) {
|
|
socket_sessions[socket.id].wtvsec = new WTVSec(minisrv_config, ssid_sessions[socket.ssid].get("wtv-incarnation"));
|
|
} else {
|
|
socket_sessions[socket.id].wtvsec = new WTVSec(minisrv_config);
|
|
}
|
|
socket_sessions[socket.id].wtvsec.DecodeTicket(headers["wtv-ticket"]);
|
|
socket_sessions[socket.id].wtvsec.ticket_b64 = headers["wtv-ticket"];
|
|
socket_sessions[socket.id].wtvsec.SecureOn();
|
|
}
|
|
if (socket_sessions[socket.id].secure !== true) {
|
|
// first time so reroll sessions
|
|
socket_sessions[socket.id].secure = true;
|
|
}
|
|
if (!headers.request_url) {
|
|
if (data_hex.includes("0d0a0d0a")) {
|
|
// \r\n\r\n
|
|
header_length = data.length + 4;
|
|
} else if (data_hex.includes("0a0a")) {
|
|
// \n\n
|
|
header_length = data.length + 2;
|
|
}
|
|
const enc_data = CryptoJS.enc.Hex.parse(data_hex.slice(header_length * 2));
|
|
if (enc_data.sigBytes > 0) {
|
|
|
|
// SECURE ON and detected encrypted data
|
|
const dec_data = CryptoJS.lib.WordArray.create(socket_sessions[socket.id].wtvsec.Decrypt(0, enc_data))
|
|
if (!socket_sessions[socket.id].secure_buffer) socket_sessions[socket.id].secure_buffer = "";
|
|
socket_sessions[socket.id].secure_buffer += dec_data.toString(CryptoJS.enc.Hex);
|
|
let secure_headers = null;
|
|
if (headers['request']) {
|
|
if (headers['request'] === "GET") {
|
|
if (socket_sessions[socket.id].secure_buffer.indexOf("0d0a0d0a") || socket_sessions[socket.id].secure_buffer.indexOf("0a0d0a") ||socket_sessions[socket.id].secure_buffer.indexOf("0a0a")) {
|
|
secure_headers = await processRequest(socket, socket_sessions[socket.id].secure_buffer, true, true);
|
|
}
|
|
} else {
|
|
secure_headers = await processRequest(socket, socket_sessions[socket.id].secure_buffer, true, true);
|
|
}
|
|
} else {
|
|
secure_headers = await processRequest(socket, socket_sessions[socket.id].secure_buffer, true, true);
|
|
}
|
|
if (!secure_headers) return;
|
|
|
|
delete socket_sessions[socket.id].secure_buffer;
|
|
if (minisrv_config.config.debug_flags.debug) console.debug(" # Encrypted Request (SECURE ON)", "on", socket.id);
|
|
if (!secure_headers.request) {
|
|
socket_sessions[socket.id].secure = false;
|
|
const errpage = wtvshared.doErrorPage(400);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
|
|
// Merge new headers into existing headers object
|
|
Object.keys(secure_headers).forEach(function (k) {
|
|
headers[k] = secure_headers[k];
|
|
});
|
|
} else {
|
|
socket_sessions[socket.id].headers = headers;
|
|
return;
|
|
}
|
|
}
|
|
} else if (skipSecure) {
|
|
if (headers) {
|
|
if (headers['request']) {
|
|
if (headers['request'].slice(0, 4) === "POST") {
|
|
if (socket_sessions[socket.id].secure_buffer) delete socket_sessions[socket.id].secure_buffer;
|
|
} else {
|
|
return headers;
|
|
}
|
|
} else {
|
|
return headers;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
// handle POST
|
|
if (headers['request'] && !socket_sessions[socket.id].expecting_post_data) {
|
|
if (headers['request'].slice(0, 4) === "POST") {
|
|
let post_string = "POST";
|
|
socket.setTimeout(minisrv_config.config.post_data_socket_timeout * 1000);
|
|
if (typeof socket_sessions[socket.id].post_data === "undefined") {
|
|
if (socket_sessions[socket.id].post_data_percents_shown) delete socket_sessions[socket.id].post_data_percents_shown;
|
|
socket_sessions[socket.id].post_data_length = parseInt(headers['Content-length'] || headers['Content-Length'] || 0);
|
|
socket_sessions[socket.id].post_data = "";
|
|
socket_sessions[socket.id].headers = headers;
|
|
|
|
if (socket_sessions[socket.id].secure) post_string = "Encrypted " + post_string;
|
|
|
|
// the client may have just sent the data with the primary headers, so lets look for that.
|
|
if (data_hex.includes("0d0a0d0a")) {
|
|
socket_sessions[socket.id].post_data = data_hex.slice(data_hex.indexOf("0d0a0d0a") + 8);
|
|
} else if (data_hex.includes("0a0d0a")) {
|
|
socket_sessions[socket.id].post_data = data_hex.slice(data_hex.indexOf("0a0d0a") + 6);
|
|
} else if (data_hex.includes("0a0a")) {
|
|
socket_sessions[socket.id].post_data = data_hex.slice(data_hex.indexOf("0a0a") + 4);
|
|
}
|
|
}
|
|
|
|
if (socket_sessions[socket.id].post_data.length === (socket_sessions[socket.id].post_data_length * 2)) {
|
|
// got all expected data
|
|
if (socket_sessions[socket.id].expecting_post_data) delete socket_sessions[socket.id].expecting_post_data;
|
|
console.log(" * Incoming", post_string, "request on", socket.id, "from", wtvshared.filterSSID(socket.ssid), "to", headers['request_url'], "(got all expected", socket_sessions[socket.id].post_data_length, "bytes of data from client already)");
|
|
headers.post_data = CryptoJS.enc.Hex.parse(socket_sessions[socket.id].post_data);
|
|
delete socket_sessions[socket.id].headers;
|
|
delete socket_sessions[socket.id].post_data;
|
|
delete socket_sessions[socket.id].post_data_length;
|
|
processURL(socket, headers);
|
|
} else if (socket_sessions[socket.id].post_data.length > (socket_sessions[socket.id].post_data_length * 2)) {
|
|
// got too much data ? ... should not ever reach this code (section 2)
|
|
const errpage = wtvshared.doErrorPage(400, null, "Received too much data in POST request<br>Got " + (socket_sessions[socket.id].post_data.length / 2) + ", expected " + socket_sessions[socket.id].post_data_length) + " (2)";
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
} else {
|
|
// expecting more data (see below)
|
|
socket_sessions[socket.id].expecting_post_data = true;
|
|
console.log(" * Incoming", post_string, "request on", socket.id, "from", wtvshared.filterSSID(socket.ssid), "to", headers['request_url'], "(expecting", socket_sessions[socket.id].post_data_length, "bytes of data from client...)");
|
|
}
|
|
return;
|
|
} else {
|
|
delete socket_sessions[socket.id].headers;
|
|
delete socket_sessions[socket.id].post_data;
|
|
delete socket_sessions[socket.id].post_data_length;
|
|
processURL(socket, headers);
|
|
return;
|
|
}
|
|
} else {
|
|
if (headers.length > 0) {
|
|
socket_sessions[socket.id].headers = headers;
|
|
}
|
|
}
|
|
} else if (socket.ssid) {
|
|
try {
|
|
// handle streaming POST
|
|
if (socket_sessions[socket.id].expecting_post_data) {
|
|
if (socket_sessions[socket.id].post_data_length > (minisrv_config.config.max_post_length * 1024 * 1024)) {
|
|
cleanupSocket(socket);
|
|
} else {
|
|
if (headers.length === 0) {
|
|
headers = socket_sessions[socket.id].headers;
|
|
} else {
|
|
socket_sessions[socket.id].headers = headers;
|
|
}
|
|
if (socket_sessions[socket.id].post_data.length < (socket_sessions[socket.id].post_data_length * 2)) {
|
|
const enc_data = CryptoJS.enc.Hex.parse(data_hex);
|
|
let dec_data;
|
|
if (socket_sessions[socket.id].secure) {
|
|
// decrypt if encrypted
|
|
dec_data = CryptoJS.lib.WordArray.create(socket_sessions[socket.id].wtvsec.Decrypt(0, enc_data));
|
|
} else {
|
|
// just pass it over
|
|
dec_data = enc_data;
|
|
}
|
|
|
|
socket_sessions[socket.id].post_data += dec_data.toString(CryptoJS.enc.Hex);
|
|
|
|
let post_string = "POST";
|
|
if (socket_sessions[socket.id].secure === true) post_string = "Encrypted " + post_string;
|
|
|
|
if (minisrv_config.config.post_debug) {
|
|
// `post_debug` logging of every chunk
|
|
console.debug(" * ", Math.floor(new Date().getTime() / 1000), "Receiving", post_string, "data on", socket.id, "[", socket_sessions[socket.id].post_data.length / 2, "of", socket_sessions[socket.id].post_data_length, "bytes ]");
|
|
} else {
|
|
// calculate and display percentage of data received
|
|
const postPercent = wtvshared.getPercentage(socket_sessions[socket.id].post_data.length, (socket_sessions[socket.id].post_data_length * 2));
|
|
if (minisrv_config.config.post_percentages) {
|
|
if (minisrv_config.config.post_percentages.includes(postPercent)) {
|
|
if (!socket_sessions[socket.id].post_data_percents_shown) socket_sessions[socket.id].post_data_percents_shown = new Array();
|
|
if (!socket_sessions[socket.id].post_data_percents_shown[postPercent]) {
|
|
console.debug(" * Received", postPercent, "% of", socket_sessions[socket.id].post_data_length, "bytes on", socket.id, "from", wtvshared.filterSSID(socket.ssid));
|
|
socket_sessions[socket.id].post_data_percents_shown[postPercent] = true;
|
|
}
|
|
if (postPercent === 100) delete socket_sessions[socket.id].post_data_percents_shown;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (socket_sessions[socket.id].post_data.length === (socket_sessions[socket.id].post_data_length * 2)) {
|
|
// got all expected data
|
|
if (socket_sessions[socket.id].expecting_post_data) delete socket_sessions[socket.id].expecting_post_data;
|
|
socket.setTimeout(minisrv_config.config.socket_timeout * 1000);
|
|
if (headers.length === 0) {
|
|
const errpage = wtvshared.doErrorPage(400);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
headers.post_data = CryptoJS.enc.Hex.parse(socket_sessions[socket.id].post_data);
|
|
if (socket_sessions[socket.id].secure === true) {
|
|
if (minisrv_config.config.debug_flags.debug) console.debug(" # Encrypted POST Content (SECURE ON)", "on", socket.id, "[", headers.post_data.sigBytes, "bytes ]");
|
|
} else {
|
|
if (minisrv_config.config.debug_flags.debug) console.debug(" # Unencrypted POST Content", "on", socket.id);
|
|
}
|
|
delete socket_sessions[socket.id].headers;
|
|
delete socket_sessions[socket.id].post_data;
|
|
delete socket_sessions[socket.id].post_data_length;
|
|
processURL(socket, headers);
|
|
return;
|
|
} else if (socket_sessions[socket.id].post_data.length > (socket_sessions[socket.id].post_data_length * 2)) {
|
|
if (socket_sessions[socket.id].expecting_post_data) delete socket_sessions[socket.id].expecting_post_data;
|
|
socket.setTimeout(minisrv_config.config.socket_timeout * 1000);
|
|
// got too much data ? ... should not ever reach this code
|
|
const errmsg = "Received too much data in POST request<br>Got " + (socket_sessions[socket.id].post_data.length / 2) + ", expected " + socket_sessions[socket.id].post_data_length;
|
|
console.error(errmsg);
|
|
const errpage = wtvshared.doErrorPage(400, null, errmsg);
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
return;
|
|
}
|
|
}
|
|
} else if (!skipSecure) {
|
|
if (!encryptedRequest) {
|
|
if (socket_sessions[socket.id].secure !== true) {
|
|
socket_sessions[socket.id].wtvsec = new WTVSec(minisrv_config);
|
|
socket_sessions[socket.id].wtvsec.IssueChallenge();
|
|
socket_sessions[socket.id].wtvsec.SecureOn();
|
|
socket_sessions[socket.id].secure = true;
|
|
}
|
|
const enc_data = CryptoJS.enc.Hex.parse(data_hex);
|
|
let dec_data;
|
|
if (enc_data.sigBytes > 0) {
|
|
if (!socket_sessions[socket.id].wtvsec) {
|
|
const errpage = wtvshared.doErrorPage(400);
|
|
sendToClient(socket, errpage[0] + "wtv-visit: client:relog\n", errpage[1]);
|
|
return;
|
|
}
|
|
const str_test = enc_data.toString(CryptoJS.enc.Latin1);
|
|
if (isUnencryptedString(str_test)) {
|
|
dec_data = enc_data;
|
|
} else {
|
|
dec_data = CryptoJS.lib.WordArray.create(socket_sessions[socket.id].wtvsec.Decrypt(0, enc_data));
|
|
}
|
|
if (!socket_sessions[socket.id].secure_buffer) socket_sessions[socket.id].secure_buffer = "";
|
|
socket_sessions[socket.id].secure_buffer += dec_data.toString(CryptoJS.enc.Hex);
|
|
let secure_headers = null;
|
|
if (headers['request']) {
|
|
if (headers['request'] === "GET") {
|
|
if (socket_sessions[socket.id].secure_buffer.indexOf("0d0a0d0a") || socket_sessions[socket.id].secure_buffer.indexOf("0a0d0a") || socket_sessions[socket.id].secure_buffer.indexOf("0a0a")) {
|
|
secure_headers = await processRequest(socket, socket_sessions[socket.id].secure_buffer, true, true);
|
|
}
|
|
} else {
|
|
secure_headers = await processRequest(socket, socket_sessions[socket.id].secure_buffer, true, true);
|
|
}
|
|
} else {
|
|
secure_headers = await processRequest(socket, socket_sessions[socket.id].secure_buffer, true, true);
|
|
}
|
|
if (secure_headers) {
|
|
delete socket_sessions[socket.id].secure_buffer;
|
|
if (!headers) headers = new Array();
|
|
headers.encrypted = true;
|
|
Object.keys(secure_headers).forEach(function (k, v) {
|
|
headers[k] = secure_headers[k];
|
|
});
|
|
if (headers['request']) {
|
|
if (headers['request'].slice(0, 4) === "POST") {
|
|
if (!socket_sessions[socket.id].post_data) {
|
|
socket_sessions[socket.id].post_data_length = headers['Content-length'] || headers['Content-Length'] || 0;
|
|
socket_sessions[socket.id].post_data = "";
|
|
}
|
|
processRequest(socket, dec_data.toString(CryptoJS.enc.Hex));
|
|
} else {
|
|
processURL(socket, headers);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
const errpage = wtvshared.doErrorPage(400);
|
|
socket.close_me = true;
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
}
|
|
} else {
|
|
const errpage = wtvshared.doErrorPage(400);
|
|
socket.close_me = true;
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
}
|
|
} else {
|
|
const errpage = wtvshared.doErrorPage(400);
|
|
socket.close_me = true;
|
|
sendToClient(socket, errpage[0], errpage[1]);
|
|
}
|
|
}
|
|
|
|
async function cleanupSocket(socket) {
|
|
try {
|
|
if (socket_sessions[socket.id]) {
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(' * Cleaning up disconnected socket', socket.id, `(${socket_sessions[socket.id].socket_total_read || 0} bytes read, ${socket_sessions[socket.id].socket_total_written || 0} bytes written) (${socket.remoteAddress})`);
|
|
delete socket_sessions[socket.id];
|
|
}
|
|
if (socket.ssid) {
|
|
ssid_sessions[socket.ssid].data_store.sockets.delete(socket);
|
|
|
|
if (ssid_sessions[socket.ssid].currentConnections() === 0) {
|
|
// clean up possible minibrowser session data
|
|
if (ssid_sessions[socket.ssid].get("wtv-need-upgrade")) ssid_sessions[socket.ssid].delete("wtv-need-upgrade");
|
|
if (ssid_sessions[socket.ssid].get("wtv-used-8675309")) ssid_sessions[socket.ssid].delete("wtv-used-8675309");
|
|
|
|
// set timer to destroy entirety of session data if client does not return in X time
|
|
const timeout = 180000; // timeout is in milliseconds, default 180000 (3 min) .. be sure to allow time for dialup reconnections
|
|
|
|
// clear any existing timeout check
|
|
if (ssid_sessions[socket.ssid].data_store.socket_check) clearTimeout(ssid_sessions[socket.ssid].data_store.socket_check);
|
|
|
|
// set timeout to check
|
|
ssid_sessions[socket.ssid].data_store.socket_check = setTimeout(function (ssid) {
|
|
if (ssid_sessions[ssid].currentConnections() === 0) {
|
|
if (!minisrv_config.config.debug_flags.quiet) console.debug(" * WebTV SSID", wtvshared.filterSSID(ssid), "has not been seen in", (timeout / 1000), "seconds, cleaning up session data for this SSID");
|
|
delete ssid_sessions[ssid];
|
|
}
|
|
}, timeout, socket.ssid);
|
|
}
|
|
}
|
|
socket.end();
|
|
} catch (e) {
|
|
console.error(" # Could not clean up socket data for socket ID", socket.id, e);
|
|
}
|
|
}
|
|
|
|
function getSocketRandomID(socket) {
|
|
//return parseInt(crc16('CCITT-FALSE', Buffer.from(String(req.socket.remoteAddress) + String(req.socket.remotePort), "utf8")).toString(16), 16);
|
|
return parseInt(
|
|
crypto.createHash('sha256')
|
|
.update(String(socket.remoteAddress) + String(socket.remotePort))
|
|
.digest('hex')
|
|
.slice(0, 8), 16
|
|
) % 100000000;
|
|
}
|
|
|
|
async function handleSocket(socket) {
|
|
// create unique socket id with client address and port
|
|
socket.id = getSocketRandomID(socket);
|
|
socket.ssid = null;
|
|
socket_sessions[socket.id] = [];
|
|
socket_sessions[socket.id].socket_total_read = 0;
|
|
socket.minisrv_pc_mode = false;
|
|
socket.setEncoding('hex'); //set data encoding (Text: 'ascii', 'utf8' ~ Binary: 'hex', 'base64' (do not trust 'binary' encoding))
|
|
socket.setTimeout(minisrv_config.config.socket_timeout * 1000);
|
|
socket.on('data', function (data_hex) {
|
|
if (socket_sessions[socket.id]) {
|
|
socket_sessions[socket.id].socket_total_read += data_hex.length / 2; // hex encoding, so divide by 2
|
|
if (!socket_sessions[socket.id].secure && !socket_sessions[socket.id].expecting_post_data) {
|
|
// buffer unencrypted data until we see the classic double-newline, or get blank
|
|
if (!socket_sessions[socket.id].header_buffer) socket_sessions[socket.id].header_buffer = "";
|
|
socket_sessions[socket.id].header_buffer += data_hex;
|
|
if (socket_sessions[socket.id].header_buffer.includes("0d0a0d0a") || socket_sessions[socket.id].header_buffer.includes("0a0d0a") || socket_sessions[socket.id].header_buffer.includes("0a0a")) {
|
|
data_hex = socket_sessions[socket.id].header_buffer;
|
|
delete socket_sessions[socket.id].header_buffer;
|
|
processRequest(this, data_hex);
|
|
}
|
|
} else {
|
|
// stream encrypted requests through the processor
|
|
if (socket_sessions[socket.id].header_buffer) delete socket_sessions[socket.id].header_buffer;
|
|
processRequest(this, data_hex);
|
|
}
|
|
} else {
|
|
cleanupSocket(socket);
|
|
}
|
|
});
|
|
|
|
socket.on('timeout', function () {
|
|
cleanupSocket(socket);
|
|
});
|
|
|
|
socket.on('error', (err) => {
|
|
cleanupSocket(socket);
|
|
});
|
|
|
|
socket.on('end', function () {
|
|
// Attempt to clean up all of our WTVSec instances
|
|
cleanupSocket(socket);
|
|
});
|
|
|
|
socket.on('close', function () {
|
|
// Attempt to clean up all of our WTVSec instances
|
|
cleanupSocket(socket);
|
|
});
|
|
}
|
|
|
|
function getGitRevision() {
|
|
try {
|
|
const rev = fs.readFileSync(__dirname + path.sep + ".." + path.sep + ".git" + path.sep + "HEAD").toString().trim();
|
|
if (!rev.includes(':')) {
|
|
return rev.slice(0, 8);
|
|
} else {
|
|
return fs.readFileSync(__dirname + path.sep + ".." + path.sep + ".git" + path.sep + rev.slice(5)).toString().trim().slice(0, 8) + "-" + rev.split('/').pop();
|
|
}
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function reloadConfig() {
|
|
const temp = { "version": minisrv_config.version }
|
|
const config = wtvshared.readMiniSrvConfig(true, false, true); // snatches minisrv_config
|
|
|
|
if (temp.git_commit) config.config.git_commit = temp.git_commit;
|
|
if (!config.config.service_logo.includes(':')) {
|
|
config.config.service_logo_pc = "/ROMCache/" + config.config.service_logo;
|
|
config.config.service_logo = "wtv-star:/ROMCache/" + config.config.service_logo;
|
|
}
|
|
|
|
if (config.config.git_commit) temp.git_commit = config.config.git_commit;
|
|
config.version = temp.version
|
|
|
|
if (!config.config.service_splash_logo.includes(':')) config.config.service_splash_logo = "wtv-star:/ROMCache/" + config.config.service_splash_logo;
|
|
Object.keys(config.services).forEach((k) => {
|
|
configureService(k, config.services[k])
|
|
});
|
|
|
|
return config;
|
|
}
|
|
|
|
// SERVER START
|
|
const git_commit = getGitRevision()
|
|
const pkgjson = require('./package.json');
|
|
const { head } = require('nntp-server-zefie/lib/commands/article');
|
|
let z_title = "zefie's wtv minisrv v" + pkgjson.version;
|
|
const z_cgiver = "minisrv/" + pkgjson.version;
|
|
if (git_commit) z_title += " (git " + git_commit + ")";
|
|
console.log("**** Welcome to " + z_title + " ****");
|
|
console.log("**** Detected nodejs v" + process.versions.node + " ****")
|
|
const application_root = wtvshared.getAbsolutePath('', __dirname)
|
|
console.log("**** Application Root Path:", application_root, "****")
|
|
|
|
if (git_commit) {
|
|
minisrv_config.config.git_commit = git_commit;
|
|
delete this.git_commit;
|
|
}
|
|
|
|
if (!minisrv_config) {
|
|
throw ("An error has occured while reading the configuration files.");
|
|
}
|
|
|
|
const service_vaults = [];
|
|
if (minisrv_config.config.ServiceVaults) {
|
|
Object.keys(minisrv_config.config.ServiceVaults).forEach(function (k) {
|
|
const service_vault = wtvshared.getAbsolutePath(minisrv_config.config.ServiceVaults[k]);
|
|
service_vaults.push(service_vault);
|
|
console.log(" * Configured Service Vault at", service_vault, "with priority", (parseInt(k) + 1));
|
|
})
|
|
} else {
|
|
throw ("ERROR: No Service Vaults defined!");
|
|
}
|
|
|
|
const service_deps = [];
|
|
if (minisrv_config.config.ServiceDeps) {
|
|
Object.keys(minisrv_config.config.ServiceDeps).forEach(function (k) {
|
|
const service_dep = wtvshared.getAbsolutePath(minisrv_config.config.ServiceDeps[k]);
|
|
service_deps.push(service_dep);
|
|
console.log(" * Configured Service Dependencies at", service_dep, "with priority", (parseInt(k) + 1));
|
|
})
|
|
} else {
|
|
throw ("ERROR: No Service Dependancies Directory (SessionDeps) defined!");
|
|
}
|
|
|
|
let SessionStore = null;
|
|
if (minisrv_config.config.SessionStore) {
|
|
SessionStore = wtvshared.getAbsolutePath(minisrv_config.config.SessionStore);
|
|
console.log(" * Configured Session Storage at", SessionStore);
|
|
} else {
|
|
throw ("ERROR: No Session Storage Directory (SessionStore) defined!");
|
|
}
|
|
|
|
|
|
const service_ip = minisrv_config.config.service_ip;
|
|
Object.keys(minisrv_config.services).forEach(function (k) {
|
|
if (typeof(minisrv_config.services[k]) === 'function') return;
|
|
if (configureService(k, minisrv_config.services[k], true)) {
|
|
let loadedModule = false;
|
|
if (minisrv_config.services[k].handler_module) {
|
|
try {
|
|
if (!handlerModules[minisrv_config.services[k].handler_module + "_main"]) {
|
|
handlerModules[minisrv_config.services[k].handler_module + "_main"] = require(classPath + "/" + minisrv_config.services[k].handler_module + ".js");
|
|
var args = [];
|
|
for (let i = 0; i < (minisrv_config.services[k].handler_extra_vars || []).length; i++) {
|
|
// is there a better way to do this than eval ? ...
|
|
// concept: server owner can specify handler_extra_vars in the config as an array of
|
|
// variable/function/module names (as strings in the config) that they want to pass to the handler module constructor
|
|
let extraVar = eval(minisrv_config.services[k].handler_extra_vars[i]);
|
|
args.push(extraVar);
|
|
}
|
|
const constructorArgs = [minisrv_config, k, wtvshared, sendToClient, net, ...args];
|
|
handlerModules[minisrv_config.services[k].handler_module.toLowerCase()] = new handlerModules[minisrv_config.services[k].handler_module + "_main"](...constructorArgs);
|
|
}
|
|
loadedModule = true;
|
|
} catch (e) {
|
|
console.error(" # Failed to load handler module for service", k, "module:", minisrv_config.services[k].handler_module, e);
|
|
}
|
|
}
|
|
const using_tls = (minisrv_config.services[k].pc_services && minisrv_config.services[k].https_cert && minisrv_config.services[k].use_https) ? true : false;
|
|
const protocol = (minisrv_config.services[k].protocol) ? minisrv_config.services[k].protocol.toUpperCase() : (minisrv_config.services[k].pc_services) ? "HTTP" : "WTVP";
|
|
console.log(" * Configured Service:", k, "on Port", minisrv_config.services[k].port, "- Service Host:", minisrv_config.services[k].host + ((using_tls) ? " (TLS)" : ""), "- Protocol:", protocol, (loadedModule) ? "- Handler Module: " + minisrv_config.services[k].handler_module : "");
|
|
|
|
if (minisrv_config.services[k].local_nntp_enabled && minisrv_config.services[k].local_nntp_port) {
|
|
if (!wtvnewsserver) {
|
|
const WTVNewsServer = require(classPath + "/WTVNewsServer.js");
|
|
let local_nntp_using_auth = false;
|
|
if (minisrv_config.services[k].local_nntp_requires_auth) {
|
|
local_nntp_using_auth = true;
|
|
if (minisrv_config.services[k].local_auth) {
|
|
// auth required, and info defined in config
|
|
wtvnewsserver = new WTVNewsServer(minisrv_config, minisrv_config.services[k].local_nntp_port, true, minisrv_config.services[k].local_auth.username, minisrv_config.services[k].local_auth.password);
|
|
console.log(" * Configured Service: Local NNTP", "on 127.0.0.1:" + minisrv_config.services[k].local_nntp_port, "(TLS) - Auth required:", local_nntp_using_auth, "- Auth: As Configured");
|
|
} else {
|
|
// auth required, but randomly generated
|
|
wtvnewsserver = new WTVNewsServer(minisrv_config, minisrv_config.services[k].local_nntp_port, true);
|
|
console.log(" * Configured Service: Local NNTP", "on 127.0.0.1:" + minisrv_config.services[k].local_nntp_port, "(TLS) - Auth required:", local_nntp_using_auth, "- Auth (randgen): User:", wtvnewsserver.username, "Pass:", wtvnewsserver.password);
|
|
}
|
|
} else {
|
|
// no auth required on local server
|
|
wtvnewsserver = new WTVNewsServer(minisrv_config, minisrv_config.services[k].local_nntp_port);
|
|
console.log(" * Configured Service: Local NNTP", "on 127.0.0.1:" + minisrv_config.services[k].local_nntp_port, "(TLS) - Auth required:", local_nntp_using_auth, "- Auth: None");
|
|
}
|
|
if (minisrv_config.services[k].featuredGroups) {
|
|
Object.keys(minisrv_config.services[k].featuredGroups).forEach((j) => {
|
|
wtvnewsserver.createGroup(minisrv_config.services[k].featuredGroups[j].group, minisrv_config.services[k].featuredGroups[j].description || null);
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
})
|
|
|
|
if (minisrv_config.config.hide_ssid_in_logs) console.log(" * Masking SSIDs in console logs for security");
|
|
else console.log(" * Full SSIDs will be shown in console logs");
|
|
|
|
if (minisrv_config.config.filter_passwords_in_logs) console.log(" * Will attempt to filter passwords in browser queries")
|
|
else console.log(" * Passwords in browser queries will not be filtered")
|
|
|
|
if (!minisrv_config.config.service_logo.includes(':')) {
|
|
minisrv_config.config.service_logo_pc = "/ROMCache/" + minisrv_config.config.service_logo;
|
|
minisrv_config.config.service_logo = "wtv-star:/ROMCache/" + minisrv_config.config.service_logo;
|
|
}
|
|
if (!minisrv_config.config.service_splash_logo.includes(':')) minisrv_config.config.service_splash_logo = "wtv-star:/ROMCache/" + minisrv_config.config.service_splash_logo;
|
|
|
|
minisrv_config.version = require('./package.json').version;
|
|
if (minisrv_config.config.error_log_file) {
|
|
const error_log_stream = fs.createWriteStream(wtvshared.returnAbsolutePath(minisrv_config.config.error_log_file), { flags: 'a' });
|
|
const process_stderr = process.stderr.write;
|
|
const writeError = function () {
|
|
process_stderr.apply(process.stderr, arguments);
|
|
if (error_log_stream) error_log_stream.write.apply(error_log_stream, arguments);
|
|
}
|
|
process.stderr.write = writeError
|
|
}
|
|
|
|
// sanity
|
|
if (minisrv_config.config.user_accounts.max_users_per_account < 1) {
|
|
console.log(" * WARNING: user_accounts.max_users_per_account should be >= 1, we have set it to 1.");
|
|
minisrv_config.config.user_accounts.max_users_per_account = 1;
|
|
}
|
|
if (minisrv_config.config.user_accounts.max_users_per_account > 99) {
|
|
console.log(" * WARNING: user_accounts.max_users_per_account should be <= 99, we have set it to 99.");
|
|
minisrv_config.config.user_accounts.max_users_per_account = 99;
|
|
}
|
|
|
|
// shenanigans
|
|
if (minisrv_config.config.shenanigans) console.log(" * WARNING: Shenanigans level", minisrv_config.config.shenanigans, "enabled");
|
|
else console.log(" * Shenanigans disabled");
|
|
|
|
// WTVImage
|
|
if (minisrv_config.config.image_decoder.enabled) console.log(" * WebTV Unsupported images will be processed and converted for WebTV clients");
|
|
else console.log(" * WebTV Unsupported images will not be processed, and sent to client as-is");
|
|
|
|
validateAudioProxy();
|
|
|
|
ports.sort();
|
|
pc_ports.sort();
|
|
|
|
Object.keys(minisrv_config.services).forEach((service_name) => {
|
|
if (typeof (minisrv_config.services[service_name]) === 'function') return;
|
|
const service = minisrv_config.services[service_name];
|
|
if (!service || service.disabled || !service.port) return;
|
|
if (service.handler_handles_port && service.protocol && service.handler_module) {
|
|
try {
|
|
handlerModules[service.handler_module.toLowerCase()].listen(service.port, minisrv_config.config.bind_ip);
|
|
protocolServers.push(handlerModules[service.handler_module.toLowerCase()]);
|
|
} catch (e) {
|
|
throw ("Could not bind port for protocol " + service.protocol + " to port " + service.port + " on " + minisrv_config.config.bind_ip + ": " + e.toString());
|
|
}
|
|
}
|
|
});
|
|
|
|
const protocolHandledPorts = new Set();
|
|
Object.keys(minisrv_config.services).forEach((service_name) => {
|
|
if (typeof (minisrv_config.services[service_name]) === 'function') return;
|
|
const service = minisrv_config.services[service_name];
|
|
if (!service || service.disabled || !service.port) return;
|
|
if (service.protocol) {
|
|
protocolHandledPorts.add([service_name, service.protocol, parseInt(service.port)]);
|
|
}
|
|
});
|
|
|
|
// de-duplicate ports in case user configured multiple services on same port
|
|
const bind_ports = [...new Set(ports)].filter((port) => ![...protocolHandledPorts].some(([sn, sp, pt]) => pt === parseInt(port)));
|
|
if (!minisrv_config.config.bind_ip) minisrv_config.config.bind_ip = "0.0.0.0";
|
|
bind_ports.every(function (v) {
|
|
try {
|
|
const server = net.createServer(handleSocket);
|
|
server.listen(v, minisrv_config.config.bind_ip);
|
|
return true;
|
|
} catch (e) {
|
|
throw ("Could not bind to port", v, "on", minisrv_config.config.bind_ip, e.toString());
|
|
}
|
|
return false;
|
|
});
|
|
|
|
// PC Services via express
|
|
// de-duplicate ports in case user configured multiple services on same port
|
|
const pc_bind_ports = [...new Set(pc_ports)]
|
|
if (!minisrv_config.config.bind_ip) minisrv_config.config.bind_ip = "0.0.0.0";
|
|
pc_bind_ports.every(function (v) {
|
|
try {
|
|
const server = express();
|
|
server.use(express.raw({ type: '*/*' }))
|
|
const service_name = getServiceByPort(v);
|
|
let service_handler = http;
|
|
let server_opts = {};
|
|
const using_tls = (minisrv_config.services[service_name].https_cert && minisrv_config.services[service_name].use_https) ? true : false;
|
|
|
|
if (using_tls) {
|
|
service_handler = httpx;
|
|
server_opts =
|
|
{
|
|
key: fs.readFileSync(wtvshared.parseConfigVars(minisrv_config.services[service_name].https_cert.key)),
|
|
cert: fs.readFileSync(wtvshared.parseConfigVars(minisrv_config.services[service_name].https_cert.cert)),
|
|
};
|
|
}
|
|
//service_handler.createServer(server_opts, server).listen(v, minisrv_config.config.bind_ip);
|
|
|
|
if (using_tls && !minisrv_config.services[service_name].force_https) {
|
|
service_handler = httpx; // HTTP and HTTPS on the same port
|
|
}
|
|
|
|
service_handler.createServer(server_opts, server).listen(v, minisrv_config.config.bind_ip);
|
|
|
|
server.get('*', (req, res) => {
|
|
const ssl = (req.socket.ssl) ? true : false;
|
|
let service_name = getServiceByPort(v);
|
|
const request_headers = {};
|
|
|
|
request_headers['request'] = "GET " + req.originalUrl + " HTTP/1.1";
|
|
request_headers.request_url = req.originalUrl;
|
|
request_headers.raw_headers = "Request: " + request_headers['request'] + "\r\n";
|
|
Object.keys(req.headers).forEach(function (k) {
|
|
request_headers[k] = req.headers[k];
|
|
request_headers.raw_headers += k + ": " + req.headers[k] + "\r\n";
|
|
});
|
|
request_headers.query = req.query;
|
|
|
|
let host_name = (request_headers['host']) ? request_headers['host'] : null;
|
|
|
|
if (host_name) {
|
|
if (host_name.includes(":")) host_name = host_name.slice(0, host_name.indexOf(":"));
|
|
service_name = (getServiceByVHost(host_name)) ? getServiceByVHost(host_name) : service_name
|
|
}
|
|
|
|
req.socket.minisrv_pc_mode = true;
|
|
req.socket.res = res;
|
|
req.socket.service_name = service_name;
|
|
req.socket.id = getSocketRandomID(req.socket);
|
|
socket_sessions[req.socket.id] = [];
|
|
|
|
if (getServiceEnabled(service_name)) {
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * ["+req.socket.remoteAddress+"] Incoming " + ((ssl) ? "HTTPS" : "HTTP") + " PC GET Headers on", service_name, "socket ID", req.socket.id, wtvshared.filterRequestLog(request_headers));
|
|
else debug(" * ["+req.socket.remoteAddress+"] Incoming " + ((ssl) ? "HTTPS" : "HTTP") + " PC GET Headers on", service_name, "socket ID", req.socket.id, wtvshared.filterRequestLog(request_headers));
|
|
|
|
if (!ssl && minisrv_config.services[service_name].force_https && minisrv_config.services[service_name].https_cert) {
|
|
const headers = `302 Moved
|
|
Location: https://${(minisrv_config.services[service_name].https_cert.domain) ? minisrv_config.services[service_name].https_cert.domain : minisrv_config.services[service_name].host}:${minisrv_config.services[service_name].port}${req.originalUrl}
|
|
Content-type: text/html`;
|
|
sendToClient(req.socket, headers);
|
|
} else {
|
|
processURL(req.socket, request_headers, true)
|
|
}
|
|
} else {
|
|
debug(" * ["+req.socket.remoteAddress+"] Service Not Found ("+service_name+")");
|
|
const errpage = wtvshared.doErrorPage(404, "Service Not Found ("+service_name+")", null, true);
|
|
sendToClient(req.socket, errpage[0], errpage[1]);
|
|
}
|
|
})
|
|
|
|
server.post('*', (req, res) => {
|
|
let errpage = null;
|
|
const ssl = (req.socket.ssl) ? true : false;
|
|
let service_name = getServiceByPort(v);
|
|
|
|
const request_headers = {};
|
|
request_headers['request'] = "POST " + req.originalUrl + " HTTP/1.1";
|
|
request_headers.request_url = req.originalUrl;
|
|
request_headers.raw_headers = "Request: "+request_headers['request']+"\r\n";
|
|
Object.keys(req.headers).forEach(function (k) {
|
|
request_headers[k] = req.headers[k];
|
|
request_headers.raw_headers += k+": "+req.headers[k] + "\r\n";
|
|
});
|
|
request_headers.query = req.query;
|
|
|
|
let host_name = (request_headers['host']) ? request_headers['host'] : null;
|
|
|
|
if (host_name) {
|
|
if (host_name.includes(":")) host_name = host_name.slice(0, host_name.indexOf(":"));
|
|
service_name = (getServiceByVHost(host_name)) ? getServiceByVHost(host_name) : service_name
|
|
}
|
|
|
|
req.socket.minisrv_pc_mode = true;
|
|
req.socket.res = res;
|
|
req.socket.service_name = service_name;
|
|
req.socket.id = getSocketRandomID(req.socket);
|
|
socket_sessions[req.socket.id] = [];
|
|
|
|
if (getServiceEnabled(service_name)) {
|
|
if (req.body) {
|
|
if (typeof (req.body) === "string") {
|
|
request_headers.post_data = req.body;
|
|
} else if (Buffer.isBuffer(req.body)) {
|
|
const bodyString = req.body.toString('utf8');
|
|
if (bodyString.length > (minisrv_config.config.max_post_length * 1024 * 1024)) {
|
|
errpage = wtvshared.doErrorPage("400", "POST size too large", null, true);
|
|
} else {
|
|
request_headers.post_data = "";
|
|
for (let i = 0; i < bodyString.length; i++) {
|
|
request_headers.post_data += String.fromCharCode(bodyString.charCodeAt(i));
|
|
}
|
|
}
|
|
} else {
|
|
request_headers.post_data = req.body.toString('utf8');
|
|
}
|
|
} else {
|
|
request_headers.post_data = ""; // Invalid type (array/object), possible type confusion attack
|
|
errpage = wtvshared.doErrorPage("400", "Invalid POST data type", null, true);
|
|
}
|
|
|
|
if (minisrv_config.config.debug_flags.show_headers) console.debug(" * ["+req.socket.remoteAddress+"] Incoming " + ((ssl) ? "HTTPS" : "HTTP") + " PC POST Headers on", service_name, "socket ID", req.socket.id, wtvshared.filterRequestLog(request_headers));
|
|
else debug(" * ["+req.socket.remoteAddress+"] Incoming " + ((ssl) ? "HTTPS" : "HTTP") + " PC POST Headers on", service_name, "socket ID", req.socket.id, wtvshared.filterRequestLog(request_headers));
|
|
|
|
if (!ssl && minisrv_config.services[service_name].force_https && minisrv_config.services[service_name].https_cert) {
|
|
const headers = `302 Moved
|
|
Location: https://${(minisrv_config.services[service_name].https_cert.domain) ? minisrv_config.services[service_name].https_cert.domain : minisrv_config.services[service_name].host}:${minisrv_config.services[service_name].port}${req.originalUrl}
|
|
Content-type: text/html`;
|
|
sendToClient(req.socket, headers);
|
|
} else if (errpage) {
|
|
sendToClient(req.socket, errpage[0], errpage[1]);
|
|
} else {
|
|
processURL(req.socket, request_headers, true)
|
|
}
|
|
} else {
|
|
debug(" * ["+req.socket.remoteAddress+"] Service Not Found ("+service_name+")");
|
|
const errpage = wtvshared.doErrorPage(404, "Service Not Found (" + service_name +")", null, true);
|
|
sendToClient(req.socket, errpage[0], errpage[1]);
|
|
}
|
|
})
|
|
return true;
|
|
} catch (e) {
|
|
throw ("Could not bind to port", v, "on", minisrv_config.config.bind_ip, e.toString());
|
|
}
|
|
return false;
|
|
});
|
|
|
|
if (bind_ports.length > 0) console.log(` * Started WTVP Server on port${bind_ports.length !== 1 ? "s" : ""} ` + bind_ports.join(", ") + "...");
|
|
if (pc_bind_ports.length > 0) console.log(` * Started HTTP Server on port${pc_bind_ports.length !== 1 ? "s" : ""} ` + pc_bind_ports.join(", ") + "...");
|
|
if (protocolHandledPorts.size > 0) console.log(` * Started ${protocolHandledPorts.size} specialized protocol handler${protocolHandledPorts.size !== 1 ? "s" : ""} on port${protocolHandledPorts.size !== 1 ? "s" : ""} ` + [...protocolHandledPorts].map(([sn, sp, pt]) => `${pt} (${sp.toUpperCase()})`).join(", ") + "...");
|
|
const listening_ip_string = (minisrv_config.config.bind_ip !== "0.0.0.0") ? "IP: " + minisrv_config.config.bind_ip : "all interfaces";
|
|
console.log(" * Listening on", listening_ip_string, "~", "Service IP:", service_ip);
|
|
|
|
if (minisrv_config.config.keys.user_data_key === "PNa$WN7gz}!T=t6X7^=|Ii##CEB~p\\EP") {
|
|
console.log(" * WARNING: You are using the default user data encryption key. This is not secure, and you should change it in the configuration file before registering any users.");
|
|
console.log(" * To generate a random key in bash or PowerShell, you can run: node ./tools/configurator.js config.keys.user_data_key $(openssl rand -base64 32)");
|
|
console.log(" * After changing the key in the user_config, you can run tools/update_user_data_key.js to update existing accounts with the new key.");
|
|
console.log(" * Making a backup of your user accounts before doing this is highly recommended, in case something goes wrong during the update process.");
|
|
} |