2 -- The code in this file should be self-explanatory, though the logic is horrible
3 -- for more info on that, see doc/stanza_routing.txt, which attempts to condense
4 -- the rules from the RFCs (mainly 3921)
6 require "core.servermanager"
8 local log = require "util.logger".init("stanzarouter")
10 local st = require "util.stanza";
11 local send = require "core.sessionmanager".send_to_session;
12 local user_exists = require "core.usermanager".user_exists;
14 local jid_split = require "util.jid".split;
17 function core_process_stanza(origin, stanza)
18 log("debug", "Received: "..tostring(stanza))
19 -- TODO verify validity of stanza (as well as JID validity)
20 if stanza.name == "iq" and not(#stanza.tags == 1 and stanza.tags[1].attr.xmlns) then
21 if stanza.attr.type == "set" or stanza.attr.type == "get" then
23 elseif #stanza.tags > 1 or not(stanza.attr.type == "error" or stanza.attr.type == "result") then
28 if origin.type == "c2s" and not origin.full_jid
29 and not(stanza.name == "iq" and stanza.tags[1].name == "bind"
30 and stanza.tags[1].attr.xmlns == "urn:ietf:params:xml:ns:xmpp-bind") then
31 error("Client MUST bind resource after auth");
34 local to = stanza.attr.to;
35 stanza.attr.from = origin.full_jid; -- quick fix to prevent impersonation (FIXME this would be incorrect when the origin is not c2s)
36 -- TODO also, stazas should be returned to their original state before the function ends
38 -- TODO presence subscriptions
40 core_handle_stanza(origin, stanza);
41 elseif hosts[to] and hosts[to].type == "local" then
42 core_handle_stanza(origin, stanza);
43 elseif stanza.name == "iq" and not select(3, jid_split(to)) then
44 core_handle_stanza(origin, stanza);
45 elseif origin.type == "c2s" then
46 core_route_stanza(origin, stanza);
50 function core_handle_stanza(origin, stanza)
52 if origin.type == "c2s" or origin.type == "c2s_unauthed" then
53 local session = origin;
55 if stanza.name == "presence" and origin.roster then
56 if stanza.attr.type == nil or stanza.attr.type == "available" or stanza.attr.type == "unavailable" then
57 for jid in pairs(origin.roster) do -- broadcast to all interested contacts
58 local subscription = origin.roster[jid].subscription;
59 if subscription == "both" or subscription == "from" then
61 core_route_stanza(origin, stanza);
64 --[[local node, host = jid_split(stanza.attr.from);
65 for _, res in pairs(hosts[host].sessions[node].sessions) do -- broadcast to all resources
67 res = user.sessions[k];
71 if not origin.presence then -- presence probes on initial presence
72 local probe = st.presence({from = origin.full_jid, type = "probe"});
73 for jid in pairs(origin.roster) do
74 local subscription = origin.roster[jid].subscription;
75 if subscription == "both" or subscription == "to" then
77 core_route_stanza(origin, probe);
81 origin.presence = stanza;
82 stanza.attr.to = nil; -- reset it
84 -- TODO error, bad type
87 log("debug", "Routing stanza to local");
88 handle_stanza(session, stanza);
93 function is_authorized_to_see_presence(origin, username, host)
94 local roster = datamanager.load(username, host, "roster") or {};
95 local item = roster[origin.username.."@"..origin.host];
96 return item and (item.subscription == "both" or item.subscription == "from");
99 function core_route_stanza(origin, stanza)
104 local to = stanza.attr.to;
105 local node, host, resource = jid_split(to);
107 if stanza.name == "presence" and stanza.attr.type == "probe" then resource = nil; end
109 local host_session = hosts[host]
110 if host_session and host_session.type == "local" then
112 local user = host_session.sessions[node];
114 local res = user.sessions[resource];
116 -- if we get here, resource was not specified or was unavailable
117 if stanza.name == "presence" then
118 if stanza.attr.type == "probe" then
119 if is_authorized_to_see_presence(origin, node, host) then
120 for k in pairs(user.sessions) do -- return presence for all resources
121 if user.sessions[k].presence then
122 local pres = user.sessions[k].presence;
123 pres.attr.to = origin.full_jid;
124 pres.attr.from = user.sessions[k].full_jid;
127 pres.attr.from = nil;
131 send(origin, st.presence({from = user.."@"..host, to = origin.username.."@"..origin.host, type = "unsubscribed"}));
134 for k in pairs(user.sessions) do -- presence broadcast to all user resources
135 if user.sessions[k].full_jid then
136 stanza.attr.to = user.sessions[k].full_jid;
137 send(user.sessions[k], stanza);
141 elseif stanza.name == "message" then -- select a resource to recieve message
142 for k in pairs(user.sessions) do
143 if user.sessions[k].full_jid then
144 res = user.sessions[k];
148 -- TODO find resource with greatest priority
151 -- TODO send IQ error
154 stanza.attr.to = res.full_jid;
155 send(res, stanza); -- Yay \o/
159 if user_exists(node, host) then
160 if stanza.name == "presence" then
161 if stanza.attr.type == "probe" and is_authorized_to_see_presence(origin, node, host) then -- FIXME what to do for not c2s?
162 -- TODO send last recieved unavailable presence
164 -- TODO send unavailable presence
166 elseif stanza.name == "message" then
167 -- TODO send message error, or store offline messages
168 elseif stanza.name == "iq" then
169 -- TODO send IQ error
171 else -- user does not exist
172 -- TODO we would get here for nodeless JIDs too. Do something fun maybe? Echo service? Let plugins use xmpp:server/resource addresses?
173 if stanza.name == "presence" then
174 if stanza.attr.type == "probe" then
175 send(origin, st.presence({from = user.."@"..host, to = origin.username.."@"..origin.host, type = "unsubscribed"}));
179 send(origin, st.error_reply(stanza, "cancel", "service-unavailable"));
188 -- Need to establish the connection
191 stanza.attr.to = to; -- reset
194 function handle_stanza_nodest(stanza)
195 if stanza.name == "iq" then
196 handle_stanza_iq_no_to(session, stanza);
197 elseif stanza.name == "presence" then
198 -- Broadcast to this user's contacts
199 handle_stanza_presence_broadcast(session, stanza);
200 -- also, if it is initial presence, send out presence probes
201 if not session.last_presence then
202 handle_stanza_presence_probe_broadcast(session, stanza);
204 session.last_presence = stanza;
205 elseif stanza.name == "message" then
206 -- Treat as if message was sent to bare JID of the sender
207 handle_stanza_to_local_user(stanza);
211 function handle_stanza_tolocal(stanza)
212 local node, host, resource = jid.split(stanza.attr.to);
213 if host and hosts[host] and hosts[host].type == "local" then
214 -- Is a local host, handle internally
216 -- Is a local user, send to their session
217 log("debug", "Routing stanza to %s@%s", node, host);
218 if not session.username then return; end --FIXME: Correct response when trying to use unauthed stream is what?
219 handle_stanza_to_local_user(stanza);
221 -- Is sent to this server, let's handle it...
222 log("debug", "Routing stanza to %s", host);
223 handle_stanza_to_server(stanza, session);
228 function handle_stanza_toremote(stanza)
229 log("error", "Stanza bound for remote host, but s2s is not implemented");
234 local function route_c2s_stanza(session, stanza)
235 stanza.attr.from = session.full_jid;
236 if not stanza.attr.to and session.username then
237 -- Has no 'to' attribute, handle internally
238 if stanza.name == "iq" then
239 handle_stanza_iq_no_to(session, stanza);
240 elseif stanza.name == "presence" then
241 -- Broadcast to this user's contacts
242 handle_stanza_presence_broadcast(session, stanza);
243 -- also, if it is initial presence, send out presence probes
244 if not session.last_presence then
245 handle_stanza_presence_probe_broadcast(session, stanza);
247 session.last_presence = stanza;
248 elseif stanza.name == "message" then
249 -- Treat as if message was sent to bare JID of the sender
250 handle_stanza_to_local_user(stanza);
253 local node, host, resource = jid.split(stanza.attr.to);
254 if host and hosts[host] and hosts[host].type == "local" then
255 -- Is a local host, handle internally
257 -- Is a local user, send to their session
258 if not session.username then return; end --FIXME: Correct response when trying to use unauthed stream is what?
259 handle_stanza_to_local_user(stanza);
261 -- Is sent to this server, let's handle it...
262 handle_stanza_to_server(stanza, session);
265 -- Is not for us or a local user, route accordingly
266 route_s2s_stanza(stanza);
270 function handle_stanza_no_to(session, stanza)
271 if not stanza.attr.id then log("warn", "<iq> without id attribute is invalid"); end
272 local xmlns = (stanza.tags[1].attr and stanza.tags[1].attr.xmlns);
273 if stanza.attr.type == "get" or stanza.attr.type == "set" then
274 if iq_handlers[xmlns] then
275 if iq_handlers[xmlns](stanza) then return; end; -- If handler returns true, it handled it
277 -- Oh, handler didn't handle it. Need to send service-unavailable now.
278 log("warn", "Unhandled namespace: "..xmlns);
279 session:send(format("<iq type='error' id='%s'><error type='cancel'><service-unavailable/></error></iq>", stanza.attr.id));
284 function handle_stanza_to_local_user(stanza)
285 if stanza.name == "message" then
286 handle_stanza_message_to_local_user(stanza);
287 elseif stanza.name == "presence" then
288 handle_stanza_presence_to_local_user(stanza);
289 elseif stanza.name == "iq" then
290 handle_stanza_iq_to_local_user(stanza);
294 function handle_stanza_message_to_local_user(stanza)
295 local node, host, resource = stanza.to.node, stanza.to.host, stanza.to.resource;
296 local destuser = hosts[host].sessions[node];
298 if resource and destuser[resource] then
299 destuser[resource]:send(stanza);
301 -- Bare JID, or resource offline
303 for resource, session in pairs(destuser.sessions) do
304 if not best_session then best_session = session;
305 elseif session.priority >= best_session.priority and session.priority >= 0 then
306 best_session = session;
309 if not best_session then
310 offlinemessage.new(node, host, stanza);
312 print("resource '"..resource.."' was not online, have chosen to send to '"..best_session.username.."@"..best_session.host.."/"..best_session.resource.."'");
313 destuser[best_session]:send(stanza);
318 offlinemessage.new(node, host, stanza);
322 function handle_stanza_presence_to_local_user(stanza)
323 local node, host, resource = stanza.to.node, stanza.to.host, stanza.to.resource;
324 local destuser = hosts[host].sessions[node];
327 if destuser[resource] then
328 destuser[resource]:send(stanza);
333 -- Broadcast to all user's resources
334 for resource, session in pairs(destuser.sessions) do
335 session:send(stanza);
341 function handle_stanza_iq_to_local_user(stanza)
346 local node, host, resource = stanza.to.node, stanza.to.host, stanza.to.resource;
347 local destuser = hosts[host].sessions[node];
348 if destuser and destuser.sessions then
350 if resource and destuser.sessions[resource] then
351 stanza.to:send(stanza);
353 --User is online, but specified resource isn't (or no resource specified)
355 for resource, session in pairs(destuser.sessions) do
356 if not best_session then best_session = session;
357 elseif session.priority >= best_session.priority and session.priority >= 0 then
358 best_session = session;
361 if not best_session then
362 offlinemessage.new(node, host, stanza);
364 print("resource '"..resource.."' was not online, have chosen to send to '"..best_session.username.."@"..best_session.host.."/"..best_session.resource.."'");
365 resource = best_session.resource;
368 if destuser.sessions[resource] == session then
369 log("warn", "core", "Attempt to send stanza to self, dropping...");
371 print("...sending...", tostring(stanza));
372 --destuser.sessions[resource].conn.write(tostring(data));
373 print(" to conn ", destuser.sessions[resource].conn);
374 destuser.sessions[resource].conn.write(tostring(stanza));
377 elseif stanza.name == "message" then
378 print(" ...will be stored offline");
379 offlinemessage.new(node, host, stanza);
380 elseif stanza.name == "iq" then
381 print(" ...is an iq");
382 stanza.from:send(st.reply(stanza)
383 :tag("error", { type = "cancel" })
384 :tag("service-unavailable", { xmlns = "urn:ietf:params:xml:ns:xmpp-stanzas" }));
388 -- Broadcast a presence stanza to all of a user's contacts
389 function handle_stanza_presence_broadcast(session, stanza)
390 if session.roster then
391 local initial_presence = not session.last_presence;
392 session.last_presence = stanza;
394 -- Broadcast presence and probes
395 local broadcast = st.presence({ from = session.full_jid, type = stanza.attr.type });
397 for child in stanza:childtags() do
398 broadcast:add_child(child);
400 for contact_jid in pairs(session.roster) do
401 broadcast.attr.to = contact_jid;
402 send_to(contact_jid, broadcast);
403 if initial_presence then
404 local node, host = jid.split(contact_jid);
405 if hosts[host] and hosts[host].type == "local" then
406 local contact = hosts[host].sessions[node]
408 local pres = st.presence { to = session.full_jid };
409 for resource, contact_session in pairs(contact.sessions) do
410 if contact_session.last_presence then
411 pres.tags = contact_session.last_presence.tags;
412 pres.attr.from = contact_session.full_jid;
417 --FIXME: Do we send unavailable if they are offline?
419 probe.attr.to = contact;
420 send_to(contact, probe);
425 -- Probe for our contacts' presence
429 -- Broadcast presence probes to all of a user's contacts
430 function handle_stanza_presence_probe_broadcast(session, stanza)
434 function handle_stanza_to_server(stanza)
437 function handle_stanza_iq_no_to(session, stanza)