xmpp.chapril.org-ejabberd/src/mod_pubsub/mod_pubsub.erl

%%% ====================================================================
%%% ``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-2012, ProcessOne
%%% All Rights Reserved.''
%%% This software is copyright 2006-2012, ProcessOne.
%%%
%%% @copyright 2006-2012 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.
%%%
%%% Support for subscription-options and multi-subscribe features was
%%% added by Brian Cully (bjc AT kublai.com). Subscriptions and options are
%%% stored in the pubsub_subscription table, with a link to them provided
%%% by the subscriptions field of pubsub_state. For information on
%%% subscription-options and mulit-subscribe see XEP-0060 sections 6.1.6,
%%% 6.2.3.1, 6.2.3.5, and 6.3. For information on subscription leases see
%%% XEP-0060 section 12.18.

-module(mod_pubsub).

-author('christophe.romain@process-one.net').

-version('1.13-0').

-behaviour(gen_server).

-behaviour(gen_mod).

-include("ejabberd.hrl").

-include("adhoc.hrl").

-include("jlib.hrl").

-include("pubsub.hrl").

-define(STDTREE, <<"tree">>).

-define(STDNODE, <<"flat">>).

-define(PEPNODE, <<"pep">>).

%% exports for hooks
-export([presence_probe/3, caps_update/3,
	 in_subscription/6, out_subscription/4,
	 on_user_offline/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_sm/3]).

%% exports for console debug manual use
-export([create_node/5, create_node/7, delete_node/3,
	 subscribe_node/5, unsubscribe_node/5, publish_item/6,
	 delete_item/4, send_items/6, get_items/2, get_item/3,
	 get_cached_item/2, get_configure/5, set_configure/5,
	 tree_action/3, node_action/4]).

%% general helpers for plugins
-export([subscription_to_string/1, affiliation_to_string/1,
	 string_to_subscription/1, string_to_affiliation/1,
	 extended_error/2, extended_error/3,
	 rename_default_nodeplugin/0]).

%% 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]).

%% calls for parallel sending of last items
-export([send_loop/1]).

-define(PROCNAME, ejabberd_mod_pubsub).

-define(LOOPNAME, ejabberd_mod_pubsub_loop).

-define(PLUGIN_PREFIX, <<"node_">>).

-define(TREE_PREFIX, <<"nodetree_">>).

%
-export_type([
    host/0,
    hostPubsub/0,
    hostPEP/0,
    %%
    nodeIdx/0,
    nodeId/0,
    itemId/0,
    subId/0,
    payload/0,
    %%
    nodeOption/0,
    nodeOptions/0,
    subOption/0,
    subOptions/0,
    %%
    affiliation/0,
    subscription/0,
    accessModel/0,
    publishModel/0
]).

%% -type payload() defined here because the -type xmlel() is not accessible
%% from pubsub.hrl
-type(payload() :: [] | [xmlel(),...]).

-export_type([
    pubsubNode/0,
    pubsubState/0,
    pubsubItem/0,
    pubsubSubscription/0,
    pubsubLastItem/0
]).

-type(pubsubNode() ::
    #pubsub_node{
        nodeid  :: {Host::mod_pubsub:host(), NodeId::mod_pubsub:nodeId()},
        id      :: mod_pubsub:nodeIdx(),
        parents :: [Parent_NodeId::mod_pubsub:nodeId()],
        type    :: binary(),
        owners  :: [Owner::ljid(),...],
        options :: mod_pubsub:nodeOptions()
    }
).

-type(pubsubState() ::
    #pubsub_state{
        stateid       :: {Entity::ljid(), NodeIdx::mod_pubsub:nodeIdx()},
        nodeidx       :: mod_pubsub:nodeIdx(),
        items         :: [ItemId::mod_pubsub:itemId()],
        affiliation   :: mod_pubsub:affiliation(),
        subscriptions :: [{mod_pubsub:subscription(), mod_pubsub:subId()}]
    }
).

-type(pubsubItem() ::
    #pubsub_item{
        itemid       :: {mod_pubsub:itemId(), mod_pubsub:nodeIdx()},
        nodeidx      :: mod_pubsub:nodeIdx(),
        creation     :: {erlang:timestamp(), ljid()},
        modification :: {erlang:timestamp(), ljid()},
        payload      :: mod_pubsub:payload()
    }
).

-type(pubsubSubscription() ::
    #pubsub_subscription{
        subid   :: mod_pubsub:subId(),
        options :: [] | mod_pubsub:subOptions()
    }
).

-type(pubsubLastItem() ::
    #pubsub_last_item{
        nodeid   :: mod_pubsub:nodeIdx(),
        itemid   :: mod_pubsub:itemId(),
        creation :: {erlang:timestamp(), ljid()},
        payload  :: mod_pubsub:payload()
    }
).

-record(state,
{
    server_host,
    host,
    access,
    pep_mapping             = [],
    ignore_pep_from_offline = true,
    last_item_cache         = false,
    max_items_node          = ?MAXITEMS,
    nodetree                = ?STDTREE,
    plugins                 = [?STDNODE]
}).

-type(state() ::
    #state{
        server_host             :: binary(),
        host                    :: mod_pubsub:hostPubsub(),
        access                  :: atom(),
        pep_mapping             :: [{binary(), binary()}],
        ignore_pep_from_offline :: boolean(),
        last_item_cache         :: boolean(),
        max_items_node          :: non_neg_integer(),
        nodetree                :: binary(),
        plugins                 :: [binary(),...]
    }

).


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
%%====================================================================

-spec(init/1 ::
(
    _:: _)
    -> {ok, state()}
).

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,
        fun(A) when is_atom(A) -> A end, all),
    PepOffline = gen_mod:get_opt(ignore_pep_from_offline, Opts,
				 fun(A) when is_boolean(A) -> A end, true),
    IQDisc = gen_mod:get_opt(iqdisc, Opts,
                fun(A) when is_atom(A) -> A end, one_queue),
    LastItemCache = gen_mod:get_opt(last_item_cache, Opts,
				    fun(A) when is_boolean(A) -> A end, false),
    MaxItemsNode = gen_mod:get_opt(max_items_node, Opts,
				   fun(A) when is_integer(A) andalso A >= 0 -> A end, ?MAXITEMS),
    pubsub_index:init(Host, ServerHost, Opts),
    ets:new(gen_mod:get_module_proc(Host, config),
	    [set, named_table]),
    ets:new(gen_mod:get_module_proc(ServerHost, config),
	    [set, named_table]),
    {Plugins, NodeTree, PepMapping} = init_plugins(Host,
						   ServerHost, Opts),
    mnesia:create_table(pubsub_last_item,
			[{ram_copies, [node()]},
			 {attributes, record_info(fields, pubsub_last_item)}]),
    mod_disco:register_feature(ServerHost, ?NS_PUBSUB),
    ets:insert(gen_mod:get_module_proc(Host, config),
	       {nodetree, NodeTree}),
    ets:insert(gen_mod:get_module_proc(Host, config),
	       {plugins, Plugins}),
    ets:insert(gen_mod:get_module_proc(Host, config),
	       {last_item_cache, LastItemCache}),
    ets:insert(gen_mod:get_module_proc(Host, config),
	       {max_items_node, MaxItemsNode}),
    ets:insert(gen_mod:get_module_proc(ServerHost, config),
	       {nodetree, NodeTree}),
    ets:insert(gen_mod:get_module_proc(ServerHost, config),
	       {plugins, Plugins}),
    ets:insert(gen_mod:get_module_proc(ServerHost, config),
	       {last_item_cache, LastItemCache}),
    ets:insert(gen_mod:get_module_proc(ServerHost, config),
	       {max_items_node, MaxItemsNode}),
    ets:insert(gen_mod:get_module_proc(ServerHost, config),
	       {pep_mapping, PepMapping}),
    ets:insert(gen_mod:get_module_proc(ServerHost, config),
	       {ignore_pep_from_offline, PepOffline}),
    ets:insert(gen_mod:get_module_proc(ServerHost, config),
	       {host, Host}),
    ejabberd_hooks:add(sm_remove_connection_hook,
		       ServerHost, ?MODULE, on_user_offline, 75),
    ejabberd_hooks:add(disco_local_identity, ServerHost,
		       ?MODULE, disco_local_identity, 75),
    ejabberd_hooks:add(disco_local_features, ServerHost,
		       ?MODULE, disco_local_features, 75),
    ejabberd_hooks:add(disco_local_items, ServerHost,
		       ?MODULE, disco_local_items, 75),
    ejabberd_hooks:add(presence_probe_hook, ServerHost,
		       ?MODULE, presence_probe, 80),
    ejabberd_hooks:add(roster_in_subscription, ServerHost,
		       ?MODULE, in_subscription, 50),
    ejabberd_hooks:add(roster_out_subscription, ServerHost,
		       ?MODULE, out_subscription, 50),
    ejabberd_hooks:add(remove_user, ServerHost, ?MODULE,
		       remove_user, 50),
    ejabberd_hooks:add(anonymous_purge_hook, ServerHost,
		       ?MODULE, remove_user, 50),
    case lists:member(?PEPNODE, Plugins) of
      true ->
	  ejabberd_hooks:add(caps_update, ServerHost, ?MODULE,
			     caps_update, 80),
	  ejabberd_hooks:add(disco_sm_identity, ServerHost,
			     ?MODULE, disco_sm_identity, 75),
	  ejabberd_hooks:add(disco_sm_features, ServerHost,
			     ?MODULE, disco_sm_features, 75),
	  ejabberd_hooks:add(disco_sm_items, ServerHost, ?MODULE,
			     disco_sm_items, 75),
	  gen_iq_handler:add_iq_handler(ejabberd_sm, ServerHost,
					?NS_PUBSUB, ?MODULE, iq_sm, IQDisc),
	  gen_iq_handler:add_iq_handler(ejabberd_sm, ServerHost,
					?NS_PUBSUB_OWNER, ?MODULE, iq_sm,
					IQDisc);
      false -> ok
    end,
    ejabberd_router:register_route(Host),
    update_node_database(Host, ServerHost),
    update_state_database(Host, ServerHost),
    put(server_host, ServerHost),
    init_nodes(Host, ServerHost, NodeTree, Plugins),
    State = #state{host = Host, server_host = ServerHost,
		   access = Access, pep_mapping = PepMapping,
		   ignore_pep_from_offline = PepOffline,
		   last_item_cache = LastItemCache,
		   max_items_node = MaxItemsNode, nodetree = NodeTree,
		   plugins = Plugins},
    init_send_loop(ServerHost, State),
    {ok, State}.

init_send_loop(ServerHost, State) ->
    Proc = gen_mod:get_module_proc(ServerHost, ?LOOPNAME),
    SendLoop = spawn(?MODULE, send_loop, [State]),
    register(Proc, SendLoop),
    SendLoop.

init_plugins(Host, ServerHost, Opts) ->
    TreePlugin =
	jlib:binary_to_atom(<<(?TREE_PREFIX)/binary,
				(gen_mod:get_opt(nodetree, Opts, fun(A) when is_list(A) -> A end,
						 ?STDTREE))/binary>>),
    ?DEBUG("** tree plugin is ~p", [TreePlugin]),
    TreePlugin:init(Host, ServerHost, Opts),
    Plugins = gen_mod:get_opt(plugins, Opts,
        fun(A) when is_list(A) -> A end, [?STDNODE]),
    PepMapping = gen_mod:get_opt(pep_mapping, Opts,
        fun(A) when is_list(A) -> A end, []),
    ?DEBUG("** PEP Mapping : ~p~n", [PepMapping]),
    PluginsOK = lists:foldl(fun (Name, Acc) ->
				    Plugin =
					jlib:binary_to_atom(<<(?PLUGIN_PREFIX)/binary,
								Name/binary>>),
				    case catch apply(Plugin, init,
						     [Host, ServerHost, Opts])
					of
				      {'EXIT', _Error} -> Acc;
				      _ ->
					  ?DEBUG("** init ~s plugin", [Name]),
					  [Name | Acc]
				    end
			    end,
			    [], Plugins),
    {lists:reverse(PluginsOK), TreePlugin, PepMapping}.

terminate_plugins(Host, ServerHost, Plugins,
		  TreePlugin) ->
    lists:foreach(fun (Name) ->
			  ?DEBUG("** terminate ~s plugin", [Name]),
			  Plugin =
			      jlib:binary_to_atom(<<(?PLUGIN_PREFIX)/binary,
						      Name/binary>>),
			  Plugin:terminate(Host, ServerHost)
		  end,
		  Plugins),
    TreePlugin:terminate(Host, ServerHost),
    ok.

init_nodes(Host, ServerHost, _NodeTree, Plugins) ->
    case lists:member(<<"hometree">>, Plugins) of
      true ->
	    create_node(Host, ServerHost, <<"/home">>, service_jid(Host), <<"hometree">>),
	    create_node(Host, ServerHost, <<"/home/", ServerHost/binary>>, service_jid(Host),
	      <<"hometree">>);
      false -> ok
    end.

update_node_database(Host, ServerHost) ->
    mnesia:del_table_index(pubsub_node, type),
    mnesia:del_table_index(pubsub_node, parentid),
    case catch mnesia:table_info(pubsub_node, attributes) of
      [host_node, host_parent, info] ->
	  ?INFO_MSG("upgrade node pubsub tables", []),
	  F = fun () ->
		      {Result, LastIdx} = lists:foldl(fun ({pubsub_node,
							    NodeId, ParentId,
							    {nodeinfo, Items,
							     Options,
							     Entities}},
							   {RecList,
							    NodeIdx}) ->
							      ItemsList =
								  lists:foldl(fun
										({item,
										  IID,
										  Publisher,
										  Payload},
										 Acc) ->
										    C =
											{unknown,
											 Publisher},
										    M =
											{now(),
											 Publisher},
										    mnesia:write(#pubsub_item{itemid
														  =
														  {IID,
														   NodeIdx},
													      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,
												{JID,
												 NodeIdx},
												UsrItems,
												Aff,
												Sub}),
										  case
										    Aff
										      of
										    owner ->
											[JID
											 | Acc];
										    _ ->
											Acc
										  end
									    end,
									    [],
									    Entities),
							      mnesia:delete({pubsub_node,
									     NodeId}),
							      {[#pubsub_node{nodeid
										 =
										 NodeId,
									     id
										 =
										 NodeIdx,
									     parents
										 =
										 [element(2,
											  ParentId)],
									     owners
										 =
										 Owners,
									     options
										 =
										 Options}
								| RecList],
							       NodeIdx + 1}
						      end,
						      {[], 1},
						      mnesia:match_object({pubsub_node,
									   {Host,
									    '_'},
									   '_',
									   '_'})),
		      mnesia:write(#pubsub_index{index = node, last = LastIdx,
						 free = []}),
		      Result
	      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 node tables updated correctly: ~p",
			  [Result]);
	    {aborted, Reason} ->
		?ERROR_MSG("Problem updating Pubsub node tables:~n~p",
			   [Reason])
	  end;
      [nodeid, parentid, type, owners, options] ->
	  F = fun ({pubsub_node, NodeId, {_, Parent}, Type,
		    Owners, Options}) ->
		      #pubsub_node{nodeid = NodeId, id = 0,
				   parents = [Parent], type = Type,
				   owners = Owners, options = Options}
	      end,
	  mnesia:transform_table(pubsub_node, F,
				 [nodeid, id, parents, type, owners, options]),
	  FNew = fun () ->
			 LastIdx = lists:foldl(fun (#pubsub_node{nodeid =
								     NodeId} =
							PubsubNode,
						    NodeIdx) ->
						       mnesia:write(PubsubNode#pubsub_node{id
											       =
											       NodeIdx}),
						       lists:foreach(fun
								       (#pubsub_state{stateid
											  =
											  StateId} =
									    State) ->
									   {JID,
									    _} =
									       StateId,
									   mnesia:delete({pubsub_state,
											  StateId}),
									   mnesia:write(State#pubsub_state{stateid
													       =
													       {JID,
														NodeIdx}})
								     end,
								     mnesia:match_object(#pubsub_state{stateid
													   =
													   {'_',
													    NodeId},
												       _
													   =
													   '_'})),
						       lists:foreach(fun
								       (#pubsub_item{itemid
											 =
											 ItemId} =
									    Item) ->
									   {IID,
									    _} =
									       ItemId,
									   {M1,
									    M2} =
									       Item#pubsub_item.modification,
									   {C1,
									    C2} =
									       Item#pubsub_item.creation,
									   mnesia:delete({pubsub_item,
											  ItemId}),
									   mnesia:write(Item#pubsub_item{itemid
													     =
													     {IID,
													      NodeIdx},
													 modification
													     =
													     {M2,
													      M1},
													 creation
													     =
													     {C2,
													      C1}})
								     end,
								     mnesia:match_object(#pubsub_item{itemid
													  =
													  {'_',
													   NodeId},
												      _
													  =
													  '_'})),
						       NodeIdx + 1
					       end,
					       1,
					       mnesia:match_object({pubsub_node,
								    {Host, '_'},
								    '_', '_',
								    '_', '_',
								    '_'})
						 ++
						 mnesia:match_object({pubsub_node,
								      {{'_',
									ServerHost,
									'_'},
								       '_'},
								      '_', '_',
								      '_', '_',
								      '_'})),
			 mnesia:write(#pubsub_index{index = node,
						    last = LastIdx, free = []})
		 end,
	  case mnesia:transaction(FNew) of
	    {atomic, Result} ->
		rename_default_nodeplugin(),
		?INFO_MSG("Pubsub node tables updated correctly: ~p",
			  [Result]);
	    {aborted, Reason} ->
		?ERROR_MSG("Problem updating Pubsub node tables:~n~p",
			   [Reason])
	  end;
      [nodeid, id, parent, type, owners, options] ->
	  F = fun ({pubsub_node, NodeId, Id, Parent, Type, Owners,
		    Options}) ->
		      #pubsub_node{nodeid = NodeId, id = Id,
				   parents = [Parent], type = Type,
				   owners = Owners, options = Options}
	      end,
	  mnesia:transform_table(pubsub_node, F,
				 [nodeid, id, parents, type, owners, options]),
	  rename_default_nodeplugin();
      _ -> ok
    end,
    mnesia:transaction(fun () ->
			       case catch mnesia:first(pubsub_node) of
				 {_, L} when is_binary(L) ->
				     lists:foreach(fun ({H, N})
							   when is_binary(N) ->
							   [Node] =
							       mnesia:read({pubsub_node,
									    {H,
									     N}}),
							   Type =
							       Node#pubsub_node.type,
							   BN = element(2,
									node_call(Type,
										  path_to_node,
										  [N])),
							   BP = case [element(2,
									      node_call(Type,
											path_to_node,
											[P]))
								      || P
									     <- Node#pubsub_node.parents]
								    of
								  [<<>>] -> [];
								  Parents ->
								      Parents
								end,
							   mnesia:write(Node#pubsub_node{nodeid
											     =
											     {H,
											      BN},
											 parents
											     =
											     BP}),
							   mnesia:delete({pubsub_node,
									  {H,
									   N}});
						       (_) -> ok
						   end,
						   mnesia:all_keys(pubsub_node));
				 _ -> ok
			       end
		       end).

rename_default_nodeplugin() ->
    lists:foreach(fun (Node) ->
			  mnesia:dirty_write(Node#pubsub_node{type =
								  <<"hometree">>})
		  end,
		  mnesia:dirty_match_object(#pubsub_node{type =
							     <<"default">>,
							 _ = '_'})).

