# HG changeset patch # User Matthew Wild # Date 1224829656 -3600 # Node ID 4c0dcd245d34ca063dc5280daf03f0be97bb467c # Parent ccebb27207414c955d50807cad15d11126da93e1 s2s works! \o/ \o/ diff -r ccebb2720741 -r 4c0dcd245d34 core/s2smanager.lua --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/core/s2smanager.lua Fri Oct 24 07:27:36 2008 +0100 @@ -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([[]], 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(""); + send(format("", 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("%s", 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(""); + + for _, feature in ipairs(features) do + send(tostring(feature)); + end + + send("");]] + 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 -r ccebb2720741 -r 4c0dcd245d34 core/sessionmanager.lua --- a/core/sessionmanager.lua Fri Oct 24 06:13:38 2008 +0100 +++ b/core/sessionmanager.lua Fri Oct 24 07:27:36 2008 +0100 @@ -35,14 +35,15 @@ 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 -r ccebb2720741 -r 4c0dcd245d34 core/stanza_router.lua --- a/core/stanza_router.lua Fri Oct 24 06:13:38 2008 +0100 +++ b/core/stanza_router.lua Fri Oct 24 07:27:36 2008 +0100 @@ -26,7 +26,7 @@ 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 @@ -49,10 +49,8 @@ core_handle_stanza(origin, stanza); elseif stanza.name == "iq" and not select(3, jid_split(to)) then core_handle_stanza(origin, stanza); - elseif origin.type == "c2s" then + elseif origin.type == "c2s" or origin.type == "s2sin" then core_route_stanza(origin, stanza); - elseif origin.type == "s2sin" then - core_deliver_stanza(origin, stanza); end end @@ -98,7 +96,7 @@ log("debug", "Routing stanza to local"); handle_stanza(session, stanza); end - elseif origin.type == "s2sin_unauthed" then + elseif origin.type == "s2sin_unauthed" or origin.type == "s2sin" then if stanza.attr.xmlns == "jabber:server:dialback" then if stanza.name == "verify" then -- We are being asked to verify the key, to ensure it was generated by us @@ -113,7 +111,8 @@ type = "valid" end origin.send(format("%s", attr.to, attr.from, attr.id, type, stanza[1])); - elseif stanza.name == "result" then + elseif stanza.name == "result" and origin.type == "s2sin_unauthed" then + -- he wants to be identified through dialback -- We need to check the key with the Authoritative server local attr = stanza.attr; origin.from_host = attr.from; @@ -244,22 +243,18 @@ end end end - else + elseif origin.type == "c2s" then -- Remote host + --stanza.attr.xmlns = "jabber:server"; + stanza.attr.xmlns = nil; log("debug", "sending s2s stanza: %s", tostring(stanza)); - stanza.attr.xmlns = "jabber:server"; send_s2s(origin.host, host, stanza); + else + log("warn", "received stanza from unhandled connection type: %s", origin.type); end stanza.attr.to = to; -- reset end -function core_deliver_stanza(origin, stanza) - local name, attr = stanza.name, stanza.attr; - if name == "message" then - - end -end - function handle_stanza_toremote(stanza) log("error", "Stanza bound for remote host, but s2s is not implemented"); end diff -r ccebb2720741 -r 4c0dcd245d34 core/xmlhandlers.lua --- a/core/xmlhandlers.lua Fri Oct 24 06:13:38 2008 +0100 +++ b/core/xmlhandlers.lua Fri Oct 24 07:27:36 2008 +0100 @@ -3,6 +3,10 @@ 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; @@ -17,6 +21,10 @@ module "xmlhandlers" +local ns_prefixes = { + ["http://www.w3.org/XML/1998/namespace"] = "xml"; + } + function init_xmlhandlers(session, streamopened) local ns_stack = { "" }; local curr_ns = ""; @@ -24,7 +32,7 @@ local chardata = {}; local xml_handlers = {}; local log = session.log or default_log; - local print = function (...) log("info", "xmlhandlers", t_concatall({...}, "\t")); end + --local print = function (...) log("info", "xmlhandlers", t_concatall({...}, "\t")); end local send = session.send; @@ -35,8 +43,25 @@ stanza:text(t_concat(chardata)); chardata = {}; end - curr_ns,name = name:match("^(.+):([%w%-]+)$"); - attr.xmlns = curr_ns; + curr_ns,name = name:match("^(.+)|([%w%-]+)$"); + if curr_ns ~= "jabber:server" then + attr.xmlns = curr_ns; + end + + -- FIXME !!!!! + for i, k in ipairs(attr) do + if type(k) == "string" then + local ns, nm = k:match("^([^|]+)|?([^|]-)$") + if ns and nm then + ns = ns_prefixes[ns]; + if ns then + attr[ns..":"..nm] = attr[k]; + attr[i] = ns..":"..nm; + attr[k] = nil; + end + end + end + end if not stanza then --if we are not currently inside a stanza if session.notopen then @@ -53,7 +78,10 @@ stanza = st.stanza(name, attr); --{ to = attr.to, type = attr.type, id = attr.id, xmlns = curr_ns }); curr_tag = stanza; else -- we are inside a stanza, so add a tag - attr.xmlns = curr_ns; + attr.xmlns = nil; + if curr_ns ~= "jabber:server" and curr_ns ~= "jabber:client" then + attr.xmlns = curr_ns; + end stanza:tag(name, attr); end end @@ -63,7 +91,7 @@ end end function xml_handlers:EndElement(name) - curr_ns,name = name:match("^(.+):([%w%-]+)$"); + curr_ns,name = name:match("^(.+)|([%w%-]+)$"); if (not stanza) or #stanza.last_add < 0 or (#stanza.last_add > 0 and name ~= stanza.last_add[#stanza.last_add].name) then if name == "stream" then log("debug", "Stream closed"); diff -r ccebb2720741 -r 4c0dcd245d34 net/xmppclient_listener.lua --- a/net/xmppclient_listener.lua Fri Oct 24 06:13:38 2008 +0100 +++ b/net/xmppclient_listener.lua Fri Oct 24 07:27:36 2008 +0100 @@ -22,7 +22,7 @@ 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 -r ccebb2720741 -r 4c0dcd245d34 net/xmppserver_listener.lua --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/net/xmppserver_listener.lua Fri Oct 24 07:27:36 2008 +0100 @@ -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 -r ccebb2720741 -r 4c0dcd245d34 util/hashes.lua --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/util/hashes.lua Fri Oct 24 07:27:36 2008 +0100 @@ -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;