-- Prosody IM

-- Copyright (C) 2008-2010 Matthew Wild

-- Copyright (C) 2008-2010 Waqas Hussain

--

-- This project is MIT/X11 licensed. Please see the

-- COPYING file in the source package for more information.

--

-- luacheck: ignore 212/self

module:set_global();

module:depends("admin_socket");

local hostmanager = require "prosody.core.hostmanager";

local modulemanager = require "prosody.core.modulemanager";

local s2smanager = require "prosody.core.s2smanager";

local portmanager = require "prosody.core.portmanager";

local helpers = require "prosody.util.helpers";

local it = require "prosody.util.iterators";

local server = require "prosody.net.server";

local st = require "prosody.util.stanza";

local _G = _G;

local prosody = _G.prosody;

local unpack = table.unpack;

local iterators = require "prosody.util.iterators";

local keys, values = iterators.keys, iterators.values;

local jid_bare, jid_split, jid_join, jid_resource, jid_compare = import("prosody.util.jid", "bare", "prepped_split", "join", "resource", "compare");

local set, array = require "prosody.util.set", require "prosody.util.array";

local cert_verify_identity = require "prosody.util.x509".verify_identity;

local envload = require "prosody.util.envload".envload;

local envloadfile = require "prosody.util.envload".envloadfile;

local has_pposix, pposix = pcall(require, "prosody.util.pposix");

local async = require "prosody.util.async";

local serialization = require "prosody.util.serialization";

local serialize_config = serialization.new ({ fatal = false, unquoted = true});

local time = require "prosody.util.time";

local promise = require "prosody.util.promise";

local logger = require "prosody.util.logger";

local t_insert = table.insert;

local t_concat = table.concat;

local format_number = require "prosody.util.human.units".format;

local format_table = require "prosody.util.human.io".table;

local function capitalize(s)

	if not s then return end

	return (s:gsub("^%a", string.upper):gsub("_", " "));

end

local function pre(prefix, str, alt)

	if type(str) ~= "string" or str == "" then return alt or ""; end

	return prefix .. str;

end

local function suf(str, suffix, alt)

	if type(str) ~= "string" or str == "" then return alt or ""; end

	return str .. suffix;

end

local commands = module:shared("commands")

local def_env = module:shared("env");

local default_env_mt = { __index = def_env };

local function new_section(section_desc)

	return setmetatable({}, {

		help = {

			desc = section_desc;

			commands = {};

		};

	});

end

local help_topics = {};

local function help_topic(name)

	return function (desc)

		return function (content)

			help_topics[name] = {

				desc = desc;

				content = content;

			};

		end;

	end

end

-- Seed with default sections and their description text

help_topic "console" "Help regarding the console itself" [[

Hey! Welcome to Prosody's admin console.

First thing, if you're ever wondering how to get out, simply type 'quit'.

Secondly, note that we don't support the full telnet protocol yet (it's coming)

so you may have trouble using the arrow keys, etc. depending on your system.

For now we offer a couple of handy shortcuts:

!! - Repeat the last command

!old!new! - repeat the last command, but with 'old' replaced by 'new'

For those well-versed in Prosody's internals, or taking instruction from those who are,

you can prefix a command with > to escape the console sandbox, and access everything in

the running server. Great fun, but be careful not to break anything :)

]];

local available_columns; --forward declaration so it is reachable from the help