update_state_database(_Host, _ServerHost) ->
    case catch mnesia:table_info(pubsub_state, attributes)
	of
      [stateid, items, affiliation, subscription] ->
	  ?INFO_MSG("upgrade state pubsub tables", []),
	  F = fun ({pubsub_state, {JID, NodeID}, Items, Aff, Sub},
		   Acc) ->
		      Subs = case Sub of
			       none -> [];
			       _ ->
				   {result, SubID} =
				       pubsub_subscription:subscribe_node(JID,
									  NodeID,
									  []),
				   [{Sub, SubID}]
			     end,
		      NewState = #pubsub_state{stateid = {JID, NodeID},
					       items = Items, affiliation = Aff,
					       subscriptions = Subs},
		      [NewState | Acc]
	      end,
	  {atomic, NewRecs} =
	      mnesia:transaction(fun mnesia:foldl/3,
				 [F, [], pubsub_state]),
	  {atomic, ok} = mnesia:delete_table(pubsub_state),
	  {atomic, ok} = mnesia:create_table(pubsub_state,
					     [{disc_copies, [node()]},
						{type, ordered_set},
					      {attributes,
					       record_info(fields,
							   pubsub_state)}]),
	  FNew = fun () ->
			 lists:foreach(fun mnesia:write/1, NewRecs)
		 end,
	  case mnesia:transaction(FNew) of
	    {atomic, Result} ->
		?INFO_MSG("Pubsub state tables updated correctly: ~p",
			  [Result]);
	    {aborted, Reason} ->
		?ERROR_MSG("Problem updating Pubsub state tables:~n~p",
			   [Reason])
	  end;
      [stateid, items, affiliation, subscriptions] ->
	  ?INFO_MSG("upgrade state pubsub table", []),
	  F = fun ({pubsub_state, {JID, Nidx}, Items, Aff, Subs},
		   Acc) ->
		      NewState = #pubsub_state{stateid = {JID, Nidx},
					       nodeidx = Nidx, items = Items,
					       affiliation = Aff,
					       subscriptions = Subs},
		      [NewState | Acc]
	      end,
	  {atomic, NewRecs} =
	      mnesia:transaction(fun mnesia:foldl/3,
				 [F, [], pubsub_state]),
	  {atomic, ok} = mnesia:delete_table(pubsub_state),
	  {atomic, ok} = mnesia:create_table(pubsub_state,
					     [{disc_copies, [node()]},
						{type, ordered_set},
					      {attributes,
					       record_info(fields,
							   pubsub_state)}]),
	  FNew = fun () ->
			 lists:foreach(fun mnesia:write/1, NewRecs)
		 end,
	  case mnesia:transaction(FNew) of
	    {atomic, Res1} ->
		?INFO_MSG("Pubsub state tables updated correctly: ~p",
			  [Res1]);
	    {aborted, Rea1} ->
		?ERROR_MSG("Problem updating Pubsub state table:~n~p",
			   [Rea1])
	  end,
	  ?INFO_MSG("upgrade item pubsub table", []),
	  F = fun ({pubsub_item, {ItemId, Nidx}, C, M, P}, Acc) ->
		      NewItem = #pubsub_item{itemid = {ItemId, Nidx},
					     nodeidx = Nidx, creation = C,
					     modification = M, payload = P},
		      [NewItem | Acc]
	      end,
	  {atomic, NewRecs} =
	      mnesia:transaction(fun mnesia:foldl/3,
				 [F, [], pubsub_item]),
	  {atomic, ok} = mnesia:delete_table(pubsub_item),
	  {atomic, ok} = mnesia:create_table(pubsub_item,
					     [{disc_copies, [node()]},
					      {attributes,
					       record_info(fields,
							   pubsub_item)}]),
	  FNew = fun () ->
			 lists:foreach(fun mnesia:write/1, NewRecs)
		 end,
	  case mnesia:transaction(FNew) of
	    {atomic, Res2} ->
		?INFO_MSG("Pubsub item tables updated correctly: ~p",
			  [Res2]);
	    {aborted, Rea2} ->
		?ERROR_MSG("Problem updating Pubsub item table:~n~p",
			   [Rea2])
	  end;
      _ -> ok
    end.

send_loop(State) ->
    receive
      {presence, JID, Pid} ->
	  Host = State#state.host,
	  ServerHost = State#state.server_host,
	  LJID = jlib:jid_tolower(JID),
	  BJID = jlib:jid_remove_resource(LJID),
	  lists:foreach(fun (PType) ->
				{result, Subscriptions} = node_action(Host,
								      PType,
								      get_entity_subscriptions,
								      [Host,
								       JID]),
				lists:foreach(fun ({Node, subscribed, _,
						    SubJID}) ->
						      if (SubJID == LJID) or
							   (SubJID == BJID) ->
							     #pubsub_node{nodeid
									      =
									      {H,
									       N},
									  type =
									      Type,
									  id =
									      NodeId,
									  options
									      =
									      Options} =
								 Node,
							     case
							       get_option(Options,
									  send_last_published_item)
								 of
							       on_sub_and_presence ->
								   send_items(H,
									      N,
									      NodeId,
									      Type,
									      LJID,
									      last);
							       _ -> ok
							     end;
							 true ->
							     % resource not concerned about that subscription
							     ok
						      end;
						  (_) -> ok
					      end,
					      Subscriptions)
			end,
			State#state.plugins),
	  if not State#state.ignore_pep_from_offline ->
		 {User, Server, Resource} = jlib:jid_tolower(JID),
		 case catch ejabberd_c2s:get_subscribed(Pid) of
		   Contacts when is_list(Contacts) ->
		       lists:foreach(fun ({U, S, R}) ->
					     case S of
					       ServerHost ->  %% local contacts
						   case user_resources(U, S) of
						     [] -> %% offline
							 PeerJID =
							     jlib:make_jid(U, S,
									   R),
							 self() !
							   {presence, User,
							    Server, [Resource],
							    PeerJID};
						     _ -> %% online
							 % this is already handled by presence probe
							 ok
						   end;
					       _ ->  %% remote contacts
						   % we can not do anything in any cases
						   ok
					     end
				     end,
				     Contacts);
		   _ -> ok
		 end;
	     true -> ok
	  end,
	  send_loop(State);
      {presence, User, Server, Resources, JID} ->
	  spawn(fun () ->
			Host = State#state.host,
			Owner = jlib:jid_remove_resource(jlib:jid_tolower(JID)),
			lists:foreach(fun (#pubsub_node{nodeid = {_, Node},
							type = Type,
							id = NodeId,
							options = Options}) ->
					      case get_option(Options,
							      send_last_published_item)
						  of
						on_sub_and_presence ->
						    lists:foreach(fun
								    (Resource) ->
									LJID =
									    {User,
									     Server,
									     Resource},
									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,
												 []),
										  {OU,
										   OS,
										   _} =
										      Owner,
										  element(2,
											  get_roster_info(OU,
													  OS,
													  LJID,
													  Grps))
									    end,
									if
									  Subscribed ->
									      send_items(Owner,
											 Node,
											 NodeId,
											 Type,
											 LJID,
											 last);
									  true ->
									      ok
									end
								  end,
								  Resources);
						_ -> ok
					      end
				      end,
				      tree_action(Host, get_nodes,
						  [Owner, JID]))
		end),
	  send_loop(State);
      stop -> ok
    end.

%% -------
%% disco hooks handling functions
%%

-spec(disco_local_identity/5 ::
(
  Acc    :: [xmlel()],
  _From  :: jid(),
  To     :: jid(),
  NodeId :: <<>> | mod_pubsub:nodeId(),
  Lang   :: binary())
    -> [xmlel()]
).
disco_local_identity(Acc, _From, To, <<>>, _Lang) ->
    case lists:member(?PEPNODE, plugins(To#jid.lserver)) of
      true ->
	  [#xmlel{name = <<"identity">>,
		  attrs =
		      [{<<"category">>, <<"pubsub">>},
		       {<<"type">>, <<"pep">>}],
		  children = []}
	   | Acc];
      false -> Acc
    end;
disco_local_identity(Acc, _From, _To, _Node, _Lang) ->
    Acc.

-spec(disco_local_features/5 ::
(
  Acc    :: [xmlel()],
  _From  :: jid(),
  To     :: jid(),
  NodeId :: <<>> | mod_pubsub:nodeId(),
  Lang   :: binary())
    -> [binary(),...]
).
disco_local_features(Acc, _From, To, <<>>, _Lang) ->
    Host = To#jid.lserver,
    Feats = case Acc of
	      {result, I} -> I;
	      _ -> []
	    end,
    {result,
     Feats ++
       lists:map(fun (Feature) ->
			 <<(?NS_PUBSUB)/binary, "#", Feature/binary>>
		 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, Node, Lang)
%    when is_binary(Node) ->
%    disco_sm_identity(Acc, From, To, iolist_to_binary(Node),
%		      Lang);
-spec(disco_sm_identity/5 ::
(
  Acc  :: empty | [xmlel()],
  From :: jid(),
  To   :: jid(),
  Node :: mod_pubsub:nodeId(),
  Lang :: binary())
    -> [xmlel()]
).
disco_sm_identity(empty, From, To, Node, Lang) ->
    disco_sm_identity([], From, To, Node, Lang);
disco_sm_identity(Acc, From, To, Node, _Lang) ->
    disco_identity(jlib:jid_tolower(jlib:jid_remove_resource(To)), Node, From)
      ++ Acc.

disco_identity(_Host, <<>>, _From) ->
    [#xmlel{name = <<"identity">>,
	    attrs =
		[{<<"category">>, <<"pubsub">>},
		 {<<"type">>, <<"pep">>}],
	    children = []}];
disco_identity(Host, Node, From) ->
    Action = fun (#pubsub_node{id = Idx, type = Type,
			       options = Options, owners = Owners}) ->
		     case get_allowed_items_call(Host, Idx, From, Type, Options, Owners) of
		       {result, _} ->
			   {result,
			    [#xmlel{name = <<"identity">>,
				    attrs =
					[{<<"category">>, <<"pubsub">>},
					 {<<"type">>, <<"pep">>}],
				    children = []},
			     #xmlel{name = <<"identity">>,
				    attrs =
					[{<<"category">>, <<"pubsub">>},
					 {<<"type">>, <<"leaf">>}
					 | case get_option(Options, title) of
					     false -> [];
					     [Title] -> [{<<"name">>, Title}]
					   end],
				    children = []}]};
		       _ -> {result, []}
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Result}} -> Result;
      _ -> []
    end.

-spec(disco_sm_features/5 ::
(
  Acc  :: empty | {result, Features::[Feature::binary()]},
  From :: jid(),
  To   :: jid(),
  Node :: mod_pubsub:nodeId(),
  Lang :: binary())
    -> {result, Features::[Feature::binary()]}
).
%disco_sm_features(Acc, From, To, Node, Lang)
%    when is_binary(Node) ->
%    disco_sm_features(Acc, From, To, iolist_to_binary(Node),
%		      Lang);
disco_sm_features(empty, From, To, Node, Lang) ->
    disco_sm_features({result, []}, From, To, Node, Lang);
disco_sm_features({result, OtherFeatures} = _Acc, From, To, Node, _Lang) ->
    {result,
     OtherFeatures ++
       disco_features(jlib:jid_tolower(jlib:jid_remove_resource(To)), Node, From)};
disco_sm_features(Acc, _From, _To, _Node, _Lang) -> Acc.

disco_features(_Host, <<>>, _From) ->
    [?NS_PUBSUB | [<<(?NS_PUBSUB)/binary, "#", Feature/binary>>
        || Feature <- features(<<"pep">>)]];
disco_features(Host, Node, From) ->
    Action = fun (#pubsub_node{id = Idx, type = Type,
			       options = Options, owners = Owners}) ->
		     case get_allowed_items_call(Host, Idx, From, Type, Options, Owners) of
		       {result, _} ->
			   {result,
			    [?NS_PUBSUB | [<<(?NS_PUBSUB)/binary, "#",
					     Feature/binary>>
					   || Feature <- features(<<"pep">>)]]};
		       _ -> {result, []}
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Result}} -> Result;
      _ -> []
    end.

-spec(disco_sm_items/5 ::
(
  Acc  :: empty | {result, [xmlel()]},
  From :: jid(),
  To   :: jid(),
  Node :: mod_pubsub:nodeId(),
  Lang :: binary())
    -> {result, [xmlel()]}
).
%disco_sm_items(Acc, From, To, Node, Lang)
%    when is_binary(Node) ->
%    disco_sm_items(Acc, From, To, iolist_to_binary(Node),
%		   Lang);
disco_sm_items(empty, From, To, Node, Lang) ->
    disco_sm_items({result, []}, From, To, Node, Lang);
disco_sm_items({result, OtherItems}, From, To, Node, _Lang) ->
    {result,
     lists:usort(OtherItems ++
		disco_items(jlib:jid_tolower(jlib:jid_remove_resource(To)), Node, From))};
disco_sm_items(Acc, _From, _To, _Node, _Lang) -> Acc.

-spec(disco_items/3 ::
(
  Host :: mod_pubsub:host(),
  Node :: mod_pubsub:nodeId(),
  From :: jid())
    -> [xmlel()]
).
disco_items(Host, <<>>, From) ->
    Action = fun (#pubsub_node{nodeid = {_, NodeID},
			       options = Options, type = Type, id = Idx,
			       owners = Owners},
		  Acc) ->
		     case get_allowed_items_call(Host, Idx, From, Type, Options, Owners) of
		       {result, _} ->
			   [#xmlel{name = <<"item">>,
				   attrs =
				       [{<<"node">>, (NodeID)},
					{<<"jid">>,
					 case Host of
					   {_, _, _} ->
					       jlib:jid_to_string(Host);
					   _Host -> Host
					 end}
					| case get_option(Options, title) of
					    false -> [];
					    [Title] -> [{<<"name">>, Title}]
					  end],
				   children = []}
			    | Acc];
		       _ -> Acc
		     end
	     end,
    case transaction(Host, Action, sync_dirty) of
      {result, Items} -> Items;
      _ -> []
    end;
disco_items(Host, Node, From) ->
    Action = fun (#pubsub_node{id = Idx, type = Type,
			       options = Options, owners = Owners}) ->
		     case get_allowed_items_call(Host, Idx, From, Type,
						 Options, Owners)
			 of
		       {result, Items} ->
			   {result,
			    [#xmlel{name = <<"item">>,
				    attrs =
					[{<<"jid">>,
					  case Host of
					    {_, _, _} ->
						jlib:jid_to_string(Host);
					    _Host -> Host
					  end},
					 {<<"name">>, ItemID}],
				    children = []}
			     || #pubsub_item{itemid = {ItemID, _}} <- Items]};
		       _ -> {result, []}
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Result}} -> Result;
      _ -> []
    end.

%% -------
%% presence hooks handling functions
%%

caps_update(#jid{luser = U, lserver = S, lresource = R} = From, To, _Features) ->
    Pid = ejabberd_sm:get_session_pid(U, S, R),
    presence_probe(From, To, Pid).

presence_probe(#jid{luser = User, lserver = Server, lresource = Resource} = JID,
  JID, Pid) ->
    presence(Server, {presence, JID, Pid}),
    presence(Server, {presence, User, Server, [Resource], JID});
presence_probe(#jid{luser = User, lserver = Server},
  #jid{luser = User, lserver = Server}, _Pid) ->
    %% ignore presence_probe from other ressources for the current user
    %% this way, we do not send duplicated last items if user already connected with other clients
    ok;
presence_probe(#jid{luser = User, lserver = Server, lresource = Resource},
  #jid{lserver = Host} = JID, _Pid) ->
    presence(Host, {presence, User, Server, [Resource], JID}).

presence(ServerHost, Presence) ->
    SendLoop = case
		 whereis(gen_mod:get_module_proc(ServerHost, ?LOOPNAME))
		   of
		 undefined ->
		     Host = host(ServerHost),
		     Plugins = plugins(Host),
		     PepOffline = case catch
					 ets:lookup(gen_mod:get_module_proc(ServerHost,
									    config),
						    ignore_pep_from_offline)
				      of
				    [{ignore_pep_from_offline, PO}] -> PO;
				    _ -> true
				  end,
		     State = #state{host = Host, server_host = ServerHost,
				    ignore_pep_from_offline = PepOffline,
				    plugins = Plugins},
		     init_send_loop(ServerHost, State);
		 Pid -> Pid
	       end,
    SendLoop ! Presence.

%% -------
%% subscription hooks handling functions
%%

out_subscription(User, Server, JID, subscribed) ->
    Owner = jlib:make_jid(User, Server, <<"">>),
    {PUser, PServer, PResource} = jlib:jid_tolower(JID),
    PResources = case PResource of
		   <<>> -> user_resources(PUser, PServer);
		   _ -> [PResource]
		 end,
    presence(Server,
	     {presence, PUser, PServer, PResources, Owner}),
    true;
out_subscription(_, _, _, _) -> true.

in_subscription(_, User, Server, Owner, unsubscribed,
		_) ->
    unsubscribe_user(jlib:make_jid(User, Server, <<"">>),
		     Owner),
    true;
in_subscription(_, _, _, _, _, _) -> true.

unsubscribe_user(Entity, Owner) ->
    BJID = jlib:jid_tolower(jlib:jid_remove_resource(Owner)),
    Host = host(element(2, BJID)),
    spawn(fun () ->
		  lists:foreach(fun (PType) ->
					{result, Subscriptions} =
					    node_action(Host, PType,
							get_entity_subscriptions,
							[Host, Entity]),
					lists:foreach(fun ({#pubsub_node{options
									     =
									     Options,
									 owners
									     =
									     Owners,
									 id =
									     NodeId},
							    subscribed, _,
							    JID}) ->
							      case
								get_option(Options,
									   access_model)
								  of
								presence ->
								    case
								      lists:member(BJID,
										   Owners)
									of
								      true ->
									  node_action(Host,
										      PType,
										      unsubscribe_node,
										      [NodeId,
										       Entity,
										       JID,
										       all]);
								      false ->
									  {result,
									   ok}
								    end;
								_ ->
								    {result, ok}
							      end;
							  (_) -> ok
						      end,
						      Subscriptions)
				end,
				plugins(Host))
	  end).

%% -------
%% user remove hook handling function
%%

remove_user(User, Server) ->
    LUser = jlib:nodeprep(User),
    LServer = jlib:nameprep(Server),
    Entity = jlib:make_jid(LUser, LServer, <<"">>),
    Host = host(LServer),
    HomeTreeBase = <<"/home/", LServer/binary, "/", LUser/binary>>,
    spawn(fun () ->
		  lists:foreach(fun (PType) ->
					{result, Subscriptions} =
					    node_action(Host, PType,
							get_entity_subscriptions,
							[Host, Entity]),
					lists:foreach(fun ({#pubsub_node{id =
									     NodeId},
							    _, _, JID}) ->
							      node_action(Host,
									  PType,
									  unsubscribe_node,
									  [NodeId,
									   Entity,
									   JID,
									   all])
						      end,
						      Subscriptions),
					{result, Affiliations} =
					    node_action(Host, PType,
							get_entity_affiliations,
							[Host, Entity]),
					lists:foreach(fun ({#pubsub_node{nodeid
									     =
									     {H,
									      N},
									 parents
									     =
									     []},
							    owner}) ->
							      delete_node(H, N,
									  Entity);
							  ({#pubsub_node{nodeid
									     =
									     {H,
									      N},
									 type =
									     <<"hometree">>},
							    owner})
							      when N ==
								     HomeTreeBase ->
							      delete_node(H, N,
									  Entity);
							  ({#pubsub_node{id =
									     NodeId},
							    publisher}) ->
							      node_action(Host,
									  PType,
									  set_affiliation,
									  [NodeId,
									   Entity,
									   none]);
							  (_) -> ok
						      end,
						      Affiliations)
				end,
				plugins(Host))
	  end).

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}.

handle_cast(_Msg, State) -> {noreply, State}.

-spec(handle_info/2 ::
(
  _     :: {route, From::jid(), To::jid(), Packet::xmlel()},
  State :: state())
    -> {noreply, state()}
).

handle_info({route, From, To, Packet},
	    #state{server_host = ServerHost, access = Access,
		   plugins = Plugins} =
		State) ->
    case catch do_route(ServerHost, Access, Plugins,
			To#jid.lserver, From, To, Packet)
	of
      {'EXIT', Reason} -> ?ERROR_MSG("~p", [Reason]);
      _ -> ok
    end,
    {noreply, State};
handle_info(_Info, State) -> {noreply, State}.

terminate(_Reason,
	  #state{host = Host, server_host = ServerHost,
		 nodetree = TreePlugin, plugins = Plugins}) ->
    ejabberd_router:unregister_route(Host),
    case lists:member(?PEPNODE, Plugins) of
      true ->
	  ejabberd_hooks:delete(caps_update, ServerHost, ?MODULE,
				caps_update, 80),
	  ejabberd_hooks:delete(disco_sm_identity, ServerHost,
				?MODULE, disco_sm_identity, 75),
	  ejabberd_hooks:delete(disco_sm_features, ServerHost,
				?MODULE, disco_sm_features, 75),
	  ejabberd_hooks:delete(disco_sm_items, ServerHost,
				?MODULE, disco_sm_items, 75),
	  gen_iq_handler:remove_iq_handler(ejabberd_sm,
					   ServerHost, ?NS_PUBSUB),
	  gen_iq_handler:remove_iq_handler(ejabberd_sm,
					   ServerHost, ?NS_PUBSUB_OWNER);
      false -> ok
    end,
    ejabberd_hooks:delete(sm_remove_connection_hook,
			  ServerHost, ?MODULE, on_user_offline, 75),
    ejabberd_hooks:delete(disco_local_identity, ServerHost,
			  ?MODULE, disco_local_identity, 75),
    ejabberd_hooks:delete(disco_local_features, ServerHost,
			  ?MODULE, disco_local_features, 75),
    ejabberd_hooks:delete(disco_local_items, ServerHost,
			  ?MODULE, disco_local_items, 75),
    ejabberd_hooks:delete(presence_probe_hook, ServerHost,
			  ?MODULE, presence_probe, 80),
    ejabberd_hooks:delete(roster_in_subscription,
			  ServerHost, ?MODULE, in_subscription, 50),
    ejabberd_hooks:delete(roster_out_subscription,
			  ServerHost, ?MODULE, out_subscription, 50),
    ejabberd_hooks:delete(remove_user, ServerHost, ?MODULE,
			  remove_user, 50),
    ejabberd_hooks:delete(anonymous_purge_hook, ServerHost,
			  ?MODULE, remove_user, 50),
    mod_disco:unregister_feature(ServerHost, ?NS_PUBSUB),
    gen_mod:get_module_proc(ServerHost, ?LOOPNAME) ! stop,
    terminate_plugins(Host, ServerHost, Plugins,
		      TreePlugin).

code_change(_OldVsn, State, _Extra) -> {ok, State}.

