--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plugins/disco.lua Sat Aug 21 14:51:36 2010 +0100
@@ -0,0 +1,349 @@
+-- Verse XMPP Library
+-- Copyright (C) 2010 Hubert Chathi <hubert@uhoreg.ca>
+-- Copyright (C) 2010 Matthew Wild <mwild1@gmail.com>
+--
+-- This project is MIT/X11 licensed. Please see the
+-- COPYING file in the source package for more information.
+--
+
+local st = require "util.stanza"
+local b64 = require("mime").b64
+-- NOTE: The b64 routine in LuaSocket 2.0.2 and below
+-- contains a bug regarding handling \0, it's advisable
+-- that you use another base64 routine, or a patched
+-- version of LuaSocket.
+-- You can borrow Prosody's (binary) util.encodings lib:
+--local b64 = require("util.encodings").base64.encode
+
+local sha1 = require("util.sha1").sha1
+
+local xmlns_disco = "http://jabber.org/protocol/disco";
+local xmlns_disco_info = xmlns_disco.."#info";
+local xmlns_disco_items = xmlns_disco.."#items";
+
+function verse.plugins.disco(stream)
+ stream.disco = { cache = {}, info = {} }
+ stream.disco.info.identities = {
+ {category = 'client', type='pc', name='Verse'},
+ }
+ stream.disco.info.features = {
+ {var = 'http://jabber.org/protocol/caps'},
+ {var = 'http://jabber.org/protocol/disco#info'},
+ {var = 'http://jabber.org/protocol/disco#items'},
+ }
+ stream.disco.items = {}
+ stream.disco.nodes = {}
+
+ stream.caps = {}
+ stream.caps.node = 'http://code.matthewwild.co.uk/verse/'
+
+ local function cmp_identity(item1, item2)
+ if item1.category < item2.category then
+ return true;
+ elseif item2.category < item1.category then
+ return false;
+ end
+ if item1.type < item2.type then
+ return true;
+ elseif item2.type < item1.type then
+ return false;
+ end
+ if (not item1['xml:lang'] and item2['xml:lang']) or
+ (item2['xml:lang'] and item1['xml:lang'] < item2['xml:lang']) then
+ return true
+ end
+ return false
+ end
+
+ local function cmp_feature(item1, item2)
+ return item1.var < item2.var
+ end
+
+ local function calculate_hash()
+ table.sort(stream.disco.info.identities, cmp_identity)
+ table.sort(stream.disco.info.features, cmp_feature)
+ local S = ''
+ for key,identity in pairs(stream.disco.info.identities) do
+ S = S .. string.format(
+ '%s/%s/%s/%s', identity.category, identity.type,
+ identity['xml:lang'] or '', identity.name or ''
+ ) .. '<'
+ end
+ for key,feature in pairs(stream.disco.info.features) do
+ S = S .. feature.var .. '<'
+ end
+ -- FIXME: make sure S is utf8-encoded
+ --stream:debug("Computed hash string: "..S);
+ --stream:debug("Computed hash string (sha1): "..sha1(S, true));
+ --stream:debug("Computed hash string (sha1+b64): "..b64(sha1(S)));
+ return (b64(sha1(S)))
+ end
+
+ setmetatable(stream.caps, {
+ __call = function (...) -- vararg: allow calling as function or member
+ -- retrieve the c stanza to insert into the
+ -- presence stanza
+ local hash = calculate_hash()
+ return st.stanza('c', {
+ xmlns = 'http://jabber.org/protocol/caps',
+ hash = 'sha-1',
+ node = stream.caps.node,
+ ver = hash
+ })
+ end
+ })
+
+ function stream:add_disco_feature(feature)
+ table.insert(self.disco.info.features, {var=feature});
+ end
+
+ function stream:jid_has_identity(jid, category, type)
+ local cached_disco = self.disco.cache[jid];
+ if not cached_disco then
+ return nil, "no-cache";
+ end
+ local identities = self.disco.cache[jid].identities;
+ if type then
+ return identities[category.."/"..type] or false;
+ end
+ -- Check whether we have any identities with this category instead
+ for identity in pairs(identities) do
+ if identity:match("^(.*)/") == category then
+ return true;
+ end
+ end
+ end
+
+ function stream:jid_supports(jid, feature)
+ local cached_disco = self.disco.cache[jid];
+ if not cached_disco or not cached_disco.features then
+ return nil, "no-cache";
+ end
+ return cached_disco.features[feature] or false;
+ end
+
+ function stream:get_local_services(category, type)
+ local host_disco = self.disco.cache[self.host];
+ if not(host_disco) or not(host_disco.items) then
+ return nil, "no-cache";
+ end
+
+ local results = {};
+ for _, service in ipairs(host_disco.items) do
+ if self:jid_has_identity(service.jid, category, type) then
+ table.insert(results, service.jid);
+ end
+ end
+ return results;
+ end
+
+ function stream:disco_local_services(callback)
+ self:disco_items(self.host, nil, function (items)
+ local n_items = 0;
+ local function item_callback()
+ n_items = n_items - 1;
+ if n_items == 0 then
+ return callback(items);
+ end
+ end
+
+ for _, item in ipairs(items) do
+ if item.jid then
+ n_items = n_items + 1;
+ self:disco_info(item.jid, nil, item_callback);
+ end
+ end
+ if n_items == 0 then
+ return callback(items);
+ end
+ end);
+ end
+
+ function stream:disco_info(jid, node, callback)
+ local disco_request = verse.iq({ to = jid, type = "get" })
+ :tag("query", { xmlns = xmlns_disco_info, node = node });
+ self:send_iq(disco_request, function (result)
+ if result.attr.type == "error" then
+ return callback(nil, result:get_error());
+ end
+
+ local identities, features = {}, {};
+
+ for tag in result:get_child("query", xmlns_disco_info):childtags() do
+ if tag.name == "identity" then
+ identities[tag.attr.category.."/"..tag.attr.type] = tag.attr.name or true;
+ elseif tag.name == "feature" then
+ features[tag.attr.var] = true;
+ end
+ end
+
+
+ if not self.disco.cache[jid] then
+ self.disco.cache[jid] = { nodes = {} };
+ end
+
+ if node then
+ if not self.disco.cache.nodes[node] then
+ self.disco.cache.nodes[node] = { nodes = {} };
+ end
+ self.disco.cache[jid].nodes[node].identities = identities;
+ self.disco.cache[jid].nodes[node].features = features;
+ else
+ self.disco.cache[jid].identities = identities;
+ self.disco.cache[jid].features = features;
+ end
+ return callback(self.disco.cache[jid]);
+ end);
+ end
+
+ function stream:disco_items(jid, node, callback)
+ local disco_request = verse.iq({ to = jid, type = "get" })
+ :tag("query", { xmlns = xmlns_disco_items, node = node });
+ self:send_iq(disco_request, function (result)
+ if result.attr.type == "error" then
+ return callback(nil, result:get_error());
+ end
+ local disco_items = { };
+ for tag in result:get_child("query", xmlns_disco_items):childtags() do
+ if tag.name == "item" then
+ table.insert(disco_items, {
+ name = tag.attr.name;
+ jid = tag.attr.jid;
+ });
+ end
+ end
+
+ if not self.disco.cache[jid] then
+ self.disco.cache[jid] = { nodes = {} };
+ end
+
+ if node then
+ if not self.disco.cache.nodes[node] then
+ self.disco.cache.nodes[node] = { nodes = {} };
+ end
+ self.disco.cache.nodes[node].items = disco_items;
+ else
+ self.disco.cache[jid].items = disco_items;
+ end
+ return callback(disco_items);
+ end);
+ end
+
+ stream:hook("iq/http://jabber.org/protocol/disco#info", function (stanza)
+ if stanza.attr.type == 'get' then
+ local query = stanza:child_with_name('query')
+ if not query then return; end
+ -- figure out what identities/features to send
+ local identities
+ local features
+ if query.attr.node then
+ local hash = calculate_hash()
+ local node = stream.disco.nodes[query.attr.node]
+ if node and node.info then
+ identities = node.info.identities or {}
+ features = node.info.identities or {}
+ elseif query.attr.node == stream.caps.node..'#'..hash then
+ -- matches caps hash, so use the main info
+ identities = stream.disco.info.identities
+ features = stream.disco.info.features
+ else
+ -- unknown node: give an error
+ local response = st.stanza('iq',{
+ to = stanza.attr.from,
+ from = stanza.attr.to,
+ id = stanza.attr.id,
+ type = 'error'
+ })
+ response:tag('query',{xmlns = 'http://jabber.org/protocol/disco#info'}):reset()
+ response:tag('error',{type = 'cancel'}):tag(
+ 'item-not-found',{xmlns = 'urn:ietf:params:xml:ns:xmpp-stanzas'}
+ )
+ stream:send(response)
+ return true
+ end
+ else
+ identities = stream.disco.info.identities
+ features = stream.disco.info.features
+ end
+ -- construct the response
+ local result = st.stanza('query',{
+ xmlns = 'http://jabber.org/protocol/disco#info',
+ node = query.attr.node
+ })
+ for key,identity in pairs(identities) do
+ result:tag('identity', identity):reset()
+ end
+ for key,feature in pairs(features) do
+ result:tag('feature', feature):reset()
+ end
+ stream:send(st.stanza('iq',{
+ to = stanza.attr.from,
+ from = stanza.attr.to,
+ id = stanza.attr.id,
+ type = 'result'
+ }):add_child(result))
+ return true
+ end
+ end);
+
+ stream:hook("iq/http://jabber.org/protocol/disco#items", function (stanza)
+ if stanza.attr.type == 'get' then
+ local query = stanza:child_with_name('query')
+ if not query then return; end
+ -- figure out what items to send
+ local items
+ if query.attr.node then
+ local node = stream.disco.nodes[query.attr.node]
+ if node then
+ items = node.items or {}
+ else
+ -- unknown node: give an error
+ local response = st.stanza('iq',{
+ to = stanza.attr.from,
+ from = stanza.attr.to,
+ id = stanza.attr.id,
+ type = 'error'
+ })
+ response:tag('query',{xmlns = 'http://jabber.org/protocol/disco#items'}):reset()
+ response:tag('error',{type = 'cancel'}):tag(
+ 'item-not-found',{xmlns = 'urn:ietf:params:xml:ns:xmpp-stanzas'}
+ )
+ stream:send(response)
+ return true
+ end
+ else
+ items = stream.disco.items
+ end
+ -- construct the response
+ local result = st.stanza('query',{
+ xmlns = 'http://jabber.org/protocol/disco#items',
+ node = query.attr.node
+ })
+ for key,item in pairs(items) do
+ result:tag('item', item):reset()
+ end
+ stream:send(st.stanza('iq',{
+ to = stanza.attr.from,
+ from = stanza.attr.to,
+ id = stanza.attr.id,
+ type = 'result'
+ }):add_child(result))
+ return true
+ end
+ end);
+
+ stream:hook("ready", function ()
+ stream:disco_local_services(function (services)
+ for _, service in ipairs(services) do
+ for identity in pairs(stream.disco.cache[service.jid].identities) do
+ local category, type = identity:match("^(.*)/(.*)$");
+ stream:event("disco/service-discovered/"..category, {
+ type = type, jid = service.jid;
+ });
+ end
+ end
+ end);
+ end, 5);
+end
+
+-- end of disco.lua