help_topic "columns" "Information about customizing session listings" (function (self, print)

	print [[The columns shown by c2s:show() and s2s:show() can be customizied via the]]

	print [['columns' argument as described here.]]

	print [[]]

	print [[Columns can be specified either as "id jid ipv" or as {"id", "jid", "ipv"}.]]

	print [[Available columns are:]]

	local meta_columns = {

		{ title = "ID"; width = 5 };

		{ title = "Column Title"; width = 12 };

		{ title = "Description"; width = 12 };

	};

	-- auto-adjust widths

	for column, spec in pairs(available_columns) do

		meta_columns[1].width = math.max(meta_columns[1].width or 0, #column);

		meta_columns[2].width = math.max(meta_columns[2].width or 0, #(spec.title or ""));

		meta_columns[3].width = math.max(meta_columns[3].width or 0, #(spec.description or ""));

	end

	local row = format_table(meta_columns, self.session.width)

	print(row());

	for column, spec in iterators.sorted_pairs(available_columns) do

		print(row({ column, spec.title, spec.description }));

	end

	print [[]]

	print [[Most fields on the internal session structures can also be used as columns]]

	-- Also, you can pass a table column specification directly, with mapper callback and all

end);

help_topic "roles"   "Show information about user roles" [[

Roles may grant access or restrict users from certain operations.

Built-in roles are:

  prosody:guest      - Guest/anonymous user

  prosody:registered - Registered user

  prosody:member     - Provisioned user

  prosody:admin      - Host administrator

  prosody:operator - Server administrator

Roles can be assigned using the user management commands (see 'help user').

]];

local function redirect_output(target, session)

	local env = setmetatable({ print = session.print }, { __index = function (_, k) return rawget(target, k); end });

	env.dofile = function(name)

		local f, err = envloadfile(name, env);

		if not f then return f, err; end

		return f();

	end;

	return env;

end

console = {};

local runner_callbacks = {};

function runner_callbacks:error(err)

	module:log("error", "Traceback[shell]: %s", err);

	self.data.print("Fatal error while running command, it did not complete");

	self.data.print("Error: "..tostring(err));

end

local function send_repl_output(session, line, attr)

	return session.send(st.stanza("repl-output", attr):text(tostring(line)));

end

function console:new_session(admin_session)

	local session = {

		send = function (t)

			return send_repl_output(admin_session, t);

		end;

		print = function (...)

			local t = {};

			for i=1,select("#", ...) do

				t[i] = tostring(select(i, ...));

			end

			return send_repl_output(admin_session, table.concat(t, "\t"));

		end;

		write = function (t)

			return send_repl_output(admin_session, t, { eol = "0" });

		end;

		serialize = tostring;

		disconnect = function () admin_session:close(); end;

		is_connected = function ()

			return not not admin_session.conn;

		end

	};

	session.env = setmetatable({}, default_env_mt);

	session.thread = async.runner(function (line)

		console:process_line(session, line);

	end, runner_callbacks, session);

	-- Load up environment with helper objects

	for name, t in pairs(def_env) do

		if type(t) == "table" then

			session.env[name] = setmetatable({ session = session }, { __index = t });

		end

	end

	session.env.output:configure();

	return session;

end

local function handle_line(event)

	local session = event.origin.shell_session;

	if not session then

		session = console:new_session(event.origin);

		event.origin.shell_session = session;

	end

	local default_width = 132; -- The common default of 80 is a bit too narrow for e.g. s2s:show(), 132 was another common width for hardware terminals

	local margin = 2; -- To account for '| ' when lines are printed

	session.width = (tonumber(event.stanza.attr.width) or default_width)-margin;

	local line = event.stanza:get_text();

	local useglobalenv;

	local result = st.stanza("repl-result");

	module:log("warn", "Processing line: %q", line);

	if line:match("^>") then

		line = line:gsub("^>", "");

		useglobalenv = true;

	else

		local command = line:match("^(%w+) ") or line:match("^%w+$") or line:match("%p");

		if commands[command] then

			commands[command](session, line);

			event.origin.send(result);

			return;

		end

	end

	session.env._ = line;

	if not useglobalenv and commands[line:lower()] then

		commands[line:lower()](session, line);

		event.origin.send(result);

		return;

	end

	if useglobalenv and not session.globalenv then

		session.globalenv = redirect_output(_G, session);

	end

	local chunkname = "=console";

	local env = (useglobalenv and session.globalenv) or session.env or nil

	-- luacheck: ignore 311/err

	local chunk, err = envload("return "..line, chunkname, env);

	if not chunk then

		chunk, err = envload(line, chunkname, env);

		if not chunk then

			err = err:gsub("^%[string .-%]:%d+: ", "");

			err = err:gsub("^:%d+: ", "");

			err = err:gsub("'<eof>'", "the end of the line");

			result.attr.type = "error";

			result:text("Sorry, I couldn't understand that... "..err);

			event.origin.send(result);

			return;

		end

	end

	local taskok, message = chunk();

	if promise.is_promise(taskok) then

		taskok, message = async.wait_for(taskok);

	end

	if not message then

		if type(taskok) ~= "string" and useglobalenv then

			taskok = session.serialize(taskok);

		end

		result:text("Result: "..tostring(taskok));

	elseif (not taskok) and message then

		result.attr.type = "error";

		result:text("Error: "..tostring(message));

	else

		result:text("OK: "..tostring(message));

	end

	event.origin.send(result);

end

module:hook("admin/repl-input", function (event)

	local ok, err = pcall(handle_line, event);

	if not ok then

		event.origin.send(st.stanza("repl-result", { type = "error" }):text(err));

	end

	return true;

end);

local function describe_command(s)

	local section, name, args, desc = s:match("^([%w_]+):([%w_]+)%(([^)]*)%) %- (.+)$");

	if not section then

		error("Failed to parse command description: "..s);

	end

	local command_help = getmetatable(def_env[section]).help.commands;

	command_help[name] = {

		desc = desc;

		args = array.collect(args:gmatch("[%w_]+")):map(function (name)

			return { name = name };

		end);

	};

end

-- Console commands --

-- These are simple commands, not valid standalone in Lua

-- Help about individual topics is handled by def_env.help

function commands.help(session, data)

	local print = session.print;

	local section = data:match("^help (%w+)");

	if not section then

		print [[Commands are divided into multiple sections. For help on a particular section, ]]

		print [[type: help SECTION (for example, 'help c2s'). Sections are: ]]

		print [[]]

		local row = format_table({ { title = "Section", width = 7 }, { title = "Description", width = "100%" } }, session.width)

		print(row())

		for section_name, section in it.sorted_pairs(def_env) do

			local section_mt = getmetatable(section);

			local section_help = section_mt and section_mt.help;

			print(row { section_name; section_help and section_help.desc or "" });

		end

	else

		return def_env.help[section]({ session = session });

	end

	print("");

	print [[In addition to info about commands, the following general topics are available:]]

	print("");

	for topic_name, topic in it.sorted_pairs(help_topics) do

		print(topic_name .. " - "..topic.desc);

	end

end

-- Session environment --

-- Anything in def_env will be accessible within the session as a global variable

--luacheck: ignore 212/self

local serialize_defaults = module:get_option("console_prettyprint_settings", {

	preset = "pretty";

	maxdepth = 2;

	table_iterator = "pairs";

})

def_env.output = new_section("Configure admin console output");

function def_env.output:configure(opts)

	if type(opts) ~= "table" then

		opts = { preset = opts };

	end

	if not opts.fallback then

		-- XXX Error message passed to fallback is lost, does it matter?

		opts.fallback = tostring;

	end

	for k,v in pairs(serialize_defaults) do

		if opts[k] == nil then

			opts[k] = v;

		end

	end

	if opts.table_iterator == "pairs" then

		opts.table_iterator = pairs;

	elseif type(opts.table_iterator) ~= "function" then

		opts.table_iterator = nil; -- rawpairs is the default

	end

	self.session.serialize = serialization.new(opts);

end

def_env.help = setmetatable({}, {

	help = {

		desc = "Show this help about available commands";