-spec(do_route/7 ::
(
  ServerHost :: binary(),
  Access     :: atom(),
  Plugins    :: [binary(),...],
  Host       :: mod_pubsub:hostPubsub(),
  From       :: jid(),
  To         :: jid(),
  Packet     :: xmlel())
    -> ok
).

do_route(ServerHost, Access, Plugins, Host, From, To, Packet) ->
    #xmlel{name = Name, attrs = Attrs} = Packet,
    case To of
      #jid{luser = <<"">>, lresource = <<"">>} ->
	  case Name of
	    <<"iq">> ->
		case jlib:iq_query_info(Packet) of
		  #iq{type = get, xmlns = ?NS_DISCO_INFO, sub_el = SubEl,
		      lang = Lang} =
		      IQ ->
		      #xmlel{attrs = QAttrs} = SubEl,
		      Node = xml:get_attr_s(<<"node">>, QAttrs),
		      Info = ejabberd_hooks:run_fold(disco_info, ServerHost,
						     [],
						     [ServerHost, ?MODULE,
						      <<"">>, <<"">>]),
		      Res = case iq_disco_info(Host, Node, From, Lang) of
			      {result, IQRes} ->
				  jlib:iq_to_xml(IQ#iq{type = result,
						       sub_el =
							   [#xmlel{name =
								       <<"query">>,
								   attrs =
								       QAttrs,
								   children =
								       IQRes ++
									 Info}]});
			      {error, Error} ->
				  jlib:make_error_reply(Packet, Error)
			    end,
		      ejabberd_router:route(To, From, Res);
		  #iq{type = get, xmlns = ?NS_DISCO_ITEMS,
		      sub_el = SubEl} =
		      IQ ->
		      #xmlel{attrs = QAttrs} = SubEl,
		      Node = xml:get_attr_s(<<"node">>, QAttrs),
		      Res = case iq_disco_items(Host, Node, From) of
			      {result, IQRes} ->
				  jlib:iq_to_xml(IQ#iq{type = result,
						       sub_el =
							   [#xmlel{name =
								       <<"query">>,
								   attrs =
								       QAttrs,
								   children =
								       IQRes}]})
%			      {error, Error} ->
%				  jlib:make_error_reply(Packet, Error)
			    end,
		      ejabberd_router:route(To, From, Res);
		  #iq{type = IQType, xmlns = ?NS_PUBSUB, lang = Lang,
		      sub_el = SubEl} =
		      IQ ->
		      Res = case iq_pubsub(Host, ServerHost, From, IQType,
					   SubEl, Lang, Access, Plugins)
				of
			      {result, IQRes} ->
				  jlib:iq_to_xml(IQ#iq{type = result,
						       sub_el = IQRes});
			      {error, Error} ->
				  jlib:make_error_reply(Packet, Error)
			    end,
		      ejabberd_router:route(To, From, Res);
		  #iq{type = IQType, xmlns = ?NS_PUBSUB_OWNER,
		      lang = Lang, sub_el = SubEl} =
		      IQ ->
		      Res = case iq_pubsub_owner(Host, ServerHost, From,
						 IQType, SubEl, Lang)
				of
			      {result, IQRes} ->
				  jlib:iq_to_xml(IQ#iq{type = result,
						       sub_el = IQRes});
			      {error, Error} ->
				  jlib:make_error_reply(Packet, Error)
			    end,
		      ejabberd_router:route(To, From, Res);
		  #iq{type = get, xmlns = (?NS_VCARD) = XMLNS,
		      lang = Lang, sub_el = _SubEl} =
		      IQ ->
		      Res = IQ#iq{type = result,
				  sub_el =
				      [#xmlel{name = <<"vCard">>,
					      attrs = [{<<"xmlns">>, XMLNS}],
					      children = iq_get_vcard(Lang)}]},
		      ejabberd_router:route(To, From, jlib:iq_to_xml(Res));
		  #iq{type = set, xmlns = ?NS_COMMANDS} = IQ ->
		      Res = case iq_command(Host, ServerHost, From, IQ,
					    Access, Plugins)
				of
			      {error, Error} ->
				  jlib:make_error_reply(Packet, Error);
			      {result, IQRes} ->
				  jlib:iq_to_xml(IQ#iq{type = result,
						       sub_el = IQRes})
			    end,
		      ejabberd_router:route(To, From, Res);
		  #iq{} ->
		      Err = jlib:make_error_reply(Packet,
						  ?ERR_FEATURE_NOT_IMPLEMENTED),
		      ejabberd_router:route(To, From, Err);
		  _ -> ok
		end;
	    <<"message">> ->
		case xml:get_attr_s(<<"type">>, Attrs) of
		  <<"error">> -> ok;
		  _ ->
		      case find_authorization_response(Packet) of
			none -> ok;
			invalid ->
			    ejabberd_router:route(To, From,
						  jlib:make_error_reply(Packet,
									?ERR_BAD_REQUEST));
			XFields ->
			    handle_authorization_response(Host, From, To,
							  Packet, XFields)
		      end
		end;
	    _ -> ok
	  end;
      _ ->
	  case xml:get_attr_s(<<"type">>, Attrs) of
	    <<"error">> -> ok;
	    <<"result">> -> ok;
	    _ ->
		Err = jlib:make_error_reply(Packet,
					    ?ERR_ITEM_NOT_FOUND),
		ejabberd_router:route(To, From, Err)
	  end
    end.

command_disco_info(_Host, ?NS_COMMANDS, _From) ->
    IdentityEl = #xmlel{name = <<"identity">>,
			attrs =
			    [{<<"category">>, <<"automation">>},
			     {<<"type">>, <<"command-list">>}],
			children = []},
    {result, [IdentityEl]};
command_disco_info(_Host, ?NS_PUBSUB_GET_PENDING,
		   _From) ->
    IdentityEl = #xmlel{name = <<"identity">>,
			attrs =
			    [{<<"category">>, <<"automation">>},
			     {<<"type">>, <<"command-node">>}],
			children = []},
    FeaturesEl = #xmlel{name = <<"feature">>,
			attrs = [{<<"var">>, ?NS_COMMANDS}], children = []},
    {result, [IdentityEl, FeaturesEl]}.

node_disco_info(Host, Node, From) ->
    node_disco_info(Host, Node, From, true, true).

node_disco_info(Host, Node, From, Identity, Features) ->
%    Action =
%	fun(#pubsub_node{type = Type, id = NodeId}) ->
%		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, [NodeId, From]) of
%					    {result, []} -> [<<"collection">>];
%					    {result, _} -> [<<"leaf">>, <<"collection">>];
%					    _ -> []
%					end
%				end,
%			    lists:map(fun(T) ->
%						 #xmlel{name = <<"identity">>,
%							attrs =
%							    [{<<"category">>,
%							      <<"pubsub">>},
%							     {<<"type">>, T}],
%							children = []}
%				      end, Types)
%		    end,
%		F = case Features of
%			false ->
%			    [];
%			true ->
%			    [#xmlel{name = <<"feature">>,
%				       attrs = [{<<"var">>, ?NS_PUBSUB}],
%				       children = []}
%				| lists:map(fun (T) ->
%						    #xmlel{name = <<"feature">>,
%							   attrs =
%							       [{<<"var">>,
%								 <<(?NS_PUBSUB)/binary,
%								   "#",
%								   T/binary>>}],
%							   children = []}
%					    end,
%					    features(Type))]
%		    end,
%		%% TODO: add meta-data info (spec section 5.4)
%		{result, I ++ F}
%	end,
%    case transaction(Host, Node, Action, sync_dirty) of
%	{result, {_, Result}} -> {result, Result};
%	Other -> Other
%    end.
    Action = fun (#pubsub_node{type = Type, id = NodeId}) ->
		     I = Types = case tree_call(Host, get_subnodes,
						      [Host, Node, From])
					   of
					 [] -> [<<"leaf">>];
					 _ ->
					     case node_call(Type, get_items,
							    [NodeId, From])
						 of
					       {result, []} ->
						   [<<"collection">>];
					       {result, _} ->
						   [<<"leaf">>,
						    <<"collection">>];
					       _ -> []
					     end
				       end,
			       lists:map(fun (T) ->
						 #xmlel{name = <<"identity">>,
							attrs =
							    [{<<"category">>,
							      <<"pubsub">>},
							     {<<"type">>, T}],
							children = []}
					 end,
					 Types),
		     F = [#xmlel{name = <<"feature">>,
				       attrs = [{<<"var">>, ?NS_PUBSUB}],
				       children = []}
				| lists:map(fun (T) ->
						    #xmlel{name = <<"feature">>,
							   attrs =
							       [{<<"var">>,
								 <<(?NS_PUBSUB)/binary,
								   "#",
								   T/binary>>}],
							   children = []}
					    end,
					    features(Type))],
		     {result, I ++ F}
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Result}} -> {result, Result};
      Other -> Other
    end.

iq_disco_info(Host, SNode, From, Lang) ->
    [Node | _] = case SNode of
			<<>> -> [<<>>];
			_ -> str:tokens(SNode, <<"!">>)
		      end,
 %   Node = string_to_node(RealSNode),
    case Node of
      <<>> ->
	  {result,
	   [#xmlel{name = <<"identity">>,
		   attrs =
		       [{<<"category">>, <<"pubsub">>},
			{<<"type">>, <<"service">>},
			{<<"name">>,
			 translate:translate(Lang, <<"Publish-Subscribe">>)}],
		   children = []},
	    #xmlel{name = <<"feature">>,
		   attrs = [{<<"var">>, ?NS_DISCO_INFO}], children = []},
	    #xmlel{name = <<"feature">>,
		   attrs = [{<<"var">>, ?NS_DISCO_ITEMS}], children = []},
	    #xmlel{name = <<"feature">>,
		   attrs = [{<<"var">>, ?NS_PUBSUB}], children = []},
	    #xmlel{name = <<"feature">>,
		   attrs = [{<<"var">>, ?NS_COMMANDS}], children = []},
	    #xmlel{name = <<"feature">>,
		   attrs = [{<<"var">>, ?NS_VCARD}], children = []}]
	     ++
	     lists:map(fun (Feature) ->
			       #xmlel{name = <<"feature">>,
				      attrs =
					  [{<<"var">>, <<(?NS_PUBSUB)/binary, "#", Feature/binary>>}],
				      children = []}
		       end,
		       features(Host, Node))};
      ?NS_COMMANDS -> command_disco_info(Host, Node, From);
      ?NS_PUBSUB_GET_PENDING ->
	  command_disco_info(Host, Node, From);
      _ -> node_disco_info(Host, Node, From)
    end.

-spec(iq_disco_items/3 ::
(
  Host   :: mod_pubsub:host(),
  NodeId :: <<>> | mod_pubsub:nodeId(),
  From   :: jid())
    -> {result, [xmlel()]}
).
iq_disco_items(Host, <<>>, From) ->
	  {result,
	   lists:map(fun (#pubsub_node{nodeid = {_, SubNode},
				       options = Options}) ->
			     Attrs = case get_option(Options, title) of
				       false ->
					   [{<<"jid">>, Host}
					    | nodeAttr(SubNode)];
				       Title ->
					   [{<<"jid">>, Host},
					    {<<"name">>, Title}
					    | nodeAttr(SubNode)]
				     end,
			     #xmlel{name = <<"item">>, attrs = Attrs,
				    children = []}
		     end,
		     tree_action(Host, get_subnodes, [Host, <<>>, From]))};
%    case tree_action(Host, get_subnodes, [Host, <<>>, From]) of
%      Nodes when is_list(Nodes) ->
%	  {result,
%	   lists:map(fun (#pubsub_node{nodeid = {_, SubNode},
%				       options = Options}) ->
%			     Attrs = case get_option(Options, title) of
%				       false ->
%					   [{<<"jid">>, Host}
%					    | nodeAttr(SubNode)];
%				       Title ->
%					   [{<<"jid">>, Host},
%					    {<<"name">>, Title}
%					    | nodeAttr(SubNode)]
%				     end,
%			     #xmlel{name = <<"item">>, attrs = Attrs,
%				    children = []}
%		     end,
%		     Nodes)};
%      Other -> Other
%    end;
iq_disco_items(Host, ?NS_COMMANDS, _From) ->
    CommandItems = [#xmlel{name = <<"item">>,
			   attrs =
			       [{<<"jid">>, Host},
				{<<"node">>, ?NS_PUBSUB_GET_PENDING},
				{<<"name">>, <<"Get Pending">>}],
			   children = []}],
    {result, CommandItems};
iq_disco_items(_Host, ?NS_PUBSUB_GET_PENDING, _From) ->
    CommandItems = [], {result, CommandItems};
iq_disco_items(Host, Item, From) ->
    case str:tokens(Item, <<"!">>) of
      [_Node, _ItemID] -> {result, []};
      [Node] ->
%	  Node = string_to_node(SNode),
	  Action = fun (#pubsub_node{id = Idx, type = Type,
				     options = Options, owners = Owners}) ->
			   NodeItems = case get_allowed_items_call(Host, Idx,
								   From, Type,
								   Options,
								   Owners)
					   of
					 {result, R} -> R;
					 _ -> []
				       end,
			   Nodes = lists:map(fun (#pubsub_node{nodeid =
								   {_, SubNode},
							       options =
								   SubOptions}) ->
						     Attrs = case
							       get_option(SubOptions,
									  title)
								 of
							       false ->
								   [{<<"jid">>,
								     Host}
								    | nodeAttr(SubNode)];
							       Title ->
								   [{<<"jid">>,
								     Host},
								    {<<"name">>,
								     Title}
								    | nodeAttr(SubNode)]
							     end,
						     #xmlel{name = <<"item">>,
							    attrs = Attrs,
							    children = []}
					     end,
					     tree_call(Host, get_subnodes,
						       [Host, Node, From])),
			   Items = lists:map(fun (#pubsub_item{itemid =
								   {RN, _}}) ->
						     {result, Name} =
							 node_call(Type,
								   get_item_name,
								   [Host, Node,
								    RN]),
						     #xmlel{name = <<"item">>,
							    attrs =
								[{<<"jid">>,
								  Host},
								 {<<"name">>,
								  Name}],
							    children = []}
					     end,
					     NodeItems),
			   {result, Nodes ++ Items}
		   end,
	  case transaction(Host, Node, Action, sync_dirty) of
	    {result, {_, Result}} -> {result, Result};
	    Other -> Other
	  end
    end.

-spec(iq_sm/3 ::
(
  From :: jid(),
  To   :: jid(),
  IQ   :: iq_request())
    -> iq_result() | iq_error()
).
iq_sm(From, To, #iq{type = Type, sub_el = SubEl, xmlns = XMLNS, lang = Lang} = IQ) ->
    ServerHost = To#jid.lserver,
    LOwner = jlib:jid_tolower(jlib:jid_remove_resource(To)),
    Res = case XMLNS of
	    ?NS_PUBSUB ->
		iq_pubsub(LOwner, ServerHost, From, Type, SubEl, Lang);
	    ?NS_PUBSUB_OWNER ->
		iq_pubsub_owner(LOwner, ServerHost, From, Type, SubEl,
				Lang)
	  end,
    case Res of
      {result, IQRes} -> IQ#iq{type = result, sub_el = IQRes};
      {error, Error} ->
	  IQ#iq{type = error, sub_el = [Error, SubEl]}
    end.

iq_get_vcard(Lang) ->
    [#xmlel{name = <<"FN">>, attrs = [],
	    children = [{xmlcdata, <<"ejabberd/mod_pubsub">>}]},
     #xmlel{name = <<"URL">>, attrs = [],
	    children = [{xmlcdata, ?EJABBERD_URI}]},
     #xmlel{name = <<"DESC">>, attrs = [],
	    children =
		[{xmlcdata,
		  <<(translate:translate(Lang,
					 <<"ejabberd Publish-Subscribe module">>))/binary,
		    "\nCopyright (c) 2004-2012 ProcessOne">>}]}].

-spec(iq_pubsub/6 ::
(
  Host       :: mod_pubsub:host(),
  ServerHost :: binary(),
  From       :: jid(),
  IQType     :: 'get' | 'set',
  SubEl      :: xmlel(),
  Lang       :: binary())
    -> {result, [xmlel()]}
    %%%
     | {error, xmlel()}
).

iq_pubsub(Host, ServerHost, From, IQType, SubEl, Lang) ->
    iq_pubsub(Host, ServerHost, From, IQType, SubEl, Lang, all, plugins(ServerHost)).

-spec(iq_pubsub/8 ::
(
  Host       :: mod_pubsub:host(),
  ServerHost :: binary(),
  From       :: jid(),
  IQType     :: 'get' | 'set',
  SubEl      :: xmlel(),
  Lang       :: binary(),
  Access     :: atom(),
  Plugins    :: [binary(),...])
    -> {result, [xmlel()]}
    %%%
     | {error, xmlel()}
).

iq_pubsub(Host, ServerHost, From, IQType, SubEl, Lang, Access, Plugins) ->
    #xmlel{children = SubEls} = SubEl,
    case xml:remove_cdata(SubEls) of
      [#xmlel{name = Name, attrs = Attrs, children = Els} | Rest] ->
	  Node = xml:get_attr_s(<<"node">>, Attrs),
	  case {IQType, Name} of
	    {set, <<"create">>} ->
		Config = case Rest of
			   [#xmlel{name = <<"configure">>, children = C}] -> C;
			   _ -> []
			 end,
		Type = case xml:get_attr_s(<<"type">>, Attrs) of
			 <<>> -> hd(Plugins);
			 T -> T
		       end,
		case lists:member(Type, Plugins) of
		  false ->
		      {error,
		       extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
				      unsupported, <<"create-nodes">>)};
		  true ->
		      create_node(Host, ServerHost, Node, From, Type, Access, Config)
		end;
	    {set, <<"publish">>} ->
		case xml:remove_cdata(Els) of
		  [#xmlel{name = <<"item">>, attrs = ItemAttrs,
			  children = Payload}] ->
		      ItemId = xml:get_attr_s(<<"id">>, ItemAttrs),
		      publish_item(Host, ServerHost, Node, From, ItemId, Payload);
		  [] ->
		      {error,
		       extended_error(?ERR_BAD_REQUEST, <<"item-required">>)};
		  _ ->
		      {error,
		       extended_error(?ERR_BAD_REQUEST, <<"invalid-payload">>)}
		end;
	    {set, <<"retract">>} ->
		ForceNotify = case xml:get_attr_s(<<"notify">>, Attrs)
				  of
				<<"1">> -> true;
				<<"true">> -> true;
				_ -> false
			      end,
		case xml:remove_cdata(Els) of
		  [#xmlel{name = <<"item">>, attrs = ItemAttrs}] ->
		      ItemId = xml:get_attr_s(<<"id">>, ItemAttrs),
		      delete_item(Host, Node, From, ItemId, ForceNotify);
		  _ ->
		      {error,
		       extended_error(?ERR_BAD_REQUEST, <<"item-required">>)}
		end;
	    {set, <<"subscribe">>} ->
		Config = case Rest of
			   [#xmlel{name = <<"options">>, children = C}] -> C;
			   _ -> []
			 end,
		JID = xml:get_attr_s(<<"jid">>, Attrs),
		subscribe_node(Host, Node, From, JID, Config);
	    {set, <<"unsubscribe">>} ->
		JID = xml:get_attr_s(<<"jid">>, Attrs),
		SubId = xml:get_attr_s(<<"subid">>, Attrs),
		unsubscribe_node(Host, Node, From, JID, SubId);
	    {get, <<"items">>} ->
		MaxItems = xml:get_attr_s(<<"max_items">>, Attrs),
		SubId = xml:get_attr_s(<<"subid">>, Attrs),
		ItemIDs = lists:foldl(fun (#xmlel{name = <<"item">>,
						  attrs = ItemAttrs},
					   Acc) ->
					      case xml:get_attr_s(<<"id">>,
								  ItemAttrs)
						  of
						<<"">> -> Acc;
						ItemID -> [ItemID | Acc]
					      end;
					  (_, Acc) -> Acc
				      end,
				      [], xml:remove_cdata(Els)),
		get_items(Host, Node, From, SubId, MaxItems, ItemIDs);
	    {get, <<"subscriptions">>} ->
		get_subscriptions(Host, Node, From, Plugins);
	    {get, <<"affiliations">>} ->
		get_affiliations(Host, Node, From, Plugins);
	    {get, <<"options">>} ->
		SubID = xml:get_attr_s(<<"subid">>, Attrs),
		JID = xml:get_attr_s(<<"jid">>, Attrs),
		get_options(Host, Node, JID, SubID, Lang);
	    {set, <<"options">>} ->
		SubID = xml:get_attr_s(<<"subid">>, Attrs),
		JID = xml:get_attr_s(<<"jid">>, Attrs),
		set_options(Host, Node, JID, SubID, Els);
	    _ -> {error, ?ERR_FEATURE_NOT_IMPLEMENTED}
	  end;
      Other ->
	  ?INFO_MSG("Too many actions: ~p", [Other]),
	  {error, ?ERR_BAD_REQUEST}
    end.


-spec(iq_pubsub_owner/6 ::
(
  Host       :: mod_pubsub:host(),
  ServerHost :: binary(),
  From       :: jid(),
  IQType     :: 'get' | 'set',
  SubEl      :: xmlel(),
  Lang       :: binary())
    -> {result, [xmlel()]}
    %%%
     | {error, xmlel()}
).
iq_pubsub_owner(Host, ServerHost, From, IQType, SubEl, Lang) ->
    #xmlel{children = SubEls} = SubEl,
    Action = xml:remove_cdata(SubEls),
    case Action of
      [#xmlel{name = Name, attrs = Attrs, children = Els}] ->
	  Node = xml:get_attr_s(<<"node">>, Attrs),
	  case {IQType, Name} of
	    {get, <<"configure">>} ->
		get_configure(Host, ServerHost, 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,
				  xml:remove_cdata(Els));
	    {get, <<"affiliations">>} ->
		get_affiliations(Host, Node, From);
	    {set, <<"affiliations">>} ->
		set_affiliations(Host, Node, From, xml:remove_cdata(Els));
	    _ -> {error, ?ERR_FEATURE_NOT_IMPLEMENTED}
	  end;
      _ ->
	  ?INFO_MSG("Too many actions: ~p", [Action]),
	  {error, ?ERR_BAD_REQUEST}
    end.

iq_command(Host, ServerHost, From, IQ, Access, Plugins) ->
    case adhoc:parse_request(IQ) of
      Req when is_record(Req, adhoc_request) ->
	  case adhoc_request(Host, ServerHost, From, Req, Access,
			     Plugins)
	      of
	    Resp when is_record(Resp, adhoc_response) ->
		{result, [adhoc:produce_response(Req, Resp)]};
	    Error -> Error
	  end;
      Err -> Err
    end.

adhoc_request(Host, _ServerHost, Owner,
	      #adhoc_request{node = ?NS_PUBSUB_GET_PENDING,
			     lang = Lang, action = <<"execute">>,
			     xdata = false},
	      _Access, Plugins) ->
    send_pending_node_form(Host, Owner, Lang, Plugins);
adhoc_request(Host, _ServerHost, Owner,
	      #adhoc_request{node = ?NS_PUBSUB_GET_PENDING,
			     action = <<"execute">>, xdata = XData},
	      _Access, _Plugins) ->
    ParseOptions = case XData of
		     #xmlel{name = <<"x">>} = XEl ->
			 case jlib:parse_xdata_submit(XEl) of
			   invalid -> {error, ?ERR_BAD_REQUEST};
			   XData2 ->
			       case set_xoption(Host, XData2, []) of
				 NewOpts when is_list(NewOpts) ->
				     {result, NewOpts};
				 Err -> Err
			       end
			 end;
		     _ ->
			 ?INFO_MSG("Bad XForm: ~p", [XData]),
			 {error, ?ERR_BAD_REQUEST}
		   end,
    case ParseOptions of
      {result, XForm} ->
	  case lists:keysearch(node, 1, XForm) of
	    {value, {_, Node}} ->
		send_pending_auth_events(Host, Node, Owner);
	    false ->
		{error,
		 extended_error(?ERR_BAD_REQUEST, <<"bad-payload">>)}
	  end;
      Error -> Error
    end;
