plugins/mod_console.lua

   1 -- Prosody IM v0.4
   2 -- Copyright (C) 2008-2009 Matthew Wild
   3 -- Copyright (C) 2008-2009 Waqas Hussain
   4 --
   5 -- This project is MIT/X11 licensed. Please see the
   6 -- COPYING file in the source package for more information.
   7 --
   8
   9 module.host = "*";
  10
  11 local hosts = _G.hosts;
  12 local connlisteners_register = require "net.connlisteners".register;
  13
  14 local console_listener = { default_port = 5582; default_mode = "*l"; };
  15
  16 local commands = {};
  17 local def_env = {};
  18 local default_env_mt = { __index = def_env };
  19
  20 console = {};
  21
  22 function console:new_session(conn)
  23         local w = function(s) conn.write(s:gsub("\n", "\r\n")); end;
  24         local session = { conn = conn;
  25                         send = function (t) w(tostring(t)); end;
  26                         print = function (t) w("| "..tostring(t).."\n"); end;
  27                         disconnect = function () conn.close(); end;
  28                         };
  29         session.env = setmetatable({}, default_env_mt);
  30
  31         -- Load up environment with helper objects
  32         for name, t in pairs(def_env) do
  33                 if type(t) == "table" then
  34                         session.env[name] = setmetatable({ session = session }, { __index = t });
  35                 end
  36         end
  37
  38         return session;
  39 end
  40
  41 local sessions = {};
  42
  43 function console_listener.listener(conn, data)
  44         local session = sessions[conn];
  45
  46         if not session then
  47                 -- Handle new connection
  48                 session = console:new_session(conn);
  49                 sessions[conn] = session;
  50                 printbanner(session);
  51         end
  52         if data then
  53                 -- Handle data
  54                 (function(session, data)
  55                         if data:match("[!.]$") then
  56                                 local command = data:lower();
  57                                 command = data:match("^%w+") or data:match("%p");
  58                                 if commands[command] then
  59                                         commands[command](session, data);
  60                                         return;
  61                                 end
  62                         end
  63
  64                         session.env._ = data;
  65
  66                         local chunk, err = loadstring("return "..data);
  67                         if not chunk then
  68                                 chunk, err = loadstring(data);
  69                                 if not chunk then
  70                                         err = err:gsub("^%[string .-%]:%d+: ", "");
  71                                         err = err:gsub("^:%d+: ", "");
  72                                         err = err:gsub("'<eof>'", "the end of the line");
  73                                         session.print("Sorry, I couldn't understand that... "..err);
  74                                         return;
  75                                 end
  76                         end
  77
  78                         setfenv(chunk, session.env);
  79                         local ranok, taskok, message = pcall(chunk);
  80
  81                         if not ranok then
  82                                 session.print("Fatal error while running command, it did not complete");
  83                                 session.print("Error: "..taskok);
  84                                 return;
  85                         end
  86
  87                         if not message then
  88                                 session.print("Result: "..tostring(taskok));
  89                                 return;
  90                         elseif (not taskok) and message then
  91                                 session.print("Command completed with a problem");
  92                                 session.print("Message: "..tostring(message));
  93                                 return;
  94                         end
  95
  96                         session.print("OK: "..tostring(message));
  97                 end)(session, data);
  98         end
  99         session.send(string.char(0));
 100 end
 101
 102 function console_listener.disconnect(conn, err)
 103
 104 end
 105
 106 connlisteners_register('console', console_listener);
 107
 108 -- Console commands --
 109 -- These are simple commands, not valid standalone in Lua
 110
 111 function commands.bye(session)
 112         session.print("See you! :)");
 113         session.disconnect();
 114 end
 115
 116 commands["!"] = function (session, data)
 117         if data:match("^!!") then
 118                 session.print("!> "..session.env._);
 119                 return console_listener.listener(session.conn, session.env._);
 120         end
 121         local old, new = data:match("^!(.-[^\\])!(.-)!$");
 122         if old and new then
 123                 local ok, res = pcall(string.gsub, session.env._, old, new);
 124                 if not ok then
 125                         session.print(res)
 126                         return;
 127                 end
 128                 session.print("!> "..res);
 129                 return console_listener.listener(session.conn, res);
 130         end
 131         session.print("Sorry, not sure what you want");
 132 end
 133
 134 -- Session environment --
 135 -- Anything in def_env will be accessible within the session as a global variable
 136
 137 def_env.server = {};
 138 function def_env.server:reload()
 139         dofile "prosody"
 140         return true, "Server reloaded";
 141 end
 142
 143 def_env.module = {};
 144 function def_env.module:load(name, host, config)
 145         local mm = require "modulemanager";
 146         local ok, err = mm.load(host or self.env.host, name, config);
 147         if not ok then
 148                 return false, err or "Unknown error loading module";
 149         end
 150         return true, "Module loaded";
 151 end
 152
 153 function def_env.module:unload(name, host)
 154         local mm = require "modulemanager";
 155         local ok, err = mm.unload(host or self.env.host, name);
 156         if not ok then
 157                 return false, err or "Unknown error unloading module";
 158         end
 159         return true, "Module unloaded";
 160 end
 161
 162 function def_env.module:reload(name, host)
 163         local mm = require "modulemanager";
 164         local ok, err = mm.reload(host or self.env.host, name);
 165         if not ok then
 166                 return false, err or "Unknown error reloading module";
 167         end
 168         return true, "Module reloaded";
 169 end
 170
 171 def_env.config = {};
 172 function def_env.config:load(filename, format)
 173         local config_load = require "core.configmanager".load;
 174         local ok, err = config_load(filename, format);
 175         if not ok then
 176                 return false, err or "Unknown error loading config";
 177         end
 178         return true, "Config loaded";
 179 end
 180
 181 function def_env.config:get(host, section, key)
 182         local config_get = require "core.configmanager".get
 183         return true, tostring(config_get(host, section, key));
 184 end
 185
 186 def_env.hosts = {};
 187 function def_env.hosts:list()
 188         for host, host_session in pairs(hosts) do
 189                 self.session.print(host);
 190         end
 191         return true, "Done";
 192 end
 193
 194 function def_env.hosts:add(name)
 195 end
 196
 197 def_env.s2s = {};
 198 function def_env.s2s:show()
 199         local _print = self.session.print;
 200         local print = self.session.print;
 201         for host, host_session in pairs(hosts) do
 202                 print = function (...) _print(host); _print(...); print = _print; end
 203                 for remotehost, session in pairs(host_session.s2sout) do
 204                         print("    "..host.." -> "..remotehost);
 205                         if session.sendq then
 206                                 print("        There are "..#session.sendq.." queued outgoing stanzas for this connection");
 207                         end
 208                         if session.type == "s2sout_unauthed" then
 209                                 if session.connecting then
 210                                         print("        Connection not yet established");
 211                                         if not session.srv_hosts then
 212                                                 if not session.conn then
 213                                                         print("        We do not yet have a DNS answer for this host's SRV records");
 214                                                 else
 215                                                         print("        This host has no SRV records, using A record instead");
 216                                                 end
 217                                         elseif session.srv_choice then
 218                                                 print("        We are on SRV record "..session.srv_choice.." of "..#session.srv_hosts);
 219                                                 local srv_choice = session.srv_hosts[session.srv_choice];
 220                                                 print("        Using "..(srv_choice.target or ".")..":"..(srv_choice.port or 5269));
 221                                         end
 222                                 elseif session.notopen then
 223                                         print("        The <stream> has not yet been opened");
 224                                 elseif not session.dialback_key then
 225                                         print("        Dialback has not been initiated yet");
 226                                 elseif session.dialback_key then
 227                                         print("        Dialback has been requested, but no result received");
 228                                 end
 229                         end
 230                 end
 231
 232                 for session in pairs(incoming_s2s) do
 233                         if session.to_host == host then
 234                                 print("    "..host.." <- "..(session.from_host or "(unknown)"));
 235                                 if session.type == "s2sin_unauthed" then
 236                                         print("        Connection not yet authenticated");
 237                                 end
 238                                 for name in pairs(session.hosts) do
 239                                         if name ~= session.from_host then
 240                                                 print("        also hosts "..tostring(name));
 241                                         end
 242                                 end
 243                         end
 244                 end
 245                 print = _print;
 246         end
 247         for session in pairs(incoming_s2s) do
 248                 if not session.to_host then
 249                         print("Other incoming s2s connections");
 250                         print("    (unknown) <- "..(session.from_host or "(unknown)"));
 251                 end
 252         end
 253 end
 254
 255 -------------
 256
 257 function printbanner(session)
 258 session.print [[
 259                    ____                \   /     _
 260                     |  _ \ _ __ ___  ___  _-_   __| |_   _
 261                     | |_) | '__/ _ \/ __|/ _ \ / _` | | | |
 262                     |  __/| | | (_) \__ \ |_| | (_| | |_| |
 263                     |_|   |_|  \___/|___/\___/ \__,_|\__, |
 264                     A study in simplicity            |___/
 265
 266 ]]
 267 session.print("Welcome to the Prosody administration console. For a list of commands, type: help");
 268 session.print("You may find more help on using this console in our online documentation at ");
 269 session.print("http://prosody.im/doc/console\n");
 270 end