mirror of
https://github.com/processone/ejabberd.git
synced 2024-09-29 14:37:44 +02:00
842ebfcca0
o Fix some bugs by getting attributes as list() instead of binary(). o Instead creating #xmlattr directly, use the new ?XMLATTR macro; it'll take care of the anything-to-binary() conversion. o Fix a bug where recipient and sender were used as binary() instead of list(), which is required by the rest of the S2S code. o Fix a bug where binary_to_list/1 was called on a list(). Now concerning JIDs : o Now that #jid{} isn't part of the API of Exmppp anymore, replace remaining direct usages by calls to exmpp_jid. o Replace exmpp_jid:make_bare_jid() by exmpp_jid:make_jid(). o Replace exmpp_jid:*_to_jid/1 by exmpp_jid:parse_jid/1. PR: EJABP-1 SVN Revision: 1841
2828 lines
102 KiB
Erlang
2828 lines
102 KiB
Erlang
%%% ====================================================================
|
|
%%% ``The contents of this file are subject to the Erlang Public License,
|
|
%%% Version 1.1, (the "License"); you may not use this file except in
|
|
%%% compliance with the License. You should have received a copy of the
|
|
%%% Erlang Public License along with this software. If not, it can be
|
|
%%% retrieved via the world wide web at http://www.erlang.org/.
|
|
%%%
|
|
%%% Software distributed under the License is distributed on an "AS IS"
|
|
%%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
|
|
%%% the License for the specific language governing rights and limitations
|
|
%%% under the License.
|
|
%%%
|
|
%%% The Initial Developer of the Original Code is ProcessOne.
|
|
%%% Portions created by ProcessOne are Copyright 2006-2009, ProcessOne
|
|
%%% All Rights Reserved.''
|
|
%%% This software is copyright 2006-2009, ProcessOne.
|
|
%%%
|
|
%%% @copyright 2006-2009 ProcessOne
|
|
%%% @author Christophe Romain <christophe.romain@process-one.net>
|
|
%%% [http://www.process-one.net/]
|
|
%%% @version {@vsn}, {@date} {@time}
|
|
%%% @end
|
|
%%% ====================================================================
|
|
|
|
|
|
%%% @doc The module <strong>{@module}</strong> is the core of the PubSub
|
|
%%% extension. It relies on PubSub plugins for a large part of its functions.
|
|
%%%
|
|
%%% @headerfile "pubsub.hrl"
|
|
%%%
|
|
%%% @reference See <a href="http://www.xmpp.org/extensions/xep-0060.html">XEP-0060: Pubsub</a> for
|
|
%%% the latest version of the PubSub specification.
|
|
%%% This module uses version 1.12 of the specification as a base.
|
|
%%% Most of the specification is implemented.
|
|
%%% Functions concerning configuration should be rewritten.
|
|
%%% Code is derivated from the original pubsub v1.7, by Alexey Shchepin
|
|
|
|
%%% TODO
|
|
%%% plugin: generate Reply (do not use broadcast atom anymore)
|
|
|
|
-module(mod_pubsub).
|
|
-author('christophe.romain@process-one.net').
|
|
-version('1.12-01').
|
|
|
|
-behaviour(gen_server).
|
|
-behaviour(gen_mod).
|
|
|
|
-include_lib("exmpp/include/exmpp.hrl").
|
|
|
|
-include("ejabberd.hrl").
|
|
-include("pubsub.hrl").
|
|
|
|
-define(STDTREE, "default").
|
|
-define(STDNODE, "default").
|
|
-define(PEPNODE, "pep").
|
|
|
|
%% exports for hooks
|
|
-export([presence_probe/3,
|
|
remove_user/2,
|
|
disco_local_identity/5,
|
|
disco_local_features/5,
|
|
disco_local_items/5,
|
|
disco_sm_identity/5,
|
|
disco_sm_features/5,
|
|
disco_sm_items/5
|
|
]).
|
|
%% exported iq handlers
|
|
-export([iq_local/3,
|
|
iq_sm/3
|
|
]).
|
|
|
|
%% exports for console debug manual use
|
|
-export([create_node/5,
|
|
delete_node/3,
|
|
subscribe_node/4,
|
|
unsubscribe_node/5,
|
|
publish_item/6,
|
|
delete_item/4,
|
|
get_configure/4,
|
|
set_configure/5,
|
|
get_items/3,
|
|
tree_action/3,
|
|
node_action/3,
|
|
node_action/4
|
|
]).
|
|
|
|
%% general helpers for plugins
|
|
-export([node_to_string/1,
|
|
string_to_node/1,
|
|
subscription_to_string/1,
|
|
affiliation_to_string/1,
|
|
string_to_subscription/1,
|
|
string_to_affiliation/1,
|
|
extended_error/2,
|
|
extended_error/3
|
|
]).
|
|
|
|
%% API and gen_server callbacks
|
|
-export([start_link/2,
|
|
start/2,
|
|
stop/1,
|
|
init/1,
|
|
handle_call/3,
|
|
handle_cast/2,
|
|
handle_info/2,
|
|
terminate/2,
|
|
code_change/3
|
|
]).
|
|
|
|
-define(PROCNAME, ejabberd_mod_pubsub).
|
|
-define(PLUGIN_PREFIX, "node_").
|
|
-define(TREE_PREFIX, "nodetree_").
|
|
|
|
-record(state, {server_host,
|
|
host,
|
|
access,
|
|
pep_mapping = [],
|
|
nodetree = ?STDTREE,
|
|
plugins = [?STDNODE]}).
|
|
|
|
%%====================================================================
|
|
%% API
|
|
%%====================================================================
|
|
%%--------------------------------------------------------------------
|
|
%% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
|
|
%% Description: Starts the server
|
|
%%--------------------------------------------------------------------
|
|
start_link(Host, Opts) ->
|
|
Proc = gen_mod:get_module_proc(Host, ?PROCNAME),
|
|
gen_server:start_link({local, Proc}, ?MODULE, [Host, Opts], []).
|
|
|
|
start(Host, Opts) ->
|
|
Proc = gen_mod:get_module_proc(Host, ?PROCNAME),
|
|
ChildSpec = {Proc,
|
|
{?MODULE, start_link, [Host, Opts]},
|
|
transient, 1000, worker, [?MODULE]},
|
|
supervisor:start_child(ejabberd_sup, ChildSpec).
|
|
|
|
stop(Host) ->
|
|
Proc = gen_mod:get_module_proc(Host, ?PROCNAME),
|
|
gen_server:call(Proc, stop),
|
|
supervisor:delete_child(ejabberd_sup, Proc).
|
|
|
|
%%====================================================================
|
|
%% gen_server callbacks
|
|
%%====================================================================
|
|
|
|
%%--------------------------------------------------------------------
|
|
%% Function: init(Args) -> {ok, State} |
|
|
%% {ok, State, Timeout} |
|
|
%% ignore |
|
|
%% {stop, Reason}
|
|
%% Description: Initiates the server
|
|
%%--------------------------------------------------------------------
|
|
init([ServerHost, Opts]) ->
|
|
?DEBUG("pubsub init ~p ~p",[ServerHost,Opts]),
|
|
Host = gen_mod:get_opt_host(ServerHost, Opts, "pubsub.@HOST@"),
|
|
Access = gen_mod:get_opt(access_createnode, Opts, all),
|
|
ServerHostB = list_to_binary(ServerHost),
|
|
mod_disco:register_feature(ServerHost, ?NS_PUBSUB_s),
|
|
ejabberd_hooks:add(disco_local_identity, ServerHostB, ?MODULE, disco_local_identity, 75),
|
|
ejabberd_hooks:add(disco_local_features, ServerHostB, ?MODULE, disco_local_features, 75),
|
|
ejabberd_hooks:add(disco_local_items, ServerHostB, ?MODULE, disco_local_items, 75),
|
|
ejabberd_hooks:add(disco_sm_identity, ServerHostB, ?MODULE, disco_sm_identity, 75),
|
|
ejabberd_hooks:add(disco_sm_features, ServerHostB, ?MODULE, disco_sm_features, 75),
|
|
ejabberd_hooks:add(disco_sm_items, ServerHostB, ?MODULE, disco_sm_items, 75),
|
|
ejabberd_hooks:add(presence_probe_hook, ServerHostB, ?MODULE, presence_probe, 50),
|
|
ejabberd_hooks:add(remove_user, ServerHostB, ?MODULE, remove_user, 50),
|
|
IQDisc = gen_mod:get_opt(iqdisc, Opts, one_queue),
|
|
lists:foreach(
|
|
fun({NS,Mod,Fun}) ->
|
|
gen_iq_handler:add_iq_handler(
|
|
Mod, ServerHostB, NS, ?MODULE, Fun, IQDisc)
|
|
end,
|
|
[{?NS_PUBSUB, ejabberd_local, iq_local},
|
|
{?NS_PUBSUB_OWNER, ejabberd_local, iq_local},
|
|
{?NS_PUBSUB, ejabberd_sm, iq_sm},
|
|
{?NS_PUBSUB_OWNER, ejabberd_sm, iq_sm}]),
|
|
ejabberd_router:register_route(Host),
|
|
{Plugins, NodeTree, PepMapping} = init_plugins(Host, ServerHost, Opts),
|
|
update_database(Host),
|
|
ets:new(gen_mod:get_module_proc(Host, pubsub_state), [set, named_table]),
|
|
ets:insert(gen_mod:get_module_proc(Host, pubsub_state), {nodetree, NodeTree}),
|
|
ets:insert(gen_mod:get_module_proc(Host, pubsub_state), {plugins, Plugins}),
|
|
ets:new(gen_mod:get_module_proc(ServerHost, pubsub_state), [set, named_table]),
|
|
ets:insert(gen_mod:get_module_proc(ServerHost, pubsub_state), {nodetree, NodeTree}),
|
|
ets:insert(gen_mod:get_module_proc(ServerHost, pubsub_state), {plugins, Plugins}),
|
|
ets:insert(gen_mod:get_module_proc(ServerHost, pubsub_state), {pep_mapping, PepMapping}),
|
|
init_nodes(Host, ServerHost),
|
|
{ok, #state{host = Host,
|
|
server_host = ServerHost,
|
|
access = Access,
|
|
pep_mapping = PepMapping,
|
|
nodetree = NodeTree,
|
|
plugins = Plugins}}.
|
|
|
|
%% @spec (Host, ServerHost, Opts) -> Plugins
|
|
%% Host = mod_pubsub:host() Opts = [{Key,Value}]
|
|
%% ServerHost = host()
|
|
%% Key = atom()
|
|
%% Value = term()
|
|
%% Plugins = [Plugin::string()]
|
|
%% @doc Call the init/1 function for each plugin declared in the config file.
|
|
%% The default plugin module is implicit.
|
|
%% <p>The Erlang code for the plugin is located in a module called
|
|
%% <em>node_plugin</em>. The 'node_' prefix is mandatory.</p>
|
|
%% <p>The modules are initialized in alphetical order and the list is checked
|
|
%% and sorted to ensure that each module is initialized only once.</p>
|
|
%% <p>See {@link node_default:init/1} for an example implementation.</p>
|
|
init_plugins(Host, ServerHost, Opts) ->
|
|
TreePlugin = list_to_atom(?TREE_PREFIX ++
|
|
gen_mod:get_opt(nodetree, Opts, ?STDTREE)),
|
|
?DEBUG("** tree plugin is ~p",[TreePlugin]),
|
|
TreePlugin:init(Host, ServerHost, Opts),
|
|
Plugins = lists:usort(gen_mod:get_opt(plugins, Opts, []) ++ [?STDNODE]),
|
|
PepMapping = lists:usort(gen_mod:get_opt(pep_mapping, Opts, [])),
|
|
?DEBUG("** PEP Mapping : ~p~n",[PepMapping]),
|
|
lists:foreach(fun(Name) ->
|
|
?DEBUG("** init ~s plugin",[Name]),
|
|
Plugin = list_to_atom(?PLUGIN_PREFIX ++ Name),
|
|
Plugin:init(Host, ServerHost, Opts)
|
|
end, Plugins),
|
|
{Plugins, TreePlugin, PepMapping}.
|
|
|
|
terminate_plugins(Host, ServerHost, Plugins, TreePlugin) ->
|
|
lists:foreach(fun(Name) ->
|
|
?DEBUG("** terminate ~s plugin",[Name]),
|
|
Plugin = list_to_atom(?PLUGIN_PREFIX++Name),
|
|
Plugin:terminate(Host, ServerHost)
|
|
end, Plugins),
|
|
TreePlugin:terminate(Host, ServerHost),
|
|
ok.
|
|
|
|
init_nodes(Host, ServerHost) ->
|
|
create_node(Host, ServerHost, ["home"], service_jid(Host), ?STDNODE),
|
|
create_node(Host, ServerHost, ["home", ServerHost], service_jid(Host), ?STDNODE),
|
|
ok.
|
|
|
|
update_database(Host) ->
|
|
case catch mnesia:table_info(pubsub_node, attributes) of
|
|
[host_node, host_parent, info] ->
|
|
?INFO_MSG("upgrade pubsub tables",[]),
|
|
F = fun() ->
|
|
lists:foldl(
|
|
fun({pubsub_node, NodeId, ParentId, {nodeinfo, Items, Options, Entities}}, RecList) ->
|
|
ItemsList =
|
|
lists:foldl(
|
|
fun({item, IID, Publisher, Payload}, Acc) ->
|
|
C = {Publisher, unknown},
|
|
M = {Publisher, now()},
|
|
mnesia:write(
|
|
#pubsub_item{itemid = {IID, NodeId},
|
|
creation = C,
|
|
modification = M,
|
|
payload = Payload}),
|
|
[{Publisher, IID} | Acc]
|
|
end, [], Items),
|
|
Owners =
|
|
dict:fold(
|
|
fun(JID, {entity, Aff, Sub}, Acc) ->
|
|
UsrItems =
|
|
lists:foldl(
|
|
fun({P, I}, IAcc) ->
|
|
case P of
|
|
JID -> [I | IAcc];
|
|
_ -> IAcc
|
|
end
|
|
end, [], ItemsList),
|
|
mnesia:write(
|
|
#pubsub_state{stateid = {JID, NodeId},
|
|
items = UsrItems,
|
|
affiliation = Aff,
|
|
subscription = Sub}),
|
|
case Aff of
|
|
owner -> [JID | Acc];
|
|
_ -> Acc
|
|
end
|
|
end, [], Entities),
|
|
mnesia:delete({pubsub_node, NodeId}),
|
|
[#pubsub_node{nodeid = NodeId,
|
|
parentid = ParentId,
|
|
owners = Owners,
|
|
options = Options} |
|
|
RecList]
|
|
end, [],
|
|
mnesia:match_object(
|
|
{pubsub_node, {Host, '_'}, '_', '_'}))
|
|
end,
|
|
{atomic, NewRecords} = mnesia:transaction(F),
|
|
{atomic, ok} = mnesia:delete_table(pubsub_node),
|
|
{atomic, ok} = mnesia:create_table(pubsub_node,
|
|
[{disc_copies, [node()]},
|
|
{attributes, record_info(fields, pubsub_node)}]),
|
|
FNew = fun() -> lists:foreach(fun(Record) ->
|
|
mnesia:write(Record)
|
|
end, NewRecords)
|
|
end,
|
|
case mnesia:transaction(FNew) of
|
|
{atomic, Result} ->
|
|
?INFO_MSG("Pubsub tables updated correctly: ~p", [Result]);
|
|
{aborted, Reason} ->
|
|
?ERROR_MSG("Problem updating Pubsub tables:~n~p", [Reason])
|
|
end;
|
|
_ ->
|
|
ok
|
|
end.
|
|
|
|
%% -------
|
|
%% disco hooks handling functions
|
|
%%
|
|
|
|
identity(Host) ->
|
|
Identity = case lists:member(?PEPNODE, plugins(Host)) of
|
|
true -> [?XMLATTR('category', <<"pubsub">>), ?XMLATTR('type', <<"pep">>)];
|
|
false -> [?XMLATTR('category', <<"pubsub">>), ?XMLATTR('type', <<"service">>)]
|
|
end,
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'identity', attrs = Identity}.
|
|
|
|
disco_local_identity(Acc, _From, To, <<>>, _Lang) ->
|
|
Acc ++ [identity(exmpp_jid:ldomain_as_list(To))];
|
|
disco_local_identity(Acc, _From, _To, _Node, _Lang) ->
|
|
Acc.
|
|
|
|
disco_local_features(Acc, _From, To, <<>>, _Lang) ->
|
|
Host = exmpp_jid:ldomain_as_list(To),
|
|
Feats = case Acc of
|
|
{result, I} -> I;
|
|
_ -> []
|
|
end,
|
|
{result, Feats ++ lists:map(fun(Feature) ->
|
|
?NS_PUBSUB_s++"#"++Feature
|
|
end, features(Host, []))};
|
|
disco_local_features(Acc, _From, _To, _Node, _Lang) ->
|
|
Acc.
|
|
|
|
disco_local_items(Acc, _From, _To, <<>>, _Lang) ->
|
|
Acc;
|
|
disco_local_items(Acc, _From, _To, _Node, _Lang) ->
|
|
Acc.
|
|
|
|
disco_sm_identity(Acc, _From, To, <<>>, _Lang) ->
|
|
Acc ++ [identity(exmpp_jid:ldomain_as_list(To))];
|
|
disco_sm_identity(Acc, From, To, Node, _Lang) ->
|
|
LOwner = jlib:short_prepd_bare_jid(To),
|
|
Acc ++ case node_disco_identity(LOwner, From, Node) of
|
|
{result, I} -> I;
|
|
_ -> []
|
|
end.
|
|
|
|
disco_sm_features(Acc, _From, _To, [], _Lang) ->
|
|
Acc;
|
|
disco_sm_features(Acc, From, To, Node, _Lang) ->
|
|
LOwner = jlib:short_prepd_bare_jid(To),
|
|
Features = node_disco_features(LOwner, From, Node),
|
|
case {Acc, Features} of
|
|
{{result, AccFeatures}, {result, AddFeatures}} ->
|
|
{result, AccFeatures++AddFeatures};
|
|
{_, {result, AddFeatures}} ->
|
|
{result, AddFeatures};
|
|
{_, _} ->
|
|
Acc
|
|
end.
|
|
|
|
disco_sm_items(Acc, From, To, <<>>, _Lang) ->
|
|
%% TODO, use iq_disco_items(Host, [], From)
|
|
Host = exmpp_jid:ldomain_as_list(To),
|
|
LJID = jlib:short_prepd_bare_jid(To),
|
|
case tree_action(Host, get_nodes, [Host, From]) of
|
|
[] ->
|
|
Acc;
|
|
Nodes ->
|
|
Items = case Acc of
|
|
{result, I} -> I;
|
|
_ -> []
|
|
end,
|
|
NodeItems = lists:map(
|
|
fun(Node) ->
|
|
#xmlel{ns = ?NS_DISCO_ITEMS, name = 'item', attrs =
|
|
[?XMLATTR('jid', exmpp_jid:jid_to_binary(LJID)),
|
|
?XMLATTR('node', node_to_string(Node))]}
|
|
end, Nodes),
|
|
{result, NodeItems ++ Items}
|
|
end;
|
|
|
|
disco_sm_items(Acc, From, To, NodeB, _Lang) ->
|
|
Node = binary_to_list(NodeB),
|
|
%% TODO, use iq_disco_items(Host, Node, From)
|
|
Host = exmpp_jid:ldomain_as_list(To),
|
|
LJID = jlib:short_prepd_bare_jid(To),
|
|
case get_items(Host, Node, From) of
|
|
[] ->
|
|
Acc;
|
|
AllItems ->
|
|
Items = case Acc of
|
|
{result, I} -> I;
|
|
_ -> []
|
|
end,
|
|
NodeItems = lists:map(
|
|
fun(#pubsub_item{itemid = Id}) ->
|
|
%% "jid" is required by XEP-0030, and
|
|
%% "node" is forbidden by XEP-0060.
|
|
{result, Name} = node_action(Host, Node, get_item_name, [Host, Node, Id]),
|
|
#xmlel{ns = ?NS_DISCO_ITEMS, name = 'item', attrs =
|
|
[?XMLATTR('jid', exmpp_jid:jid_to_binary(LJID)),
|
|
?XMLATTR('name', Name)]}
|
|
end, AllItems),
|
|
{result, NodeItems ++ Items}
|
|
end.
|
|
|
|
%% -------
|
|
%% presence hooks handling functions
|
|
%%
|
|
|
|
presence_probe(JID, JID, Pid) ->
|
|
Proc = gen_mod:get_module_proc(exmpp_jid:ldomain_as_list(JID), ?PROCNAME),
|
|
gen_server:cast(Proc, {presence, JID, Pid});
|
|
presence_probe(_, _, _) ->
|
|
ok.
|
|
|
|
%% -------
|
|
%% user remove hook handling function
|
|
%%
|
|
|
|
remove_user(User, Server) ->
|
|
LUser = exmpp_stringprep:nodeprep(User),
|
|
LServer = exmpp_stringprep:nameprep(Server),
|
|
Proc = gen_mod:get_module_proc(Server, ?PROCNAME),
|
|
gen_server:cast(Proc, {remove_user, LUser, LServer}).
|
|
|
|
%%--------------------------------------------------------------------
|
|
%% Function:
|
|
%% handle_call(Request, From, State) -> {reply, Reply, State} |
|
|
%% {reply, Reply, State, Timeout} |
|
|
%% {noreply, State} |
|
|
%% {noreply, State, Timeout} |
|
|
%% {stop, Reason, Reply, State} |
|
|
%% {stop, Reason, State}
|
|
%% Description: Handling call messages
|
|
%%--------------------------------------------------------------------
|
|
%% @private
|
|
handle_call(server_host, _From, State) ->
|
|
{reply, State#state.server_host, State};
|
|
handle_call(plugins, _From, State) ->
|
|
{reply, State#state.plugins, State};
|
|
handle_call(pep_mapping, _From, State) ->
|
|
{reply, State#state.pep_mapping, State};
|
|
handle_call(nodetree, _From, State) ->
|
|
{reply, State#state.nodetree, State};
|
|
handle_call(stop, _From, State) ->
|
|
{stop, normal, ok, State}.
|
|
|
|
%%--------------------------------------------------------------------
|
|
%% Function: handle_cast(Msg, State) -> {noreply, State} |
|
|
%% {noreply, State, Timeout} |
|
|
%% {stop, Reason, State}
|
|
%% Description: Handling cast messages
|
|
%%--------------------------------------------------------------------
|
|
%% @private
|
|
handle_cast({presence, JID, Pid}, State) ->
|
|
%% A new resource is available. send last published items
|
|
LJID = jlib:short_prepd_jid(JID),
|
|
Host = State#state.host,
|
|
ServerHost = State#state.server_host,
|
|
%% for each node From is subscribed to
|
|
%% and if the node is so configured, send the last published item to From
|
|
lists:foreach(fun(Type) ->
|
|
{result, Subscriptions} = node_action(Type, get_entity_subscriptions, [Host, JID]),
|
|
lists:foreach(
|
|
fun({Node, subscribed, SubJID}) ->
|
|
case tree_action(Host, get_node, [Host, Node, JID]) of
|
|
#pubsub_node{options = Options} ->
|
|
case get_option(Options, send_last_published_item) of
|
|
on_sub_and_presence ->
|
|
send_last_item(Host, Node, SubJID);
|
|
_ ->
|
|
ok
|
|
end;
|
|
_ ->
|
|
ok
|
|
end;
|
|
(_) ->
|
|
ok
|
|
end, Subscriptions)
|
|
end, State#state.plugins),
|
|
%% and send to From last PEP events published by its contacts
|
|
case catch ejabberd_c2s:get_subscribed(Pid) of
|
|
Contacts when is_list(Contacts) ->
|
|
lists:foreach(
|
|
fun({User, Server, _}) ->
|
|
Owner = {User, Server, undefined},
|
|
lists:foreach(fun(#pubsub_node{nodeid = {_, Node}, options = Options}) ->
|
|
case get_option(Options, send_last_published_item) of
|
|
on_sub_and_presence ->
|
|
case is_caps_notify(ServerHost, Node, LJID) of
|
|
true ->
|
|
Subscribed = case get_option(Options, access_model) of
|
|
open -> true;
|
|
presence -> true;
|
|
whitelist -> false; % subscribers are added manually
|
|
authorize -> false; % likewise
|
|
roster ->
|
|
Grps = get_option(Options, roster_groups_allowed, []),
|
|
element(2, get_roster_info(User, Server, LJID, Grps))
|
|
end,
|
|
if Subscribed ->
|
|
send_last_item(Owner, Node, LJID);
|
|
true ->
|
|
ok
|
|
end;
|
|
false ->
|
|
ok
|
|
end;
|
|
_ ->
|
|
ok
|
|
end
|
|
end, tree_action(Host, get_nodes, [Owner, JID]))
|
|
end, Contacts);
|
|
_ ->
|
|
ok
|
|
end,
|
|
{noreply, State};
|
|
|
|
handle_cast({remove_user, LUser, LServer}, State) ->
|
|
Host = State#state.host,
|
|
Owner = exmpp_jid:make_jid(LUser, LServer),
|
|
%% remove user's subscriptions
|
|
lists:foreach(fun(Type) ->
|
|
{result, Subscriptions} = node_action(Type, get_entity_subscriptions, [Host, Owner]),
|
|
lists:foreach(fun
|
|
({Node, subscribed, JID}) ->
|
|
unsubscribe_node(Host, Node, Owner, JID, all);
|
|
(_) ->
|
|
ok
|
|
end, Subscriptions)
|
|
end, State#state.plugins),
|
|
%% remove user's PEP nodes
|
|
lists:foreach(fun(#pubsub_node{nodeid={NodeKey, NodeName}}) ->
|
|
delete_node(NodeKey, NodeName, Owner)
|
|
end, tree_action(Host, get_nodes, [jlib:short_prepd_bare_jid(Owner)])),
|
|
%% remove user's nodes
|
|
delete_node(Host, ["home", LServer, LUser], Owner),
|
|
{noreply, State};
|
|
|
|
handle_cast(_Msg, State) ->
|
|
{noreply, State}.
|
|
|
|
%%--------------------------------------------------------------------
|
|
%% Function: handle_info(Info, State) -> {noreply, State} |
|
|
%% {noreply, State, Timeout} |
|
|
%% {stop, Reason, State}
|
|
%% Description: Handling all non call/cast messages
|
|
%%--------------------------------------------------------------------
|
|
%% @private
|
|
handle_info({route, From, To, Packet},
|
|
#state{server_host = ServerHost,
|
|
access = Access,
|
|
plugins = Plugins} = State) ->
|
|
case catch do_route(ServerHost, Access, Plugins, exmpp_jid:ldomain_as_list(To), From, To, Packet) of
|
|
{'EXIT', Reason} -> ?ERROR_MSG("~p", [Reason]);
|
|
_ -> ok
|
|
end,
|
|
{noreply, State};
|
|
handle_info(_Info, State) ->
|
|
{noreply, State}.
|
|
|
|
%%--------------------------------------------------------------------
|
|
%% Function: terminate(Reason, State) -> void()
|
|
%% Description: This function is called by a gen_server when it is about to
|
|
%% terminate. It should be the opposite of Module:init/1 and do any necessary
|
|
%% cleaning up. When it returns, the gen_server terminates with Reason.
|
|
%% The return value is ignored.
|
|
%%--------------------------------------------------------------------
|
|
%% @private
|
|
terminate(_Reason, #state{host = Host,
|
|
server_host = ServerHost,
|
|
nodetree = TreePlugin,
|
|
plugins = Plugins}) ->
|
|
terminate_plugins(Host, ServerHost, Plugins, TreePlugin),
|
|
ejabberd_router:unregister_route(Host),
|
|
ServerHostB = list_to_binary(ServerHost),
|
|
ejabberd_hooks:delete(disco_local_identity, ServerHostB, ?MODULE, disco_local_identity, 75),
|
|
ejabberd_hooks:delete(disco_local_features, ServerHostB, ?MODULE, disco_local_features, 75),
|
|
ejabberd_hooks:delete(disco_local_items, ServerHostB, ?MODULE, disco_local_items, 75),
|
|
ejabberd_hooks:delete(disco_sm_identity, ServerHostB, ?MODULE, disco_sm_identity, 75),
|
|
ejabberd_hooks:delete(disco_sm_features, ServerHostB, ?MODULE, disco_sm_features, 75),
|
|
ejabberd_hooks:delete(disco_sm_items, ServerHostB, ?MODULE, disco_sm_items, 75),
|
|
ejabberd_hooks:delete(presence_probe_hook, ServerHostB, ?MODULE, presence_probe, 50),
|
|
ejabberd_hooks:delete(remove_user, ServerHostB, ?MODULE, remove_user, 50),
|
|
lists:foreach(fun({NS,Mod}) ->
|
|
gen_iq_handler:remove_iq_handler(Mod, ServerHostB, NS)
|
|
end, [{?NS_PUBSUB, ejabberd_local},
|
|
{?NS_PUBSUB_OWNER, ejabberd_local},
|
|
{?NS_PUBSUB, ejabberd_sm},
|
|
{?NS_PUBSUB_OWNER, ejabberd_sm}]),
|
|
mod_disco:unregister_feature(ServerHost, ?NS_PUBSUB_s),
|
|
ok.
|
|
|
|
%%--------------------------------------------------------------------
|
|
%% Func: code_change(OldVsn, State, Extra) -> {ok, NewState}
|
|
%% Description: Convert process state when code is changed
|
|
%%--------------------------------------------------------------------
|
|
%% @private
|
|
code_change(_OldVsn, State, _Extra) ->
|
|
{ok, State}.
|
|
|
|
%%--------------------------------------------------------------------
|
|
%%% Internal functions
|
|
%%--------------------------------------------------------------------
|
|
do_route(ServerHost, Access, Plugins, Host, From, To, Packet) ->
|
|
#xmlel{name = Name} = Packet,
|
|
LNode = exmpp_jid:lnode(To),
|
|
LRes = exmpp_jid:lresource(To),
|
|
case {LNode, LRes} of
|
|
{undefined, undefined} ->
|
|
case Name of
|
|
'iq' ->
|
|
case exmpp_iq:xmlel_to_iq(Packet) of
|
|
#iq{type = get, ns = ?NS_DISCO_INFO,
|
|
payload = SubEl, lang = Lang} ->
|
|
QAttrs = SubEl#xmlel.attrs,
|
|
Node = exmpp_xml:get_attribute_from_list_as_list(QAttrs,
|
|
'node', ""),
|
|
Res = case iq_disco_info(Host, Node, From, Lang) of
|
|
{result, IQRes} ->
|
|
Result = #xmlel{ns = ?NS_DISCO_INFO,
|
|
name = 'query', attrs = QAttrs,
|
|
children = IQRes},
|
|
exmpp_iq:result(Packet, Result);
|
|
{error, Error} ->
|
|
exmpp_iq:error(Packet, Error)
|
|
end,
|
|
ejabberd_router:route(To, From, Res);
|
|
#iq{type = get, ns = ?NS_DISCO_ITEMS,
|
|
payload = SubEl} ->
|
|
QAttrs = SubEl#xmlel.attrs,
|
|
Node = exmpp_xml:get_attribute_from_list_as_list(QAttrs,
|
|
'node', ""),
|
|
Res = case iq_disco_items(Host, Node, From) of
|
|
{result, IQRes} ->
|
|
Result = #xmlel{ns = ?NS_DISCO_ITEMS,
|
|
name = 'query', attrs = QAttrs,
|
|
children = IQRes},
|
|
exmpp_iq:result(Packet, Result);
|
|
{error, Error} ->
|
|
exmpp_iq:error(Packet, Error)
|
|
end,
|
|
ejabberd_router:route(To, From, Res);
|
|
#iq{type = IQType, ns = ?NS_PUBSUB,
|
|
lang = Lang, payload = SubEl} ->
|
|
Res =
|
|
case iq_pubsub(Host, ServerHost, From, IQType, SubEl, Lang, Access, Plugins) of
|
|
{result, IQRes} ->
|
|
exmpp_iq:result(Packet, IQRes);
|
|
{error, Error} ->
|
|
exmpp_iq:error(Packet, Error)
|
|
end,
|
|
ejabberd_router:route(To, From, Res);
|
|
#iq{type = IQType, ns = ?NS_PUBSUB_OWNER,
|
|
lang = Lang, payload = SubEl} ->
|
|
Res =
|
|
case iq_pubsub_owner(Host, From, IQType, SubEl, Lang) of
|
|
{result, IQRes} ->
|
|
exmpp_iq:result(Packet, IQRes);
|
|
{error, Error} ->
|
|
exmpp_iq:error(Packet, Error)
|
|
end,
|
|
ejabberd_router:route(To, From, Res);
|
|
#iq{type = get, ns = ?NS_VCARD = XMLNS,
|
|
lang = Lang} ->
|
|
VCard = #xmlel{ns = XMLNS, name = 'vCard',
|
|
children = iq_get_vcard(Lang)},
|
|
Res = exmpp_iq:result(Packet, VCard),
|
|
ejabberd_router:route(To, From, Res);
|
|
#iq{} ->
|
|
Err = exmpp_iq:error(Packet,
|
|
'feature-not-implemented'),
|
|
ejabberd_router:route(To, From, Err);
|
|
_ ->
|
|
ok
|
|
end;
|
|
'message' ->
|
|
case exmpp_stanza:is_stanza_error(Packet) of
|
|
true ->
|
|
ok;
|
|
false ->
|
|
case find_authorization_response(Packet) of
|
|
none ->
|
|
ok;
|
|
invalid ->
|
|
ejabberd_router:route(To, From,
|
|
exmpp_message:error(Packet, 'bad-request'));
|
|
XFields ->
|
|
handle_authorization_response(Host, From, To, Packet, XFields)
|
|
end
|
|
end;
|
|
_ ->
|
|
ok
|
|
end;
|
|
_ ->
|
|
case exmpp_stanza:get_type(Packet) of
|
|
<<"error">> ->
|
|
ok;
|
|
<<"result">> ->
|
|
ok;
|
|
_ ->
|
|
Err = exmpp_stanza:reply_with_error(Packet,
|
|
'item-not-found'),
|
|
ejabberd_router:route(To, From, Err)
|
|
end
|
|
end.
|
|
|
|
node_disco_info(Host, Node, From) ->
|
|
node_disco_info(Host, Node, From, true, true).
|
|
node_disco_identity(Host, Node, From) ->
|
|
node_disco_info(Host, Node, From, true, false).
|
|
node_disco_features(Host, Node, From) ->
|
|
node_disco_info(Host, Node, From, false, true).
|
|
node_disco_info(Host, Node, From, Identity, Features) ->
|
|
Action =
|
|
fun(#pubsub_node{type = Type}) ->
|
|
I = case Identity of
|
|
false ->
|
|
[];
|
|
true ->
|
|
Types =
|
|
case tree_call(Host, get_subnodes, [Host, Node, From]) of
|
|
[] ->
|
|
["leaf"]; %% No sub-nodes: it's a leaf node
|
|
_ ->
|
|
case node_call(Type, get_items, [Host, Node, From]) of
|
|
{result, []} -> ["collection"];
|
|
{result, _} -> ["leaf", "collection"];
|
|
_ -> []
|
|
end
|
|
end,
|
|
lists:map(fun(T) ->
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'identity', attrs = [?XMLATTR('category', <<"pubsub">>),
|
|
?XMLATTR('type', T)]}
|
|
end, Types)
|
|
end,
|
|
F = case Features of
|
|
false ->
|
|
[];
|
|
true ->
|
|
[#xmlel{ns = ?NS_DISCO_INFO, name = 'feature', attrs = [?XMLATTR('var', ?NS_PUBSUB_s)]} |
|
|
lists:map(fun(T) ->
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'feature', attrs = [?XMLATTR('var', ?NS_PUBSUB_s++"#"++T)]}
|
|
end, features(Type))]
|
|
end,
|
|
%% TODO: add meta-data info (spec section 5.4)
|
|
{result, I ++ F}
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty).
|
|
|
|
iq_disco_info(Host, SNode, From, Lang) ->
|
|
Node = string_to_node(SNode),
|
|
case Node of
|
|
[] ->
|
|
{result,
|
|
[#xmlel{ns = ?NS_DISCO_INFO, name = 'identity', attrs =
|
|
[?XMLATTR('category', "pubsub"),
|
|
?XMLATTR('type', "service"),
|
|
?XMLATTR('name', translate:translate(Lang, "Publish-Subscribe"))]},
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'feature', attrs = [?XMLATTR('var', ?NS_DISCO_INFO_s)]},
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'feature', attrs = [?XMLATTR('var', ?NS_DISCO_ITEMS_s)]},
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'feature', attrs = [?XMLATTR('var', ?NS_PUBSUB_s)]},
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'feature', attrs = [?XMLATTR('var', ?NS_VCARD_s)]}] ++
|
|
lists:map(fun(Feature) ->
|
|
#xmlel{ns = ?NS_DISCO_INFO, name = 'feature', attrs = [?XMLATTR('var', ?NS_PUBSUB_s++"#"++Feature)]}
|
|
end, features(Host, SNode))};
|
|
_ ->
|
|
node_disco_info(Host, Node, From)
|
|
end.
|
|
|
|
iq_disco_items(Host, [], From) ->
|
|
{result, lists:map(
|
|
fun(#pubsub_node{nodeid = {_, SubNode}}) ->
|
|
SN = node_to_string(SubNode),
|
|
RN = lists:last(SubNode),
|
|
%% remove name attribute
|
|
#xmlel{ns = ?NS_DISCO_ITEMS, name = 'item', attrs = [?XMLATTR('jid', Host),
|
|
?XMLATTR('node', SN),
|
|
?XMLATTR('name', RN)]}
|
|
end, tree_action(Host, get_subnodes, [Host, [], From]))};
|
|
iq_disco_items(Host, Item, From) ->
|
|
case string:tokens(Item, "!") of
|
|
[_SNode, _ItemID] ->
|
|
{result, []};
|
|
[SNode] ->
|
|
Node = string_to_node(SNode),
|
|
%% Note: Multiple Node Discovery not supported (mask on pubsub#type)
|
|
%% TODO this code is also back-compatible with pubsub v1.8 (for client issue)
|
|
%% TODO make it pubsub v1.12 compliant (breaks client compatibility ?)
|
|
%% TODO That is, remove name attribute
|
|
Action =
|
|
fun(#pubsub_node{type = Type}) ->
|
|
NodeItems = case node_call(Type, get_items, [Host, Node, From]) of
|
|
{result, I} -> I;
|
|
_ -> []
|
|
end,
|
|
Nodes = lists:map(
|
|
fun(#pubsub_node{nodeid = {_, SubNode}}) ->
|
|
SN = node_to_string(SubNode),
|
|
RN = lists:last(SubNode),
|
|
#xmlel{ns = ?NS_DISCO_ITEMS, name = 'item', attrs = [?XMLATTR('jid', Host), ?XMLATTR('node', SN),
|
|
?XMLATTR('name', RN)]}
|
|
end, tree_call(Host, get_subnodes, [Host, Node, From])),
|
|
Items = lists:map(
|
|
fun(#pubsub_item{itemid = {RN, _}}) ->
|
|
SN = node_to_string(Node) ++ "!" ++ RN,
|
|
{result, Name} = node_call(Type, get_item_name, [Host, Node, RN]),
|
|
#xmlel{ns = ?NS_DISCO_ITEMS, name = 'item', attrs = [?XMLATTR('jid', Host), ?XMLATTR('node', SN),
|
|
?XMLATTR('name', Name)]}
|
|
end, NodeItems),
|
|
{result, Nodes ++ Items}
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty)
|
|
end.
|
|
|
|
iq_local(From, To, #iq{type = Type,
|
|
payload = SubEl,
|
|
ns = XMLNS,
|
|
lang = Lang} = IQ_Rec) ->
|
|
ServerHost = exmpp_jid:ldomain_as_list(To),
|
|
FromHost = exmpp_jid:ldomain_as_list(To),
|
|
%% Accept IQs to server only from our own users.
|
|
if
|
|
FromHost /= ServerHost ->
|
|
exmpp_iq:error(IQ_Rec, 'forbidden');
|
|
true ->
|
|
LOwner = jlib:short_prepd_bare_jid(From),
|
|
Res = case XMLNS of
|
|
?NS_PUBSUB -> iq_pubsub(LOwner, ServerHost, From, Type, SubEl, Lang);
|
|
?NS_PUBSUB_OWNER -> iq_pubsub_owner(LOwner, From, Type, SubEl, Lang)
|
|
end,
|
|
case Res of
|
|
{result, []} -> exmpp_iq:result(IQ_Rec);
|
|
{result, [IQRes]} -> exmpp_iq:result(IQ_Rec, IQRes);
|
|
{error, Error} -> exmpp_iq:error(IQ_Rec, Error)
|
|
end
|
|
end.
|
|
|
|
iq_sm(From, To, #iq{type = Type, payload = SubEl, ns = XMLNS, lang = Lang} = IQ_Rec) ->
|
|
ServerHost = exmpp_jid:ldomain_as_list(To),
|
|
LOwner = jlib:short_prepd_bare_jid(To),
|
|
Res = case XMLNS of
|
|
?NS_PUBSUB -> iq_pubsub(LOwner, ServerHost, From, Type, SubEl, Lang);
|
|
?NS_PUBSUB_OWNER -> iq_pubsub_owner(LOwner, From, Type, SubEl, Lang)
|
|
end,
|
|
case Res of
|
|
{result, []} -> exmpp_iq:result(IQ_Rec);
|
|
{result, [IQRes]} -> exmpp_iq:result(IQ_Rec, IQRes);
|
|
{error, Error} -> exmpp_iq:error(IQ_Rec, Error)
|
|
end.
|
|
|
|
iq_get_vcard(Lang) ->
|
|
[#xmlel{ns = ?NS_VCARD, name = 'FN', children = [#xmlcdata{cdata = <<"ejabberd/mod_pubsub">>}]},
|
|
#xmlel{ns = ?NS_VCARD, name = 'URL', children = [#xmlcdata{cdata = list_to_binary(?EJABBERD_URI)}]},
|
|
#xmlel{ns = ?NS_VCARD, name = 'DESC', children =
|
|
[#xmlcdata{cdata = list_to_binary(
|
|
translate:translate(Lang,
|
|
"ejabberd Publish-Subscribe module") ++
|
|
"\nCopyright (c) 2004-2009 Process-One")}]}].
|
|
|
|
iq_pubsub(Host, ServerHost, From, IQType, SubEl, Lang) ->
|
|
iq_pubsub(Host, ServerHost, From, IQType, SubEl, Lang, all, plugins(ServerHost)).
|
|
|
|
iq_pubsub(Host, ServerHost, From, IQType, SubEl, _Lang, Access, Plugins) ->
|
|
WithoutCdata = exmpp_xml:remove_cdata_from_list(SubEl#xmlel.children),
|
|
Configuration = lists:filter(fun(#xmlel{name = 'configure'}) -> true;
|
|
(_) -> false
|
|
end, WithoutCdata),
|
|
Action = WithoutCdata -- Configuration,
|
|
case Action of
|
|
[#xmlel{name = Name, attrs = Attrs, children = Els}] ->
|
|
Node = case Host of
|
|
{_, _, _} -> exmpp_xml:get_attribute_from_list_as_list(Attrs, 'node', false);
|
|
_ -> string_to_node(exmpp_xml:get_attribute_from_list_as_list(Attrs, 'node', false))
|
|
end,
|
|
case {IQType, Name} of
|
|
{set, 'create'} ->
|
|
case Configuration of
|
|
[#xmlel{name = 'configure', children = Config}] ->
|
|
%% Get the type of the node
|
|
Type = case exmpp_xml:get_attribute_from_list_as_list(Attrs, 'type', "") of
|
|
[] -> hd(Plugins);
|
|
T -> T
|
|
end,
|
|
%% we use Plugins list matching because we do not want to allocate
|
|
%% atoms for non existing type, this prevent atom allocation overflow
|
|
case lists:member(Type, Plugins) of
|
|
false ->
|
|
{error, extended_error(
|
|
'feature-not-implemented',
|
|
unsupported, "create-nodes")};
|
|
true ->
|
|
create_node(Host, ServerHost, Node, From,
|
|
Type, Access, Config)
|
|
end;
|
|
_ ->
|
|
%% this breaks backward compatibility!
|
|
%% can not create node without <configure/>
|
|
%% but this is the new spec anyway
|
|
?INFO_MSG("Node ~p ; invalid configuration: ~p", [Node, Configuration]),
|
|
{error, 'bad-request'}
|
|
end;
|
|
{set, 'publish'} ->
|
|
case exmpp_xml:remove_cdata_from_list(Els) of
|
|
[#xmlel{name = 'item', attrs = ItemAttrs, children = Payload}] ->
|
|
ItemId = exmpp_xml:get_attribute_from_list_as_list(ItemAttrs, 'id', ""),
|
|
publish_item(Host, ServerHost, Node, From, ItemId, Payload);
|
|
[] ->
|
|
%% Publisher attempts to publish to persistent node with no item
|
|
{error, extended_error('bad-request',
|
|
"item-required")};
|
|
_ ->
|
|
%% Entity attempts to publish item with multiple payload elements or namespace does not match
|
|
{error, extended_error('bad-request',
|
|
"invalid-payload")}
|
|
end;
|
|
{set, 'retract'} ->
|
|
ForceNotify = case exmpp_xml:get_attribute_from_list_as_list(Attrs, 'notify', "") of
|
|
"1" -> true;
|
|
"true" -> true;
|
|
_ -> false
|
|
end,
|
|
case exmpp_xml:remove_cdata_from_list(Els) of
|
|
[#xmlel{name = 'item', attrs = ItemAttrs}] ->
|
|
ItemId = exmpp_xml:get_attribute_from_list_as_list(ItemAttrs, 'id', ""),
|
|
delete_item(Host, Node, From, ItemId, ForceNotify);
|
|
_ ->
|
|
%% Request does not specify an item
|
|
{error, extended_error('bad-request',
|
|
"item-required")}
|
|
end;
|
|
{set, 'subscribe'} ->
|
|
JID = exmpp_xml:get_attribute_from_list_as_list(Attrs, 'jid', ""),
|
|
subscribe_node(Host, Node, From, JID);
|
|
{set, 'unsubscribe'} ->
|
|
JID = exmpp_xml:get_attribute_from_list_as_list(Attrs, 'jid', ""),
|
|
SubId = exmpp_xml:get_attribute_from_list_as_list(Attrs, 'subid', ""),
|
|
unsubscribe_node(Host, Node, From, JID, SubId);
|
|
{get, 'items'} ->
|
|
MaxItems = exmpp_xml:get_attribute_from_list_as_list(Attrs, 'max_items', ""),
|
|
SubId = exmpp_xml:get_attribute_from_list_as_list(Attrs, 'subid', ""),
|
|
ItemIDs = lists:foldl(fun
|
|
(#xmlel{name = 'item', attrs = ItemAttrs}, Acc) ->
|
|
case exmpp_xml:get_attribute_from_list_as_list(ItemAttrs, 'id', "") of
|
|
"" -> Acc;
|
|
ItemID -> [ItemID|Acc]
|
|
end;
|
|
(_, Acc) ->
|
|
Acc
|
|
end, [], exmpp_xml:remove_cdata_from_list(Els)),
|
|
get_items(Host, Node, From, SubId, MaxItems, ItemIDs);
|
|
{get, 'subscriptions'} ->
|
|
get_subscriptions(Host, From, Plugins);
|
|
{get, 'affiliations'} ->
|
|
get_affiliations(Host, From, Plugins);
|
|
{get, "options"} ->
|
|
{error, extended_error('feature-not-implemented', unsupported, "subscription-options")};
|
|
{set, "options"} ->
|
|
{error, extended_error('feature-not-implemented', unsupported, "subscription-options")};
|
|
_ ->
|
|
{error, 'feature-not-implemented'}
|
|
end;
|
|
_ ->
|
|
?INFO_MSG("Too many actions: ~p", [Action]),
|
|
{error, 'bad-request'}
|
|
end.
|
|
|
|
iq_pubsub_owner(Host, From, IQType, SubEl, Lang) ->
|
|
SubEls = SubEl#xmlel.children,
|
|
Action = exmpp_xml:remove_cdata_from_list(SubEls),
|
|
case Action of
|
|
[#xmlel{name = Name, attrs = Attrs, children = Els}] ->
|
|
Node = case Host of
|
|
{_, _, _} -> exmpp_xml:get_attribute_from_list_as_list(Attrs, 'node', "");
|
|
_ -> string_to_node(exmpp_xml:get_attribute_from_list_as_list(Attrs, 'node', ""))
|
|
end,
|
|
case {IQType, Name} of
|
|
{get, 'configure'} ->
|
|
get_configure(Host, Node, From, Lang);
|
|
{set, 'configure'} ->
|
|
set_configure(Host, Node, From, Els, Lang);
|
|
{get, 'default'} ->
|
|
get_default(Host, Node, From, Lang);
|
|
{set, 'delete'} ->
|
|
delete_node(Host, Node, From);
|
|
{set, 'purge'} ->
|
|
purge_node(Host, Node, From);
|
|
{get, 'subscriptions'} ->
|
|
get_subscriptions(Host, Node, From);
|
|
{set, 'subscriptions'} ->
|
|
set_subscriptions(Host, Node, From, exmpp_xml:remove_cdata_from_list(Els));
|
|
{get, 'affiliations'} ->
|
|
get_affiliations(Host, Node, From);
|
|
{set, 'affiliations'} ->
|
|
set_affiliations(Host, Node, From, exmpp_xml:remove_cdata_from_list(Els));
|
|
_ ->
|
|
{error, 'feature-not-implemented'}
|
|
end;
|
|
_ ->
|
|
?INFO_MSG("Too many actions: ~p", [Action]),
|
|
{error, 'bad-request'}
|
|
end.
|
|
|
|
%%% authorization handling
|
|
|
|
send_authorization_request(Host, Node, Subscriber) ->
|
|
Lang = "en", %% TODO fix
|
|
{U, S, R} = Subscriber,
|
|
Stanza = #xmlel{ns = ?NS_JABBER_CLIENT, name = 'message', children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'x', attrs = [?XMLATTR('type', <<"form">>)], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'title', children =
|
|
[#xmlcdata{cdata = list_to_binary(translate:translate(Lang, "PubSub subscriber request"))}]},
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'instructions', children =
|
|
[#xmlcdata{cdata = list_to_binary(translate:translate(Lang, "Choose whether to approve this entity's subscription."))}]},
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'field', attrs =
|
|
[?XMLATTR('var', <<"FORM_TYPE">>), ?XMLATTR('type', <<"hidden">>)], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children = [#xmlcdata{cdata = list_to_binary(?NS_PUBSUB_SUBSCRIBE_AUTH_s)}]}]},
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'field', attrs =
|
|
[?XMLATTR('var', <<"pubsub#node">>), ?XMLATTR('type', <<"text-single">>),
|
|
?XMLATTR('label', translate:translate(Lang, "Node ID"))], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children =
|
|
[#xmlcdata{cdata = node_to_string(Node)}]}]},
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'field', attrs = [?XMLATTR('var', <<"pubsub#subscriber_jid">>),
|
|
?XMLATTR('type', <<"jid-single">>),
|
|
?XMLATTR('label', translate:translate(Lang, "Subscriber Address"))], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children =
|
|
[#xmlcdata{cdata = exmpp_jid:jid_to_binary(U, S, R)}]}]},
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'field', attrs =
|
|
[?XMLATTR('var', <<"pubsub#allow">>),
|
|
?XMLATTR('type', <<"boolean">>),
|
|
?XMLATTR('label', translate:translate(Lang, "Allow this Jabber ID to subscribe to this pubsub node?"))], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children = [#xmlcdata{cdata = <<"false">>}]}]}]}]},
|
|
case tree_action(Host, get_node, [Host, Node, Subscriber]) of
|
|
#pubsub_node{owners = Owners} ->
|
|
lists:foreach(
|
|
fun({U1, S1, R1}) ->
|
|
ejabberd_router ! {route, service_jid(Host), exmpp_jid:make_jid(U1, S1, R1), Stanza}
|
|
end, Owners),
|
|
ok;
|
|
_ ->
|
|
ok
|
|
end.
|
|
|
|
find_authorization_response(Packet) ->
|
|
Els = Packet#xmlel.children,
|
|
XData1 = lists:map(fun(#xmlel{ns = ?NS_DATA_FORMS, name = 'x', attrs = XAttrs} = XEl) ->
|
|
case exmpp_xml:get_attribute_from_list_as_list(XAttrs, 'type', "") of
|
|
"cancel" ->
|
|
none;
|
|
_ ->
|
|
jlib:parse_xdata_submit(XEl)
|
|
end;
|
|
(_) ->
|
|
none
|
|
end, exmpp_xml:remove_cdata(Els)),
|
|
XData = lists:filter(fun(E) -> E /= none end, XData1),
|
|
case XData of
|
|
[invalid] -> invalid;
|
|
[] -> none;
|
|
[XFields] when is_list(XFields) ->
|
|
case lists:keysearch("FORM_TYPE", 1, XFields) of
|
|
{value, {_, [?NS_PUBSUB_SUBSCRIBE_AUTH_s]}} ->
|
|
XFields;
|
|
_ ->
|
|
invalid
|
|
end
|
|
end.
|
|
|
|
%% @spec (Host, JID, Node, Subscription) -> void
|
|
%% Host = mod_pubsub:host()
|
|
%% JID = jlib:jid()
|
|
%% Node = string()
|
|
%% Subscription = atom()
|
|
%% Plugins = [Plugin::string()]
|
|
%% @doc Send a message to JID with the supplied Subscription
|
|
send_authorization_approval(Host, JID, Node, Subscription) ->
|
|
Stanza = event_stanza(
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'subscription', attrs =
|
|
[?XMLATTR('node', Node),
|
|
?XMLATTR('jid', exmpp_jid:jid_to_binary(JID)),
|
|
?XMLATTR('subscription', subscription_to_string(Subscription))]}]),
|
|
ejabberd_router ! {route, service_jid(Host), JID, Stanza}.
|
|
|
|
handle_authorization_response(Host, From, To, Packet, XFields) ->
|
|
case {lists:keysearch("pubsub#node", 1, XFields),
|
|
lists:keysearch("pubsub#subscriber_jid", 1, XFields),
|
|
lists:keysearch("pubsub#allow", 1, XFields)} of
|
|
{{value, {_, [SNode]}}, {value, {_, [SSubscriber]}},
|
|
{value, {_, [SAllow]}}} ->
|
|
Node = case Host of
|
|
{_, _, _} -> [SNode];
|
|
_ -> string:tokens(SNode, "/")
|
|
end,
|
|
Subscriber = exmpp_jid:parse_jid(SSubscriber),
|
|
Allow = case SAllow of
|
|
"1" -> true;
|
|
"true" -> true;
|
|
_ -> false
|
|
end,
|
|
Action = fun(#pubsub_node{type = Type,
|
|
%%options = Options,
|
|
owners = Owners}) ->
|
|
IsApprover = lists:member(jlib:short_prepd_bare_jid(From), Owners),
|
|
{result, Subscription} = node_call(Type, get_subscription, [Host, Node, Subscriber]),
|
|
if
|
|
not IsApprover ->
|
|
{error, 'forbidden'};
|
|
Subscription /= pending ->
|
|
{error, 'unexpected-request'};
|
|
true ->
|
|
NewSubscription = case Allow of
|
|
true -> subscribed;
|
|
false -> none
|
|
end,
|
|
send_authorization_approval(Host, Subscriber, SNode, NewSubscription),
|
|
node_call(Type, set_subscription, [Host, Node, Subscriber, NewSubscription])
|
|
end
|
|
end,
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, Error} ->
|
|
ejabberd_router:route(
|
|
To, From,
|
|
exmpp_stanza:reply_with_error(Packet, Error));
|
|
{result, _NewSubscription} ->
|
|
%% XXX: notify about subscription state change, section 12.11
|
|
ok;
|
|
_ ->
|
|
ejabberd_router:route(
|
|
To, From,
|
|
exmpp_stanza:reply_with_error(Packet, 'internal-server-error'))
|
|
end;
|
|
_ ->
|
|
ejabberd_router:route(
|
|
To, From,
|
|
exmpp_stanza:reply_with_error(Packet, 'not-acceptable'))
|
|
end.
|
|
|
|
-define(XFIELD(Type, Label, Var, Val),
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'field', attrs = [?XMLATTR('type', Type),
|
|
?XMLATTR('label', translate:translate(Lang, Label)),
|
|
?XMLATTR('var', Var)], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children = [#xmlcdata{cdata = list_to_binary(Val)}]}]}).
|
|
|
|
-define(BOOLXFIELD(Label, Var, Val),
|
|
?XFIELD("boolean", Label, Var,
|
|
case Val of
|
|
true -> "1";
|
|
_ -> "0"
|
|
end)).
|
|
|
|
-define(STRINGXFIELD(Label, Var, Val),
|
|
?XFIELD("text-single", Label, Var, Val)).
|
|
|
|
-define(XFIELDOPT(Type, Label, Var, Val, Opts),
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'field', attrs = [?XMLATTR('type', Type),
|
|
?XMLATTR('label', translate:translate(Lang, Label)),
|
|
?XMLATTR('var', Var)], children =
|
|
lists:map(fun(Opt) ->
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'option', children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children =
|
|
[#xmlcdata{cdata = list_to_binary(Opt)}]}]}
|
|
end, Opts) ++
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children = [#xmlcdata{cdata = list_to_binary(Val)}]}]}).
|
|
|
|
-define(LISTXFIELD(Label, Var, Val, Opts),
|
|
?XFIELDOPT("list-single", Label, Var, Val, Opts)).
|
|
|
|
%% @spec (Host::host(), ServerHost::host(), Node::pubsubNode(), Owner::jid(), NodeType::nodeType()) ->
|
|
%% {error, Reason::stanzaError()} |
|
|
%% {result, []}
|
|
%% @doc <p>Create new pubsub nodes</p>
|
|
%%<p>In addition to method-specific error conditions, there are several general reasons why the node creation request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The service does not support node creation.</li>
|
|
%%<li>Only entities that are registered with the service are allowed to create nodes but the requesting entity is not registered.</li>
|
|
%%<li>The requesting entity does not have sufficient privileges to create nodes.</li>
|
|
%%<li>The requested NodeID already exists.</li>
|
|
%%<li>The request did not include a NodeID and "instant nodes" are not supported.</li>
|
|
%%</ul>
|
|
%%<p>ote: node creation is a particular case, error return code is evaluated at many places:</p>
|
|
%%<ul>
|
|
%%<li>iq_pubsub checks if service supports node creation (type exists)</li>
|
|
%%<li>create_node checks if instant nodes are supported</li>
|
|
%%<li>create_node asks node plugin if entity have sufficient privilege</li>
|
|
%%<li>nodetree create_node checks if nodeid already exists</li>
|
|
%%<li>node plugin create_node just sets default affiliation/subscription</li>
|
|
%%</ul>
|
|
create_node(Host, ServerHost, Node, Owner, Type) ->
|
|
create_node(Host, ServerHost, Node, Owner, Type, all, []).
|
|
|
|
create_node(Host, ServerHost, [], Owner, Type, Access, Configuration) ->
|
|
case lists:member("instant-nodes", features(Type)) of
|
|
true ->
|
|
{LOU, LOS, _} = jlib:short_prepd_jid(Owner),
|
|
HomeNode = ["home", LOS, LOU],
|
|
create_node(Host, ServerHost,
|
|
HomeNode, Owner, Type, Access, Configuration),
|
|
NewNode = HomeNode ++ [randoms:get_string()],
|
|
case create_node(Host, ServerHost,
|
|
NewNode, Owner, Type, Access, Configuration) of
|
|
{result, []} ->
|
|
{result,
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'create', attrs = [?XMLATTR('node', node_to_string(NewNode))]}]}]};
|
|
Error -> Error
|
|
end;
|
|
false ->
|
|
%% Service does not support instant nodes
|
|
{error, extended_error('not-acceptable', "nodeid-required")}
|
|
end;
|
|
create_node(Host, ServerHost, Node, Owner, GivenType, Access, Configuration) ->
|
|
Type = select_type(ServerHost, Host, Node, GivenType),
|
|
Parent = lists:sublist(Node, length(Node) - 1),
|
|
%% TODO, check/set node_type = Type
|
|
ParseOptions = case exmpp_xml:remove_cdata_from_list(Configuration) of
|
|
[] ->
|
|
{result, node_options(Type)};
|
|
[#xmlel{name = 'x'} = XEl] ->
|
|
case jlib:parse_xdata_submit(XEl) of
|
|
invalid ->
|
|
{error, 'bad-request'};
|
|
XData ->
|
|
case set_xoption(XData, node_options(Type)) of
|
|
NewOpts when is_list(NewOpts) ->
|
|
{result, NewOpts};
|
|
Err ->
|
|
Err
|
|
end
|
|
end;
|
|
_ ->
|
|
?INFO_MSG("Node ~p; bad configuration: ~p", [Node, Configuration]),
|
|
{error, 'bad-request'}
|
|
end,
|
|
case ParseOptions of
|
|
{result, NodeOptions} ->
|
|
CreateNode =
|
|
fun() ->
|
|
case node_call(Type, create_node_permission, [Host, ServerHost, Node, Parent, Owner, Access]) of
|
|
{result, true} ->
|
|
case tree_call(Host, create_node, [Host, Node, Type, Owner, NodeOptions]) of
|
|
ok ->
|
|
node_call(Type, create_node, [Host, Node, Owner]);
|
|
{error, 'conflict'} ->
|
|
case proplists:get_value(virtual_tree, tree_call(Host, options, [])) of
|
|
true -> node_call(Type, create_node, [Host, Node, Owner]);
|
|
_ -> {error, 'conflict'}
|
|
end;
|
|
Error ->
|
|
Error
|
|
end;
|
|
_ ->
|
|
{error, 'forbidden'}
|
|
end
|
|
end,
|
|
Reply = [#xmlel{ns = ?NS_PUBSUB, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'create', attrs = [?XMLATTR('node', node_to_string(Node))]}]}],
|
|
case transaction(CreateNode, transaction) of
|
|
{error, Error} ->
|
|
%% in case we change transaction to sync_dirty...
|
|
%%node_action:
|
|
%% node_call(Type, delete_node, [Host, Node]),
|
|
%% tree_call(Host, delete_node, [Host, Node]),
|
|
{error, Error};
|
|
{result, {Result, broadcast}} ->
|
|
%%Lang = "en", %% TODO: fix
|
|
%%OwnerKey = jlib:jid_tolower(jlib:jid_remove_resource(Owner)),
|
|
%%broadcast_publish_item(Host, Node, uniqid(), Owner,
|
|
%% [{xmlelement, "x", [{"xmlns", ?NS_DATA_FORMS}, {"type", "result"}],
|
|
%% [?XFIELD("hidden", "", "FORM_TYPE", ?NS_PUBSUB_NMI),
|
|
%% ?XFIELD("jid-single", "Node Creator", "creator", jlib:jid_to_string(OwnerKey))]}]),
|
|
case Result of
|
|
default -> {result, Reply};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, default} ->
|
|
{result, Reply};
|
|
{result, Result} ->
|
|
{result, Result}
|
|
end;
|
|
Error ->
|
|
Error
|
|
end.
|
|
|
|
%% @spec (Host, Node, Owner) ->
|
|
%% {error, Reason} | {result, []}
|
|
%% Host = host()
|
|
%% Node = pubsubNode()
|
|
%% Owner = jid()
|
|
%% Reason = stanzaError()
|
|
%% @doc <p>Delete specified node and all childs.</p>
|
|
%%<p>There are several reasons why the node deletion request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The requesting entity does not have sufficient privileges to delete the node.</li>
|
|
%%<li>The node is the root collection node, which cannot be deleted.</li>
|
|
%%<li>The specified node does not exist.</li>
|
|
%%</ul>
|
|
delete_node(_Host, [], _Owner) ->
|
|
%% Node is the root
|
|
{error, 'not-allowed'};
|
|
delete_node(Host, Node, Owner) ->
|
|
Action = fun(#pubsub_node{type = Type}) ->
|
|
case node_call(Type, get_affiliation, [Host, Node, Owner]) of
|
|
{result, owner} ->
|
|
Removed = tree_call(Host, delete_node, [Host, Node]),
|
|
node_call(Type, delete_node, [Host, Removed]);
|
|
_ ->
|
|
%% Entity is not an owner
|
|
{error, 'forbidden'}
|
|
end
|
|
end,
|
|
Reply = [],
|
|
case transaction(Host, Node, Action, transaction) of
|
|
{error, Error} ->
|
|
{error, Error};
|
|
{result, {Result, broadcast, Removed}} ->
|
|
lists:foreach(fun(RNode) ->
|
|
broadcast_removed_node(Host, RNode)
|
|
end, Removed),
|
|
case Result of
|
|
default -> {result, Reply};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, {Result, Removed}} ->
|
|
lists:foreach(fun(RNode) ->
|
|
broadcast_removed_node(Host, RNode)
|
|
end, Removed),
|
|
case Result of
|
|
default -> {result, Reply};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, default} ->
|
|
{result, Reply};
|
|
{result, Result} ->
|
|
{result, Result}
|
|
end.
|
|
|
|
%% @spec (Host, Node, From, JID) ->
|
|
%% {error, Reason::stanzaError()} |
|
|
%% {result, []}
|
|
%% Host = host()
|
|
%% Node = pubsubNode()
|
|
%% From = jid()
|
|
%% JID = jid()
|
|
%% @see node_default:subscribe_node/5
|
|
%% @doc <p>Accepts or rejects subcription requests on a PubSub node.</p>
|
|
%%<p>There are several reasons why the subscription request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The bare JID portions of the JIDs do not match.</li>
|
|
%%<li>The node has an access model of "presence" and the requesting entity is not subscribed to the owner's presence.</li>
|
|
%%<li>The node has an access model of "roster" and the requesting entity is not in one of the authorized roster groups.</li>
|
|
%%<li>The node has an access model of "whitelist" and the requesting entity is not on the whitelist.</li>
|
|
%%<li>The service requires payment for subscriptions to the node.</li>
|
|
%%<li>The requesting entity is anonymous and the service does not allow anonymous entities to subscribe.</li>
|
|
%%<li>The requesting entity has a pending subscription.</li>
|
|
%%<li>The requesting entity is blocked from subscribing (e.g., because having an affiliation of outcast).</li>
|
|
%%<li>The node does not support subscriptions.</li>
|
|
%%<li>The node does not exist.</li>
|
|
%%</ul>
|
|
subscribe_node(Host, Node, From, JID) ->
|
|
Subscriber = try
|
|
jlib:short_prepd_jid(exmpp_jid:parse_jid(JID))
|
|
catch
|
|
_:_ ->
|
|
{undefined, undefined, undefined}
|
|
end,
|
|
SubId = uniqid(),
|
|
Action = fun(#pubsub_node{options = Options, type = Type}) ->
|
|
Features = features(Type),
|
|
SubscribeFeature = lists:member("subscribe", Features),
|
|
SubscribeConfig = get_option(Options, subscribe),
|
|
AccessModel = get_option(Options, access_model),
|
|
SendLast = get_option(Options, send_last_published_item),
|
|
AllowedGroups = get_option(Options, roster_groups_allowed, []),
|
|
{PresenceSubscription, RosterGroup} =
|
|
case Host of
|
|
{OUser, OServer, _} ->
|
|
get_roster_info(OUser, OServer,
|
|
Subscriber, AllowedGroups);
|
|
_ ->
|
|
{true, true}
|
|
end,
|
|
if
|
|
not SubscribeFeature ->
|
|
%% Node does not support subscriptions
|
|
{error, extended_error('feature-not-implemented', unsupported, "subscribe")};
|
|
not SubscribeConfig ->
|
|
%% Node does not support subscriptions
|
|
{error, extended_error('feature-not-implemented', unsupported, "subscribe")};
|
|
true ->
|
|
node_call(Type, subscribe_node,
|
|
[Host, Node, From, Subscriber,
|
|
AccessModel, SendLast,
|
|
PresenceSubscription, RosterGroup])
|
|
end
|
|
end,
|
|
Reply = fun(Subscription) ->
|
|
%% TODO, this is subscription-notification, should depends on node features
|
|
Fields =
|
|
[?XMLATTR('node', node_to_string(Node)),
|
|
?XMLATTR('jid', exmpp_jid:jid_to_binary(Subscriber)),
|
|
?XMLATTR('subscription', subscription_to_string(Subscription))],
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'subscription', attrs =
|
|
case Subscription of
|
|
subscribed -> [?XMLATTR('subid', SubId)|Fields];
|
|
_ -> Fields
|
|
end}]}]
|
|
end,
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, Error} ->
|
|
{error, Error};
|
|
{result, {Result, subscribed, send_last}} ->
|
|
send_last_item(Host, Node, Subscriber),
|
|
case Result of
|
|
default -> {result, Reply(subscribed)};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, {Result, Subscription}} ->
|
|
case Subscription of
|
|
pending -> send_authorization_request(Host, Node, Subscriber);
|
|
_ -> ok
|
|
end,
|
|
case Result of
|
|
default -> {result, Reply(Subscription)};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, Result} ->
|
|
%% this case should never occure anyway
|
|
{result, Result}
|
|
end.
|
|
|
|
%% @spec (Host, Noce, From, JID, SubId) -> {error, Reason} | {result, []}
|
|
%% Host = host()
|
|
%% Node = pubsubNode()
|
|
%% From = jid()
|
|
%% JID = string()
|
|
%% SubId = string()
|
|
%% Reason = stanzaError()
|
|
%% @doc <p>Unsubscribe <tt>JID</tt> from the <tt>Node</tt>.</p>
|
|
%%<p>There are several reasons why the unsubscribe request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The requesting entity has multiple subscriptions to the node but does not specify a subscription ID.</li>
|
|
%%<li>The request does not specify an existing subscriber.</li>
|
|
%%<li>The requesting entity does not have sufficient privileges to unsubscribe the specified JID.</li>
|
|
%%<li>The node does not exist.</li>
|
|
%%<li>The request specifies a subscription ID that is not valid or current.</li>
|
|
%%</ul>
|
|
unsubscribe_node(Host, Node, From, JID, SubId) when is_list(JID) ->
|
|
Subscriber = try jlib:short_prepd_jid(exmpp_jid:parse_jid(JID))
|
|
catch
|
|
_:_ ->
|
|
{undefined, undefined, undefined}
|
|
end,
|
|
unsubscribe_node(Host, Node, From, Subscriber, SubId);
|
|
unsubscribe_node(Host, Node, From, Subscriber, SubId) ->
|
|
case node_action(Host, Node, unsubscribe_node,
|
|
[Host, Node, From, Subscriber, SubId]) of
|
|
{error, Error} ->
|
|
{error, Error};
|
|
{result, default} ->
|
|
{result, []};
|
|
{result, Result} ->
|
|
{result, Result}
|
|
end.
|
|
|
|
%% @spec (Host::host(), ServerHost::host(), JID::jid(), Node::pubsubNode(), ItemId::string(), Payload::term()) ->
|
|
%% {error, Reason::stanzaError()} |
|
|
%% {result, []}
|
|
%% @doc <p>Publish item to a PubSub node.</p>
|
|
%% <p>The permission to publish an item must be verified by the plugin implementation.</p>
|
|
%%<p>There are several reasons why the publish request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The requesting entity does not have sufficient privileges to publish.</li>
|
|
%%<li>The node does not support item publication.</li>
|
|
%%<li>The node does not exist.</li>
|
|
%%<li>The payload size exceeds a service-defined limit.</li>
|
|
%%<li>The item contains more than one payload element or the namespace of the root payload element does not match the configured namespace for the node.</li>
|
|
%%<li>The request does not match the node configuration.</li>
|
|
%%</ul>
|
|
publish_item(Host, ServerHost, Node, Publisher, "", Payload) ->
|
|
%% if publisher does not specify an ItemId, the service MUST generate the ItemId
|
|
publish_item(Host, ServerHost, Node, Publisher, uniqid(), Payload);
|
|
publish_item(Host, ServerHost, Node, Publisher, ItemId, Payload) ->
|
|
Action = fun(#pubsub_node{options = Options, type = Type}) ->
|
|
Features = features(Type),
|
|
PublishFeature = lists:member("publish", Features),
|
|
PublishModel = get_option(Options, publish_model),
|
|
MaxItems = max_items(Options),
|
|
PayloadCount = payload_xmlelements(Payload),
|
|
PayloadSize = size(term_to_binary(Payload)),
|
|
PayloadMaxSize = get_option(Options, max_payload_size),
|
|
% pubsub#deliver_payloads true
|
|
% pubsub#persist_items true -> 1 item; false -> 0 item
|
|
if
|
|
not PublishFeature ->
|
|
%% Node does not support item publication
|
|
{error, extended_error('feature-not-implemented', unsupported, "publish")};
|
|
PayloadSize > PayloadMaxSize ->
|
|
%% Entity attempts to publish very large payload
|
|
{error, extended_error('not-acceptable', "payload-too-big")};
|
|
PayloadCount > 1 ->
|
|
%% Entity attempts to publish item with multiple payload elements
|
|
{error, extended_error('bad-request', "invalid-payload")};
|
|
Payload == "" ->
|
|
%% Publisher attempts to publish to payload node with no payload
|
|
{error, extended_error('bad-request', "payload-required")};
|
|
(MaxItems == 0) and (PayloadSize > 0) ->
|
|
% Publisher attempts to publish to transient notification node with item
|
|
{error, extended_error('bad-request', "item-forbidden")};
|
|
(MaxItems > 0) and (PayloadSize == 0) ->
|
|
% Publisher attempts to publish to persistent node with no item
|
|
{error, extended_error('bad-request', "item-required")};
|
|
true ->
|
|
node_call(Type, publish_item, [Host, Node, Publisher, PublishModel, MaxItems, ItemId, Payload])
|
|
end
|
|
end,
|
|
ejabberd_hooks:run(pubsub_publish_item, ServerHost, [ServerHost, Node, Publisher, service_jid(Host), ItemId, Payload]),
|
|
Reply = [],
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, 'item-not-found'} ->
|
|
%% handles auto-create feature
|
|
%% for automatic node creation. we'll take the default node type:
|
|
%% first listed into the plugins configuration option, or pep
|
|
Type = select_type(ServerHost, Host, Node),
|
|
case lists:member("auto-create", features(Type)) of
|
|
true ->
|
|
case create_node(Host, ServerHost, Node, Publisher, Type) of
|
|
{result, _} ->
|
|
publish_item(Host, ServerHost, Node, Publisher, ItemId, Payload);
|
|
_ ->
|
|
{error, 'item-not-found'}
|
|
end;
|
|
false ->
|
|
{error, 'item-not-found'}
|
|
end;
|
|
{error, Reason} ->
|
|
{error, Reason};
|
|
{result, {Result, broadcast, Removed}} ->
|
|
broadcast_retract_items(Host, Node, Removed),
|
|
broadcast_publish_item(Host, Node, ItemId, jlib:short_prepd_jid(Publisher), Payload),
|
|
case Result of
|
|
default -> {result, Reply};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, default, Removed} ->
|
|
broadcast_retract_items(Host, Node, Removed),
|
|
{result, Reply};
|
|
{result, Result, Removed} ->
|
|
broadcast_retract_items(Host, Node, Removed),
|
|
{result, Result};
|
|
{result, default} ->
|
|
{result, Reply};
|
|
{result, Result} ->
|
|
{result, Result}
|
|
end.
|
|
|
|
%% @spec (Host::host(), JID::jid(), Node::pubsubNode(), ItemId::string()) ->
|
|
%% {error, Reason::stanzaError()} |
|
|
%% {result, []}
|
|
%% @doc <p>Delete item from a PubSub node.</p>
|
|
%% <p>The permission to delete an item must be verified by the plugin implementation.</p>
|
|
%%<p>There are several reasons why the item retraction request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The publisher does not have sufficient privileges to delete the requested item.</li>
|
|
%%<li>The node or item does not exist.</li>
|
|
%%<li>The request does not specify a node.</li>
|
|
%%<li>The request does not include an <item/> element or the <item/> element does not specify an ItemId.</li>
|
|
%%<li>The node does not support persistent items.</li>
|
|
%%<li>The service does not support the deletion of items.</li>
|
|
%%</ul>
|
|
delete_item(Host, Node, Publisher, ItemId) ->
|
|
delete_item(Host, Node, Publisher, ItemId, false).
|
|
delete_item(_, "", _, _, _) ->
|
|
%% Request does not specify a node
|
|
{error, extended_error('bad-request', "node-required")};
|
|
delete_item(Host, Node, Publisher, ItemId, ForceNotify) ->
|
|
Action = fun(#pubsub_node{type = Type}) ->
|
|
Features = features(Type),
|
|
PersistentFeature = lists:member("persistent-items", Features),
|
|
DeleteFeature = lists:member("delete-any", Features),
|
|
if
|
|
%%-> iq_pubsub just does that matchs
|
|
%% %% Request does not specify an item
|
|
%% {error, extended_error('bad-request', "item-required")};
|
|
not PersistentFeature ->
|
|
%% Node does not support persistent items
|
|
{error, extended_error('feature-not-implemented', unsupported, "persistent-items")};
|
|
not DeleteFeature ->
|
|
%% Service does not support item deletion
|
|
{error, extended_error('feature-not-implemented', unsupported, "delete-any")};
|
|
true ->
|
|
node_call(Type, delete_item, [Host, Node, Publisher, ItemId])
|
|
end
|
|
end,
|
|
Reply = [],
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, Reason} ->
|
|
{error, Reason};
|
|
{result, {Result, broadcast}} ->
|
|
broadcast_retract_items(Host, Node, [ItemId], ForceNotify),
|
|
case Result of
|
|
default -> {result, Reply};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, default} ->
|
|
{result, Reply};
|
|
{result, Result} ->
|
|
{result, Result}
|
|
end.
|
|
|
|
%% @spec (Host, JID, Node) ->
|
|
%% {error, Reason} | {result, []}
|
|
%% Host = host()
|
|
%% Node = pubsubNode()
|
|
%% JID = jid()
|
|
%% Reason = stanzaError()
|
|
%% @doc <p>Delete all items of specified node owned by JID.</p>
|
|
%%<p>There are several reasons why the node purge request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The node or service does not support node purging.</li>
|
|
%%<li>The requesting entity does not have sufficient privileges to purge the node.</li>
|
|
%%<li>The node is not configured to persist items.</li>
|
|
%%<li>The specified node does not exist.</li>
|
|
%%</ul>
|
|
purge_node(Host, Node, Owner) ->
|
|
Action = fun(#pubsub_node{type = Type, options = Options}) ->
|
|
Features = features(Type),
|
|
PurgeFeature = lists:member("purge-nodes", Features),
|
|
PersistentFeature = lists:member("persistent-items", Features),
|
|
PersistentConfig = get_option(Options, persist_items),
|
|
if
|
|
not PurgeFeature ->
|
|
%% Service does not support node purging
|
|
{error, extended_error('feature-not-implemented', unsupported, "purge-nodes")};
|
|
not PersistentFeature ->
|
|
%% Node does not support persistent items
|
|
{error, extended_error('feature-not-implemented', unsupported, "persistent-items")};
|
|
not PersistentConfig ->
|
|
%% Node is not configured for persistent items
|
|
{error, extended_error('feature-not-implemented', unsupported, "persistent-items")};
|
|
true ->
|
|
node_call(Type, purge_node, [Host, Node, Owner])
|
|
end
|
|
end,
|
|
Reply = [],
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, Reason} ->
|
|
{error, Reason};
|
|
{result, {Result, broadcast}} ->
|
|
broadcast_purge_node(Host, Node),
|
|
case Result of
|
|
default -> {result, Reply};
|
|
_ -> {result, Result}
|
|
end;
|
|
{result, default} ->
|
|
{result, Reply};
|
|
{result, Result} ->
|
|
{result, Result}
|
|
end.
|
|
|
|
%% @doc <p>Return the items of a given node.</p>
|
|
%% <p>The number of items to return is limited by MaxItems.</p>
|
|
%% <p>The permission are not checked in this function.</p>
|
|
%% @todo We probably need to check that the user doing the query has the right
|
|
%% to read the items.
|
|
get_items(Host, Node, From, SubId, SMaxItems, ItemIDs) ->
|
|
MaxItems =
|
|
if
|
|
SMaxItems == "" -> ?MAXITEMS;
|
|
true ->
|
|
case catch list_to_integer(SMaxItems) of
|
|
{'EXIT', _} -> {error, 'bad-request'};
|
|
Val -> Val
|
|
end
|
|
end,
|
|
case MaxItems of
|
|
{error, Error} ->
|
|
{error, Error};
|
|
_ ->
|
|
Action = fun(#pubsub_node{options = Options, type = Type}) ->
|
|
Features = features(Type),
|
|
RetreiveFeature = lists:member("retrieve-items", Features),
|
|
PersistentFeature = lists:member("persistent-items", Features),
|
|
AccessModel = get_option(Options, access_model),
|
|
AllowedGroups = get_option(Options, roster_groups_allowed, []),
|
|
{PresenceSubscription, RosterGroup} =
|
|
case Host of
|
|
{OUser, OServer, _} ->
|
|
get_roster_info(OUser, OServer,
|
|
jlib:short_prepd_jid(From), AllowedGroups);
|
|
_ ->
|
|
{true, true}
|
|
end,
|
|
if
|
|
not RetreiveFeature ->
|
|
%% Item Retrieval Not Supported
|
|
{error, extended_error('feature-not-implemented', unsupported, "retrieve-items")};
|
|
not PersistentFeature ->
|
|
%% Persistent Items Not Supported
|
|
{error, extended_error('feature-not-implemented', unsupported, "persistent-items")};
|
|
true ->
|
|
node_call(Type, get_items,
|
|
[Host, Node, From,
|
|
AccessModel, PresenceSubscription, RosterGroup,
|
|
SubId])
|
|
end
|
|
end,
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, Reason} ->
|
|
{error, Reason};
|
|
{result, Items} ->
|
|
SendItems = case ItemIDs of
|
|
[] ->
|
|
Items;
|
|
_ ->
|
|
lists:filter(fun(#pubsub_item{itemid = {ItemId, _}}) ->
|
|
lists:member(ItemId, ItemIDs)
|
|
end, Items)
|
|
end,
|
|
%% Generate the XML response (Item list), limiting the
|
|
%% number of items sent to MaxItems:
|
|
ItemsEls = lists:map(
|
|
fun(#pubsub_item{itemid = {ItemId, _},
|
|
payload = Payload}) ->
|
|
ItemAttrs = case ItemId of
|
|
"" -> [];
|
|
_ -> [?XMLATTR('id', ItemId)]
|
|
end,
|
|
#xmlel{ns = ?NS_PUBSUB, name = 'item', attrs = ItemAttrs, children = Payload}
|
|
end, lists:sublist(SendItems, MaxItems)),
|
|
{result, [#xmlel{ns = ?NS_PUBSUB, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'items', attrs = [?XMLATTR('node', node_to_string(Node))], children =
|
|
ItemsEls}]}]}
|
|
end
|
|
end.
|
|
|
|
get_items(Host, Node, From) ->
|
|
case node_action(Host, Node, get_items, [Host, Node, From]) of
|
|
{result, Items} -> Items;
|
|
_ -> []
|
|
end.
|
|
|
|
%% @spec (Host, Node, LJID) -> any()
|
|
%% Host = host()
|
|
%% Node = pubsubNode()
|
|
%% LJID = {U, S, []}
|
|
%% @doc <p>Resend the last item of a node to the user.</p>
|
|
send_last_item(Host, Node, LJID) ->
|
|
send_items(Host, Node, LJID, last).
|
|
|
|
%% @spec (Host, Node, LJID, Number) -> any()
|
|
%% Host = host()
|
|
%% Node = pubsubNode()
|
|
%% LJID = {U, S, []}
|
|
%% Number = last | integer()
|
|
%% @doc <p>Resend the items of a node to the user.</p>
|
|
%% @todo use cache-last-item feature
|
|
send_items(Host, Node, {LU, LS, LR} = LJID, Number) ->
|
|
ToSend = case get_items(Host, Node, LJID) of
|
|
[] ->
|
|
[];
|
|
Items ->
|
|
case Number of
|
|
last ->
|
|
%%% [lists:last(Items)] does not work on clustered table
|
|
[First|Tail] = Items,
|
|
[lists:foldl(
|
|
fun(CurItem, LastItem) ->
|
|
{_, LTimeStamp} = LastItem#pubsub_item.creation,
|
|
{_, CTimeStamp} = CurItem#pubsub_item.creation,
|
|
if
|
|
CTimeStamp > LTimeStamp -> CurItem;
|
|
true -> LastItem
|
|
end
|
|
end, First, Tail)];
|
|
N when N > 0 ->
|
|
%%% This case is buggy on clustered table due to lake of order
|
|
lists:nthtail(length(Items)-N, Items);
|
|
_ ->
|
|
Items
|
|
end
|
|
end,
|
|
ItemsEls = lists:map(
|
|
fun(#pubsub_item{itemid = {ItemId, _}, payload = Payload}) ->
|
|
ItemAttrs = case ItemId of
|
|
"" -> [];
|
|
_ -> [?XMLATTR('id', ItemId)]
|
|
end,
|
|
#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'item', attrs = ItemAttrs, children = Payload}
|
|
end, ToSend),
|
|
Stanza = event_stanza(
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'items', attrs = [?XMLATTR('node', node_to_string(Node))], children =
|
|
ItemsEls}]),
|
|
ejabberd_router ! {route, service_jid(Host), exmpp_jid:make_jid(LU, LS, LR), Stanza}.
|
|
|
|
%% @spec (Host, JID, Plugins) -> {error, Reason} | {result, Response}
|
|
%% Host = host()
|
|
%% JID = jid()
|
|
%% Plugins = [Plugin::string()]
|
|
%% Reason = stanzaError()
|
|
%% Response = [pubsubIQResponse()]
|
|
%% @doc <p>Return the list of affiliations as an XMPP response.</p>
|
|
get_affiliations(Host, JID, Plugins) when is_list(Plugins) ->
|
|
Result = lists:foldl(
|
|
fun(Type, {Status, Acc}) ->
|
|
Features = features(Type),
|
|
RetrieveFeature = lists:member("retrieve-affiliations", Features),
|
|
if
|
|
not RetrieveFeature ->
|
|
%% Service does not support retreive affiliatons
|
|
{{error, extended_error('feature-not-implemented', unsupported, "retrieve-affiliations")}, Acc};
|
|
true ->
|
|
{result, Affiliations} = node_action(Type, get_entity_affiliations, [Host, JID]),
|
|
{Status, [Affiliations|Acc]}
|
|
end
|
|
end, {ok, []}, Plugins),
|
|
case Result of
|
|
{ok, Affiliations} ->
|
|
Entities = lists:flatmap(
|
|
fun({_, none}) -> [];
|
|
({Node, Affiliation}) ->
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'affiliation', attrs =
|
|
[?XMLATTR('node', node_to_string(Node)),
|
|
?XMLATTR('affiliation', affiliation_to_string(Affiliation))]}]
|
|
end, lists:usort(lists:flatten(Affiliations))),
|
|
{result, [#xmlel{ns = ?NS_PUBSUB, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'affiliations', children =
|
|
Entities}]}]};
|
|
{Error, _} ->
|
|
Error
|
|
end;
|
|
get_affiliations(Host, Node, JID) ->
|
|
Action = fun(#pubsub_node{type = Type}) ->
|
|
Features = features(Type),
|
|
RetrieveFeature = lists:member("modify-affiliations", Features),
|
|
Affiliation = node_call(Type, get_affiliation, [Host, Node, JID]),
|
|
if
|
|
not RetrieveFeature ->
|
|
%% Service does not support modify affiliations
|
|
{error, extended_error('feature-not-implemented', unsupported, "modify-affiliations")};
|
|
Affiliation /= {result, owner} ->
|
|
%% Entity is not an owner
|
|
{error, 'forbidden'};
|
|
true ->
|
|
node_call(Type, get_node_affiliations, [Host, Node])
|
|
end
|
|
end,
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, Reason} ->
|
|
{error, Reason};
|
|
{result, []} ->
|
|
{error, 'item-not-found'};
|
|
{result, Affiliations} ->
|
|
Entities = lists:flatmap(
|
|
fun({_, none}) -> [];
|
|
({{AU, AS, AR}, Affiliation}) ->
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'affiliation', attrs =
|
|
[?XMLATTR('jid', exmpp_jid:jid_to_binary(AU, AS, AR)),
|
|
?XMLATTR('affiliation', affiliation_to_string(Affiliation))]}]
|
|
end, Affiliations),
|
|
{result, [#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'affiliations', attrs = [?XMLATTR('node', node_to_string(Node))], children =
|
|
Entities}]}]}
|
|
end.
|
|
|
|
set_affiliations(Host, Node, From, EntitiesEls) ->
|
|
Owner = jlib:short_prepd_bare_jid(From),
|
|
Entities =
|
|
lists:foldl(
|
|
fun(El, Acc) ->
|
|
case Acc of
|
|
error ->
|
|
error;
|
|
_ ->
|
|
case El of
|
|
#xmlel{name = 'affiliation', attrs = Attrs} ->
|
|
JID = try
|
|
exmpp_jid:parse_jid(
|
|
exmpp_xml:get_attribute_from_list_as_list(Attrs, 'jid', ""))
|
|
catch
|
|
_:_ -> error
|
|
end,
|
|
Affiliation = string_to_affiliation(
|
|
exmpp_xml:get_attribute_from_list_as_list(Attrs, 'affiliation', false)),
|
|
if
|
|
(JID == error) or
|
|
(Affiliation == false) ->
|
|
error;
|
|
true ->
|
|
[{jlib:short_prepd_jid(JID), Affiliation} | Acc]
|
|
end
|
|
end
|
|
end
|
|
end, [], EntitiesEls),
|
|
case Entities of
|
|
error ->
|
|
{error, 'bad-request'};
|
|
_ ->
|
|
Action = fun(#pubsub_node{type = Type, owners = Owners}=N) ->
|
|
case lists:member(Owner, Owners) of
|
|
true ->
|
|
lists:foreach(
|
|
fun({JID, Affiliation}) ->
|
|
node_call(Type, set_affiliation, [Host, Node, JID, Affiliation]),
|
|
case Affiliation of
|
|
owner ->
|
|
NewOwner = jlib:short_prepd_bare_jid(JID),
|
|
NewOwners = [NewOwner|Owners],
|
|
tree_call(Host, set_node, [N#pubsub_node{owners = NewOwners}]);
|
|
none ->
|
|
OldOwner = jlib:short_prepd_bare_jid(JID),
|
|
case lists:member(OldOwner, Owners) of
|
|
true ->
|
|
NewOwners = Owners--[OldOwner],
|
|
tree_call(Host, set_node, [N#pubsub_node{owners = NewOwners}]);
|
|
_ ->
|
|
ok
|
|
end;
|
|
_ ->
|
|
ok
|
|
end
|
|
end, Entities),
|
|
{result, []};
|
|
_ ->
|
|
{error, 'forbidden'}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty)
|
|
end.
|
|
|
|
|
|
%% @spec (Host, JID, Plugins) -> {error, Reason} | {result, Response}
|
|
%% Host = host()
|
|
%% JID = jid()
|
|
%% Plugins = [Plugin::string()]
|
|
%% Reason = stanzaError()
|
|
%% Response = [pubsubIQResponse()]
|
|
%% @doc <p>Return the list of subscriptions as an XMPP response.</p>
|
|
get_subscriptions(Host, JID, Plugins) when is_list(Plugins) ->
|
|
Result = lists:foldl(
|
|
fun(Type, {Status, Acc}) ->
|
|
Features = features(Type),
|
|
RetrieveFeature = lists:member("retrieve-subscriptions", Features),
|
|
if
|
|
not RetrieveFeature ->
|
|
%% Service does not support retreive subscriptions
|
|
{{error, extended_error('feature-not-implemented', unsupported, "retrieve-subscriptions")}, Acc};
|
|
true ->
|
|
Subscriber = jlib:jid_remove_resource(JID),
|
|
{result, Subscriptions} = node_action(Type, get_entity_subscriptions, [Host, Subscriber]),
|
|
{Status, [Subscriptions|Acc]}
|
|
end
|
|
end, {ok, []}, Plugins),
|
|
case Result of
|
|
{ok, Subscriptions} ->
|
|
Entities = lists:flatmap(
|
|
fun({_, none}) -> [];
|
|
({Node, Subscription}) ->
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'subscription', attrs =
|
|
[?XMLATTR('node', node_to_string(Node)),
|
|
?XMLATTR('subscription', subscription_to_string(Subscription))]}];
|
|
({_, none, _}) -> [];
|
|
({Node, Subscription, SubJID}) ->
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'subscription', attrs =
|
|
[?XMLATTR('node', node_to_string(Node)),
|
|
?XMLATTR('jid', exmpp_jid:jid_to_binary(SubJID)),
|
|
?XMLATTR('subscription', subscription_to_string(Subscription))]}]
|
|
end, lists:usort(lists:flatten(Subscriptions))),
|
|
{result, [#xmlel{ns = ?NS_PUBSUB, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB, name = 'subscriptions', children =
|
|
Entities}]}]};
|
|
{Error, _} ->
|
|
Error
|
|
end;
|
|
get_subscriptions(Host, Node, JID) ->
|
|
Action = fun(#pubsub_node{type = Type}) ->
|
|
Features = features(Type),
|
|
RetrieveFeature = lists:member("manage-subscriptions", Features),
|
|
Affiliation = node_call(Type, get_affiliation, [Host, Node, JID]),
|
|
if
|
|
not RetrieveFeature ->
|
|
%% Service does not support manage subscriptions
|
|
{error, extended_error('feature-not-implemented', unsupported, "manage-affiliations")};
|
|
Affiliation /= {result, owner} ->
|
|
%% Entity is not an owner
|
|
{error, 'forbidden'};
|
|
true ->
|
|
node_call(Type, get_node_subscriptions, [Host, Node])
|
|
end
|
|
end,
|
|
case transaction(Host, Node, Action, sync_dirty) of
|
|
{error, Reason} ->
|
|
{error, Reason};
|
|
{result, []} ->
|
|
{error, 'item-not-found'};
|
|
{result, Subscriptions} ->
|
|
Entities = lists:flatmap(
|
|
fun({_, none}) -> [];
|
|
({{AU, AS, AR}, Subscription}) ->
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'subscription', attrs =
|
|
[?XMLATTR('jid', exmpp_jid:jid_to_binary(AU, AS, AR)),
|
|
?XMLATTR('subscription', subscription_to_string(Subscription))]}];
|
|
({{AU, AS, AR}, Subscription, SubId}) ->
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'subscription', attrs =
|
|
[?XMLATTR('jid', exmpp_jid:jid_to_binary(AU, AS, AR)),
|
|
?XMLATTR('subscription', subscription_to_string(Subscription)),
|
|
?XMLATTR('subid', SubId)]}]
|
|
end, Subscriptions),
|
|
{result, [#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'subscriptions', attrs = [?XMLATTR('node', node_to_string(Node))], children =
|
|
Entities}]}]}
|
|
end.
|
|
|
|
set_subscriptions(Host, Node, From, EntitiesEls) ->
|
|
Owner = jlib:short_prepd_bare_jid(From),
|
|
Entities =
|
|
lists:foldl(
|
|
fun(El, Acc) ->
|
|
case Acc of
|
|
error ->
|
|
error;
|
|
_ ->
|
|
case El of
|
|
#xmlel{name = 'subscription', attrs = Attrs} ->
|
|
JID = try
|
|
exmpp_jid:parse_jid(
|
|
exmpp_xml:get_attribute_from_list_as_list(Attrs, 'jid', ""))
|
|
catch
|
|
_:_ ->
|
|
error
|
|
end,
|
|
Subscription = string_to_subscription(
|
|
exmpp_xml:get_attribute_from_list_as_list(Attrs, 'subscription', false)),
|
|
if
|
|
(JID == error) or
|
|
(Subscription == false) ->
|
|
error;
|
|
true ->
|
|
[{jlib:short_prepd_jid(JID), Subscription} | Acc]
|
|
end
|
|
end
|
|
end
|
|
end, [], EntitiesEls),
|
|
case Entities of
|
|
error ->
|
|
{error, 'bad-request'};
|
|
_ ->
|
|
Action = fun(#pubsub_node{type = Type, owners = Owners}) ->
|
|
case lists:member(Owner, Owners) of
|
|
true ->
|
|
lists:foreach(
|
|
fun({JID, Subscription}) ->
|
|
node_call(
|
|
Type, set_subscription,
|
|
[Host, Node, JID, Subscription])
|
|
end, Entities),
|
|
{result, []};
|
|
_ ->
|
|
{error, 'forbidden'}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty)
|
|
end.
|
|
|
|
|
|
%% @spec (OwnerUser, OwnerServer, {SubscriberUser, SubscriberServer, SubscriberResource}, AllowedGroups)
|
|
%% -> {PresenceSubscription, RosterGroup}
|
|
get_roster_info(OwnerUser, OwnerServer, {SubscriberUser, SubscriberServer, _}, AllowedGroups) ->
|
|
{Subscription, Groups} =
|
|
ejabberd_hooks:run_fold(
|
|
roster_get_jid_info, OwnerServer,
|
|
{none, []},
|
|
[OwnerUser, OwnerServer, {SubscriberUser, SubscriberServer, undefined}]),
|
|
PresenceSubscription = (Subscription == both) orelse (Subscription == from)
|
|
orelse ({OwnerUser, OwnerServer} == {SubscriberUser, SubscriberServer}),
|
|
RosterGroup = lists:any(fun(Group) ->
|
|
lists:member(Group, AllowedGroups)
|
|
end, Groups),
|
|
{PresenceSubscription, RosterGroup}.
|
|
|
|
%% @spec (AffiliationStr) -> Affiliation
|
|
%% AffiliationStr = string()
|
|
%% Affiliation = atom()
|
|
%% @doc <p>Convert an affiliation type from string to atom.</p>
|
|
string_to_affiliation("owner") -> owner;
|
|
string_to_affiliation("publisher") -> publisher;
|
|
string_to_affiliation("member") -> member;
|
|
string_to_affiliation("outcast") -> outcast;
|
|
string_to_affiliation("none") -> none;
|
|
string_to_affiliation(_) -> false.
|
|
|
|
%% @spec (SubscriptionStr) -> Subscription
|
|
%% SubscriptionStr = string()
|
|
%% Subscription = atom()
|
|
%% @doc <p>Convert a subscription type from string to atom.</p>
|
|
string_to_subscription("subscribed") -> subscribed;
|
|
string_to_subscription("pending") -> pending;
|
|
string_to_subscription("unconfigured") -> unconfigured;
|
|
string_to_subscription("none") -> none;
|
|
string_to_subscription(_) -> false.
|
|
|
|
%% @spec (Affiliation) -> AffiliationStr
|
|
%% Affiliation = atom()
|
|
%% AffiliationStr = string()
|
|
%% @doc <p>Convert an affiliation type from atom to string.</p>
|
|
affiliation_to_string(owner) -> "owner";
|
|
affiliation_to_string(publisher) -> "publisher";
|
|
affiliation_to_string(member) -> "member";
|
|
affiliation_to_string(outcast) -> "outcast";
|
|
affiliation_to_string(_) -> "none".
|
|
|
|
%% @spec (Subscription) -> SubscriptionStr
|
|
%% Subscription = atom()
|
|
%% SubscriptionStr = string()
|
|
%% @doc <p>Convert a subscription type from atom to string.</p>
|
|
subscription_to_string(subscribed) -> "subscribed";
|
|
subscription_to_string(pending) -> "pending";
|
|
subscription_to_string(unconfigured) -> "unconfigured";
|
|
subscription_to_string(_) -> "none".
|
|
|
|
%% @spec (Node) -> NodeStr
|
|
%% Node = pubsubNode()
|
|
%% NodeStr = string()
|
|
%% @doc <p>Convert a node type from pubsubNode to string.</p>
|
|
node_to_string([]) -> "/";
|
|
node_to_string(Node) ->
|
|
case Node of
|
|
[[_ | _] | _] -> string:strip(lists:flatten(["/", lists:map(fun(S) -> [S, "/"] end, Node)]), right, $/);
|
|
[Head | _] when is_integer(Head) -> Node
|
|
end.
|
|
string_to_node(SNode) ->
|
|
string:tokens(SNode, "/").
|
|
|
|
%% @spec (Host) -> jid()
|
|
%% Host = host()
|
|
%% @doc <p>Generate pubsub service JID.</p>
|
|
service_jid(Host) ->
|
|
case Host of
|
|
{U,S,_} -> exmpp_jid:make_jid(U, S);
|
|
_ -> exmpp_jid:make_jid(Host)
|
|
end.
|
|
|
|
%% @spec (LJID, Subscription, PresenceDelivery) -> boolean()
|
|
%% LJID = jid()
|
|
%% Subscription = atom()
|
|
%% PresenceDelivery = boolean()
|
|
%% @doc <p>Check if a notification must be delivered or not.</p>
|
|
is_to_deliver(_, none, _) -> false;
|
|
is_to_deliver(_, pending, _) -> false;
|
|
is_to_deliver(_, _, false) -> true;
|
|
is_to_deliver({User, Server, _}, _, true) ->
|
|
case mnesia:dirty_match_object({session, '_', '_', {User, Server}, '_', '_'}) of
|
|
[] -> false;
|
|
Ss ->
|
|
lists:foldl(fun({session, _, _, _, undefined, _}, Acc) -> Acc;
|
|
({session, _, _, _, _Priority, _}, _Acc) -> true
|
|
end, false, Ss)
|
|
end.
|
|
|
|
%% @spec (Payload) -> int()
|
|
%% Payload = term()
|
|
%% @doc <p>Count occurence of XML elements in payload.</p>
|
|
payload_xmlelements(Payload) -> payload_xmlelements(Payload, 0).
|
|
payload_xmlelements([], Count) -> Count;
|
|
payload_xmlelements([#xmlel{}|Tail], Count) -> payload_xmlelements(Tail, Count+1);
|
|
payload_xmlelements([_|Tail], Count) -> payload_xmlelements(Tail, Count).
|
|
|
|
%% @spec (Els) -> stanza()
|
|
%% Els = [xmlelement()]
|
|
%% @doc <p>Build pubsub event stanza</p>
|
|
event_stanza(Els) ->
|
|
#xmlel{ns = ?NS_JABBER_CLIENT, name = 'message', children =
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'event', children = Els}]}.
|
|
|
|
%%%%%% broadcast functions
|
|
|
|
broadcast_publish_item(Host, Node, ItemId, _From, Payload) ->
|
|
Action =
|
|
fun(#pubsub_node{options = Options, type = Type}) ->
|
|
case node_call(Type, get_states, [Host, Node]) of
|
|
{result, []} ->
|
|
{result, false};
|
|
{result, States} ->
|
|
Content = case get_option(Options, deliver_payloads) of
|
|
true -> Payload;
|
|
false -> []
|
|
end,
|
|
ItemAttrs = case ItemId of
|
|
"" -> [];
|
|
_ -> [?XMLATTR('id', ItemId)]
|
|
end,
|
|
Stanza = event_stanza(
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'items', attrs = [?XMLATTR('node', node_to_string(Node))], children =
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'item', attrs = ItemAttrs, children = Content}]}]),
|
|
broadcast_stanza(Host, Options, States, Stanza),
|
|
broadcast_by_caps(Host, Node, Type, Stanza),
|
|
{result, true};
|
|
_ ->
|
|
{result, false}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty).
|
|
|
|
broadcast_retract_items(Host, Node, ItemIds) ->
|
|
broadcast_retract_items(Host, Node, ItemIds, false).
|
|
broadcast_retract_items(Host, Node, ItemIds, ForceNotify) ->
|
|
Action =
|
|
fun(#pubsub_node{options = Options, type = Type}) ->
|
|
case (get_option(Options, notify_retract) or ForceNotify) of
|
|
true ->
|
|
case node_call(Type, get_states, [Host, Node]) of
|
|
{result, []} ->
|
|
{result, false};
|
|
{result, States} ->
|
|
RetractEls = lists:map(
|
|
fun(ItemId) ->
|
|
ItemAttrs = case ItemId of
|
|
"" -> [];
|
|
_ -> [?XMLATTR('id', ItemId)]
|
|
end,
|
|
#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'retract', attrs = ItemAttrs}
|
|
end, ItemIds),
|
|
Stanza = event_stanza(
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'items', attrs = [?XMLATTR('node', node_to_string(Node))],
|
|
children = RetractEls}]),
|
|
broadcast_stanza(Host, Options, States, Stanza),
|
|
broadcast_by_caps(Host, Node, Type, Stanza),
|
|
{result, true};
|
|
_ ->
|
|
{result, false}
|
|
end;
|
|
_ ->
|
|
{result, false}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty).
|
|
|
|
broadcast_purge_node(Host, Node) ->
|
|
Action =
|
|
fun(#pubsub_node{options = Options, type = Type}) ->
|
|
case get_option(Options, notify_retract) of
|
|
true ->
|
|
case node_call(Type, get_states, [Host, Node]) of
|
|
{result, []} ->
|
|
{result, false};
|
|
{result, States} ->
|
|
Stanza = event_stanza(
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'purge', attrs = [?XMLATTR('node', node_to_string(Node))]}]),
|
|
broadcast_stanza(Host, Options, States, Stanza),
|
|
broadcast_by_caps(Host, Node, Type, Stanza),
|
|
{result, true};
|
|
_ ->
|
|
{result, false}
|
|
end;
|
|
_ ->
|
|
{result, false}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty).
|
|
|
|
broadcast_removed_node(Host, Node) ->
|
|
Action =
|
|
fun(#pubsub_node{options = Options, type = Type}) ->
|
|
case get_option(Options, notify_delete) of
|
|
true ->
|
|
case node_call(Type, get_states, [Host, Node]) of
|
|
{result, []} ->
|
|
{result, false};
|
|
{result, States} ->
|
|
Stanza = event_stanza(
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'delete', attrs = [?XMLATTR('node', node_to_string(Node))]}]),
|
|
broadcast_stanza(Host, Options, States, Stanza),
|
|
broadcast_by_caps(Host, Node, Type, Stanza),
|
|
{result, true};
|
|
_ ->
|
|
{result, false}
|
|
end;
|
|
_ ->
|
|
{result, false}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty).
|
|
|
|
broadcast_config_notification(Host, Node, Lang) ->
|
|
Action =
|
|
fun(#pubsub_node{options = Options, owners = Owners, type = Type}) ->
|
|
case get_option(Options, notify_config) of
|
|
true ->
|
|
case node_call(Type, get_states, [Host, Node]) of
|
|
{result, []} ->
|
|
{result, false};
|
|
{result, States} ->
|
|
Content = case get_option(Options, deliver_payloads) of
|
|
true ->
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'x', attrs = [?XMLATTR('type', <<"form">>)], children =
|
|
get_configure_xfields(Type, Options, Lang, Owners)}];
|
|
false ->
|
|
[]
|
|
end,
|
|
Stanza = event_stanza(
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'items', attrs = [?XMLATTR('node', node_to_string(Node))], children =
|
|
[#xmlel{ns = ?NS_PUBSUB_EVENT, name = 'item', attrs = [?XMLATTR('id', <<"configuration">>)], children =
|
|
Content}]}]),
|
|
broadcast_stanza(Host, Options, States, Stanza),
|
|
broadcast_by_caps(Host, Node, Type, Stanza),
|
|
{result, true};
|
|
_ ->
|
|
{result, false}
|
|
end;
|
|
_ ->
|
|
{result, false}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty).
|
|
|
|
broadcast_stanza(Host, NodeOpts, States, Stanza) ->
|
|
PresenceDelivery = get_option(NodeOpts, presence_based_delivery),
|
|
BroadcastAll = get_option(NodeOpts, broadcast_all_resources), %% XXX this is not standard
|
|
From = service_jid(Host),
|
|
lists:foreach(fun(#pubsub_state{stateid = {LJID, _}, subscription = Subs}) ->
|
|
case is_to_deliver(LJID, Subs, PresenceDelivery) of
|
|
true ->
|
|
JIDs = case BroadcastAll of
|
|
true -> ejabberd_sm:get_user_resources(element(1, LJID), element(2, LJID));
|
|
false -> [LJID]
|
|
end,
|
|
lists:foreach(fun({U, S, R}) ->
|
|
ejabberd_router ! {route, From, exmpp_jlib:make_jid(U, S, R), Stanza}
|
|
end, JIDs);
|
|
false ->
|
|
ok
|
|
end
|
|
end, States).
|
|
|
|
%% broadcast Stanza to all contacts of the user that are advertising
|
|
%% interest in this kind of Node.
|
|
broadcast_by_caps({LUser, LServer, LResource}, Node, _Type, Stanza) ->
|
|
SenderResource = user_resource(LUser, LServer, LResource),
|
|
case ejabberd_sm:get_session_pid(LUser, LServer, SenderResource) of
|
|
C2SPid when is_pid(C2SPid) ->
|
|
%% set the from address on the notification to the bare JID of the account owner
|
|
%% Also, add "replyto" if entity has presence subscription to the account owner
|
|
%% See XEP-0163 1.1 section 4.3.1
|
|
Sender = exmpp_jid:make_jid(LUser, LServer),
|
|
%%ReplyTo = jlib:make_jid(LUser, LServer, SenderResource), % This has to be used
|
|
case catch ejabberd_c2s:get_subscribed(C2SPid) of
|
|
Contacts when is_list(Contacts) ->
|
|
lists:foreach(fun({U, S, R}) ->
|
|
OR = user_resource(U, S, R),
|
|
case is_caps_notify(LServer, Node, {U, S, OR}) of
|
|
true ->
|
|
ejabberd_router ! {route, Sender, exmpp_jid:make_jid(U, S, OR), Stanza};
|
|
false ->
|
|
ok
|
|
end
|
|
end, Contacts);
|
|
_ ->
|
|
ok
|
|
end,
|
|
ok;
|
|
_ ->
|
|
?DEBUG("~p@~p has no session; can't deliver ~p to contacts", [LUser, LServer, Stanza]),
|
|
ok
|
|
end;
|
|
broadcast_by_caps(_, _, _, _) ->
|
|
ok.
|
|
|
|
%% If we don't know the resource, just pick first if any
|
|
%% If no resource available, check if caps anyway (remote online)
|
|
user_resource(LUser, LServer, []) ->
|
|
case ejabberd_sm:get_user_resources(LUser, LServer) of
|
|
[R|_] ->
|
|
R;
|
|
[] ->
|
|
mod_caps:get_user_resource(LUser, LServer)
|
|
end;
|
|
user_resource(_, _, LResource) ->
|
|
LResource.
|
|
|
|
is_caps_notify(Host, Node, LJID) ->
|
|
case mod_caps:get_caps(LJID) of
|
|
nothing ->
|
|
false;
|
|
Caps ->
|
|
case catch mod_caps:get_features(Host, Caps) of
|
|
Features when is_list(Features) -> lists:member(Node ++ "+notify", Features);
|
|
_ -> false
|
|
end
|
|
end.
|
|
|
|
%%%%%%% Configuration handling
|
|
|
|
%%<p>There are several reasons why the default node configuration options request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The service does not support node configuration.</li>
|
|
%%<li>The service does not support retrieval of default node configuration.</li>
|
|
%%</ul>
|
|
get_configure(Host, Node, From, Lang) ->
|
|
Action =
|
|
fun(#pubsub_node{options = Options, owners = Owners, type = Type}) ->
|
|
case node_call(Type, get_affiliation, [Host, Node, From]) of
|
|
{result, owner} ->
|
|
{result,
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'configure', attrs =
|
|
[?XMLATTR('node', node_to_string(Node))], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'x', attrs =
|
|
[?XMLATTR('type', <<"form">>)], children =
|
|
get_configure_xfields(Type, Options, Lang, Owners)
|
|
}]}]}]};
|
|
_ ->
|
|
{error, 'forbidden'}
|
|
end
|
|
end,
|
|
transaction(Host, Node, Action, sync_dirty).
|
|
|
|
get_default(Host, Node, _From, Lang) ->
|
|
Type = select_type(Host, Host, Node),
|
|
Options = node_options(Type),
|
|
{result, [#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'pubsub', children =
|
|
[#xmlel{ns = ?NS_PUBSUB_OWNER, name = 'default', children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'x', attrs = [?XMLATTR('type', <<"form">>)], children =
|
|
get_configure_xfields(Type, Options, Lang, [])
|
|
}]}]}]}.
|
|
|
|
%% Get node option
|
|
%% The result depend of the node type plugin system.
|
|
get_option([], _) -> false;
|
|
get_option(Options, Var) ->
|
|
get_option(Options, Var, false).
|
|
get_option(Options, Var, Def) ->
|
|
case lists:keysearch(Var, 1, Options) of
|
|
{value, {_Val, Ret}} -> Ret;
|
|
_ -> Def
|
|
end.
|
|
|
|
%% Get default options from the module plugin.
|
|
node_options(Type) ->
|
|
Module = list_to_atom(?PLUGIN_PREFIX ++ Type),
|
|
case catch Module:options() of
|
|
{'EXIT',{undef,_}} ->
|
|
DefaultModule = list_to_atom(?PLUGIN_PREFIX++?STDNODE),
|
|
DefaultModule:options();
|
|
Result ->
|
|
Result
|
|
end.
|
|
|
|
%% @spec (Options) -> MaxItems
|
|
%% Options = [Option]
|
|
%% Option = {Key::atom(), Value::term()}
|
|
%% MaxItems = integer() | unlimited
|
|
%% @doc <p>Return the maximum number of items for a given node.</p>
|
|
%% <p>Unlimited means that there is no limit in the number of items that can
|
|
%% be stored.</p>
|
|
%% @todo In practice, the current data structure means that we cannot manage
|
|
%% millions of items on a given node. This should be addressed in a new
|
|
%% version.
|
|
max_items(Options) ->
|
|
case get_option(Options, persist_items) of
|
|
true ->
|
|
case get_option(Options, max_items) of
|
|
false -> unlimited;
|
|
Result when (Result < 0) -> 0;
|
|
Result -> Result
|
|
end;
|
|
false ->
|
|
case get_option(Options, send_last_published_item) of
|
|
never -> 0;
|
|
_ -> 1
|
|
end
|
|
end.
|
|
|
|
-define(BOOL_CONFIG_FIELD(Label, Var),
|
|
?BOOLXFIELD(Label, "pubsub#" ++ atom_to_list(Var),
|
|
get_option(Options, Var))).
|
|
|
|
-define(STRING_CONFIG_FIELD(Label, Var),
|
|
?STRINGXFIELD(Label, "pubsub#" ++ atom_to_list(Var),
|
|
get_option(Options, Var, ""))).
|
|
|
|
-define(INTEGER_CONFIG_FIELD(Label, Var),
|
|
?STRINGXFIELD(Label, "pubsub#" ++ atom_to_list(Var),
|
|
integer_to_list(get_option(Options, Var)))).
|
|
|
|
-define(JLIST_CONFIG_FIELD(Label, Var, Opts),
|
|
?LISTXFIELD(Label, "pubsub#" ++ atom_to_list(Var),
|
|
exmpp_jid:jid_to_list(get_option(Options, Var)),
|
|
[exmpp_jid:jid_to_list(O) || O <- Opts])).
|
|
|
|
-define(ALIST_CONFIG_FIELD(Label, Var, Opts),
|
|
?LISTXFIELD(Label, "pubsub#" ++ atom_to_list(Var),
|
|
atom_to_list(get_option(Options, Var)),
|
|
[atom_to_list(O) || O <- Opts])).
|
|
|
|
get_configure_xfields(_Type, Options, Lang, _Owners) ->
|
|
[?XFIELD("hidden", "", "FORM_TYPE", ?NS_PUBSUB_NODE_CONFIG_s),
|
|
?BOOL_CONFIG_FIELD("Deliver payloads with event notifications", deliver_payloads),
|
|
?BOOL_CONFIG_FIELD("Deliver event notifications", deliver_notifications),
|
|
?BOOL_CONFIG_FIELD("Notify subscribers when the node configuration changes", notify_config),
|
|
?BOOL_CONFIG_FIELD("Notify subscribers when the node is deleted", notify_delete),
|
|
?BOOL_CONFIG_FIELD("Notify subscribers when items are removed from the node", notify_retract),
|
|
?BOOL_CONFIG_FIELD("Persist items to storage", persist_items),
|
|
?STRING_CONFIG_FIELD("A friendly name for the node", title),
|
|
?INTEGER_CONFIG_FIELD("Max # of items to persist", max_items),
|
|
?BOOL_CONFIG_FIELD("Whether to allow subscriptions", subscribe),
|
|
?ALIST_CONFIG_FIELD("Specify the access model", access_model,
|
|
[open, authorize, presence, roster, whitelist]),
|
|
%% XXX: change to list-multi, include current roster groups as options
|
|
#xmlel{ns = ?NS_DATA_FORMS, name = 'field', attrs = [?XMLATTR('type', <<"text-multi">>),
|
|
?XMLATTR('label', translate:translate(Lang, "Roster groups allowed to subscribe")),
|
|
?XMLATTR('var', <<"pubsub#roster_groups_allowed">>)], children =
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'value', children = [#xmlcdata{cdata = list_to_binary(Value)}]} ||
|
|
Value <- get_option(Options, roster_groups_allowed, [])]},
|
|
?ALIST_CONFIG_FIELD("Specify the publisher model", publish_model,
|
|
[publishers, subscribers, open]),
|
|
?INTEGER_CONFIG_FIELD("Max payload size in bytes", max_payload_size),
|
|
?ALIST_CONFIG_FIELD("When to send the last published item", send_last_published_item,
|
|
[never, on_sub, on_sub_and_presence]),
|
|
?BOOL_CONFIG_FIELD("Only deliver notifications to available users", presence_based_delivery)
|
|
].
|
|
|
|
%%<p>There are several reasons why the node configuration request might fail:</p>
|
|
%%<ul>
|
|
%%<li>The service does not support node configuration.</li>
|
|
%%<li>The requesting entity does not have sufficient privileges to configure the node.</li>
|
|
%%<li>The request did not specify a node.</li>
|
|
%%<li>The node has no configuration options.</li>
|
|
%%<li>The specified node does not exist.</li>
|
|
%%</ul>
|
|
set_configure(Host, Node, From, Els, Lang) ->
|
|
case exmpp_xml:remove_cdata_from_list(Els) of
|
|
[#xmlel{ns = ?NS_DATA_FORMS, name = 'x'} = XEl] ->
|
|
case exmpp_xml:get_attribute_as_list(XEl, 'type', undefined) of
|
|
"cancel" ->
|
|
{result, []};
|
|
"submit" ->
|
|
Action =
|
|
fun(#pubsub_node{options = Options, type = Type}=N) ->
|
|
case node_call(Type, get_affiliation,
|
|
[Host, Node, From]) of
|
|
{result, owner} ->
|
|
case jlib:parse_xdata_submit(XEl) of
|
|
invalid ->
|
|
{error, 'bad-request'};
|
|
XData ->
|
|
OldOpts = case Options of
|
|
[] -> node_options(Type);
|
|
_ -> Options
|
|
end,
|
|
case set_xoption(XData, OldOpts) of
|
|
NewOpts when is_list(NewOpts) ->
|
|
tree_call(Host, set_node,
|
|
[N#pubsub_node{options = NewOpts}]),
|
|
{result, ok};
|
|
Err ->
|
|
Err
|
|
end
|
|
end;
|
|
_ ->
|
|
{error, 'forbidden'}
|
|
end
|
|
end,
|
|
case transaction(Host, Node, Action, transaction) of
|
|
{result, ok} ->
|
|
broadcast_config_notification(Host, Node, Lang),
|
|
{result, []};
|
|
Other ->
|
|
Other
|
|
end;
|
|
_ ->
|
|
{error, 'bad-request'}
|
|
end;
|
|
_ ->
|
|
{error, 'bad-request'}
|
|
end.
|
|
|
|
add_opt(Key, Value, Opts) ->
|
|
Opts1 = lists:keydelete(Key, 1, Opts),
|
|
[{Key, Value} | Opts1].
|
|
|
|
-define(SET_BOOL_XOPT(Opt, Val),
|
|
BoolVal = case Val of
|
|
"0" -> false;
|
|
"1" -> true;
|
|
"false" -> false;
|
|
"true" -> true;
|
|
_ -> error
|
|
end,
|
|
case BoolVal of
|
|
error -> {error, 'not-acceptable'};
|
|
_ -> set_xoption(Opts, add_opt(Opt, BoolVal, NewOpts))
|
|
end).
|
|
|
|
-define(SET_STRING_XOPT(Opt, Val),
|
|
set_xoption(Opts, add_opt(Opt, Val, NewOpts))).
|
|
|
|
-define(SET_INTEGER_XOPT(Opt, Val, Min, Max),
|
|
case catch list_to_integer(Val) of
|
|
IVal when is_integer(IVal),
|
|
IVal >= Min,
|
|
IVal =< Max ->
|
|
set_xoption(Opts, add_opt(Opt, IVal, NewOpts));
|
|
_ ->
|
|
{error, 'not-acceptable'}
|
|
end).
|
|
|
|
-define(SET_ALIST_XOPT(Opt, Val, Vals),
|
|
case lists:member(Val, [atom_to_list(V) || V <- Vals]) of
|
|
true -> set_xoption(Opts, add_opt(Opt, list_to_atom(Val), NewOpts));
|
|
false -> {error, 'not-acceptable'}
|
|
end).
|
|
|
|
-define(SET_LIST_XOPT(Opt, Val),
|
|
set_xoption(Opts, add_opt(Opt, Val, NewOpts))).
|
|
|
|
set_xoption([], NewOpts) ->
|
|
NewOpts;
|
|
set_xoption([{"FORM_TYPE", _} | Opts], NewOpts) ->
|
|
set_xoption(Opts, NewOpts);
|
|
set_xoption([{"pubsub#roster_groups_allowed", _Value} | Opts], NewOpts) ->
|
|
?SET_LIST_XOPT(roster_groups_allowed, []); % XXX: waiting for EJAB-659 to be solved
|
|
set_xoption([{"pubsub#deliver_payloads", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(deliver_payloads, Val);
|
|
set_xoption([{"pubsub#deliver_notifications", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(deliver_notifications, Val);
|
|
set_xoption([{"pubsub#notify_config", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(notify_config, Val);
|
|
set_xoption([{"pubsub#notify_delete", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(notify_delete, Val);
|
|
set_xoption([{"pubsub#notify_retract", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(notify_retract, Val);
|
|
set_xoption([{"pubsub#persist_items", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(persist_items, Val);
|
|
set_xoption([{"pubsub#max_items", [Val]} | Opts], NewOpts) ->
|
|
?SET_INTEGER_XOPT(max_items, Val, 0, ?MAXITEMS);
|
|
set_xoption([{"pubsub#subscribe", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(subscribe, Val);
|
|
set_xoption([{"pubsub#access_model", [Val]} | Opts], NewOpts) ->
|
|
?SET_ALIST_XOPT(access_model, Val, [open, authorize, presence, roster, whitelist]);
|
|
set_xoption([{"pubsub#publish_model", [Val]} | Opts], NewOpts) ->
|
|
?SET_ALIST_XOPT(publish_model, Val, [publishers, subscribers, open]);
|
|
set_xoption([{"pubsub#node_type", [Val]} | Opts], NewOpts) ->
|
|
?SET_ALIST_XOPT(node_type, Val, [leaf, collection]);
|
|
set_xoption([{"pubsub#max_payload_size", [Val]} | Opts], NewOpts) ->
|
|
?SET_INTEGER_XOPT(max_payload_size, Val, 0, ?MAX_PAYLOAD_SIZE);
|
|
set_xoption([{"pubsub#send_last_published_item", [Val]} | Opts], NewOpts) ->
|
|
?SET_ALIST_XOPT(send_last_published_item, Val, [never, on_sub, on_sub_and_presence]);
|
|
set_xoption([{"pubsub#presence_based_delivery", [Val]} | Opts], NewOpts) ->
|
|
?SET_BOOL_XOPT(presence_based_delivery, Val);
|
|
set_xoption([{"pubsub#title", Value} | Opts], NewOpts) ->
|
|
?SET_STRING_XOPT(title, Value);
|
|
set_xoption([{"pubsub#type", Value} | Opts], NewOpts) ->
|
|
?SET_STRING_XOPT(type, Value);
|
|
set_xoption([{"pubsub#body_xslt", Value} | Opts], NewOpts) ->
|
|
?SET_STRING_XOPT(body_xslt, Value);
|
|
set_xoption([_ | Opts], NewOpts) ->
|
|
% skip unknown field
|
|
set_xoption(Opts, NewOpts).
|
|
|
|
%%%% plugin handling
|
|
|
|
plugins(Host) ->
|
|
case ets:lookup(gen_mod:get_module_proc(Host, pubsub_state), plugins) of
|
|
[{plugins, PL}] -> PL;
|
|
_ -> [?STDNODE]
|
|
end.
|
|
select_type(ServerHost, Host, Node, Type)->
|
|
?DEBUG("SELECT_TYPE : ~p~n", [[ServerHost, Host, Node, Type]]),
|
|
case Host of
|
|
{_User, _Server, _Resource} ->
|
|
case ets:lookup(gen_mod:get_module_proc(ServerHost, pubsub_state), pep_mapping) of
|
|
[{pep_mapping, PM}] -> ?DEBUG("SELECT_TYPE : ~p~n", [PM]), proplists:get_value(Node, PM, ?PEPNODE);
|
|
R -> ?DEBUG("SELECT_TYPE why ?: ~p~n", [R]), ?PEPNODE
|
|
end;
|
|
_ ->
|
|
Type
|
|
end.
|
|
select_type(ServerHost, Host, Node) ->
|
|
select_type(ServerHost, Host, Node, hd(plugins(ServerHost))).
|
|
|
|
features() ->
|
|
[
|
|
%TODO "access-authorize", % OPTIONAL
|
|
"access-open", % OPTIONAL this relates to access_model option in node_default
|
|
"access-presence", % OPTIONAL this relates to access_model option in node_pep
|
|
%TODO "access-roster", % OPTIONAL
|
|
"access-whitelist", % OPTIONAL
|
|
% see plugin "auto-create", % OPTIONAL
|
|
% see plugin "auto-subscribe", % RECOMMENDED
|
|
"collections", % RECOMMENDED
|
|
"config-node", % RECOMMENDED
|
|
"create-and-configure", % RECOMMENDED
|
|
% see plugin "create-nodes", % RECOMMENDED
|
|
% see plugin "delete-any", % RECOMMENDED
|
|
% see plugin "delete-nodes", % RECOMMENDED
|
|
% see plugin "filtered-notifications", % RECOMMENDED
|
|
%TODO "get-pending", % OPTIONAL
|
|
% see plugin "instant-nodes", % RECOMMENDED
|
|
"item-ids", % RECOMMENDED
|
|
"last-published", % RECOMMENDED
|
|
%TODO "cache-last-item",
|
|
%TODO "leased-subscription", % OPTIONAL
|
|
% see plugin "manage-subscriptions", % OPTIONAL
|
|
"member-affiliation", % RECOMMENDED
|
|
%TODO "meta-data", % RECOMMENDED
|
|
% see plugin "modify-affiliations", % OPTIONAL
|
|
%TODO "multi-collection", % OPTIONAL
|
|
%TODO "multi-subscribe", % OPTIONAL
|
|
% see plugin "outcast-affiliation", % RECOMMENDED
|
|
% see plugin "persistent-items", % RECOMMENDED
|
|
"presence-notifications", % OPTIONAL
|
|
"presence-subscribe", % RECOMMENDED
|
|
% see plugin "publish", % REQUIRED
|
|
%TODO "publish-options", % OPTIONAL
|
|
"publisher-affiliation", % RECOMMENDED
|
|
% see plugin "purge-nodes", % OPTIONAL
|
|
% see plugin "retract-items", % OPTIONAL
|
|
% see plugin "retrieve-affiliations", % RECOMMENDED
|
|
"retrieve-default" % RECOMMENDED
|
|
% see plugin "retrieve-items", % RECOMMENDED
|
|
% see plugin "retrieve-subscriptions", % RECOMMENDED
|
|
% see plugin "subscribe", % REQUIRED
|
|
%TODO "subscription-options", % OPTIONAL
|
|
% see plugin "subscription-notifications" % OPTIONAL
|
|
].
|
|
features(Type) ->
|
|
Module = list_to_atom(?PLUGIN_PREFIX++Type),
|
|
features() ++ case catch Module:features() of
|
|
{'EXIT', {undef, _}} -> [];
|
|
Result -> Result
|
|
end.
|
|
features(Host, []) ->
|
|
lists:usort(lists:foldl(fun(Plugin, Acc) ->
|
|
Acc ++ features(Plugin)
|
|
end, [], plugins(Host)));
|
|
features(Host, Node) ->
|
|
{result, Features} = node_action(Host, Node, features, []),
|
|
lists:usort(features() ++ Features).
|
|
|
|
%% @doc <p>node tree plugin call.</p>
|
|
tree_call({_User, Server, _Resource}, Function, Args) ->
|
|
tree_call(Server, Function, Args);
|
|
tree_call(Host, Function, Args) ->
|
|
Module = case ets:lookup(gen_mod:get_module_proc(Host, pubsub_state), nodetree) of
|
|
[{nodetree, N}] -> N;
|
|
_ -> list_to_atom(?TREE_PREFIX ++ ?STDNODE)
|
|
end,
|
|
catch apply(Module, Function, Args).
|
|
tree_action(Host, Function, Args) ->
|
|
Fun = fun() -> tree_call(Host, Function, Args) end,
|
|
catch mnesia:sync_dirty(Fun).
|
|
|
|
%% @doc <p>node plugin call.</p>
|
|
node_call(Type, Function, Args) ->
|
|
Module = list_to_atom(?PLUGIN_PREFIX++Type),
|
|
case catch apply(Module, Function, Args) of
|
|
{result, Result} -> {result, Result};
|
|
{error, Error} -> {error, Error};
|
|
{'EXIT', {undef, Undefined}} ->
|
|
case Type of
|
|
?STDNODE -> {error, {undef, Undefined}};
|
|
_ -> node_call(?STDNODE, Function, Args)
|
|
end;
|
|
{'EXIT', Reason} -> {error, Reason};
|
|
Result -> {result, Result} %% any other return value is forced as result
|
|
end.
|
|
|
|
node_action(Type, Function, Args) ->
|
|
transaction(fun() ->
|
|
node_call(Type, Function, Args)
|
|
end, sync_dirty).
|
|
node_action(Host, Node, Function, Args) ->
|
|
transaction(fun() ->
|
|
case tree_call(Host, get_node, [Host, Node]) of
|
|
#pubsub_node{type=Type} -> node_call(Type, Function, Args);
|
|
Other -> Other
|
|
end
|
|
end, sync_dirty).
|
|
|
|
%% @doc <p>plugin transaction handling.</p>
|
|
transaction(Host, Node, Action, Trans) ->
|
|
transaction(fun() ->
|
|
case tree_call(Host, get_node, [Host, Node]) of
|
|
Record when is_record(Record, pubsub_node) -> Action(Record);
|
|
Other -> Other
|
|
end
|
|
end, Trans).
|
|
|
|
transaction(Fun, Trans) ->
|
|
case catch mnesia:Trans(Fun) of
|
|
{result, Result} -> {result, Result};
|
|
{error, Error} -> {error, Error};
|
|
{atomic, {result, Result}} -> {result, Result};
|
|
{atomic, {error, Error}} -> {error, Error};
|
|
{aborted, Reason} ->
|
|
?ERROR_MSG("transaction return internal error: ~p~n", [{aborted, Reason}]),
|
|
{error, 'internal-server-error'};
|
|
{'EXIT', Reason} ->
|
|
?ERROR_MSG("transaction return internal error: ~p~n", [{'EXIT', Reason}]),
|
|
{error, 'internal-server-error'};
|
|
Other ->
|
|
?ERROR_MSG("transaction return internal error: ~p~n", [Other]),
|
|
{error, 'internal-server-error'}
|
|
end.
|
|
|
|
%%%% helpers
|
|
|
|
%% Add pubsub-specific error element
|
|
extended_error(Error, Ext) ->
|
|
extended_error(Error, Ext, []).
|
|
extended_error(Error, unsupported, Feature) ->
|
|
extended_error(Error, unsupported,
|
|
[?XMLATTR('feature', Feature)]);
|
|
extended_error(Error, Ext, ExtAttrs) ->
|
|
Pubsub_Err = #xmlel{ns = ?NS_PUBSUB_ERRORS, name = Ext, attrs = ExtAttrs},
|
|
exmpp_xml:append_child(exmpp_stanza:error(?NS_JABBER_CLIENT, Error),
|
|
Pubsub_Err).
|
|
|
|
%% Give a uniq identifier
|
|
uniqid() ->
|
|
{T1, T2, T3} = now(),
|
|
lists:flatten(io_lib:fwrite("~.16B~.16B~.16B", [T1, T2, T3])).
|
|
|