adhoc_request(_Host, _ServerHost, _Owner,
	      #adhoc_request{action = <<"cancel">>}, _Access,
	      _Plugins) ->
    #adhoc_response{status = canceled};
adhoc_request(Host, ServerHost, Owner,
	      #adhoc_request{action = <<>>} = R, Access, Plugins) ->
    adhoc_request(Host, ServerHost, Owner,
		  R#adhoc_request{action = <<"execute">>}, Access,
		  Plugins);
adhoc_request(_Host, _ServerHost, _Owner, Other,
	      _Access, _Plugins) ->
    ?DEBUG("Couldn't process ad hoc command:~n~p", [Other]),
    {error, ?ERR_ITEM_NOT_FOUND}.

send_pending_node_form(Host, Owner, _Lang, Plugins) ->
    Filter = fun (Plugin) ->
		     lists:member(<<"get-pending">>, features(Plugin))
	     end,
    case lists:filter(Filter, Plugins) of
      [] -> {error, ?ERR_FEATURE_NOT_IMPLEMENTED};
      Ps ->
	  XOpts = lists:map(fun (Node) ->
				    #xmlel{name = <<"option">>, attrs = [],
					   children =
					       [#xmlel{name = <<"value">>,
						       attrs = [],
						       children =
							   [{xmlcdata, Node}]}]}
			    end,
			    get_pending_nodes(Host, Owner, Ps)),
	  XForm = #xmlel{name = <<"x">>,
			 attrs =
			     [{<<"xmlns">>, ?NS_XDATA},
			      {<<"type">>, <<"form">>}],
			 children =
			     [#xmlel{name = <<"field">>,
				     attrs =
					 [{<<"type">>, <<"list-single">>},
					  {<<"var">>, <<"pubsub#node">>}],
				     children = lists:usort(XOpts)}]},
	  #adhoc_response{status = executing,
			  defaultaction = <<"execute">>, elements = [XForm]}
    end.

get_pending_nodes(Host, Owner, Plugins) ->
    Tr = fun (Type) ->
		 case node_call(Type, get_pending_nodes, [Host, Owner])
		     of
		   {result, Nodes} -> Nodes;
		   _ -> []
		 end
	 end,
    case transaction(fun () ->
			     {result, lists:flatmap(Tr, Plugins)}
		     end,
		     sync_dirty)
	of
      {result, Res} -> Res;
      Err -> Err
    end.

send_pending_auth_events(Host, Node, Owner) ->
    ?DEBUG("Sending pending auth events for ~s on "
	   "~s:~s",
	   [jlib:jid_to_string(Owner), Host, Node]),
    Action = fun (#pubsub_node{id = NodeID, type = Type}) ->
		     case lists:member(<<"get-pending">>, features(Type)) of
		       true ->
			   case node_call(Type, get_affiliation,
					  [NodeID, Owner])
			       of
			     {result, owner} ->
				 node_call(Type, get_node_subscriptions,
					   [NodeID]);
			     _ -> {error, ?ERR_FORBIDDEN}
			   end;
		       false -> {error, ?ERR_FEATURE_NOT_IMPLEMENTED}
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {N, Subscriptions}} ->
	  lists:foreach(fun ({J, pending, _SubID}) ->
				send_authorization_request(N, jlib:make_jid(J));
			    ({J, pending}) ->
				send_authorization_request(N, jlib:make_jid(J));
			    (_) -> ok
			end,
			Subscriptions),
	  #adhoc_response{};
      Err -> Err
    end.

%%% authorization handling

send_authorization_request(#pubsub_node{owners = Owners, nodeid = {Host, Node}},
	Subscriber) ->
    Lang = <<"en">>,
    Stanza = #xmlel{name = <<"message">>, attrs = [],
		    children =
			[#xmlel{name = <<"x">>,
				attrs =
				    [{<<"xmlns">>, ?NS_XDATA},
				     {<<"type">>, <<"form">>}],
				children =
				    [#xmlel{name = <<"title">>, attrs = [],
					    children =
						[{xmlcdata,
						  translate:translate(Lang,
								      <<"PubSub subscriber request">>)}]},
				     #xmlel{name = <<"instructions">>,
					    attrs = [],
					    children =
						[{xmlcdata,
						  translate:translate(Lang,
								      <<"Choose whether to approve this entity's "
									"subscription.">>)}]},
				     #xmlel{name = <<"field">>,
					    attrs =
						[{<<"var">>, <<"FORM_TYPE">>},
						 {<<"type">>, <<"hidden">>}],
					    children =
						[#xmlel{name = <<"value">>,
							attrs = [],
							children =
							    [{xmlcdata,
							      ?NS_PUBSUB_SUB_AUTH}]}]},
				     #xmlel{name = <<"field">>,
					    attrs =
						[{<<"var">>, <<"pubsub#node">>},
						 {<<"type">>,
						  <<"text-single">>},
						 {<<"label">>,
						  translate:translate(Lang,
								      <<"Node ID">>)}],
					    children =
						[#xmlel{name = <<"value">>,
							attrs = [],
							children =
							    [{xmlcdata, Node}]}]},
				     #xmlel{name = <<"field">>,
					    attrs =
						[{<<"var">>,
						  <<"pubsub#subscriber_jid">>},
						 {<<"type">>, <<"jid-single">>},
						 {<<"label">>,
						  translate:translate(Lang,
								      <<"Subscriber Address">>)}],
					    children =
						[#xmlel{name = <<"value">>,
							attrs = [],
							children =
							    [{xmlcdata,
							      jlib:jid_to_string(Subscriber)}]}]},
				     #xmlel{name = <<"field">>,
					    attrs =
						[{<<"var">>,
						  <<"pubsub#allow">>},
						 {<<"type">>, <<"boolean">>},
						 {<<"label">>,
						  translate:translate(Lang,
								      <<"Allow this Jabber ID to subscribe to "
									"this pubsub node?">>)}],
					    children =
						[#xmlel{name = <<"value">>,
							attrs = [],
							children =
							    [{xmlcdata,
							      <<"false">>}]}]}]}]},
    lists:foreach(fun (Owner) ->
			  ejabberd_router:route(service_jid(Host),
						jlib:make_jid(Owner), Stanza)
		  end,
		  Owners).

find_authorization_response(Packet) ->
    #xmlel{children = Els} = Packet,
    XData1 = lists:map(fun (#xmlel{name = <<"x">>,
				   attrs = XAttrs} =
				XEl) ->
			       case xml:get_attr_s(<<"xmlns">>, XAttrs) of
				 ?NS_XDATA ->
				     case xml:get_attr_s(<<"type">>, XAttrs) of
				       <<"cancel">> -> none;
				       _ -> jlib:parse_xdata_submit(XEl)
				     end;
				 _ -> none
			       end;
			   (_) -> none
		       end,
		       xml:remove_cdata(Els)),
    XData = lists:filter(fun (E) -> E /= none end, XData1),
    case XData of
      [invalid] -> invalid;
      [] -> none;
      [XFields] when is_list(XFields) ->
	  ?DEBUG("XFields: ~p", [XFields]),
	  case lists:keysearch(<<"FORM_TYPE">>, 1, XFields) of
	    {value, {_, [?NS_PUBSUB_SUB_AUTH]}} -> XFields;
	    _ -> invalid
	  end
    end.
%% TODO : ask Christophe's opinion
send_authorization_approval(Host, JID, SNode, Subscription) ->
    SubAttrs = case Subscription of
%		 {S, SID} ->
%		     [{<<"subscription">>, subscription_to_string(S)},
%		      {<<"subid">>, SID}];
		 S -> [{<<"subscription">>, subscription_to_string(S)}]
	       end,
    Stanza = event_stanza([#xmlel{name = <<"subscription">>,
				  attrs =
				      [{<<"jid">>, jlib:jid_to_string(JID)}
				       | nodeAttr(SNode)]
					++ SubAttrs,
				  children = []}]),
    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, {_, [Node]}}, {value, {_, [SSubscriber]}},
       {value, {_, [SAllow]}}} ->
%	  Node = string_to_node(SNode),
	  Subscriber = jlib:string_to_jid(SSubscriber),
	  Allow = case SAllow of
		    <<"1">> -> true;
		    <<"true">> -> true;
		    _ -> false
		  end,
	  Action = fun (#pubsub_node{type = Type, owners = Owners,
				     id = NodeId}) ->
			   IsApprover =
			       lists:member(jlib:jid_tolower(jlib:jid_remove_resource(From)),
					    Owners),
			   {result, Subscriptions} = node_call(Type,
							       get_subscriptions,
							       [NodeId,
								Subscriber]),
			   if not IsApprover -> {error, ?ERR_FORBIDDEN};
			      true ->
				  update_auth(Host, Node, Type, NodeId,
					      Subscriber, Allow, Subscriptions)
			   end
		   end,
	  case transaction(Host, Node, Action, sync_dirty) of
	    {error, Error} ->
		ejabberd_router:route(To, From,
				      jlib:make_error_reply(Packet, Error));
	    {result, {_, _NewSubscription}} ->
		%% XXX: notify about subscription state change, section 12.11
		ok;
	    _ ->
		ejabberd_router:route(To, From,
				      jlib:make_error_reply(Packet,
							    ?ERR_INTERNAL_SERVER_ERROR))
	  end;
      _ ->
	  ejabberd_router:route(To, From,
				jlib:make_error_reply(Packet,
						      ?ERR_NOT_ACCEPTABLE))
    end.

update_auth(Host, Node, Type, NodeId, Subscriber, Allow,
	    Subscriptions) ->
    Subscription = lists:filter(fun ({pending, _}) -> true;
				    (_) -> false
				end,
				Subscriptions),
    case Subscription of
      [{pending, SubID}] ->
	  NewSubscription = case Allow of
			      true -> subscribed;
			      false -> none
			    end,
	  node_call(Type, set_subscriptions,
		    [NodeId, Subscriber, NewSubscription, SubID]),
	  send_authorization_approval(Host, Subscriber, Node,
				      NewSubscription),
	  {result, ok};
      _ -> {error, ?ERR_UNEXPECTED_REQUEST}
    end.

-define(XFIELD(Type, Label, Var, Val),
	#xmlel{name = <<"field">>,
	       attrs =
		   [{<<"type">>, Type},
		    {<<"label">>, translate:translate(Lang, Label)},
		    {<<"var">>, Var}],
	       children =
		   [#xmlel{name = <<"value">>, attrs = [],
			   children = [{xmlcdata, 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(STRINGMXFIELD(Label, Var, Vals),
	#xmlel{name = <<"field">>,
	       attrs =
		   [{<<"type">>, <<"text-multi">>},
		    {<<"label">>, translate:translate(Lang, Label)},
		    {<<"var">>, Var}],
	       children =
		   [#xmlel{name = <<"value">>, attrs = [],
			   children = [{xmlcdata, V}]}
		    || V <- Vals]}).

-define(XFIELDOPT(Type, Label, Var, Val, Opts),
	#xmlel{name = <<"field">>,
	       attrs =
		   [{<<"type">>, Type},
		    {<<"label">>, translate:translate(Lang, Label)},
		    {<<"var">>, Var}],
	       children =
		   lists:map(fun (Opt) ->
				     #xmlel{name = <<"option">>, attrs = [],
					    children =
						[#xmlel{name = <<"value">>,
							attrs = [],
							children =
							    [{xmlcdata, Opt}]}]}
			     end,
			     Opts)
		     ++
		     [#xmlel{name = <<"value">>, attrs = [],
			     children = [{xmlcdata, Val}]}]}).

-define(LISTXFIELD(Label, Var, Val, Opts),
	?XFIELDOPT(<<"list-single">>, Label, Var, Val, Opts)).

-define(LISTMXFIELD(Label, Var, Vals, Opts),
	#xmlel{name = <<"field">>,
	       attrs =
		   [{<<"type">>, <<"list-multi">>},
		    {<<"label">>, translate:translate(Lang, Label)},
		    {<<"var">>, Var}],
	       children =
		   lists:map(fun (Opt) ->
				     #xmlel{name = <<"option">>, attrs = [],
					    children =
						[#xmlel{name = <<"value">>,
							attrs = [],
							children =
							    [{xmlcdata, Opt}]}]}
			     end,
			     Opts)
		     ++
		     lists:map(fun (Val) ->
				       #xmlel{name = <<"value">>, attrs = [],
					      children = [{xmlcdata, Val}]}
			       end,
			       Vals)}).

-spec(create_node/5 ::
(
  Host       :: mod_pubsub:host(),
  ServerHost :: binary(),
  Node       :: <<>> | mod_pubsub:nodeId(),
  Owner      :: jid(),
  Type       :: binary())
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).

create_node(Host, ServerHost, Node, Owner, Type) ->
    create_node(Host, ServerHost, Node, Owner, Type, all, []).

-spec(create_node/7 ::
(
  Host          :: mod_pubsub:host(),
  ServerHost    :: binary(),
  Node          :: <<>> | mod_pubsub:nodeId(),
  Owner         :: jid(),
  Type          :: binary(),
  Access        :: atom(),
  Configuration :: [xmlel()])
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).
create_node(Host, ServerHost, <<>>, Owner, Type, Access, Configuration) ->
    case lists:member(<<"instant-nodes">>, features(Type)) of
      true ->
	  NewNode = randoms:get_string(),
	  case create_node(Host, ServerHost, NewNode, Owner, Type,
			 Access, Configuration)
	      of
	    {result, _} ->
		{result,
		 [#xmlel{name = <<"pubsub">>,
			 attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
			 children =
			     [#xmlel{name = <<"create">>,
				     attrs = nodeAttr(NewNode),
				     children = []}]}]};
	    Error -> Error
	  end;
      false ->
	  {error,
	   extended_error(?ERR_NOT_ACCEPTABLE,
			  <<"nodeid-required">>)}
    end;
create_node(Host, ServerHost, Node, Owner, GivenType, Access, Configuration) ->
    Type = select_type(ServerHost, Host, Node, GivenType),
    ParseOptions = case xml:remove_cdata(Configuration) of
		     [] -> {result, node_options(Type)};
		     [#xmlel{name = <<"x">>} = XEl] ->
			 case jlib:parse_xdata_submit(XEl) of
			   invalid -> {error, ?ERR_BAD_REQUEST};
			   XData ->
			       case set_xoption(Host, 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, ?ERR_BAD_REQUEST}
		   end,
    case ParseOptions of
      {result, NodeOptions} ->
	  CreateNode = fun () ->
			       Parent = case node_call(Type, node_to_path, [Node]) of
					  {result, [Node]} -> <<>>;
					  {result, Path} ->
					      element(2,
						      node_call(Type, path_to_node,
						        [lists:sublist(Path, length(Path)-1)]))
					end,
			       Parents = case Parent of
					   <<>> -> [];
					   _ -> [Parent]
					 end,
			       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, Parents])
					 of
				       {ok, NodeId} ->
					   case node_call(Type, create_node, [NodeId, Owner]) of
					     {result, Result} ->
						 {result, {NodeId, Result}};
					     Error -> Error
					   end;
				       {error, {virtual, NodeId}} ->
					   case node_call(Type, create_node, [NodeId, Owner]) of
					     {result, Result} ->
						 {result, {NodeId, [], Result}};
					     Error -> Error
					   end;
				       Error -> Error
				     end;
				 _ -> {error, ?ERR_FORBIDDEN}
			       end
		       end,
	  Reply = [#xmlel{name = <<"pubsub">>,
			  attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
			  children =
			      [#xmlel{name = <<"create">>,
				      attrs = nodeAttr(Node), children = []}]}],
	  case transaction(CreateNode, transaction) of
	    {result, {NodeId, {Result, broadcast}}} ->
		broadcast_created_node(Host, Node, NodeId, Type,
				       NodeOptions),
		ejabberd_hooks:run(pubsub_create_node, ServerHost,
				   [ServerHost, Host, Node, NodeId,
				    NodeOptions]),
		case Result of
		  default -> {result, Reply};
		  _ -> {result, Result}
		end;
	    {result, {NodeId, default}} ->
		ejabberd_hooks:run(pubsub_create_node, ServerHost,
				   [ServerHost, Host, Node, NodeId,
				    NodeOptions]),
		{result, Reply};
	    {result, {NodeId, Result}} ->
		ejabberd_hooks:run(pubsub_create_node, ServerHost,
				   [ServerHost, Host, Node, NodeId,
				    NodeOptions]),
		{result, Result};
	    Error ->
		%% in case we change transaction to sync_dirty...
		%%  node_call(Type, delete_node, [Host, Node]),
		%%  tree_call(Host, delete_node, [Host, Node]),
		Error
	  end;
      Error -> Error
    end.

-spec(delete_node/3 ::
(
  Host  :: mod_pubsub:host(),
  Node  :: mod_pubsub:nodeId(),
  Owner :: jid())
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).
delete_node(_Host, <<>>, _Owner) ->
    {error, ?ERR_NOT_ALLOWED};
