diff options
| -rw-r--r-- | core/s2smanager.lua | 178 | ||||
| -rw-r--r-- | core/sessionmanager.lua | 11 | ||||
| -rw-r--r-- | core/stanza_router.lua | 2 | ||||
| -rw-r--r-- | core/xmlhandlers.lua | 8 | ||||
| -rw-r--r-- | net/xmppclient_listener.lua | 2 | ||||
| -rw-r--r-- | net/xmppserver_listener.lua | 95 | ||||
| -rw-r--r-- | util/hashes.lua | 27 |
7 files changed, 316 insertions, 7 deletions
diff --git a/core/s2smanager.lua b/core/s2smanager.lua new file mode 100644 index 00000000..1d718305 --- /dev/null +++ b/core/s2smanager.lua @@ -0,0 +1,178 @@ + +local hosts = hosts; +local sessions = sessions; +local socket = require "socket"; +local format = string.format; +local tostring, pairs, ipairs, getmetatable, print, newproxy, error, tonumber + = tostring, pairs, ipairs, getmetatable, print, newproxy, error, tonumber; + +local connlisteners_get = require "net.connlisteners".get; +local wraptlsclient = require "net.server".wraptlsclient; +local modulemanager = require "core.modulemanager"; + +local uuid_gen = require "util.uuid".generate; + +local logger_init = require "util.logger".init; + +local log = logger_init("s2smanager"); + +local md5_hash = require "util.hashes".md5; + +local dialback_secret = "This is very secret!!! Ha!"; + +module "s2smanager" + +function connect_host(from_host, to_host) +end + +function send_to_host(from_host, to_host, data) + if hosts[to_host] then + -- Write to connection + hosts[to_host].send(data); + log("debug", "stanza sent over s2s"); + else + log("debug", "opening a new outgoing connection for this stanza"); + local host_session = new_outgoing(from_host, to_host); + -- Store in buffer + host_session.sendq = { data }; + end +end + +function disconnect_host(host) + +end + +local open_sessions = 0; + +function new_incoming(conn) + local session = { conn = conn, priority = 0, type = "s2sin_unauthed", direction = "incoming" }; + if true then + session.trace = newproxy(true); + getmetatable(session.trace).__gc = function () open_sessions = open_sessions - 1; print("s2s session got collected, now "..open_sessions.." s2s sessions are allocated") end; + end + open_sessions = open_sessions + 1; + local w = conn.write; + session.send = function (t) w(tostring(t)); end + return session; +end + +function new_outgoing(from_host, to_host) + local host_session = { to_host = to_host, from_host = from_host, notopen = true, type = "s2sout_unauthed", direction = "outgoing" }; + hosts[to_host] = host_session; + + local cl = connlisteners_get("xmppserver"); + + local conn, handler = socket.tcp() + --FIXME: Below parameters (ports/ip) are incorrect (use SRV) + conn:connect(to_host, 5269); + conn = wraptlsclient(cl, conn, to_host, 5269, 0, 1, hosts[from_host].ssl_ctx ); + host_session.conn = conn; + + -- Register this outgoing connection so that xmppserver_listener knows about it + -- otherwise it will assume it is a new incoming connection + cl.register_outgoing(conn, host_session); + + do + local conn_name = "s2sout"..tostring(conn):match("[a-f0-9]*$"); + host_session.log = logger_init(conn_name); + end + + local w = conn.write; + host_session.send = function (t) w(tostring(t)); end + + conn.write(format([[<stream:stream xmlns='jabber:server' xmlns:db='jabber:server:dialback' xmlns:stream='http://etherx.jabber.org/streams' from='%s' to='%s' version='1.0'>]], from_host, to_host)); + + return host_session; +end + +function streamopened(session, attr) + session.log("debug", "s2s stream opened"); + local send = session.send; + + session.version = tonumber(attr.version) or 0; + if session.version >= 1.0 and not (attr.to and attr.from) then + print("to: "..tostring(attr.to).." from: "..tostring(attr.from)); + --error(session.to_host.." failed to specify 'to' or 'from' hostname as per RFC"); + log("warn", (session.to_host or "(unknown)").." failed to specify 'to' or 'from' hostname as per RFC"); + end + + if session.direction == "incoming" then + -- Send a reply stream header + + for k,v in pairs(attr) do print("", tostring(k), ":::", tostring(v)); end + + session.to_host = attr.to; + session.from_host = attr.from; + + session.streamid = uuid_gen(); + print(session, session.from_host, "incoming s2s stream opened"); + send("<?xml version='1.0'?>"); + send(format("<stream:stream xmlns='jabber:server' xmlns:db='jabber:server:dialback' xmlns:stream='http://etherx.jabber.org/streams' id='%s' from='%s'>", session.streamid, session.to_host)); + if session.from_host then + -- Need to perform dialback to check identity + print("to: "..tostring(attr.to).." from: "..tostring(attr.from)); + print("Need to do dialback here you know!!"); + end + elseif session.direction == "outgoing" then + -- If we are just using the connection for verifying dialback keys, we won't try and auth it + if not session.dialback_verifying then + -- generate dialback key + if not attr.id then error("stream response did not give us a streamid!!!"); end + session.streamid = attr.id; + session.dialback_key = generate_dialback(session.streamid, session.to_host, session.from_host); + session.send(format("<db:result from='%s' to='%s'>%s</db:result>", session.from_host, session.to_host, session.dialback_key)); + session.log("info", "sent dialback key on outgoing s2s stream"); + else + mark_connected(session); + end + end + --[[ + local features = {}; + modulemanager.fire_event("stream-features-s2s", session, features); + + send("<stream:features>"); + + for _, feature in ipairs(features) do + send(tostring(feature)); + end + + send("</stream:features>");]] + log("info", "s2s stream opened successfully"); + session.notopen = nil; +end + +function generate_dialback(id, to, from) + return md5_hash(id..to..from..dialback_secret); -- FIXME: See XEP-185 and XEP-220 +end + +function verify_dialback(id, to, from, key) + return key == generate_dialback(id, to, from); +end + +function make_authenticated(session) + if session.type == "s2sout_unauthed" then + session.type = "s2sout"; + elseif session.type == "s2sin_unauthed" then + session.type = "s2sin"; + else + return false; + end + session.log("info", "connection is now authenticated"); + + mark_connected(session); + + return true; +end + +function mark_connected(session) + local sendq, send = session.sendq, session.send; + if sendq then + session.log("debug", "sending queued stanzas across new connection"); + for _, data in ipairs(sendq) do + session.log("debug", "sending: %s", tostring(data)); + send(data); + end + end +end + +return _M;
\ No newline at end of file diff --git a/core/sessionmanager.lua b/core/sessionmanager.lua index d140ebe0..fd9b1272 100644 --- a/core/sessionmanager.lua +++ b/core/sessionmanager.lua @@ -35,14 +35,15 @@ end function destroy_session(session) session.log("info", "Destroying session"); - if session.username then + if session.host and session.username then if session.resource then hosts[session.host].sessions[session.username].sessions[session.resource] = nil; end - - if not next(hosts[session.host].sessions[session.username].sessions) then - log("debug", "All resources of %s are now offline", session.username); - hosts[session.host].sessions[session.username] = nil; + if hosts[session.host] and hosts[session.host].sessions[session.username] then + if not next(hosts[session.host].sessions[session.username].sessions) then + log("debug", "All resources of %s are now offline", session.username); + hosts[session.host].sessions[session.username] = nil; + end end end session.conn = nil; diff --git a/core/stanza_router.lua b/core/stanza_router.lua index 2203f351..d139bc29 100644 --- a/core/stanza_router.lua +++ b/core/stanza_router.lua @@ -21,7 +21,7 @@ function core_process_stanza(origin, stanza) if stanza.name == "iq" and not(#stanza.tags == 1 and stanza.tags[1].attr.xmlns) then if stanza.attr.type == "set" or stanza.attr.type == "get" then error("Invalid IQ"); - elseif #stanza.tags > 1 or not(stanza.attr.type == "error" or stanza.attr.type == "result") then + elseif #stanza.tags > 1 and not(stanza.attr.type == "error" or stanza.attr.type == "result") then error("Invalid IQ"); end end diff --git a/core/xmlhandlers.lua b/core/xmlhandlers.lua index b1af299f..a6b1c18a 100644 --- a/core/xmlhandlers.lua +++ b/core/xmlhandlers.lua @@ -3,6 +3,10 @@ require "util.stanza" local st = stanza; local tostring = tostring; +local pairs = pairs; +local ipairs = ipairs; +local type = type; +local print = print; local format = string.format; local m_random = math.random; local t_insert = table.insert; @@ -15,6 +19,10 @@ local error = error; module "xmlhandlers" +local ns_prefixes = { + ["http://www.w3.org/XML/1998/namespace"] = "xml"; + } + function init_xmlhandlers(session, streamopened) local ns_stack = { "" }; local curr_ns = ""; diff --git a/net/xmppclient_listener.lua b/net/xmppclient_listener.lua index e722e55b..068557c8 100644 --- a/net/xmppclient_listener.lua +++ b/net/xmppclient_listener.lua @@ -22,7 +22,7 @@ local xmppclient = { default_port = 5222 }; local function session_reset_stream(session) -- Reset stream - local parser = lxp.new(init_xmlhandlers(session, sm_streamopened), ":"); + local parser = lxp.new(init_xmlhandlers(session, sm_streamopened), "|"); session.parser = parser; session.notopen = true; diff --git a/net/xmppserver_listener.lua b/net/xmppserver_listener.lua new file mode 100644 index 00000000..7c5b0d9c --- /dev/null +++ b/net/xmppserver_listener.lua @@ -0,0 +1,95 @@ + +local logger = require "logger"; +local lxp = require "lxp" +local init_xmlhandlers = require "core.xmlhandlers" +local sm_new_session = require "core.sessionmanager".new_session; +local s2s_new_incoming = require "core.s2smanager".new_incoming; +local s2s_streamopened = require "core.s2smanager".streamopened; + +local connlisteners_register = require "net.connlisteners".register; + +local t_insert = table.insert; +local t_concat = table.concat; +local t_concatall = function (t, sep) local tt = {}; for _, s in ipairs(t) do t_insert(tt, tostring(s)); end return t_concat(tt, sep); end +local m_random = math.random; +local format = string.format; +local sm_new_session, sm_destroy_session = sessionmanager.new_session, sessionmanager.destroy_session; --import("core.sessionmanager", "new_session", "destroy_session"); +local st = stanza; + +local sessions = {}; +local xmppserver = { default_port = 5269 }; + +-- These are session methods -- + +local function session_reset_stream(session) + -- Reset stream + local parser = lxp.new(init_xmlhandlers(session, s2s_streamopened), "|"); + session.parser = parser; + + session.notopen = true; + + function session.data(conn, data) + parser:parse(data); + end + return true; +end + +-- End of session methods -- + +function xmppserver.listener(conn, data) + local session = sessions[conn]; + if not session then + session = s2s_new_incoming(conn); + sessions[conn] = session; + + -- Logging functions -- + + local mainlog, log = log; + do + local conn_name = "s2sin"..tostring(conn):match("[a-f0-9]+$"); + log = logger.init(conn_name); + end + local print = function (...) log("info", t_concatall({...}, "\t")); end + session.log = log; + + print("Incoming s2s connection"); + + session.reset_stream = session_reset_stream; + + session_reset_stream(session); -- Initialise, ready for use + + -- FIXME: Below function should be session,stanza - and xmlhandlers should use :method() notation to call, + -- this will avoid the useless indirection we have atm + -- (I'm on a mission, no time to fix now) + session.stanza_dispatch = function (stanza) return core_process_stanza(session, stanza); end + + end + if data then + session.data(conn, data); + end +end + +function xmppserver.disconnect(conn) +end + +function xmppserver.register_outgoing(conn, session) + session.direction = "outgoing"; + sessions[conn] = session; + + session.reset_stream = session_reset_stream; + session_reset_stream(session); -- Initialise, ready for use + + -- FIXME: Below function should be session,stanza - and xmlhandlers should use :method() notation to call, + -- this will avoid the useless indirection we have atm + -- (I'm on a mission, no time to fix now) + session.stanza_dispatch = function (stanza) return core_process_stanza(session, stanza); end +end + +connlisteners_register("xmppserver", xmppserver); + + +-- We need to perform some initialisation when a connection is created +-- We also need to perform that same initialisation at other points (SASL, TLS, ...) + +-- ...and we need to handle data +-- ...and record all sessions associated with connections
\ No newline at end of file diff --git a/util/hashes.lua b/util/hashes.lua new file mode 100644 index 00000000..64374a8f --- /dev/null +++ b/util/hashes.lua @@ -0,0 +1,27 @@ + +local softreq = function (...) return select(2, pcall(require, ...)); end + +module "hashes" + +local md5 = softreq("md5"); +if md5 then + if md5.digest then + local md5_digest = md5.digest; + local sha1_digest = sha1.digest; + function _M.md5(input) + return md5_digest(input); + end + function _M.sha1(input) + return sha1_digest(input); + end + elseif md5.sumhexa then + local md5_sumhexa = md5.sumhexa; + function _M.md5(input) + return md5_sumhexa(input); + end + else + error("md5 library found, but unrecognised... no hash functions will be available", 0); + end +end + +return _M; |