delete_node(Host, Node, Owner) ->
    Action = fun (#pubsub_node{type = Type, id = NodeIdx}) ->
		     case node_call(Type, get_affiliation, [NodeIdx, Owner]) of
		       {result, owner} ->
			   Removed = tree_call(Host, delete_node, [Host, Node]),
			   case node_call(Type, delete_node, [Removed]) of
			     {result, Res} -> {result, Res};
			     Error -> Error
			   end;
		       _ -> {error, ?ERR_FORBIDDEN}
		     end
	     end,
    Reply = [],
    ServerHost = get(server_host),
    case transaction(Host, Node, Action, transaction) of
      {result, {_, {Result, broadcast, Removed}}} ->
	  lists:foreach(fun ({RNode, _RSubscriptions}) ->
				{RH, RN} = RNode#pubsub_node.nodeid,
				NodeId = RNode#pubsub_node.id,
				Type = RNode#pubsub_node.type,
				Options = RNode#pubsub_node.options,
				broadcast_removed_node(RH, RN, NodeId, Type,
						       Options),
				ejabberd_hooks:run(pubsub_delete_node,
						   ServerHost,
						   [ServerHost, RH, RN, NodeId])
			end,
			Removed),
	  case Result of
	    default -> {result, Reply};
	    _ -> {result, Result}
	  end;
      {result, {_, {Result, Removed}}} ->
	  lists:foreach(fun ({RNode, _RSubscriptions}) ->
				{RH, RN} = RNode#pubsub_node.nodeid,
				NodeId = RNode#pubsub_node.id,
				ejabberd_hooks:run(pubsub_delete_node,
						   ServerHost,
						   [ServerHost, RH, RN, NodeId])
			end,
			Removed),
	  case Result of
	    default -> {result, Reply};
	    _ -> {result, Result}
	  end;
      {result, {TNode, default}} ->
	  NodeId = TNode#pubsub_node.id,
	  ejabberd_hooks:run(pubsub_delete_node, ServerHost,
			     [ServerHost, Host, Node, NodeId]),
	  {result, Reply};
      {result, {TNode, Result}} ->
	  NodeId = TNode#pubsub_node.id,
	  ejabberd_hooks:run(pubsub_delete_node, ServerHost,
			     [ServerHost, Host, Node, NodeId]),
	  {result, Result};
      Error -> Error
    end.

-spec(subscribe_node/5 ::
(
  Host          :: mod_pubsub:host(),
  Node          :: mod_pubsub:nodeId(),
  From          :: jid(),
  JID           :: binary(),
  Configuration :: [xmlel()])
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).
subscribe_node(Host, Node, From, JID, Configuration) ->
    SubOpts = case
		pubsub_subscription:parse_options_xform(Configuration)
		  of
		{result, GoodSubOpts} -> GoodSubOpts;
		_ -> invalid
	      end,
    Subscriber = case jlib:string_to_jid(JID) of
		   error -> {<<"">>, <<"">>, <<"">>};
		   J ->
		    case jlib:jid_tolower(J) of
		      error -> {<<"">>, <<"">>, <<"">>};
		      J1 -> J1
		    end
		 end,
    Action = fun (#pubsub_node{options = Options,
			       owners = Owners, type = Type, id = NodeId}) ->
		     Features = features(Type),
		     SubscribeFeature = lists:member(<<"subscribe">>, Features),
		     OptionsFeature = lists:member(<<"subscription-options">>, Features),
		     HasOptions = not (SubOpts == []),
		     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} =
			    get_presence_and_roster_permissions(Host, Subscriber,
					Owners, AccessModel, AllowedGroups),
		     if not SubscribeFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported, <<"subscribe">>)};
			not SubscribeConfig ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported, <<"subscribe">>)};
			HasOptions andalso not OptionsFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported,
					    <<"subscription-options">>)};
			SubOpts == invalid ->
			    {error,
			     extended_error(?ERR_BAD_REQUEST,
					    <<"invalid-options">>)};
			true ->
			    node_call(Type, subscribe_node,
				      [NodeId, From, Subscriber, AccessModel,
				       SendLast, PresenceSubscription,
				       RosterGroup, SubOpts])
		     end
	     end,
    Reply = fun (Subscription) ->
		    SubAttrs = case Subscription of
				 {subscribed, SubId} ->
				     [{<<"subscription">>,
				       subscription_to_string(subscribed)},
				      {<<"subid">>, SubId}, {<<"node">>, Node}];
				 Other ->
				     [{<<"subscription">>,
				       subscription_to_string(Other)},
				      {<<"node">>, Node}]
			       end,
		    Fields = [{<<"jid">>, jlib:jid_to_string(Subscriber)}
			      | SubAttrs],
		    [#xmlel{name = <<"pubsub">>,
			    attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
			    children =
				[#xmlel{name = <<"subscription">>,
					attrs = Fields, children = []}]}]
	    end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result,
       {TNode, {Result, subscribed, SubId, send_last}}} ->
	  NodeId = TNode#pubsub_node.id,
	  Type = TNode#pubsub_node.type,
	  send_items(Host, Node, NodeId, Type, Subscriber, last),
	  case Result of
	    default -> {result, Reply({subscribed, SubId})};
	    _ -> {result, Result}
	  end;
      {result, {_TNode, {default, subscribed, SubId}}} ->
	  {result, Reply({subscribed, SubId})};
      {result, {_TNode, {Result, subscribed, _SubId}}} ->
	  {result, Result};
      {result, {TNode, {default, pending, _SubId}}} ->
	  send_authorization_request(TNode, Subscriber),
	  {result, Reply(pending)};
      {result, {TNode, {Result, pending}}} ->
	  send_authorization_request(TNode, Subscriber),
	  {result, Result};
      {result, {_, Result}} -> {result, Result};
      Error -> Error
    end.

-spec(unsubscribe_node/5 ::
(
  Host  :: mod_pubsub:host(),
  Node  :: mod_pubsub:nodeId(),
  From  :: jid(),
  JID   :: binary() | ljid(),
  SubId :: mod_pubsub:subId())
    -> {result, []}
    %%%
     | {error, xmlel()}
).
unsubscribe_node(Host, Node, From, JID, SubId)
    when is_binary(JID) ->
    Subscriber = case jlib:string_to_jid(JID) of
		   error -> {<<"">>, <<"">>, <<"">>};
		   J ->
		    case jlib:jid_tolower(J) of
		        error -> {<<"">>, <<"">>, <<"">>};
		        J1 -> J1
		    end
		 end,
    unsubscribe_node(Host, Node, From, Subscriber, SubId);
unsubscribe_node(Host, Node, From, Subscriber, SubId) ->
    Action = fun (#pubsub_node{type = Type, id = NodeId}) ->
		     node_call(Type, unsubscribe_node,
			       [NodeId, From, Subscriber, SubId])
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, default}} -> {result, []};
%      {result, {_, Result}} -> {result, Result};
      Error -> Error
    end.

-spec(publish_item/6 ::
(
  Host       :: mod_pubsub:host(),
  ServerHost :: binary(),
  Node       :: mod_pubsub:nodeId(),
  Publisher  :: jid(),
  ItemId     :: <<>> | mod_pubsub:itemId(),
  Payload    :: mod_pubsub:payload())
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).
publish_item(Host, ServerHost, Node, Publisher, <<>>, Payload) ->
    publish_item(Host, ServerHost, Node, Publisher, uniqid(), Payload);
publish_item(Host, ServerHost, Node, Publisher, ItemId, Payload) ->
    Action = fun (#pubsub_node{options = Options, type = Type, id = NodeId}) ->
		     Features = features(Type),
		     PublishFeature = lists:member(<<"publish">>, Features),
		     PublishModel = get_option(Options, publish_model),
		     DeliverPayloads = get_option(Options, deliver_payloads),
		     PersistItems = get_option(Options, persist_items),
		     MaxItems = case PersistItems of
				  false -> 0;
				  true -> max_items(Host, Options)
				end,
		     PayloadCount = payload_xmlelements(Payload),
		     PayloadSize = byte_size(term_to_binary(Payload)) - 2,
		     PayloadMaxSize = get_option(Options, max_payload_size),
		     if not PublishFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					unsupported, <<"publish">>)};
			PayloadSize > PayloadMaxSize ->
			    {error,
			     extended_error(?ERR_NOT_ACCEPTABLE, <<"payload-too-big">>)};
			(PayloadCount == 0) and (Payload == []) ->
			    {error,
			     extended_error(?ERR_BAD_REQUEST, <<"payload-required">>)};
			(PayloadCount > 1) or (PayloadCount == 0) ->
			    {error,
			     extended_error(?ERR_BAD_REQUEST, <<"invalid-payload">>)};
			(DeliverPayloads == false) and (PersistItems == false) and
			  (PayloadSize > 0) ->
			    {error,
			     extended_error(?ERR_BAD_REQUEST, <<"item-forbidden">>)};
			((DeliverPayloads == true) or (PersistItems == true)) and
			  (PayloadSize == 0) ->
			    {error,
			     extended_error(?ERR_BAD_REQUEST, <<"item-required">>)};
			true ->
			    node_call(Type, publish_item,
				    [NodeId, Publisher, PublishModel, MaxItems, ItemId, Payload])
		     end
	     end,
    Reply = [#xmlel{name = <<"pubsub">>,
		    attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
		    children =
			[#xmlel{name = <<"publish">>, attrs = nodeAttr(Node),
				children =
				    [#xmlel{name = <<"item">>,
					    attrs = itemAttr(ItemId),
					    children = []}]}]}],
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {TNode, {Result, Broadcast, Removed}}} ->
	  NodeId = TNode#pubsub_node.id,
	  Type = TNode#pubsub_node.type,
	  Options = TNode#pubsub_node.options,
	  BrPayload = case Broadcast of
			broadcast -> Payload;
			PluginPayload -> PluginPayload
		      end,
	  ejabberd_hooks:run(pubsub_publish_item, ServerHost,
			     [ServerHost, Node, Publisher, service_jid(Host),
			      ItemId, BrPayload]),
	  set_cached_item(Host, NodeId, ItemId, Publisher,
			  BrPayload),
	  case get_option(Options, deliver_notifications) of
	    true ->
		broadcast_publish_item(Host, Node, NodeId, Type,
				       Options, ItemId,
				       Publisher, BrPayload,
				       Removed);
	    false -> ok
	  end,
	  case Result of
	    default -> {result, Reply};
	    _ -> {result, Result}
	  end;
      {result, {TNode, {default, Removed}}} ->
	  NodeId = TNode#pubsub_node.id,
	  Type = TNode#pubsub_node.type,
	  Options = TNode#pubsub_node.options,
	  broadcast_retract_items(Host, Node, NodeId, Type,
				  Options, Removed),
	  set_cached_item(Host, NodeId, ItemId, Publisher,
			  Payload),
	  {result, Reply};
      {result, {TNode, {Result, Removed}}} ->
	  NodeId = TNode#pubsub_node.id,
	  Type = TNode#pubsub_node.type,
	  Options = TNode#pubsub_node.options,
	  broadcast_retract_items(Host, Node, NodeId, Type,
				  Options, Removed),
	  set_cached_item(Host, NodeId, ItemId, Publisher,
			  Payload),
	  {result, Result};
      {result, {_, default}} -> {result, Reply};
      {result, {_, Result}} -> {result, Result};
      {error, ?ERR_ITEM_NOT_FOUND} ->
	  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,
		   [#xmlel{name = <<"pubsub">>,
			   attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
			   children =
			       [#xmlel{name = <<"create">>,
				       attrs = [{<<"node">>, NewNode}],
				       children = []}]}]} ->
		      publish_item(Host, ServerHost,
				   iolist_to_binary(NewNode), Publisher, ItemId,
				   Payload);
		  _ -> {error, ?ERR_ITEM_NOT_FOUND}
		end;
	    false -> {error, ?ERR_ITEM_NOT_FOUND}
	  end;
      Error -> Error
    end.

-spec(delete_item/4 ::
(
  Host      :: mod_pubsub:host(),
  Node      :: mod_pubsub:nodeId(),
  Publisher :: jid(),
  ItemId    :: mod_pubsub:itemId())
    -> {result, []}
    %%%
     | {error, xmlel()}
).
delete_item(Host, Node, Publisher, ItemId) ->
    delete_item(Host, Node, Publisher, ItemId, false).


delete_item(_, <<"">>, _, _, _) ->
    {error,
     extended_error(?ERR_BAD_REQUEST, <<"node-required">>)};
delete_item(Host, Node, Publisher, ItemId, ForceNotify) ->
    Action = fun (#pubsub_node{options = Options, type = Type, id = NodeId}) ->
		     Features = features(Type),
		     PersistentFeature = lists:member(<<"persistent-items">>, Features),
		     DeleteFeature = lists:member(<<"delete-items">>, Features),
		     PublishModel = get_option(Options, publish_model),
		     if %%->   iq_pubsub just does that matchs
			%%	%% Request does not specify an item
			%%	{error, extended_error(?ERR_BAD_REQUEST, "item-required")};
			not PersistentFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported,
					    <<"persistent-items">>)};
			not DeleteFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported, <<"delete-items">>)};
			true ->
			    node_call(Type, delete_item,
				      [NodeId, Publisher, PublishModel, ItemId])
		     end
	     end,
    Reply = [],
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {TNode, {Result, broadcast}}} ->
	  NodeId = TNode#pubsub_node.id,
	  Type = TNode#pubsub_node.type,
	  Options = TNode#pubsub_node.options,
	  broadcast_retract_items(Host, Node, NodeId, Type,
				  Options, [ItemId], ForceNotify),
	  case get_cached_item(Host, NodeId) of
	    #pubsub_item{itemid = {ItemId, NodeId}} ->
		unset_cached_item(Host, NodeId);
	    _ -> ok
	  end,
	  case Result of
	    default -> {result, Reply};
	    _ -> {result, Result}
	  end;
      {result, {_, default}} -> {result, Reply};
      {result, {_, Result}} -> {result, Result};
      Error -> Error
    end.

-spec(purge_node/3 ::
(
  Host  :: mod_pubsub:host(),
  Node  :: mod_pubsub:nodeId(),
  Owner :: jid())
    -> {result, []}
    %%%
     | {error, xmlel()}
).
purge_node(Host, Node, Owner) ->
    Action = fun (#pubsub_node{options = Options, type = Type, id = NodeId}) ->
		     Features = features(Type),
		     PurgeFeature = lists:member(<<"purge-nodes">>, Features),
		     PersistentFeature = lists:member(<<"persistent-items">>, Features),
		     PersistentConfig = get_option(Options, persist_items),
		     if not PurgeFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported, <<"purge-nodes">>)};
			not PersistentFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported,
					    <<"persistent-items">>)};
			not PersistentConfig ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported,
					    <<"persistent-items">>)};
			true -> node_call(Type, purge_node, [NodeId, Owner])
		     end
	     end,
    Reply = [],
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {TNode, {Result, broadcast}}} ->
	  NodeId = TNode#pubsub_node.id,
	  Type = TNode#pubsub_node.type,
	  Options = TNode#pubsub_node.options,
	  broadcast_purge_node(Host, Node, NodeId, Type, Options),
	  unset_cached_item(Host, NodeId),
	  case Result of
	    default -> {result, Reply};
	    _ -> {result, Result}
	  end;
      {result, {_, default}} -> {result, Reply};
      {result, {_, Result}} -> {result, Result};
      Error -> Error
    end.

-spec(get_items/6 ::
(
  Host      :: mod_pubsub:host(),
  Node      :: mod_pubsub:nodeId(),
  From      :: jid(),
  SubId     :: mod_pubsub:subId(),
  SMaxItems :: binary(),
  ItemIDs   :: [mod_pubsub:itemId()])
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).
get_items(Host, Node, From, SubId, SMaxItems, ItemIDs) ->
    MaxItems = if SMaxItems == <<"">> ->
		      get_max_items_node(Host);
		  true ->
		      case catch jlib:binary_to_integer(SMaxItems) of
			{'EXIT', _} -> {error, ?ERR_BAD_REQUEST};
			Val -> Val
		      end
	       end,
    case MaxItems of
      {error, Error} -> {error, Error};
      _ ->
	  Action = fun (#pubsub_node{options = Options, type = Type, id = NodeId,
				     owners = Owners}) ->
			   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} =
			       get_presence_and_roster_permissions(Host, From, Owners,
					    AccessModel, AllowedGroups),
			   if not RetreiveFeature ->
				  {error,
				   extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
						  unsupported,
						  <<"retrieve-items">>)};
			      not PersistentFeature ->
				  {error,
				   extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
						  unsupported,
						  <<"persistent-items">>)};
			      true ->
				  node_call(Type, get_items,
					    [NodeId, From, AccessModel,
					     PresenceSubscription, RosterGroup,
					     SubId])
			   end
		   end,
	  case transaction(Host, Node, Action, sync_dirty) of
	    {result, {_, Items}} ->
		SendItems = case ItemIDs of
			      [] -> Items;
			      _ ->
				  lists:filter(fun (#pubsub_item{itemid =
								     {ItemId,
								      _}}) ->
						       lists:member(ItemId,
								    ItemIDs)
					       end,
					       Items)
			    end,
		{result,
		 [#xmlel{name = <<"pubsub">>,
			 attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
			 children =
			     [#xmlel{name = <<"items">>, attrs = nodeAttr(Node),
				     children =
					 itemsEls(lists:sublist(SendItems,
								MaxItems))}]}]};
	    Error -> Error
	  end
    end.

get_items(Host, Node) ->
    Action = fun (#pubsub_node{type = Type, id = NodeId}) ->
		     node_call(Type, get_items, [NodeId, service_jid(Host)])
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Items}} -> Items;
      Error -> Error
    end.

get_item(Host, Node, ItemId) ->
    Action = fun (#pubsub_node{type = Type, id = NodeId}) ->
		     node_call(Type, get_item, [NodeId, ItemId])
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Items}} -> Items;
      Error -> Error
    end.

get_allowed_items_call(Host, NodeIdx, From, Type, Options, Owners) ->
    AccessModel = get_option(Options, access_model),
    AllowedGroups = get_option(Options, roster_groups_allowed, []),
    {PresenceSubscription, RosterGroup} =
	    get_presence_and_roster_permissions(Host, From, Owners, AccessModel,
	        AllowedGroups),
    node_call(Type, get_items,
	      [NodeIdx, From, AccessModel, PresenceSubscription, RosterGroup, undefined]).

send_items(Host, Node, NodeId, Type, {U, S, R} = LJID, last) ->
    case get_cached_item(Host, NodeId) of
      undefined ->
	  send_items(Host, Node, NodeId, Type, LJID, 1);
      LastItem ->
	  {ModifNow, ModifUSR} =
	      LastItem#pubsub_item.modification,
	  Stanza = event_stanza_with_delay([#xmlel{name =
						       <<"items">>,
						   attrs = nodeAttr(Node),
						   children =
						       itemsEls([LastItem])}],
					   ModifNow, ModifUSR),
	  case is_tuple(Host) of
	    false ->
		ejabberd_router:route(service_jid(Host),
				      jlib:make_jid(LJID), Stanza);
	    true ->
		case ejabberd_sm:get_session_pid(U, S, R) of
		  C2SPid when is_pid(C2SPid) ->
		      ejabberd_c2s:broadcast(C2SPid,
					     {pep_message,
					      <<((Node))/binary, "+notify">>},
					     _Sender = service_jid(Host),
					     Stanza);
		  _ -> ok
		end
	  end
    end;
send_items(Host, Node, NodeId, Type, {U, S, R} = LJID,
	   Number) ->
    ToSend = case node_action(Host, Type, get_items,
			      [NodeId, LJID])
		 of
	       {result, []} -> [];
	       {result, Items} ->
		   case Number of
		     N when N > 0 -> lists:sublist(Items, N);
		     _ -> Items
		   end;
	       _ -> []
	     end,
    Stanza = case ToSend of
	       [LastItem] ->
		   {ModifNow, ModifUSR} =
		       LastItem#pubsub_item.modification,
		   event_stanza_with_delay([#xmlel{name = <<"items">>,
						   attrs = nodeAttr(Node),
						   children =
						       itemsEls(ToSend)}],
					   ModifNow, ModifUSR);
	       _ ->
		   event_stanza([#xmlel{name = <<"items">>,
					attrs = nodeAttr(Node),
					children = itemsEls(ToSend)}])
	     end,
    case is_tuple(Host) of
      false ->
	  ejabberd_router:route(service_jid(Host),
				jlib:make_jid(LJID), Stanza);
      true ->
	  case ejabberd_sm:get_session_pid(U, S, R) of
	    C2SPid when is_pid(C2SPid) ->
		ejabberd_c2s:broadcast(C2SPid,
				       {pep_message,
					<<((Node))/binary, "+notify">>},
				       _Sender = service_jid(Host), Stanza);
	    _ -> ok
	  end
    end.

-spec(get_affiliations/4 ::
(
  Host    :: mod_pubsub:host(),
  Node    :: mod_pubsub:nodeId(),
  JID     :: jid(),
  Plugins :: [binary()])
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).
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 ->
					{{error,
					  extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
							 unsupported,
							 <<"retrieve-affiliations">>)},
					 Acc};
				    true ->
					{result, Affiliations} =
					    node_action(Host, Type,
							get_entity_affiliations,
							[Host, JID]),
					{Status, [Affiliations | Acc]}
				 end
			 end,
			 {ok, []}, Plugins),
    case Result of
      {ok, Affiliations} ->
	  Entities = lists:flatmap(fun ({_, none}) -> [];
				       ({#pubsub_node{nodeid = {_, Node}},
					 Affiliation}) ->
					   [#xmlel{name = <<"affiliation">>,
						   attrs =
						       [{<<"affiliation">>,
							 affiliation_to_string(Affiliation)}
							| nodeAttr(Node)],
						   children = []}]
				   end,
				   lists:usort(lists:flatten(Affiliations))),
	  {result,
	   [#xmlel{name = <<"pubsub">>,
		   attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
		   children =
		       [#xmlel{name = <<"affiliations">>, attrs = [],
			       children = Entities}]}]};
      {Error, _} -> Error
    end;
get_affiliations(Host, NodeId, 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 ->
					{{error,
					  extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
							 unsupported,
							 <<"retrieve-affiliations">>)},
					 Acc};
				    true ->
					{result, Affiliations} =
					    node_action(Host, Type,
							get_entity_affiliations,
							[Host, JID]),
					{Status, [Affiliations | Acc]}
				 end
			 end,
			 {ok, []}, Plugins),
    case Result of
      {ok, Affiliations} ->
	  Entities = lists:flatmap(fun ({_, none}) -> [];
				       ({#pubsub_node{nodeid = {_, Node}},
					 Affiliation})
					   when NodeId == Node ->
					   [#xmlel{name = <<"affiliation">>,
						   attrs =
						       [{<<"affiliation">>,
							 affiliation_to_string(Affiliation)}
							| nodeAttr(Node)],
						   children = []}];
				       (_) -> []
				   end,
				   lists:usort(lists:flatten(Affiliations))),
	  {result,
	   [#xmlel{name = <<"pubsub">>,
		   attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
		   children =
		       [#xmlel{name = <<"affiliations">>, attrs = [],
			       children = Entities}]}]};
      {Error, _} -> Error
    end.

-spec(get_affiliations/3 ::
(
  Host :: mod_pubsub:host(),
  Node :: mod_pubsub:nodeId(),
  JID  :: jid())
    -> {result, [xmlel(),...]}
    %%%
     | {error, xmlel()}
).
get_affiliations(Host, Node, JID) ->
    Action = fun (#pubsub_node{type = Type, id = NodeId}) ->
		     Features = features(Type),
		     RetrieveFeature =
			 lists:member(<<"modify-affiliations">>, Features),
		     {result, Affiliation} = node_call(Type, get_affiliation,
						       [NodeId, JID]),
		     if not RetrieveFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported,
					    <<"modify-affiliations">>)};
			Affiliation /= owner -> {error, ?ERR_FORBIDDEN};
			true -> node_call(Type, get_node_affiliations, [NodeId])
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, []}} -> {error, ?ERR_ITEM_NOT_FOUND};
      {result, {_, Affiliations}} ->
	  Entities = lists:flatmap(fun ({_, none}) -> [];
				       ({AJID, Affiliation}) ->
					   [#xmlel{name = <<"affiliation">>,
						   attrs =
						       [{<<"jid">>,
							 jlib:jid_to_string(AJID)},
							{<<"affiliation">>,
							 affiliation_to_string(Affiliation)}],
						   children = []}]
				   end,
				   Affiliations),
	  {result,
	   [#xmlel{name = <<"pubsub">>,
		   attrs = [{<<"xmlns">>, ?NS_PUBSUB_OWNER}],
		   children =
		       [#xmlel{name = <<"affiliations">>,
			       attrs = nodeAttr(Node), children = Entities}]}]};
      Error -> Error
    end.

-spec(set_affiliations/4 ::
(
  Host        :: mod_pubsub:host(),
  Node        :: mod_pubsub:nodeId(),
  From        :: jid(),
  EntitiesEls :: [xmlel()])
    -> {result, []}
    %%%
     | {error, xmlel()}
).
set_affiliations(Host, Node, From, EntitiesEls) ->
    Owner = jlib:jid_tolower(jlib:jid_remove_resource(From)),
    Entities = lists:foldl(fun (El, Acc) ->
				   case Acc of
				     error -> error;
				     _ ->
					 case El of
					   #xmlel{name = <<"affiliation">>,
						  attrs = Attrs} ->
					       JID =
						   jlib:string_to_jid(xml:get_attr_s(<<"jid">>,
										     Attrs)),
					       Affiliation =
						   string_to_affiliation(xml:get_attr_s(<<"affiliation">>,
											Attrs)),
					       if (JID == error) or
						    (Affiliation == false) ->
						      error;
						  true ->
						      [{jlib:jid_tolower(JID),
							Affiliation}
						       | Acc]
					       end
					 end
				   end
			   end,
			   [], EntitiesEls),
    case Entities of
      error -> {error, ?ERR_BAD_REQUEST};
      _ ->
	  Action = fun (#pubsub_node{owners = Owners, type = Type,
				     id = NodeId} =
			    N) ->
			   case lists:member(Owner, Owners) of
			     true ->
				 OwnerJID = jlib:make_jid(Owner),
				 FilteredEntities = case Owners of
						      [Owner] ->
							  [E
							   || E <- Entities,
							      element(1, E) =/=
								OwnerJID];
						      _ -> Entities
						    end,
				 lists:foreach(fun ({JID, Affiliation}) ->
						       node_call(Type,
								 set_affiliation,
								 [NodeId, JID,
								  Affiliation]),
						       case Affiliation of
							 owner ->
							     NewOwner =
								 jlib:jid_tolower(jlib:jid_remove_resource(JID)),
							     NewOwners =
								 [NewOwner
								  | Owners],
							     tree_call(Host,
								       set_node,
								       [N#pubsub_node{owners
											  =
											  NewOwners}]);
							 none ->
							     OldOwner =
								 jlib:jid_tolower(jlib:jid_remove_resource(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,
					       FilteredEntities),
				 {result, []};
			     _ -> {error, ?ERR_FORBIDDEN}
			   end
		   end,
	  case transaction(Host, Node, Action, sync_dirty) of
	    {result, {_, Result}} -> {result, Result};
	    Other -> Other
	  end
    end.

get_options(Host, Node, JID, SubID, Lang) ->
    Action = fun (#pubsub_node{type = Type, id = NodeID}) ->
		     case lists:member(<<"subscription-options">>, features(Type)) of
		       true ->
			   get_options_helper(JID, Lang, Node, NodeID, SubID, Type);
		       false ->
			   {error,
			    extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					   unsupported,
					   <<"subscription-options">>)}
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_Node, XForm}} -> {result, [XForm]};
      Error -> Error
    end.

get_options_helper(JID, Lang, Node, NodeID, SubID, Type) ->
    Subscriber = case jlib:string_to_jid(JID) of
		   error -> {<<"">>, <<"">>, <<"">>};
		   J -> case jlib:jid_tolower(J) of
		    error -> {<<"">>, <<"">>, <<"">>};
		    J1 -> J1
		   end
		 end,
    {result, Subs} = node_call(Type, get_subscriptions,
			       [NodeID, Subscriber]),
    SubIDs = lists:foldl(fun ({subscribed, SID}, Acc) ->
				 [SID | Acc];
			     (_, Acc) -> Acc
			 end,
			 [], Subs),
    case {SubID, SubIDs} of
      {_, []} ->
	  {error,
	   extended_error(?ERR_NOT_ACCEPTABLE, <<"not-subscribed">>)};
      {<<>>, [SID]} ->
	  read_sub(Subscriber, Node, NodeID, SID, Lang);
      {<<>>, _} ->
	  {error,
	   extended_error(?ERR_NOT_ACCEPTABLE, <<"subid-required">>)};
      {_, _} ->
	  read_sub(Subscriber, Node, NodeID, SubID, Lang)
    end.

read_sub(Subscriber, Node, NodeID, SubID, Lang) ->
    case pubsub_subscription:get_subscription(Subscriber, NodeID, SubID) of
      {result, #pubsub_subscription{options = Options}} ->
	  {result, XdataEl} =
	      pubsub_subscription:get_options_xform(Lang, Options),
	  OptionsEl = #xmlel{name = <<"options">>,
			     attrs =
				 [{<<"jid">>, jlib:jid_to_string(Subscriber)},
				  {<<"subid">>, SubID}
				  | nodeAttr(Node)],
			     children = [XdataEl]},
	  PubsubEl = #xmlel{name = <<"pubsub">>,
			    attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
			    children = [OptionsEl]},
	  {result, PubsubEl};
      _ ->
	  OptionsEl = #xmlel{name = <<"options">>,
			     attrs =
				 [{<<"jid">>, jlib:jid_to_string(Subscriber)},
				  {<<"subid">>, SubID}
				  | nodeAttr(Node)],
			     children = []},
	  PubsubEl = #xmlel{name = <<"pubsub">>,
			    attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
			    children = [OptionsEl]},
	  {result, PubsubEl}
    end.

set_options(Host, Node, JID, SubID, Configuration) ->
    Action = fun (#pubsub_node{type = Type, id = NodeID}) ->
		     case lists:member(<<"subscription-options">>,
				       features(Type))
			 of
		       true ->
			   set_options_helper(Configuration, JID, NodeID, SubID,
					      Type);
		       false ->
			   {error,
			    extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					   unsupported,
					   <<"subscription-options">>)}
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_Node, Result}} -> {result, Result};
      Error -> Error
    end.

set_options_helper(Configuration, JID, NodeID, SubID, Type) ->
    SubOpts = case pubsub_subscription:parse_options_xform(Configuration) of
		{result, GoodSubOpts} -> GoodSubOpts;
		_ -> invalid
	      end,
    Subscriber = case jlib:string_to_jid(JID) of
		   error -> {<<"">>, <<"">>, <<"">>};
		   J -> jlib:jid_tolower(J)
		 end,
    {result, Subs} = node_call(Type, get_subscriptions,
			       [NodeID, Subscriber]),
    SubIDs = lists:foldl(fun ({subscribed, SID}, Acc) ->
				 [SID | Acc];
			     (_, Acc) -> Acc
			 end,
			 [], Subs),
    case {SubID, SubIDs} of
      {_, []} ->
	  {error,
	   extended_error(?ERR_NOT_ACCEPTABLE,
			  <<"not-subscribed">>)};
      {<<>>, [SID]} ->
	  write_sub(Subscriber, NodeID, SID, SubOpts);
      {<<>>, _} ->
	  {error,
	   extended_error(?ERR_NOT_ACCEPTABLE,
			  <<"subid-required">>)};
      {_, _} -> write_sub(Subscriber, NodeID, SubID, SubOpts)
    end.

write_sub(_Subscriber, _NodeID, _SubID, invalid) ->
    {error,
     extended_error(?ERR_BAD_REQUEST,
		    <<"invalid-options">>)};
write_sub(_Subscriber, _NodeID, _SubID, []) ->
    {result, []};
write_sub(Subscriber, NodeID, SubID, Options) ->
    case pubsub_subscription:set_subscription(Subscriber,
					      NodeID, SubID, Options)
	of
      {result, _} -> {result, []};
      {error, _} ->
	  {error,
	   extended_error(?ERR_NOT_ACCEPTABLE,
			  <<"invalid-subid">>)}
    end.

get_subscriptions(Host, Node, 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 ->
					{{error,
					  extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
							 unsupported,
							 <<"retrieve-subscriptions">>)},
					 Acc};
				    true ->
					Subscriber =
					    jlib:jid_remove_resource(JID),
					{result, Subscriptions} =
					    node_action(Host, Type,
							get_entity_subscriptions,
							[Host, Subscriber]),
					{Status, [Subscriptions | Acc]}
				 end
			 end,
			 {ok, []}, Plugins),
    case Result of
      {ok, Subscriptions} ->
	  Entities = lists:flatmap(fun ({_, none}) -> [];
				       ({#pubsub_node{nodeid = {_, SubsNode}},
					 Subscription}) ->
					   case Node of
					     <<>> ->
						 [#xmlel{name =
							     <<"subscription">>,
							 attrs =
							     [{<<"subscription">>,
							       subscription_to_string(Subscription)}
							      | nodeAttr(SubsNode)],
							 children = []}];
					     SubsNode ->
						 [#xmlel{name =
							     <<"subscription">>,
							 attrs =
							     [{<<"subscription">>,
							       subscription_to_string(Subscription)}],
							 children = []}];
					     _ -> []
					   end;
				       ({_, none, _}) -> [];
				       ({#pubsub_node{nodeid = {_, SubsNode}},
					 Subscription, SubID, SubJID}) ->
					   case Node of
					     <<>> ->
						 [#xmlel{name =
							     <<"subscription">>,
							 attrs =
							     [{<<"jid">>,
							       jlib:jid_to_string(SubJID)},
							      {<<"subid">>,
							       SubID},
							      {<<"subscription">>,
							       subscription_to_string(Subscription)}
							      | nodeAttr(SubsNode)],
							 children = []}];
					     SubsNode ->
						 [#xmlel{name =
							     <<"subscription">>,
							 attrs =
							     [{<<"jid">>,
							       jlib:jid_to_string(SubJID)},
							      {<<"subid">>,
							       SubID},
							      {<<"subscription">>,
							       subscription_to_string(Subscription)}],
							 children = []}];
					     _ -> []
					   end;
				       ({#pubsub_node{nodeid = {_, SubsNode}},
					 Subscription, SubJID}) ->
					   case Node of
					     <<>> ->
						 [#xmlel{name =
							     <<"subscription">>,
							 attrs =
							     [{<<"jid">>,
							       jlib:jid_to_string(SubJID)},
							      {<<"subscription">>,
							       subscription_to_string(Subscription)}
							      | nodeAttr(SubsNode)],
							 children = []}];
					     SubsNode ->
						 [#xmlel{name =
							     <<"subscription">>,
							 attrs =
							     [{<<"jid">>,
							       jlib:jid_to_string(SubJID)},
							      {<<"subscription">>,
							       subscription_to_string(Subscription)}],
							 children = []}];
					     _ -> []
					   end
				   end,
				   lists:usort(lists:flatten(Subscriptions))),
	  {result,
	   [#xmlel{name = <<"pubsub">>,
		   attrs = [{<<"xmlns">>, ?NS_PUBSUB}],
		   children =
		       [#xmlel{name = <<"subscriptions">>, attrs = [],
			       children = Entities}]}]};
      {Error, _} -> Error
    end.

get_subscriptions(Host, Node, JID) ->
    Action = fun (#pubsub_node{type = Type, id = NodeId}) ->
		     Features = features(Type),
		     RetrieveFeature =
			 lists:member(<<"manage-subscriptions">>, Features),
		     {result, Affiliation} = node_call(Type, get_affiliation,
						       [NodeId, JID]),
		     if not RetrieveFeature ->
			    {error,
			     extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
					    unsupported,
					    <<"manage-subscriptions">>)};
			Affiliation /= owner -> {error, ?ERR_FORBIDDEN};
			true ->
			    node_call(Type, get_node_subscriptions, [NodeId])
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Subscriptions}} ->
	  Entities = lists:flatmap(fun ({_, none}) -> [];
				       ({_, pending, _}) -> [];
				       ({AJID, Subscription}) ->
					   [#xmlel{name = <<"subscription">>,
						   attrs =
						       [{<<"jid">>,
							 jlib:jid_to_string(AJID)},
							{<<"subscription">>,
							 subscription_to_string(Subscription)}],
						   children = []}];
				       ({AJID, Subscription, SubId}) ->
					   [#xmlel{name = <<"subscription">>,
						   attrs =
						       [{<<"jid">>,
							 jlib:jid_to_string(AJID)},
							{<<"subscription">>,
							 subscription_to_string(Subscription)},
							{<<"subid">>, SubId}],
						   children = []}]
				   end,
				   Subscriptions),
	  {result,
	   [#xmlel{name = <<"pubsub">>,
		   attrs = [{<<"xmlns">>, ?NS_PUBSUB_OWNER}],
		   children =
		       [#xmlel{name = <<"subscriptions">>,
			       attrs = nodeAttr(Node), children = Entities}]}]};
      Error -> Error
    end.

set_subscriptions(Host, Node, From, EntitiesEls) ->
    Owner =
	jlib:jid_tolower(jlib:jid_remove_resource(From)),
    Entities = lists:foldl(fun (El, Acc) ->
				   case Acc of
				     error -> error;
				     _ ->
					 case El of
					   #xmlel{name = <<"subscription">>,
						  attrs = Attrs} ->
					       JID =
						   jlib:string_to_jid(xml:get_attr_s(<<"jid">>,
										     Attrs)),
					       Subscription =
						   string_to_subscription(xml:get_attr_s(<<"subscription">>,
											 Attrs)),
					       SubId =
						   xml:get_attr_s(<<"subid">>,
								  Attrs),
					       if (JID == error) or
						    (Subscription == false) ->
						      error;
						  true ->
						      [{jlib:jid_tolower(JID),
							Subscription, SubId}
						       | Acc]
					       end
					 end
				   end
			   end,
			   [], EntitiesEls),
    case Entities of
      error -> {error, ?ERR_BAD_REQUEST};
      _ ->
	  Notify = fun (JID, Sub, _SubId) ->
			   Stanza = #xmlel{name = <<"message">>, attrs = [],
					   children =
					       [#xmlel{name = <<"pubsub">>,
						       attrs =
							   [{<<"xmlns">>,
							     ?NS_PUBSUB}],
						       children =
							   [#xmlel{name =
								       <<"subscription">>,
								   attrs =
								       [{<<"jid">>,
									 jlib:jid_to_string(JID)},
									{<<"subscription">>,
									 subscription_to_string(Sub)}
									| nodeAttr(Node)],
								   children =
								       []}]}]},
			   ejabberd_router:route(service_jid(Host),
						 jlib:make_jid(JID), Stanza)
		   end,
	  Action = fun (#pubsub_node{owners = Owners, type = Type,
				     id = NodeId}) ->
			   case lists:member(Owner, Owners) of
			     true ->
				 Result = lists:foldl(fun ({JID, Subscription,
							    SubId},
							   Acc) ->
							      case
								node_call(Type,
									  set_subscriptions,
									  [NodeId,
									   JID,
									   Subscription,
									   SubId])
								  of
								{error, Err} ->
								    [{error,
								      Err}
								     | Acc];
								_ ->
								    Notify(JID,
									   Subscription,
									   SubId),
								    Acc
							      end
						      end,
						      [], Entities),
				 case Result of
				   [] -> {result, []};
				   _ -> {error, ?ERR_NOT_ACCEPTABLE}
				 end;
			     _ -> {error, ?ERR_FORBIDDEN}
			   end
		   end,
	  case transaction(Host, Node, Action, sync_dirty) of
	    {result, {_, Result}} -> {result, Result};
	    Other -> Other
	  end
    end.

-spec(get_presence_and_roster_permissions/5 ::
(
  Host          :: mod_pubsub:host(),
  From          :: ljid(),
  Owners        :: [ljid(),...],
  AccessModel   :: mod_pubsub:accessModel(),
  AllowedGroups :: [binary()])
    -> {PresenceSubscription::boolean(), RosterGroup::boolean()}
).

get_presence_and_roster_permissions(Host, From, Owners, AccessModel, AllowedGroups) ->
    if (AccessModel == presence) or (AccessModel == roster) ->
	   case Host of
	     {User, Server, _} ->
		 get_roster_info(User, Server, From, AllowedGroups);
	     _ ->
		 [{OUser, OServer, _} | _] = Owners,
		 get_roster_info(OUser, OServer, From, AllowedGroups)
	   end;
       true -> {true, true}
    end.

get_roster_info(_, _, {<<"">>, <<"">>, _}, _) ->
    {false, false};
get_roster_info(OwnerUser, OwnerServer,
		{SubscriberUser, SubscriberServer, _}, AllowedGroups) ->
    {Subscription, Groups} =
	ejabberd_hooks:run_fold(roster_get_jid_info,
				OwnerServer, {none, []},
				[OwnerUser, OwnerServer,
				 {SubscriberUser, SubscriberServer, <<"">>}]),
    PresenceSubscription = Subscription == both orelse
			     Subscription == from orelse
			       {OwnerUser, OwnerServer} ==
				 {SubscriberUser, SubscriberServer},
    RosterGroup = lists:any(fun (Group) ->
				    lists:member(Group, AllowedGroups)
			    end,
			    Groups),
    {PresenceSubscription, RosterGroup};
get_roster_info(OwnerUser, OwnerServer, JID,
		AllowedGroups) ->
    get_roster_info(OwnerUser, OwnerServer,
		    jlib:jid_tolower(JID), AllowedGroups).

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.

string_to_subscription(<<"subscribed">>) -> subscribed;
string_to_subscription(<<"pending">>) -> pending;
string_to_subscription(<<"unconfigured">>) ->
    unconfigured;
string_to_subscription(<<"none">>) -> none;
string_to_subscription(_) -> false.

affiliation_to_string(owner) -> <<"owner">>;
affiliation_to_string(publisher) -> <<"publisher">>;
affiliation_to_string(member) -> <<"member">>;
affiliation_to_string(outcast) -> <<"outcast">>;
affiliation_to_string(_) -> <<"none">>.

subscription_to_string(subscribed) -> <<"subscribed">>;
subscription_to_string(pending) -> <<"pending">>;
subscription_to_string(unconfigured) ->
    <<"unconfigured">>;
subscription_to_string(_) -> <<"none">>.

%node_to_string(Node) -> (Node).

%string_to_node(SNode) -> iolist_to_binary(SNode).

-spec(service_jid/1 ::
(
  Host :: mod_pubsub:host())
    -> jid()
).
service_jid(Host) ->
    case Host of
      {U, S, _} -> {jid, U, S, <<"">>, U, S, <<"">>};
      _ -> {jid, <<"">>, Host, <<"">>, <<"">>, Host, <<"">>}
    end.

is_to_deliver(LJID, NotifyType, Depth, NodeOptions,
	      SubOptions) ->
    sub_to_deliver(LJID, NotifyType, Depth, SubOptions)
      andalso node_to_deliver(LJID, NodeOptions).

sub_to_deliver(_LJID, NotifyType, Depth, SubOptions) ->
    lists:all(fun (Option) ->
		      sub_option_can_deliver(NotifyType, Depth, Option)
	      end,
	      SubOptions).

node_to_deliver(LJID, NodeOptions) ->
    presence_can_deliver(LJID,
			 get_option(NodeOptions, presence_based_delivery)).

sub_option_can_deliver(items, _,
		       {subscription_type, nodes}) ->
    false;
sub_option_can_deliver(nodes, _,
		       {subscription_type, items}) ->
    false;
sub_option_can_deliver(_, _,
		       {subscription_depth, all}) ->
    true;
sub_option_can_deliver(_, Depth,
		       {subscription_depth, D}) ->
    Depth =< D;
sub_option_can_deliver(_, _, {deliver, false}) -> false;
sub_option_can_deliver(_, _, {expire, When}) ->
    now() < When;
sub_option_can_deliver(_, _, _) -> true.

-spec(presence_can_deliver/2 ::
(
  Entity :: ljid(),
  _      :: boolean())
    -> boolean()
).
presence_can_deliver(_, false) -> true;
presence_can_deliver({User, Server, Resource}, true) ->
    case ejabberd_sm:get_user_sessions(User, Server) of
      [] -> false;
      Ss ->
	  lists:foldl(fun (_, true) -> true;
			  ({session, _, _, _, undefined, _}, _Acc) -> false;
			  ({session, _, {_, _, R}, _, _Priority, _}, _Acc) ->
			      case Resource of
				[] -> true;
				R -> true;
				_ -> false
			      end
		      end,
		      false, Ss)
    end.

-spec(state_can_deliver/2 ::
(
  Entity::ljid(),
  SubOptions :: mod_pubsub:subOptions() | [])
    -> [ljid()]
).
state_can_deliver({U, S, R}, []) -> [{U, S, R}];
state_can_deliver({U, S, R}, SubOptions) ->
    case lists:keysearch(show_values, 1, SubOptions) of
      %% If not in suboptions, item can be delivered, case doesn't apply
      false -> [{U, S, R}];
      %% If in a suboptions ...
      {_, {_, ShowValues}} ->
	  Resources = case R of
			%% If the subscriber JID is a bare one, get all its resources
			<<>> -> user_resources(U, S);
			%% If the subscriber JID is a full one, use its resource
			R -> [R]
		      end,
	  lists:foldl(fun (Resource, Acc) ->
			      get_resource_state({U, S, Resource}, ShowValues,
						 Acc)
		      end,
		      [], Resources)
    end.

-spec(get_resource_state/3 ::
(
  Entity     :: ljid(),
  ShowValues :: [binary()],
  JIDs       :: [ljid()])
    -> [ljid()]
).
get_resource_state({U, S, R}, ShowValues, JIDs) ->
    case ejabberd_sm:get_session_pid(U, S, R) of
      %% If no PID, item can be delivered
      none -> lists:append([{U, S, R}], JIDs);
      %% If PID ...
      Pid ->
	  Show = case ejabberd_c2s:get_presence(Pid) of
		   {_, _, <<"available">>, _} -> <<"online">>;
		   {_, _, State, _} -> State
		 end,
	  case lists:member(Show, ShowValues) of
	    %% If yes, item can be delivered
	    true -> lists:append([{U, S, R}], JIDs);
	    %% If no, item can't be delivered
	    false -> JIDs
	  end
    end.

-spec(payload_xmlelements/1 ::
(
  Payload :: mod_pubsub:payload())
    -> Count :: non_neg_integer()
).
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).

event_stanza(Els) -> event_stanza_withmoreels(Els, []).

event_stanza_with_delay(Els, ModifNow, ModifUSR) ->
    DateTime = calendar:now_to_datetime(ModifNow),
    MoreEls = [jlib:timestamp_to_xml(DateTime, utc,
				     ModifUSR, <<"">>)],
    event_stanza_withmoreels(Els, MoreEls).

event_stanza_withmoreels(Els, MoreEls) ->
    #xmlel{name = <<"message">>, attrs = [],
	   children =
	       [#xmlel{name = <<"event">>,
		       attrs = [{<<"xmlns">>, ?NS_PUBSUB_EVENT}],
		       children = Els}
		| MoreEls]}.

event_stanza(Event, EvAttr) ->
    event_stanza([#xmlel{name = Event, attrs = EvAttr,
			 children = []}]).

event_stanza(Event, EvAttr, Entries) ->
    event_stanza([#xmlel{name = Event, attrs = EvAttr,
			 children =
			     [#xmlel{name = Entry, attrs = EnAttr,
				     children = []}
			      || {Entry, EnAttr} <- Entries]}]).

event_stanza(Event, EvAttr, Entry, EnAttr, Payload) ->
    event_stanza([#xmlel{name = Event, attrs = EvAttr,
			 children =
			     [#xmlel{name = Entry, attrs = EnAttr,
				     children = Payload}]}]).

event_stanza(Event, EvAttr, Entry, EnAttr, Payload,
	     Publisher) ->
    Stanza = event_stanza(Event, EvAttr, Entry, EnAttr,
			  Payload),
    add_extended_headers(Stanza,
			 extended_headers([jlib:jid_to_string(Publisher)])).

%%%%%% broadcast functions

broadcast_publish_item(Host, Node, NodeId, Type,
		       NodeOptions, ItemId, Publisher, Payload, Removed) ->
    Publish = case get_option(NodeOptions, deliver_payloads)
		  of
		true ->
		    event_stanza(<<"items">>, nodeAttr(Node), <<"item">>,
				 itemAttr(ItemId), Payload, Publisher);
		false ->
		    event_stanza(<<"items">>, nodeAttr(Node), <<"item">>,
				 itemAttr(ItemId), [], Publisher)
	      end,
    case Removed of
      [] ->
	  {result,
	   broadcast(Host, Node, NodeId, Type, NodeOptions, items,
		     true, Publish, true)};
      _ ->
	  Retract = event_stanza(<<"items">>, nodeAttr(Node),
				 [{<<"retract">>, itemAttr(Rid)}
				  || Rid <- Removed]),
	  Stanzas = [{true, Publish, true},
		     {get_option(NodeOptions, notify_retract), Retract,
		      true}],
	  {result,
	   broadcast(Host, Node, NodeId, Type, NodeOptions, items,
		     Stanzas)}
    end.

broadcast_retract_items(Host, Node, NodeId, Type,
			NodeOptions, ItemIds) ->
    broadcast_retract_items(Host, Node, NodeId, Type,
			    NodeOptions, ItemIds, notify_retract).

broadcast_retract_items(_Host, _Node, _NodeId, _Type,
			_NodeOptions, [], _) ->
    {result, false};
broadcast_retract_items(Host, Node, NodeId, Type,
			NodeOptions, ItemIds, false) ->
    broadcast_retract_items(Host, Node, NodeId, Type,
			    NodeOptions, ItemIds, notify_retract);
broadcast_retract_items(Host, Node, NodeId, Type,
			NodeOptions, ItemIds, Notify) ->
    Stanza = event_stanza(<<"items">>, nodeAttr(Node),
			  [{<<"retract">>, itemAttr(Rid)} || Rid <- ItemIds]),
    {result,
     broadcast(Host, Node, NodeId, Type, NodeOptions, items,
	       Notify, Stanza, true)}.

broadcast_purge_node(Host, Node, NodeId, Type,
		     NodeOptions) ->
    Stanza = event_stanza(<<"purge">>, nodeAttr(Node)),
    {result,
     broadcast(Host, Node, NodeId, Type, NodeOptions, nodes,
	       notify_retract, Stanza, false)}.

broadcast_removed_node(Host, Node, NodeId, Type,
		       NodeOptions) ->
    Stanza = event_stanza(<<"delete">>, nodeAttr(Node)),
    {result,
     broadcast(Host, Node, NodeId, Type, NodeOptions, nodes,
	       notify_delete, Stanza, false)}.

broadcast_created_node(Host, Node, NodeId, Type,
		       NodeOptions) ->
    Stanza = event_stanza(<<"create">>, nodeAttr(Node)),
    {result,
     broadcast(Host, Node, NodeId, Type, NodeOptions, nodes,
	       true, Stanza, true)}.

broadcast_config_notification(Host, Node, NodeId, Type,
			      NodeOptions, Lang) ->
    Stanza = case get_option(NodeOptions, deliver_payloads)
		 of
	       true ->
		   event_stanza(<<"configuration">>, nodeAttr(Node),
				<<"x">>,
				[{<<"xmlns">>, ?NS_XDATA},
				 {<<"type">>, <<"result">>}],
				get_configure_xfields(Type, NodeOptions, Lang,
						      []));
	       false ->
		   event_stanza(<<"configuration">>, nodeAttr(Node))
	     end,
    {result,
     broadcast(Host, Node, NodeId, Type, NodeOptions, nodes,
	       notify_config, Stanza, false)}.

broadcast(Host, Node, NodeId, Type, NodeOptions, Notify,
	  Stanzas) ->
    Subs = node_subscriptions(Host, Node, NodeId, Type,
			      NodeOptions, Notify),
    Result = [broadcast(Host, Node, NodeId, Type,
			NodeOptions, Subs, Stanza, SHIM)
	      || {Cond, Stanza, SHIM} <- Stanzas, Cond =:= true],
    lists:member(true, Result).

broadcast(Host, Node, NodeId, Type, NodeOptions, Notify,
	  true, Stanza, SHIM) ->
    Subs = node_subscriptions(Host, Node, NodeId, Type,
			      NodeOptions, Notify),
    broadcast(Host, Node, NodeId, Type, NodeOptions, Subs,
	      Stanza, SHIM);
broadcast(_Host, _Node, _NodeId, _Type, _NodeOptions,
	  _Notify, false, _Stanza, _SHIM) ->
    false;
broadcast(Host, Node, NodeId, Type, NodeOptions, Notify,
	  Condition, Stanza, SHIM) ->
    broadcast(Host, Node, NodeId, Type, NodeOptions, Notify,
	      get_option(NodeOptions, Condition), Stanza, SHIM).

broadcast({U, S, R}, Node, NodeId, Type, NodeOptions,
	  Subscriptions, Stanza, SHIM) ->
    broadcast(S, Node, NodeId, Type, NodeOptions,
	      Subscriptions, Stanza, SHIM)
      or
      case ejabberd_sm:get_session_pid(U, S,
				       user_resource(U, S, R))
	  of
	C2SPid when is_pid(C2SPid) ->
	    Event = {pep_message, <<((Node))/binary, "+notify">>},
	    Message = case get_option(NodeOptions,
				      notification_type, headline)
			  of
			normal -> Stanza;
			MsgType ->
			    add_message_type(Stanza,
					     iolist_to_binary(atom_to_list(MsgType)))
		      end,
	    ejabberd_c2s:broadcast(C2SPid, Event,
				   jlib:make_jid(U, S, <<"">>), Message),
	    true;
	_ ->
	    ?DEBUG("~p@~p has no session; can't deliver "
		   "stanza: ~p",
		   [U, S, Stanza]),
	    false
      end;
broadcast(_Host, _Node, _NodeId, _Type, _NodeOptions,
	  [], _Stanza, _SHIM) ->
    false;
broadcast(Host, _Node, _NodeId, _Type, NodeOptions,
	  Subscriptions, Stanza, SHIM) ->
    From = service_jid(Host),
    Message = case get_option(NodeOptions,
			      notification_type, headline)
		  of
		normal -> Stanza;
		MsgType ->
		    add_message_type(Stanza,
				     iolist_to_binary(atom_to_list(MsgType)))
	      end,
    lists:foreach(fun ({LJID, NodeName, SubIds}) ->
			  Send = case {SHIM, SubIds} of
				   {false, _} -> Message;
				   {true, [_]} ->
				       add_shim_headers(Message,
							collection_shim(NodeName));
				   {true, _} ->
				       add_shim_headers(Message,
							lists:append(collection_shim(NodeName),
								     subid_shim(SubIds)))
				 end,
			  ejabberd_router:route(From, jlib:make_jid(LJID), Send)
		  end,
		  Subscriptions),
    true.

node_subscriptions(Host, Node, NodeId, Type,
		   _NodeOptions, Notify) ->
    case Type of
      <<"flat">> ->
	  node_subscriptions_bare(Host, Node, NodeId, Type);
      <<"pep">> ->
	  node_subscriptions_bare(Host, Node, NodeId, Type);
      _ -> node_subscriptions_full(Host, Node, Notify)
    end.

node_subscriptions_bare(Host, Node, NodeId, Type) ->
    case node_action(Host, Type, get_node_subscriptions,
		     [NodeId])
	of
      {result, Subs} ->
	  SubsByJid = lists:foldl(fun ({JID, subscribed, SubId},
				       Acc) ->
					  case dict:is_key(JID, Acc) of
					    true ->
						dict:append(JID, SubId, Acc);
					    false ->
						dict:store(JID, [SubId], Acc)
					  end;
				      (_, Acc) -> Acc
				  end,
				  dict:new(), Subs),
	  [{J, Node, S} || {J, S} <- dict:to_list(SubsByJid)];
      _ -> []
    end.

node_subscriptions_full(Host, Node, NotifyType) ->
    Action = fun () ->
		     Collection = tree_call(Host, get_parentnodes_tree,
					    [Host, Node, service_jid(Host)]),
		     {result,
		      [{Depth, [{N, sub_with_options(N)} || N <- Nodes]}
		       || {Depth, Nodes} <- Collection]}
	     end,
    case transaction(Action, sync_dirty) of
      {result, CollSubs} ->
	  subscribed_nodes_by_jid(NotifyType, CollSubs);
      _ -> []
    end.

subscribed_nodes_by_jid(NotifyType, SubsByDepth) ->
    NodesToDeliver = fun (Depth, Node, Subs, Acc) ->
			     NodeName = case Node#pubsub_node.nodeid of
					  {_, N} -> N;
					  Other -> Other
					end,
			     NodeOptions = Node#pubsub_node.options,
			     lists:foldl(fun ({LJID, SubID, SubOptions},
					      {JIDs, Recipients}) ->
						 case is_to_deliver(LJID,
								    NotifyType,
								    Depth,
								    NodeOptions,
								    SubOptions)
						     of
						   true ->
						       case
							 state_can_deliver(LJID, SubOptions)
							   of
							 [] ->
							     {JIDs, Recipients};
							 JIDsToDeliver ->
							     lists:foldl(fun
									   (JIDToDeliver,
									    {JIDsAcc,
									     RecipientsAcc}) ->
									       case
										 lists:member(JIDToDeliver,
											      JIDs)
										   of
										 %% check if the JIDs co-accumulator contains the Subscription Jid,
										 false ->
										     {[JIDToDeliver
										       | JIDsAcc],
										      [{JIDToDeliver,
											NodeName,
											[SubID]}
										       | RecipientsAcc]};
										 true ->
										     {_,
										      {JIDToDeliver,
										       NodeName1,
										       SubIDs}} =
											 lists:keysearch(JIDToDeliver,
													 1,
													 RecipientsAcc),
										     {JIDsAcc,
										      lists:keyreplace(JIDToDeliver,
												       1,
												       RecipientsAcc,
												       {JIDToDeliver,
													NodeName1,
													[SubID
													 | SubIDs]})}
									       end
									 end,
									 {JIDs,
									  Recipients},
									 JIDsToDeliver)
						       end;
						   false -> {JIDs, Recipients}
						 end
					 end,
					 Acc, Subs)
		     end,
    DepthsToDeliver = fun ({Depth, SubsByNode}, Acc1) ->
			      lists:foldl(fun ({Node, Subs}, Acc2) ->
						  NodesToDeliver(Depth, Node,
								 Subs, Acc2)
					  end,
					  Acc1, SubsByNode)
		      end,
    {_, JIDSubs} = lists:foldl(DepthsToDeliver, {[], []},
			       SubsByDepth),
    JIDSubs.

sub_with_options(#pubsub_node{type = Type,
			      id = NodeId}) ->
    case node_call(Type, get_node_subscriptions, [NodeId])
	of
      {result, Subs} ->
	  lists:foldl(fun ({JID, subscribed, SubId}, Acc) ->
			      [sub_with_options(JID, NodeId, SubId) | Acc];
			  (_, Acc) -> Acc
		      end,
		      [], Subs);
      _ -> []
    end.

sub_with_options(JID, NodeId, SubId) ->
    case pubsub_subscription:read_subscription(JID, NodeId,
					       SubId)
	of
      #pubsub_subscription{options = Options} ->
	  {JID, SubId, Options};
      _ -> {JID, SubId, []}
    end.

user_resources(User, Server) ->
    ejabberd_sm:get_user_resources(User, Server).

user_resource(User, Server, []) ->
    case user_resources(User, Server) of
      [R | _] -> R;
      _ -> []
    end;
user_resource(_, _, Resource) -> Resource.

%%%%%%% Configuration handling

get_configure(Host, ServerHost, Node, From, Lang) ->
    Action = fun (#pubsub_node{options = Options,
			       type = Type, id = NodeId}) ->
		     case node_call(Type, get_affiliation, [NodeId, From]) of
		       {result, owner} ->
			   Groups = ejabberd_hooks:run_fold(roster_groups,
							    ServerHost, [],
							    [ServerHost]),
			   {result,
			    [#xmlel{name = <<"pubsub">>,
				    attrs = [{<<"xmlns">>, ?NS_PUBSUB_OWNER}],
				    children =
					[#xmlel{name = <<"configure">>,
						attrs = nodeAttr(Node),
						children =
						    [#xmlel{name = <<"x">>,
							    attrs =
								[{<<"xmlns">>,
								  ?NS_XDATA},
								 {<<"type">>,
								  <<"form">>}],
							    children =
								get_configure_xfields(Type,
										      Options,
										      Lang,
										      Groups)}]}]}]};
		       _ -> {error, ?ERR_FORBIDDEN}
		     end
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, {_, Result}} -> {result, Result};
      Other -> Other
    end.

get_default(Host, Node, _From, Lang) ->
    Type = select_type(Host, Host, Node),
    Options = node_options(Type),
    {result,
     [#xmlel{name = <<"pubsub">>,
	     attrs = [{<<"xmlns">>, ?NS_PUBSUB_OWNER}],
	     children =
		 [#xmlel{name = <<"default">>, attrs = [],
			 children =
			     [#xmlel{name = <<"x">>,
				     attrs =
					 [{<<"xmlns">>, ?NS_XDATA},
					  {<<"type">>, <<"form">>}],
				     children =
					 get_configure_xfields(Type, Options,
							       Lang, [])}]}]}]}.

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.

node_options(Type) ->
    Module =
	jlib:binary_to_atom(<<(?PLUGIN_PREFIX)/binary,
				Type/binary>>),
    case catch Module:options() of
      {'EXIT', {undef, _}} ->
	  DefaultModule =
	      jlib:binary_to_atom(<<(?PLUGIN_PREFIX)/binary,
				      (?STDNODE)/binary>>),
	  DefaultModule:options();
      Result -> Result
    end.

max_items(Host, 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;
	    _ ->
		case is_last_item_cache_enabled(Host) of
		  true -> 0;
		  false -> 1
		end
	  end
    end.

-define(BOOL_CONFIG_FIELD(Label, Var),
	?BOOLXFIELD(Label,
		    <<"pubsub#",
		      (iolist_to_binary(atom_to_list(Var)))/binary>>,
		    (get_option(Options, Var)))).

-define(STRING_CONFIG_FIELD(Label, Var),
	?STRINGXFIELD(Label,
		      <<"pubsub#",
			(iolist_to_binary(atom_to_list(Var)))/binary>>,
		      (get_option(Options, Var, <<"">>)))).

-define(INTEGER_CONFIG_FIELD(Label, Var),
	?STRINGXFIELD(Label,
		      <<"pubsub#",
			(iolist_to_binary(atom_to_list(Var)))/binary>>,
		      (iolist_to_binary(integer_to_list(get_option(Options,
								   Var)))))).

-define(JLIST_CONFIG_FIELD(Label, Var, Opts),
	?LISTXFIELD(Label,
		    <<"pubsub#",
		      (iolist_to_binary(atom_to_list(Var)))/binary>>,
		    (jlib:jid_to_string(get_option(Options, Var))),
		    [jlib:jid_to_string(O) || O <- Opts])).

-define(ALIST_CONFIG_FIELD(Label, Var, Opts),
	?LISTXFIELD(Label,
		    <<"pubsub#",
		      (iolist_to_binary(atom_to_list(Var)))/binary>>,
		    (iolist_to_binary(atom_to_list(get_option(Options,
							      Var)))),
		    [iolist_to_binary(atom_to_list(O)) || O <- Opts])).

-define(LISTM_CONFIG_FIELD(Label, Var, Opts),
	?LISTMXFIELD(Label,
		     <<"pubsub#",
		       (iolist_to_binary(atom_to_list(Var)))/binary>>,
		     (get_option(Options, Var)), Opts)).

-define(NLIST_CONFIG_FIELD(Label, Var),
	?STRINGMXFIELD(Label,
		       <<"pubsub#",
			 (iolist_to_binary(atom_to_list(Var)))/binary>>,
		       get_option(Options, Var, []))).

get_configure_xfields(_Type, Options, Lang, Groups) ->
    [?XFIELD(<<"hidden">>, <<"">>, <<"FORM_TYPE">>,
	     (?NS_PUBSUB_NODE_CONFIG)),
     ?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 configuratio"
			  "n 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]),
     ?LISTM_CONFIG_FIELD(<<"Roster groups allowed to subscribe">>,
			 roster_groups_allowed, Groups),
     ?ALIST_CONFIG_FIELD(<<"Specify the publisher model">>,
			 publish_model, [publishers, subscribers, open]),
     ?BOOL_CONFIG_FIELD(<<"Purge all items when the relevant publisher "
			  "goes offline">>,
			purge_offline),
     ?ALIST_CONFIG_FIELD(<<"Specify the event message type">>,
			 notification_type, [headline, normal]),
     ?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),
     ?NLIST_CONFIG_FIELD(<<"The collections with which a node is "
			   "affiliated">>,
			 collection)].

set_configure(Host, Node, From, Els, Lang) ->
    case xml:remove_cdata(Els) of
      [#xmlel{name = <<"x">>} = XEl] ->
	  case {xml:get_tag_attr_s(<<"xmlns">>, XEl),
		xml:get_tag_attr_s(<<"type">>, XEl)}
	      of
	    {?NS_XDATA, <<"cancel">>} -> {result, []};
	    {?NS_XDATA, <<"submit">>} ->
		Action = fun (#pubsub_node{options = Options,
					   type = Type, id = NodeId} =
				  N) ->
				 case node_call(Type, get_affiliation,
						[NodeId, From])
				     of
				   {result, owner} ->
				       case jlib:parse_xdata_submit(XEl) of
					 invalid -> {error, ?ERR_BAD_REQUEST};
					 XData ->
					     OldOpts = case Options of
							 [] ->
							     node_options(Type);
							 _ -> Options
						       end,
					     case set_xoption(Host, XData,
							      OldOpts)
						 of
					       NewOpts
						   when is_list(NewOpts) ->
						   case tree_call(Host,
								  set_node,
								  [N#pubsub_node{options
										     =
										     NewOpts}])
						       of
						     ok -> {result, ok};
						     Err -> Err
						   end;
					       Err -> Err
					     end
				       end;
				   _ -> {error, ?ERR_FORBIDDEN}
				 end
			 end,
		case transaction(Host, Node, Action, transaction) of
		  {result, {TNode, ok}} ->
		      NodeId = TNode#pubsub_node.id,
		      Type = TNode#pubsub_node.type,
		      Options = TNode#pubsub_node.options,
		      broadcast_config_notification(Host, Node, NodeId, Type,
						    Options, Lang),
		      {result, []};
		  Other -> Other
		end;
	    _ -> {error, ?ERR_BAD_REQUEST}
	  end;
      _ -> {error, ?ERR_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, ?ERR_NOT_ACCEPTABLE};
	  _ ->
	      set_xoption(Host, Opts, add_opt(Opt, BoolVal, NewOpts))
	end).

-define(SET_STRING_XOPT(Opt, Val),
	set_xoption(Host, Opts, add_opt(Opt, Val, NewOpts))).

-define(SET_INTEGER_XOPT(Opt, Val, Min, Max),
	case catch jlib:binary_to_integer(Val) of
	  IVal when is_integer(IVal), IVal >= Min, IVal =< Max ->
	      set_xoption(Host, Opts, add_opt(Opt, IVal, NewOpts));
	  _ -> {error, ?ERR_NOT_ACCEPTABLE}
	end).

-define(SET_ALIST_XOPT(Opt, Val, Vals),
	case lists:member(Val,
			  [iolist_to_binary(atom_to_list(V)) || V <- Vals])
	    of
	  true ->
	      set_xoption(Host, Opts,
			  add_opt(Opt, jlib:binary_to_atom(Val), NewOpts));
	  false -> {error, ?ERR_NOT_ACCEPTABLE}
	end).

-define(SET_LIST_XOPT(Opt, Val),
	set_xoption(Host, Opts, add_opt(Opt, Val, NewOpts))).

set_xoption(_Host, [], NewOpts) -> NewOpts;
set_xoption(Host, [{<<"FORM_TYPE">>, _} | Opts],
	    NewOpts) ->
    set_xoption(Host, Opts, NewOpts);
set_xoption(Host,
	    [{<<"pubsub#roster_groups_allowed">>, Value} | Opts],
	    NewOpts) ->
    ?SET_LIST_XOPT(roster_groups_allowed, Value);
set_xoption(Host,
	    [{<<"pubsub#deliver_payloads">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(deliver_payloads, Val);
set_xoption(Host,
	    [{<<"pubsub#deliver_notifications">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(deliver_notifications, Val);
set_xoption(Host,
	    [{<<"pubsub#notify_config">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(notify_config, Val);
set_xoption(Host,
	    [{<<"pubsub#notify_delete">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(notify_delete, Val);
set_xoption(Host,
	    [{<<"pubsub#notify_retract">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(notify_retract, Val);
set_xoption(Host,
	    [{<<"pubsub#persist_items">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(persist_items, Val);
set_xoption(Host,
	    [{<<"pubsub#max_items">>, [Val]} | Opts], NewOpts) ->
    MaxItems = get_max_items_node(Host),
    ?SET_INTEGER_XOPT(max_items, Val, 0, MaxItems);
set_xoption(Host,
	    [{<<"pubsub#subscribe">>, [Val]} | Opts], NewOpts) ->
    ?SET_BOOL_XOPT(subscribe, Val);
set_xoption(Host,
	    [{<<"pubsub#access_model">>, [Val]} | Opts], NewOpts) ->
    ?SET_ALIST_XOPT(access_model, Val,
		    [open, authorize, presence, roster, whitelist]);
set_xoption(Host,
	    [{<<"pubsub#publish_model">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_ALIST_XOPT(publish_model, Val,
		    [publishers, subscribers, open]);
set_xoption(Host,
	    [{<<"pubsub#notification_type">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_ALIST_XOPT(notification_type, Val,
		    [headline, normal]);
set_xoption(Host,
	    [{<<"pubsub#node_type">>, [Val]} | Opts], NewOpts) ->
    ?SET_ALIST_XOPT(node_type, Val, [leaf, collection]);
set_xoption(Host,
	    [{<<"pubsub#max_payload_size">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_INTEGER_XOPT(max_payload_size, Val, 0,
		      (?MAX_PAYLOAD_SIZE));
set_xoption(Host,
	    [{<<"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(Host,
	    [{<<"pubsub#presence_based_delivery">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(presence_based_delivery, Val);
set_xoption(Host,
	    [{<<"pubsub#purge_offline">>, [Val]} | Opts],
	    NewOpts) ->
    ?SET_BOOL_XOPT(purge_offline, Val);
set_xoption(Host, [{<<"pubsub#title">>, Value} | Opts],
	    NewOpts) ->
    ?SET_STRING_XOPT(title, Value);
set_xoption(Host, [{<<"pubsub#type">>, Value} | Opts],
	    NewOpts) ->
    ?SET_STRING_XOPT(type, Value);
set_xoption(Host,
	    [{<<"pubsub#body_xslt">>, Value} | Opts], NewOpts) ->
    ?SET_STRING_XOPT(body_xslt, Value);
set_xoption(Host,
	    [{<<"pubsub#collection">>, Value} | Opts], NewOpts) ->
%    NewValue = [string_to_node(V) || V <- Value],
    ?SET_LIST_XOPT(collection, Value);
set_xoption(Host, [{<<"pubsub#node">>, [Value]} | Opts],
	    NewOpts) ->
%    NewValue = string_to_node(Value),
    ?SET_LIST_XOPT(node, Value);
set_xoption(Host, [_ | Opts], NewOpts) ->
    set_xoption(Host, Opts, NewOpts).

get_max_items_node({_, ServerHost, _}) ->
    get_max_items_node(ServerHost);
get_max_items_node(Host) ->
    case catch ets:lookup(gen_mod:get_module_proc(Host,
						  config),
			  max_items_node)
	of
      [{max_items_node, Integer}] -> Integer;
      _ -> ?MAXITEMS
    end.

%%%% last item cache handling

is_last_item_cache_enabled({_, ServerHost, _}) ->
    is_last_item_cache_enabled(ServerHost);
is_last_item_cache_enabled(Host) ->
    case catch ets:lookup(gen_mod:get_module_proc(Host,
						  config),
			  last_item_cache)
	of
      [{last_item_cache, true}] -> true;
      _ -> false
    end.

set_cached_item({_, ServerHost, _}, NodeId, ItemId,
		Publisher, Payload) ->
    set_cached_item(ServerHost, NodeId, ItemId, Publisher,
		    Payload);
set_cached_item(Host, NodeId, ItemId, Publisher,
		Payload) ->
    case is_last_item_cache_enabled(Host) of
      true ->
	  mnesia:dirty_write({pubsub_last_item, NodeId, ItemId,
			      {now(),
			       jlib:jid_tolower(jlib:jid_remove_resource(Publisher))},
			      Payload});
      _ -> ok
    end.

unset_cached_item({_, ServerHost, _}, NodeId) ->
    unset_cached_item(ServerHost, NodeId);
unset_cached_item(Host, NodeId) ->
    case is_last_item_cache_enabled(Host) of
      true -> mnesia:dirty_delete({pubsub_last_item, NodeId});
      _ -> ok
    end.

-spec(get_cached_item/2 ::
(
  Host    :: mod_pubsub:host(),
  NodeIdx :: mod_pubsub:nodeIdx())
    -> undefined | mod_pubsub:pubsubItem()
).
get_cached_item({_, ServerHost, _}, NodeId) ->
    get_cached_item(ServerHost, NodeId);
get_cached_item(Host, NodeIdx) ->
    case is_last_item_cache_enabled(Host) of
      true ->
	  case mnesia:dirty_read({pubsub_last_item, NodeIdx}) of
	    [#pubsub_last_item{itemid = ItemId, creation = Creation, payload = Payload}] ->
%	    [{pubsub_last_item, NodeId, ItemId, Creation,
%	      Payload}] ->
		#pubsub_item{itemid = {ItemId, NodeIdx},
			     payload = Payload, creation = Creation,
			     modification = Creation};
	    _ -> undefined
	  end;
      _ -> undefined
    end.

%%%% plugin handling

host(ServerHost) ->
    case catch
	   ets:lookup(gen_mod:get_module_proc(ServerHost, config),
		      host)
	of
      [{host, Host}] -> Host;
      _ -> <<"pubsub.", ServerHost/binary>>
    end.

plugins(Host) ->
    case catch ets:lookup(gen_mod:get_module_proc(Host,
						  config),
			  plugins)
	of
      [{plugins, []}] -> [?STDNODE];
      [{plugins, PL}] -> PL;
      _ -> [?STDNODE]
    end.

select_type(ServerHost, Host, Node, Type) ->
    SelectedType = case Host of
		     {_User, _Server, _Resource} ->
			 case catch
				ets:lookup(gen_mod:get_module_proc(ServerHost,
								   config),
					   pep_mapping)
			     of
			   [{pep_mapping, PM}] ->
			       proplists:get_value(Node, PM, ?PEPNODE);
			   _ -> ?PEPNODE
			 end;
		     _ -> Type
		   end,
    ConfiguredTypes = plugins(ServerHost),
    case lists:member(SelectedType, ConfiguredTypes) of
      true -> SelectedType;
      false -> hd(ConfiguredTypes)
    end.

select_type(ServerHost, Host, Node) ->
    select_type(ServerHost, Host, Node,
		hd(plugins(ServerHost))).

features() ->
    [% see plugin "access-authorize",   % OPTIONAL
     <<"access-open">>,   % OPTIONAL this relates to access_model option in node_hometree
     <<"access-presence">>,   % OPTIONAL this relates to access_model option in node_pep
     <<"access-whitelist">>,   % OPTIONAL
     <<"collections">>,   % RECOMMENDED
     <<"config-node">>,   % RECOMMENDED
     <<"create-and-configure">>,   % RECOMMENDED
     <<"item-ids">>,   % RECOMMENDED
     <<"last-published">>,   % RECOMMENDED
     <<"member-affiliation">>,   % RECOMMENDED
     <<"presence-notifications">>,   % OPTIONAL
     <<"presence-subscribe">>,   % RECOMMENDED
     <<"publisher-affiliation">>,   % RECOMMENDED
     <<"retrieve-default">>].

         % see plugin "retrieve-items",   % RECOMMENDED
	 % see plugin "retrieve-subscriptions",   % RECOMMENDED
	 %TODO "shim", % OPTIONAL
	 % see plugin "subscribe",   % REQUIRED
	 % see plugin "subscription-options",   % OPTIONAL
	 % see plugin "subscription-notifications"   % OPTIONAL

features(Type) ->
    Module =
	jlib:binary_to_atom(<<(?PLUGIN_PREFIX)/binary,
				Type/binary>>),
    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) ->
    Action = fun (#pubsub_node{type = Type}) ->
		     {result, features(Type)}
	     end,
    case transaction(Host, Node, Action, sync_dirty) of
      {result, Features} ->
	  lists:usort(features() ++ Features);
      _ -> features()
    end.

tree_call({_User, Server, _Resource}, Function, Args) ->
    tree_call(Server, Function, Args);
tree_call(Host, Function, Args) ->
    ?DEBUG("tree_call ~p ~p ~p", [Host, Function, Args]),
    Module = case catch
		    ets:lookup(gen_mod:get_module_proc(Host, config),
			       nodetree)
		 of
	       [{nodetree, N}] -> N;
	       _ ->
		   jlib:binary_to_atom(<<(?TREE_PREFIX)/binary,
					   (?STDTREE)/binary>>)
	     end,
    catch apply(Module, Function, Args).

tree_action(Host, Function, Args) ->
    ?DEBUG("tree_action ~p ~p ~p", [Host, Function, Args]),
    Fun = fun () -> tree_call(Host, Function, Args) end,
    catch mnesia:sync_dirty(Fun).

node_call(Type, Function, Args) ->
    ?DEBUG("node_call ~p ~p ~p", [Type, Function, Args]),
    Module =
	jlib:binary_to_atom(<<(?PLUGIN_PREFIX)/binary,
				Type/binary>>),
    case 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(Host, Type, Function, Args) ->
    ?DEBUG("node_action ~p ~p ~p ~p",
	   [Host, Type, Function, Args]),
    transaction(fun () -> node_call(Type, Function, Args)
		end,
		sync_dirty).

transaction(Host, Node, Action, Trans) ->
    transaction(fun () ->
			case tree_call(Host, get_node, [Host, Node]) of
			  N when is_record(N, pubsub_node) ->
			      case Action(N) of
				{result, Result} -> {result, {N, Result}};
				{atomic, {result, Result}} ->
				    {result, {N, Result}};
				Other -> Other
			      end;
			  Error -> Error
			end
		end,
		Trans).

transaction(Host, Action, Trans) ->
    transaction(fun () ->
			{result,
			 lists:foldl(Action, [],
				     tree_call(Host, get_nodes, [Host]))}
		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, ?ERR_INTERNAL_SERVER_ERROR};
      {'EXIT', Reason} ->
	  ?ERROR_MSG("transaction return internal error: ~p~n",
		     [{'EXIT', Reason}]),
	  {error, ?ERR_INTERNAL_SERVER_ERROR};
      Other ->
	  ?ERROR_MSG("transaction return internal error: ~p~n",
		     [Other]),
	  {error, ?ERR_INTERNAL_SERVER_ERROR}
    end.

%%%% helpers

extended_error(Error, Ext) ->
    extended_error(Error, Ext,
		   [{<<"xmlns">>, ?NS_PUBSUB_ERRORS}]).

extended_error(Error, unsupported, Feature) ->
    extended_error(Error, <<"unsupported">>,
		   [{<<"xmlns">>, ?NS_PUBSUB_ERRORS},
		    {<<"feature">>, Feature}]);
extended_error(#xmlel{name = Error, attrs = Attrs,
		      children = SubEls},
	       Ext, ExtAttrs) ->
    #xmlel{name = Error, attrs = Attrs,
	   children =
	       lists:reverse([#xmlel{name = Ext, attrs = ExtAttrs,
				     children = []}
			      | SubEls])}.

-spec(uniqid/0 :: () -> mod_pubsub:itemId()).
uniqid() ->
    {T1, T2, T3} = now(),
    iolist_to_binary(io_lib:fwrite("~.16B~.16B~.16B", [T1, T2, T3])).

nodeAttr(Node) -> [{<<"node">>, Node}].

itemAttr([]) -> [];
itemAttr(ItemId) -> [{<<"id">>, ItemId}].

itemsEls(Items) ->
    lists:map(fun (#pubsub_item{itemid = {ItemId, _}, payload = Payload}) ->
		#xmlel{name = <<"item">>, attrs = itemAttr(ItemId), children = Payload}
	end, Items).

add_message_type(#xmlel{name = <<"message">>, attrs = Attrs, children = Els},
  Type) ->
    #xmlel{name = <<"message">>,
	   attrs = [{<<"type">>, Type} | Attrs], children = Els};
add_message_type(XmlEl, _Type) -> XmlEl.

%% Place of <headers/> changed at the bottom of the stanza
%% cf. http://xmpp.org/extensions/xep-0060.html#publisher-publish-success-subid
%%
%% "[SHIM Headers] SHOULD be included after the event notification information
%% (i.e., as the last child of the <message/> stanza)".

add_shim_headers(Stanza, HeaderEls) ->
    add_headers(Stanza, <<"headers">>, ?NS_SHIM, HeaderEls).

add_extended_headers(Stanza, HeaderEls) ->
    add_headers(Stanza, <<"addresses">>, ?NS_ADDRESS,
		HeaderEls).

add_headers(#xmlel{name = Name, attrs = Attrs, children = Els},
	HeaderName, HeaderNS, HeaderEls) ->
    HeaderEl = #xmlel{name = HeaderName,
		      attrs = [{<<"xmlns">>, HeaderNS}],
		      children = HeaderEls},
    #xmlel{name = Name, attrs = Attrs,
	   children = lists:append(Els, [HeaderEl])}.

%% Removed multiple <header name=Collection>Foo</header/> elements
%% Didn't seem compliant, but not sure. Confirmation required.
%% cf. http://xmpp.org/extensions/xep-0248.html#notify
%%
%% "If an item is published to a node which is also included by a collection,
%%  and an entity is subscribed to that collection with a subscription type of
%%  "items" (Is there a way to check that currently ?), then the notifications
%%  generated by the service MUST contain additional information. The <items/>
%%  element contained in the notification message MUST specify the node
%%  identifier of the node that generated the notification (not the collection)
%%  and the <item/> element MUST contain a SHIM header that specifies the node
%%  identifier of the collection".

collection_shim(Node) ->
    [#xmlel{name = <<"header">>,
	    attrs = [{<<"name">>, <<"Collection">>}],
	    children = [{xmlcdata, Node}]}].

subid_shim(SubIDs) ->
    [#xmlel{name = <<"header">>,
	    attrs = [{<<"name">>, <<"SubID">>}],
	    children = [{xmlcdata, SubID}]}
     || SubID <- SubIDs].

%% The argument is a list of Jids because this function could be used
%% with the 'pubsub#replyto' (type=jid-multi) node configuration.

extended_headers(Jids) ->
    [#xmlel{name = <<"address">>,
	    attrs = [{<<"type">>, <<"replyto">>}, {<<"jid">>, Jid}],
	    children = []}
     || Jid <- Jids].

on_user_offline(_, JID, _) ->
    {User, Server, Resource} = jlib:jid_tolower(JID),
    case user_resources(User, Server) of
      [] -> purge_offline({User, Server, Resource});
      _ -> true
    end.

purge_offline({User, Server, _} = LJID) ->
    Host = host(element(2, LJID)),
    Plugins = plugins(Host),
    Result = lists:foldl(fun (Type, {Status, Acc}) ->
				 case lists:member(<<"retrieve-affiliations">>,
						   features(Type))
				     of
				   false ->
				       {{error,
					 extended_error(?ERR_FEATURE_NOT_IMPLEMENTED,
							unsupported,
							<<"retrieve-affiliations">>)},
					Acc};
				   true ->
				       {result, Affiliations} =
					   node_action(Host, Type,
						       get_entity_affiliations,
						       [Host, LJID]),
				       {Status, [Affiliations | Acc]}
				 end
			 end,
			 {ok, []}, Plugins),
    case Result of
      {ok, Affiliations} ->
	  lists:foreach(fun ({#pubsub_node{nodeid = {_, NodeId},
					   options = Options, type = Type},
			      Affiliation})
				when Affiliation == owner orelse
				       Affiliation == publisher ->
				Action = fun (#pubsub_node{type = NType,
							   id = NodeIdx}) ->
						 node_call(NType, get_items,
							   [NodeIdx,
							    service_jid(Host)])
					 end,
				case transaction(Host, NodeId, Action,
						 sync_dirty)
				    of
				  {result, {_, []}} -> true;
				  {result, {_, Items}} ->
				      Features = features(Type),
				      case {lists:member(<<"retract-items">>,
							 Features),
					    lists:member(<<"persistent-items">>,
							 Features),
					    get_option(Options, persist_items),
					    get_option(Options, purge_offline)}
					  of
					{true, true, true, true} ->
					    ForceNotify = get_option(Options,
								     notify_retract),
					    lists:foreach(fun
							    (#pubsub_item{itemid
									      =
									      {ItemId,
									       _},
									  modification
									      =
									      {_,
									       Modification}}) ->
								case
								  Modification
								    of
								  {User, Server,
								   _} ->
								      delete_item(Host,
										  NodeId,
										  LJID,
										  ItemId,
										  ForceNotify);
								  _ -> true
								end;
							    (_) -> true
							  end,
							  Items);
					_ -> true
				      end;
				  Error -> Error
				end;
			    (_) -> true
			end,
			lists:usort(lists:flatten(Affiliations)));
      {Error, _} -> ?DEBUG("on_user_offline ~p", [Error])
    end.