-define(TDICT, dict:dict()).
-define(TGB_TREE, gb_trees:tree()).
--define(TGB_SET, gb_set:set()).
+-define(TGB_SET, gb_sets:set()).
-define(TQUEUE, queue:queue()).
-endif.
-record(private, {xml_els = [] :: [fxml:xmlel()]}).
-type private() :: #private{}.
--record(db_verify, {from :: jid:jid(),
- to :: jid:jid(),
+-record(db_verify, {from = <<>> :: binary(),
+ to = <<>> :: binary(),
id = <<>> :: binary(),
type :: 'error' | 'invalid' | 'valid',
key = <<>> :: binary(),
-record(caps, {node = <<>> :: binary(),
version = <<>> :: binary(),
hash = <<>> :: binary(),
- exts = [] :: binary() | []}).
+ exts = [] :: [binary()]}).
-type caps() :: #caps{}.
-record(muc, {history :: #muc_history{},
userid :: binary()}).
-type vcard_email() :: #vcard_email{}.
--record(db_result, {from :: jid:jid(),
- to :: jid:jid(),
+-record(db_result, {from = <<>> :: binary(),
+ to = <<>> :: binary(),
type :: 'error' | 'invalid' | 'valid',
key = <<>> :: binary(),
sub_els = [] :: [xmpp_element() | fxml:xmlel()]}).
mnesia:transaction(F).
%% Register connection
+-spec register_connection(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> ok.
register_connection(SID,
#jid{luser = LUser, lserver = LServer}, Info) ->
AuthModule = proplists:get_value(auth_module, Info, undefined),
end.
%% Remove an anonymous user from the anonymous users table
+-spec unregister_connection(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> any().
unregister_connection(SID,
#jid{luser = LUser, lserver = LServer}, _) ->
purge_hook(anonymous_user_exist(LUser, LServer), LUser,
-type state() :: #state{}.
-type fsm_stop() :: {stop, normal, state()}.
-type fsm_next() :: {next_state, state_name(), state(), non_neg_integer()}.
+-type fsm_reply() :: {reply, any(), state_name(), state(), non_neg_integer()}.
-type fsm_transition() :: fsm_stop() | fsm_next().
-export_type([state/0]).
-spec get_aux_field(any(), state()) -> {ok, any()} | error.
get_aux_field(Key, #state{aux_fields = Opts}) ->
- case lists:keysearch(Key, 1, Opts) of
- {value, {_, Val}} -> {ok, Val};
- _ -> error
+ case lists:keyfind(Key, 1, Opts) of
+ {_, Val} -> {ok, Val};
+ false -> error
end.
-spec set_aux_field(any(), any(), state()) -> state().
Auth = #legacy_auth{username = Username, password = <<>>, resource = <<>>},
Res = case ejabberd_auth:plain_password_required(StateData#state.server) of
false ->
- xmpp:make_iq_result(IQ, Auth#legacy_auth{digest = none});
+ xmpp:make_iq_result(IQ, Auth#legacy_auth{digest = <<>>});
true ->
xmpp:make_iq_result(IQ, Auth)
end,
J -> J
end,
Lang = case xmpp:get_lang(Pkt) of
- undefined -> StateData#state.lang;
<<"">> -> StateData#state.lang;
L -> L
end,
process_presence_probe(From, To, NewStateData),
{false, NewStateData};
error ->
- NewA = remove_element(jid:tolower(From), State#state.pres_a),
+ NewA = ?SETS:del_element(jid:tolower(From), State#state.pres_a),
{true, State#state{pres_a = NewA}};
subscribe ->
SRes = is_privacy_allow(State, From, To, Packet, in),
websocket -> websocket
end.
+-spec process_presence_probe(jid(), jid(), state()) -> ok.
process_presence_probe(From, To, StateData) ->
LFrom = jid:tolower(From),
LBFrom = setelement(3, LFrom, <<"">>),
end.
%% User updates his presence (non-directed presence packet)
+-spec presence_update(jid(), presence(), state()) -> state().
presence_update(From, Packet, StateData) ->
#presence{type = Type} = Packet,
case Type of
end.
%% User sends a directed presence packet
+-spec presence_track(jid(), jid(), presence(), state()) -> state().
presence_track(From, To, Packet, StateData) ->
#presence{type = Type} = Packet,
LTo = jid:tolower(To),
Server = StateData#state.server,
case Type of
unavailable ->
- A = remove_element(LTo, StateData#state.pres_a),
+ A = ?SETS:del_element(LTo, StateData#state.pres_a),
check_privacy_route(From, StateData#state{pres_a = A}, From, To, Packet);
subscribe ->
try_roster_subscribe(subscribe, User, Server, From, To, Packet, StateData);
check_privacy_route(From, StateData#state{pres_a = A}, From, To, Packet)
end.
+-spec check_privacy_route(jid(), state(), jid(), jid(), stanza()) -> state().
check_privacy_route(From, StateData, FromRoute, To,
Packet) ->
case privacy_check_packet(StateData, From, To, Packet,
end.
%% Check if privacy rules allow this delivery
+-spec privacy_check_packet(state(), jid(), jid(), stanza(), in | out) -> allow | deny.
privacy_check_packet(StateData, From, To, Packet,
Dir) ->
ejabberd_hooks:run_fold(privacy_check_packet,
StateData#state.privacy_list, {From, To, Packet},
Dir]).
+-spec is_privacy_allow(state(), jid(), jid(), stanza(), in | out) -> boolean().
is_privacy_allow(StateData, From, To, Packet, Dir) ->
allow ==
privacy_check_packet(StateData, From, To, Packet, Dir).
%%% Check ACL before allowing to send a subscription stanza
+-spec try_roster_subscribe(subscribe | unsubscribe, binary(), binary(),
+ jid(), jid(), presence(), state()) -> state().
try_roster_subscribe(Type, User, Server, From, To, Packet, StateData) ->
JID1 = jid:make(User, Server, <<"">>),
Access = gen_mod:get_module_opt(Server, mod_roster, access, fun(A) when is_atom(A) -> A end, all),
end.
%% Send presence when disconnecting
+-spec presence_broadcast(state(), jid(), ?SETS:set(), presence()) -> ok.
presence_broadcast(StateData, From, JIDSet, Packet) ->
JIDs = ?SETS:to_list(JIDSet),
JIDs2 = format_and_check_privacy(From, StateData, Packet, JIDs, out),
Server = StateData#state.server,
send_multiple(From, Server, JIDs2, Packet).
+-spec presence_broadcast_to_trusted(
+ state(), jid(), ?SETS:set(), ?SETS:set(), presence()) -> ok.
%% Send presence when updating presence
presence_broadcast_to_trusted(StateData, From, Trusted, JIDSet, Packet) ->
- JIDs = ?SETS:to_list(JIDSet),
- JIDs_trusted = [JID || JID <- JIDs, ?SETS:is_element(JID, Trusted)],
- JIDs2 = format_and_check_privacy(From, StateData, Packet, JIDs_trusted, out),
+ JIDs = ?SETS:to_list(?SETS:intersection(Trusted, JIDSet)),
+ JIDs2 = format_and_check_privacy(From, StateData, Packet, JIDs, out),
Server = StateData#state.server,
send_multiple(From, Server, JIDs2, Packet).
%% Send presence when connecting
+-spec presence_broadcast_first(jid(), state(), presence()) -> state().
presence_broadcast_first(From, StateData, Packet) ->
JIDsProbe =
?SETS:fold(
send_multiple(From, Server, JIDs2, Packet),
StateData#state{pres_a = As}.
+-spec format_and_check_privacy(
+ jid(), state(), stanza(), [ljid()], in | out) -> [jid()].
format_and_check_privacy(From, StateData, Packet, JIDs, Dir) ->
FJIDs = [jid:make(JID) || JID <- JIDs],
lists:filter(
end,
FJIDs).
+-spec send_multiple(jid(), binary(), [jid()], stanza()) -> ok.
send_multiple(From, Server, JIDs, Packet) ->
ejabberd_router_multicast:route_multicast(From, Server, JIDs, Packet).
-remove_element(E, Set) ->
- case (?SETS):is_element(E, Set) of
- true -> (?SETS):del_element(E, Set);
- _ -> Set
- end.
-
+-spec roster_change(jid(), both | from | none | remove | to, state()) -> state().
roster_change(IJID, ISubscription, StateData) ->
LIJID = jid:tolower(IJID),
IsFrom = (ISubscription == both) or (ISubscription == from),
OldIsFrom = (?SETS):is_element(LIJID, StateData#state.pres_f),
FSet = if
IsFrom -> (?SETS):add_element(LIJID, StateData#state.pres_f);
- true -> remove_element(LIJID, StateData#state.pres_f)
+ true -> ?SETS:del_element(LIJID, StateData#state.pres_f)
end,
TSet = if
IsTo -> (?SETS):add_element(LIJID, StateData#state.pres_t);
- true -> remove_element(LIJID, StateData#state.pres_t)
+ true -> ?SETS:del_element(LIJID, StateData#state.pres_t)
end,
case StateData#state.pres_last of
undefined ->
deny -> ok;
allow -> ejabberd_router:route(From, To, PU)
end,
- A = remove_element(LIJID, StateData#state.pres_a),
+ A = ?SETS:del_element(LIJID, StateData#state.pres_a),
StateData#state{pres_a = A, pres_f = FSet,
pres_t = TSet};
true -> StateData#state{pres_f = FSet, pres_t = TSet}
end
end.
+-spec update_priority(integer(), presence(), state()) -> ok.
update_priority(Priority, Packet, StateData) ->
Info = [{ip, StateData#state.ip}, {conn, StateData#state.conn},
{auth_module, StateData#state.auth_module}],
StateData#state.user, StateData#state.server,
StateData#state.resource, Priority, Packet, Info).
+-spec get_priority_from_presence(presence()) -> integer().
get_priority_from_presence(#presence{priority = Prio}) ->
case Prio of
undefined -> 0;
_ -> Prio
end.
+-spec process_privacy_iq(iq(), state()) -> state().
process_privacy_iq(#iq{from = From, to = To,
type = Type, lang = Lang} = IQ, StateData) ->
Txt = <<"No module is handling this query">>,
ejabberd_router:route(To, From, IQRes),
NewStateData.
+-spec resend_offline_messages(state()) -> ok.
resend_offline_messages(#state{ask_offline = true} = StateData) ->
case ejabberd_hooks:run_fold(resend_offline_messages_hook,
StateData#state.server, [],
resend_offline_messages(_StateData) ->
ok.
+-spec resend_subscription_requests(state()) -> state().
resend_subscription_requests(#state{user = User,
server = Server} = StateData) ->
PendingSubscriptions =
StateData,
PendingSubscriptions).
+-spec get_showtag(undefined | presence()) -> binary().
get_showtag(undefined) -> <<"unavailable">>;
get_showtag(#presence{show = undefined}) -> <<"available">>;
get_showtag(#presence{show = Show}) -> atom_to_binary(Show, utf8).
-get_statustag(#presence{status = [#text{data = Status}|_]}) -> Status;
-get_statustag(_) -> <<"">>.
+-spec get_statustag(undefined | presence()) -> binary().
+get_statustag(#presence{status = Status}) -> xmpp:get_text(Status);
+get_statustag(undefined) -> <<"">>.
+-spec process_unauthenticated_stanza(state(), iq()) -> ok | {error, any()}.
process_unauthenticated_stanza(StateData, #iq{type = T, lang = L} = IQ)
when T == set; T == get ->
Lang = if L == undefined; L == <<"">> -> StateData#state.lang;
%% Drop any stanza, which isn't IQ stanza
ok.
+-spec peerip(ejabberd_socket:sockmod(),
+ ejabberd_socket:socket()) ->
+ {inet:ip_address(), non_neg_integer()} | undefined.
peerip(SockMod, Socket) ->
IP = case SockMod of
gen_tcp -> inet:peername(Socket);
%% fsm_reply: Generate the reply FSM tuple with different timeout,
%% depending on the future state
+-spec fsm_reply(_, state_name(), state()) -> fsm_reply().
fsm_reply(Reply, session_established, StateData) ->
{reply, Reply, session_established, StateData,
?C2S_HIBERNATE_TIMEOUT};
{reply, Reply, StateName, StateData, ?C2S_OPEN_TIMEOUT}.
%% Used by c2s blacklist plugins
+-spec is_ip_blacklisted(undefined | {inet:ip_address(), non_neg_integer()},
+ binary()) -> false | {true, binary(), binary()}.
is_ip_blacklisted(undefined, _Lang) -> false;
is_ip_blacklisted({IP, _Port}, Lang) ->
ejabberd_hooks:run_fold(check_bl_c2s, false, [IP, Lang]).
end
end.
+-spec bounce_messages() -> ok.
bounce_messages() ->
receive
{route, From, To, El} ->
after 0 -> ok
end.
+-spec process_compression_request(compress(), state_name(), state()) -> fsm_next().
process_compression_request(#compress{methods = []}, StateName, StateData) ->
send_element(StateData, #compress_failure{reason = 'setup-failed'}),
fsm_next_state(StateName, StateData);
%%% XEP-0191
%%%----------------------------------------------------------------------
+-spec route_blocking(
+ {block, [jid()]} | {unblock, [jid()]} | unblock_all, state()) -> state().
route_blocking(What, StateData) ->
SubEl = case What of
{block, JIDs} ->
%%%----------------------------------------------------------------------
%%% XEP-0198
%%%----------------------------------------------------------------------
-
+-spec stream_mgmt_enabled(state()) -> boolean().
stream_mgmt_enabled(#state{mgmt_state = disabled}) ->
false;
stream_mgmt_enabled(_StateData) ->
true.
+-spec dispatch_stream_mgmt(xmpp_element(), state()) -> state().
dispatch_stream_mgmt(El, #state{mgmt_state = MgmtState} = StateData)
when MgmtState == active;
MgmtState == pending ->
dispatch_stream_mgmt(El, StateData) ->
negotiate_stream_mgmt(El, StateData).
+-spec negotiate_stream_mgmt(xmpp_element(), state()) -> state().
negotiate_stream_mgmt(_El, #state{resource = <<"">>} = StateData) ->
%% XEP-0198 says: "For client-to-server connections, the client MUST NOT
%% attempt to enable stream management until after it has completed Resource
StateData
end.
+-spec perform_stream_mgmt(xmpp_element(), state()) -> state().
perform_stream_mgmt(Pkt, StateData) ->
case xmpp:get_ns(Pkt) of
Xmlns when Xmlns == StateData#state.mgmt_xmlns ->
xmlns = StateData#state.mgmt_xmlns})
end.
+-spec handle_enable(state(), sm_enable()) -> state().
handle_enable(#state{mgmt_timeout = DefaultTimeout,
mgmt_max_timeout = MaxTimeout} = StateData,
#sm_enable{resume = Resume, max = Max}) ->
mgmt_queue = queue:new(),
mgmt_timeout = Timeout * 1000}.
+-spec handle_r(state()) -> state().
handle_r(StateData) ->
Res = #sm_a{xmlns = StateData#state.mgmt_xmlns,
h = StateData#state.mgmt_stanzas_in},
send_element(StateData, Res),
StateData.
+-spec handle_a(state(), sm_a()) -> state().
handle_a(StateData, #sm_a{h = H}) ->
check_h_attribute(StateData, H).
+-spec handle_resume(state(), sm_resume()) -> {ok, state()} | error.
handle_resume(StateData, #sm_resume{h = H, previd = PrevID, xmlns = Xmlns}) ->
R = case stream_mgmt_enabled(StateData) of
true ->
error
end.
+-spec check_h_attribute(state(), non_neg_integer()) -> state().
check_h_attribute(#state{mgmt_stanzas_out = NumStanzasOut} = StateData, H)
when H > NumStanzasOut ->
?DEBUG("~s acknowledged ~B stanzas, but only ~B were sent",
[jid:to_string(StateData#state.jid), H, NumStanzasOut]),
mgmt_queue_drop(StateData, H).
+-spec update_num_stanzas_in(state(), xmpp_element()) -> state().
update_num_stanzas_in(#state{mgmt_state = MgmtState} = StateData, El)
when MgmtState == active;
MgmtState == pending ->
update_num_stanzas_in(StateData, _El) ->
StateData.
+-spec send_stanza_and_ack_req(state(), stanza()) -> state().
send_stanza_and_ack_req(StateData, Stanza) ->
AckReq = #sm_r{xmlns = StateData#state.mgmt_xmlns},
case send_element(StateData, Stanza) == ok andalso
StateData#state{mgmt_state = pending}
end.
+-spec mgmt_queue_add(state(), xmpp_element()) -> state().
mgmt_queue_add(StateData, El) ->
NewNum = case StateData#state.mgmt_stanzas_out of
4294967295 ->
mgmt_stanzas_out = NewNum},
check_queue_length(NewState).
+-spec mgmt_queue_drop(state(), non_neg_integer()) -> state().
mgmt_queue_drop(StateData, NumHandled) ->
NewQueue = jlib:queue_drop_while(fun({N, _T, _E}) -> N =< NumHandled end,
StateData#state.mgmt_queue),
StateData#state{mgmt_queue = NewQueue}.
+-spec check_queue_length(state()) -> state().
check_queue_length(#state{mgmt_max_queue = Limit} = StateData)
when Limit == infinity;
Limit == exceeded ->
StateData
end.
+-spec handle_unacked_stanzas(state(), fun((_, _, _, _) -> _)) -> ok.
handle_unacked_stanzas(#state{mgmt_state = MgmtState} = StateData, F)
when MgmtState == active;
MgmtState == pending;
handle_unacked_stanzas(_StateData, _F) ->
ok.
+-spec handle_unacked_stanzas(state()) -> ok.
handle_unacked_stanzas(#state{mgmt_state = MgmtState} = StateData)
when MgmtState == active;
MgmtState == pending;
handle_unacked_stanzas(_StateData) ->
ok.
+-spec is_encapsulated_forward(stanza()) -> boolean().
is_encapsulated_forward(#message{} = Msg) ->
xmpp:has_subtag(Msg, #forwarded{}) orelse
xmpp:has_subtag(Msg, #carbons_sent{}) orelse
is_encapsulated_forward(_El) ->
false.
+-spec inherit_session_state(state(), binary()) -> {ok, state()} |
+ {error, binary()} |
+ {error, binary(), non_neg_integer()}.
inherit_session_state(#state{user = U, server = S} = StateData, ResumeID) ->
case jlib:base64_to_term(ResumeID) of
{term, {R, Time}} ->
{error, <<"Invalid 'previd' value">>}
end.
+-spec resume_session({integer(), pid()}) -> any().
resume_session({Time, PID}) ->
(?GEN_FSM):sync_send_all_state_event(PID, {resume_session, Time}, 5000).
+-spec make_resume_id(state()) -> binary().
make_resume_id(StateData) ->
{Time, _} = StateData#state.sid,
jlib:term_to_base64({StateData#state.resource, Time}).
+-spec add_resent_delay_info(state(), stanza(), erlang:timestamp()) -> stanza().
add_resent_delay_info(_State, #iq{} = El, _Time) ->
El;
add_resent_delay_info(#state{server = From}, El, Time) ->
%%%----------------------------------------------------------------------
%%% XEP-0352
%%%----------------------------------------------------------------------
-
+-spec csi_filter_stanza(state(), stanza()) -> state().
csi_filter_stanza(#state{csi_state = CsiState, server = Server} = StateData,
Stanza) ->
{StateData1, Stanzas} = ejabberd_hooks:run_fold(csi_filter_stanza, Server,
Stanzas),
StateData2#state{csi_state = CsiState}.
+-spec csi_flush_queue(state()) -> state().
csi_flush_queue(#state{csi_state = CsiState, server = Server} = StateData) ->
{StateData1, Stanzas} = ejabberd_hooks:run_fold(csi_flush_queue, Server,
{StateData, []}, [Server]),
%% Try to reduce the heap footprint of the four presence sets
%% by ensuring that we re-use strings and Jids wherever possible.
+-spec pack(state()) -> state().
pack(S = #state{pres_a = A, pres_f = F,
pres_t = T}) ->
{NewA, Pack2} = pack_jid_set(A, gb_trees:empty()),
transform_listen_option(Opt, Opts) ->
[Opt|Opts].
+-spec identity([{atom(), binary()}]) -> binary().
identity(Props) ->
case proplists:get_value(authzid, Props, <<>>) of
<<>> -> proplists:get_value(username, Props, <<>>);
[] -> erlang:error(badarg)
end.
--spec default_db(binary(), module()) -> atom().
+-spec default_db(global | binary(), module()) -> atom().
default_db(Host, Module) ->
case ejabberd_config:get_option(
refresh_iq_handlers() ->
ejabberd_local ! refresh_iq_handlers.
--spec bounce_resource_packet(jid(), jid(), stanza()) -> stop.
+-spec bounce_resource_packet(jid(), jid(), stanza()) -> ok.
bounce_resource_packet(From, To, Packet) ->
Lang = xmpp:get_lang(Packet),
Txt = <<"No available resource found">>,
Err = xmpp:make_error(Packet,
xmpp:err_item_not_found(Txt, Lang)),
- ejabberd_router:route(To, From, Err),
- stop.
+ ejabberd_router:route(To, From, Err).
%%====================================================================
%% gen_server callbacks
-include("logger.hrl").
-include("xmpp.hrl").
--record(route_multicast, {domain = <<"">> :: binary(),
+-record(route_multicast, {domain = <<"">> :: binary() | '_',
pid = self() :: pid()}).
-record(state, {}).
connections = (?DICT):new() :: ?TDICT,
timer = make_ref() :: reference()}).
--type state_name() :: wait_for_stream | wait_for_features | stream_established.
+-type state_name() :: wait_for_stream | wait_for_feature_request | stream_established.
-type state() :: #state{}.
-type fsm_next() :: {next_state, state_name(), state()}.
-type fsm_stop() :: {stop, normal, state()}.
end,
TLSSocket = (StateData#state.sockmod):starttls(
Socket, TLSOpts,
- fxml:element_to_binary(#starttls_proceed{})),
+ fxml:element_to_binary(
+ xmpp:encode(#starttls_proceed{}))),
{next_state, wait_for_stream,
StateData#state{socket = TLSSocket, streamid = new_id(),
tls_enabled = true, tls_options = TLSOpts}};
stream_established(#db_result{to = To, from = From, key = Key},
StateData) ->
?DEBUG("GET KEY: ~p", [{To, From, Key}]),
- LTo = To#jid.lserver,
- LFrom = From#jid.lserver,
- case {ejabberd_s2s:allow_host(LTo, LFrom),
- lists:member(LTo, ejabberd_router:dirty_get_all_domains())} of
+ case {ejabberd_s2s:allow_host(To, From),
+ lists:member(To, ejabberd_router:dirty_get_all_domains())} of
{true, true} ->
- ejabberd_s2s_out:terminate_if_waiting_delay(LTo, LFrom),
- ejabberd_s2s_out:start(LTo, LFrom,
+ ejabberd_s2s_out:terminate_if_waiting_delay(To, From),
+ ejabberd_s2s_out:start(To, From,
{verify, self(), Key,
StateData#state.streamid}),
- Conns = (?DICT):store({LFrom, LTo},
+ Conns = (?DICT):store({From, To},
wait_for_verification,
StateData#state.connections),
- change_shaper(StateData, LTo, jid:make(LFrom)),
+ change_shaper(StateData, To, jid:make(From)),
{next_state, stream_established,
StateData#state{connections = Conns}};
{_, false} ->
stream_established(#db_verify{to = To, from = From, id = Id, key = Key},
StateData) ->
?DEBUG("VERIFY KEY: ~p", [{To, From, Id, Key}]),
- LTo = jid:nameprep(To),
- LFrom = jid:nameprep(From),
- Type = case ejabberd_s2s:make_key({LTo, LFrom}, Id) of
+ Type = case ejabberd_s2s:make_key({To, From}, Id) of
Key -> valid;
_ -> invalid
end,
#db_result{from = To, to = From, type = valid}),
?INFO_MSG("Accepted s2s dialback authentication for ~s (TLS=~p)",
[From, StateData#state.tls_enabled]),
- LFrom = jid:nameprep(From),
- LTo = jid:nameprep(To),
NSD = StateData#state{connections =
- (?DICT):store({LFrom, LTo}, established,
+ (?DICT):store({From, To}, established,
StateData#state.connections)},
{next_state, stream_established, NSD};
stream_established({invalid, From, To}, StateData) ->
send_element(StateData,
#db_result{from = To, to = From, type = invalid}),
- LFrom = jid:nameprep(From),
- LTo = jid:nameprep(To),
NSD = StateData#state{connections =
- (?DICT):erase({LFrom, LTo},
+ (?DICT):erase({From, To},
StateData#state.connections)},
{next_state, stream_established, NSD};
stream_established({xmlstreamend, _Name}, StateData) ->
{StateData#state.myname, Server},
StateData#state.remote_streamid),
send_element(StateData,
- #db_result{from = jid:make(StateData#state.myname),
- to = jid:make(Server),
+ #db_result{from = StateData#state.myname,
+ to = Server,
key = Key1})
end,
case StateData#state.verify of
false -> ok;
{_Pid, Key2, SID} ->
send_element(StateData,
- #db_verify{from = jid:make(StateData#state.myname),
+ #db_verify{from = StateData#state.myname,
to = StateData#state.server,
id = SID,
key = Key2})
end.
%% Terminate s2s_out connections that are in state wait_before_retry
--spec terminate_if_waiting_delay(ljid(), ljid()) -> ok.
+-spec terminate_if_waiting_delay(binary(), binary()) -> ok.
terminate_if_waiting_delay(From, To) ->
FromTo = {From, To},
Pids = ejabberd_s2s:get_connections_pids(FromTo),
try xmpp:decode(#xmlel{name = Name, attrs = Attrs}) of
#stream_start{xmlns = ?NS_COMPONENT, to = To} when is_record(To, jid) ->
Host = To#jid.lserver,
- send_header(StateData, To),
+ send_header(StateData, Host),
HostOpts = case dict:is_key(Host, StateData#state.host_opts) of
true ->
StateData#state.host_opts;
%%====================================================================
%% API
%%====================================================================
--export_type([sid/0]).
+-export_type([sid/0, info/0]).
start() ->
ChildSpec = {?MODULE, {?MODULE, start_link, []},
false -> {stop, false}
end.
--spec bounce_offline_message(jid(), jid(), xmlel()) -> stop.
+-spec bounce_offline_message(jid(), jid(), message()) -> stop.
bounce_offline_message(From, To, Packet) ->
Lang = xmpp:get_lang(Packet),
end.
-spec set_presence(sid(), binary(), binary(), binary(),
- prio(), xmlel(), info()) -> ok.
+ prio(), presence(), info()) -> ok.
set_presence(SID, User, Server, Resource, Priority,
Presence, Info) ->
process_iq(_From, _To, #iq{}) ->
ok.
--spec force_update_presence({binary(), binary()}) -> any().
+-spec force_update_presence({binary(), binary()}) -> ok.
force_update_presence({LUser, LServer}) ->
Mod = get_sm_backend(LServer),
-type socket_state() :: #socket_state{}.
--export_type([socket_state/0, sockmod/0]).
+-export_type([socket/0, socket_state/0, sockmod/0]).
%%====================================================================
gen_server:start_link({local, ?MODULE}, ?MODULE, Opts,
[]).
+-spec process_command(jid(), jid(), stanza()) -> ok.
process_command(From, To, Packet) ->
case To of
#jid{luser = <<"">>, lresource = <<"watchdog">>} ->
process_flag(priority, high),
process_command1(From, To, BodyText)
end),
- stop;
+ ok;
false -> ok
end;
_ -> ok
process_admin(Host,
#request{lang = Lang, auth = {_, _Auth, AJID}} =
Request) ->
- {Hook, Opts} = case Host of
- global -> {webadmin_page_main, [Request]};
- Host -> {webadmin_page_host, [Host, Request]}
- end,
- case ejabberd_hooks:run_fold(Hook, Host, [], Opts) of
+ Res = case Host of
+ global ->
+ ejabberd_hooks:run_fold(
+ webadmin_page_main, Host, [], [Request]);
+ _ ->
+ ejabberd_hooks:run_fold(
+ webadmin_page_host, Host, [], [Host, Request])
+ end,
+ case Res of
[] ->
setelement(1,
make_xhtml([?XC(<<"h1">>, <<"Not Found">>)], Host, Lang,
AJID),
404);
- Res -> make_xhtml(Res, Host, Lang, AJID)
+ _ -> make_xhtml(Res, Host, Lang, AJID)
end.
%%%==================================
?BR,
?INPUTT(<<"submit">>, <<"update">>, <<"Update">>)])];
get_node(Host, Node, NPath, Query, Lang) ->
- {Hook, Opts} = case Host of
- global ->
- {webadmin_page_node, [Node, NPath, Query, Lang]};
- Host ->
- {webadmin_page_hostnode,
- [Host, Node, NPath, Query, Lang]}
- end,
- case ejabberd_hooks:run_fold(Hook, Host, [], Opts) of
+ Res = case Host of
+ global ->
+ ejabberd_hooks:run_fold(webadmin_page_node, Host, [],
+ [Node, NPath, Query, Lang]);
+ _ ->
+ ejabberd_hooks:run_fold(webadmin_page_hostnode, Host, [],
+ [Host, Node, NPath, Query, Lang])
+ end,
+ case Res of
[] -> [?XC(<<"h1">>, <<"Not Found">>)];
- Res -> Res
+ _ -> Res
end.
%%%==================================
-type component() :: ejabberd_sm | ejabberd_local.
-type type() :: no_queue | one_queue | pos_integer() | parallel.
-type opts() :: no_queue | {one_queue, pid()} | {queues, [pid()]} | parallel.
+-export_type([opts/0]).
%%====================================================================
%% API
undefined
end.
--spec db_type(binary(), opts(), module()) -> db_type().
+-spec db_type(global | binary(), opts(), module()) -> db_type().
db_type(Host, Opts, Module) ->
case catch Module:mod_opt_type(db_type) of
get_sm_identity(Acc, _From, _To, _Node, _Lang) -> Acc.
%-------------------------------------------------------------------------
-
+-spec get_local_features({error, error()} | {result, [binary()]} | empty,
+ jid(), jid(), binary(), binary()) ->
+ {error, error()} | {result, [binary()]} | empty.
get_local_features(Acc, _From, _To, <<"">>, _Lang) ->
Feats = case Acc of
{result, I} -> I;
%-------------------------------------------------------------------------
process_local_iq(IQ) ->
- process_adhoc_request(IQ, adhoc_local_commands).
+ process_adhoc_request(IQ, local).
process_sm_iq(IQ) ->
- process_adhoc_request(IQ, adhoc_sm_commands).
+ process_adhoc_request(IQ, sm).
process_adhoc_request(#iq{from = From, to = To,
type = set, lang = Lang,
- sub_els = [#adhoc_command{} = SubEl]} = IQ, Hook) ->
+ sub_els = [#adhoc_command{} = SubEl]} = IQ, Type) ->
Host = To#jid.lserver,
- case ejabberd_hooks:run_fold(Hook, Host, empty, [From, To, SubEl]) of
+ Res = case Type of
+ local ->
+ ejabberd_hooks:run_fold(adhoc_local_commands, Host, empty,
+ [From, To, SubEl]);
+ sm ->
+ ejabberd_hooks:run_fold(adhoc_sm_commands, Host, empty,
+ [From, To, SubEl])
+ end,
+ case Res of
ignore ->
ignore;
empty ->
process_adhoc_request(#iq{} = IQ, _Hooks) ->
xmpp:make_error(IQ, xmpp:err_bad_request()).
+-spec ping_item(empty | {error, error()} | {result, [disco_item()]},
+ jid(), jid(), binary()) -> {result, [disco_item()]}.
ping_item(Acc, _From, #jid{server = Server} = _To,
Lang) ->
Items = case Acc of
name = translate:translate(Lang, <<"Ping">>)}],
{result, Items ++ Nodes}.
+-spec ping_command(adhoc_command(), jid(), jid(), adhoc_command()) ->
+ adhoc_command() | {error, error()}.
ping_command(_Acc, _From, _To,
#adhoc_command{lang = Lang, node = <<"ping">>,
action = Action} = Request) ->
{wait, Proc}.
%% Announcing via messages to a custom resource
+-spec announce(jid(), jid(), stanza()) -> ok.
announce(From, #jid{luser = <<>>} = To, #message{} = Packet) ->
Proc = gen_mod:get_module_proc(To#jid.lserver, ?PROCNAME),
case To#jid.lresource of
<<"announce/all">> ->
- Proc ! {announce_all, From, To, Packet},
- stop;
+ Proc ! {announce_all, From, To, Packet};
<<"announce/all-hosts/all">> ->
- Proc ! {announce_all_hosts_all, From, To, Packet},
- stop;
+ Proc ! {announce_all_hosts_all, From, To, Packet};
<<"announce/online">> ->
- Proc ! {announce_online, From, To, Packet},
- stop;
+ Proc ! {announce_online, From, To, Packet};
<<"announce/all-hosts/online">> ->
- Proc ! {announce_all_hosts_online, From, To, Packet},
- stop;
+ Proc ! {announce_all_hosts_online, From, To, Packet};
<<"announce/motd">> ->
- Proc ! {announce_motd, From, To, Packet},
- stop;
+ Proc ! {announce_motd, From, To, Packet};
<<"announce/all-hosts/motd">> ->
- Proc ! {announce_all_hosts_motd, From, To, Packet},
- stop;
+ Proc ! {announce_all_hosts_motd, From, To, Packet};
<<"announce/motd/update">> ->
- Proc ! {announce_motd_update, From, To, Packet},
- stop;
+ Proc ! {announce_motd_update, From, To, Packet};
<<"announce/all-hosts/motd/update">> ->
- Proc ! {announce_all_hosts_motd_update, From, To, Packet},
- stop;
+ Proc ! {announce_all_hosts_motd_update, From, To, Packet};
<<"announce/motd/delete">> ->
- Proc ! {announce_motd_delete, From, To, Packet},
- stop;
+ Proc ! {announce_motd_delete, From, To, Packet};
<<"announce/all-hosts/motd/delete">> ->
- Proc ! {announce_all_hosts_motd_delete, From, To, Packet},
- stop;
+ Proc ! {announce_all_hosts_motd_delete, From, To, Packet};
_ ->
ok
- end;
+ end,
+ ok;
announce(_From, _To, _Packet) ->
ok.
end.
%%-------------------------------------------------------------------------
-
+-spec announce_items(empty | {error, error()} | {result, [disco_item()]},
+ jid(), jid(), binary()) -> {error, error()} |
+ {result, [disco_item()]} |
+ empty.
announce_items(Acc, From, #jid{lserver = LServer, server = Server} = _To, Lang) ->
Access1 = get_access(LServer),
Nodes1 = case acl:match_rule(LServer, Access1, From) of
announce_commands(From, To, Request)
end.
-
+-spec announce_commands(adhoc_command(), jid(), jid(), adhoc_command()) ->
+ adhoc_command() | {error, error()}.
announce_commands(Acc, From, #jid{lserver = LServer} = To,
#adhoc_command{node = Node} = Request) ->
LNode = tokenize(Node),
Mod = gen_mod:db_mod(LServer, ?MODULE),
Mod:delete_motd(LServer).
+-spec send_motd(jid()) -> ok | {atomic, any()}.
send_motd(#jid{luser = LUser, lserver = LServer} = JID) when LUser /= <<>> ->
Mod = gen_mod:db_mod(LServer, ?MODULE),
case Mod:get_motd(LServer) of
NeedDb = mod_privacy:is_list_needdb(List),
#userlist{name = Name, list = List, needdb = NeedDb}.
--spec broadcast_list_update(binary(), binary(), binary(), userlist()) ->
- {broadcast,
- {privacy_list, userlist(), binary() | none}}.
+-spec broadcast_list_update(binary(), binary(), binary(), userlist()) -> ok.
broadcast_list_update(LUser, LServer, Name, UserList) ->
ejabberd_sm:route(jid:make(LUser, LServer, <<"">>),
jid:make(LUser, LServer, <<"">>),
{broadcast, {privacy_list, UserList, Name}}).
--spec broadcast_blocklist_event(binary(), binary(), block_event()) ->
- {broadcast, {blocking, block_event()}}.
+-spec broadcast_blocklist_event(binary(), binary(), block_event()) -> ok.
broadcast_blocklist_event(LUser, LServer, Event) ->
JID = jid:make(LUser, LServer, <<"">>),
ejabberd_sm:route(JID, JID,
-spec disco_features({error, error()} | {result, [binary()]} | empty,
jid(), jid(),
binary(), binary()) ->
- {error, error()} | {result, [binary()]}.
+ {error, error()} | {result, [binary()]} | empty.
disco_features(Acc, From, To, Node, Lang) ->
case is_valid_node(Node) of
true ->
Acc
end.
--spec disco_info([xdata()], binary(), module(),
- binary(), binary()) -> [xdata()].
-disco_info(Acc, Host, Module, Node, Lang) ->
+-spec disco_info([xdata()], binary(), module(), binary(), binary()) -> [xdata()];
+ ([xdata()], jid(), jid(), binary(), binary()) -> [xdata()].
+disco_info(Acc, Host, Module, Node, Lang) when is_atom(Module) ->
case is_valid_node(Node) of
true ->
ejabberd_hooks:run_fold(disco_info, Host, [],
[Host, Module, <<"">>, Lang]);
false ->
Acc
- end.
+ end;
+disco_info(Acc, _, _, _Node, _Lang) ->
+ Acc.
-spec c2s_presence_in(ejabberd_c2s:state(), {jid(), jid(), presence()}) ->
ejabberd_c2s:state().
end;
c2s_broadcast_recipients(Acc, _, _, _, _, _) -> Acc.
+-spec depends(binary(), gen_mod:opts()) -> [{module(), hard | soft}].
depends(_Host, _Opts) ->
[].
[_SubNode | SubNodes]) ->
feature_request(Host, From, Caps, SubNodes).
--spec caps_read_fun(binary(), binary()) -> function().
+-spec caps_read_fun(binary(), {binary(), binary()}) -> function().
caps_read_fun(Host, Node) ->
LServer = jid:nameprep(Host),
Mod = gen_mod:db_mod(LServer, ?MODULE),
fun() -> Mod:caps_read(LServer, Node) end.
--spec caps_write_fun(binary(), binary(), [binary()]) -> function().
+-spec caps_write_fun(binary(), {binary(), binary()}, [binary()]) -> function().
caps_write_fun(Host, Node, Features) ->
LServer = jid:nameprep(Host),
Mod = gen_mod:db_mod(LServer, ?MODULE),
_Err -> <<"">>
end.
--spec make_disco_hash(disco_info(), crypto:digest_type()) -> binary().
-
+-type digest_type() :: md5 | sha | sha224 | sha256 | sha384 | sha512.
+-spec make_disco_hash(disco_info(), digest_type()) -> binary().
make_disco_hash(DiscoInfo, Algo) ->
Concat = list_to_binary([concat_identities(DiscoInfo),
concat_features(DiscoInfo), concat_info(DiscoInfo)]),
_ -> true
end.
+-spec concat_features(disco_info()) -> iolist().
concat_features(#disco_info{features = Features}) ->
lists:usort([[Feat, $<] || Feat <- Features]).
+-spec concat_identities(disco_info()) -> iolist().
concat_identities(#disco_info{identities = Identities}) ->
lists:sort(
[[Cat, $/, T, $/, Lang, $/, Name, $<] ||
#identity{category = Cat, type = T,
lang = Lang, name = Name} <- Identities]).
+-spec concat_info(disco_info()) -> iolist().
concat_info(#disco_info{xdata = Xs}) ->
lists:sort(
[concat_xdata_fields(Fs) || #xdata{type = result, fields = Fs} <- Xs]).
+-spec concat_xdata_fields([xdata_field()]) -> iolist().
concat_xdata_fields(Fields) ->
Form = case lists:keyfind(<<"FORM_TYPE">>, #xdata_field.var, Fields) of
#xdata_field{values = Values} -> Values;
is_binary(Var), Var /= <<"FORM_TYPE">>],
[Form, $<, lists:sort(Res)].
+-spec gb_trees_fold(fun((_, _, T) -> T), T, gb_trees:tree()) -> T.
gb_trees_fold(F, Acc, Tree) ->
Iter = gb_trees:iterator(Tree),
gb_trees_fold_iter(F, Acc, Iter).
+-spec gb_trees_fold_iter(fun((_, _, T) -> T), T, gb_trees:iter()) -> T.
gb_trees_fold_iter(F, Acc, Iter) ->
case gb_trees:next(Iter) of
{Key, Val, NewIter} ->
_ -> Acc
end.
+-spec now_ts() -> integer().
now_ts() ->
p1_time_compat:system_time(seconds).
-spec build_forward_packet(jid(), message(), jid(), jid(), direction()) -> message().
build_forward_packet(JID, #message{type = T} = Msg, Sender, Dest, Direction) ->
- Forwarded = #forwarded{sub_els = complete_packet(JID, Msg, Direction)},
+ Forwarded = #forwarded{sub_els = [complete_packet(JID, Msg, Direction)]},
Carbon = case Direction of
sent -> #carbons_sent{forwarded = Forwarded};
received -> #carbons_received{forwarded = Forwarded}
%% ejabberd_hooks callbacks.
%%--------------------------------------------------------------------
--spec filter_presence({term(), [stanza()]}, binary(), stanza())
- -> {term(), [stanza()]} | {stop, {term(), [stanza()]}}.
+-spec filter_presence({ejabberd_c2s:state(), [stanza()]}, binary(), stanza())
+ -> {ejabberd_c2s:state(), [stanza()]} |
+ {stop, {ejabberd_c2s:state(), [stanza()]}}.
filter_presence({C2SState, _OutStanzas} = Acc, Host,
#presence{type = Type} = Stanza) ->
- if Type == available, Type == unavailable ->
+ if Type == available; Type == unavailable ->
?DEBUG("Got availability presence stanza", []),
queue_add(presence, Stanza, Host, C2SState);
true ->
end;
filter_presence(Acc, _Host, _Stanza) -> Acc.
--spec filter_chat_states({term(), [stanza()]}, binary(), stanza())
- -> {term(), [stanza()]} | {stop, {term(), [stanza()]}}.
+-spec filter_chat_states({ejabberd_c2s:state(), [stanza()]}, binary(), stanza())
+ -> {ejabberd_c2s:state(), [stanza()]} |
+ {stop, {ejabberd_c2s:state(), [stanza()]}}.
filter_chat_states({C2SState, _OutStanzas} = Acc, Host,
#message{from = From, to = To} = Stanza) ->
end;
filter_chat_states(Acc, _Host, _Stanza) -> Acc.
--spec filter_pep({term(), [stanza()]}, binary(), stanza())
- -> {term(), [stanza()]} | {stop, {term(), [stanza()]}}.
+-spec filter_pep({ejabberd_c2s:state(), [stanza()]}, binary(), stanza())
+ -> {ejabberd_c2s:state(), [stanza()]} |
+ {stop, {ejabberd_c2s:state(), [stanza()]}}.
filter_pep({C2SState, _OutStanzas} = Acc, Host, #message{} = Stanza) ->
case get_pep_node(Stanza) of
end;
filter_pep(Acc, _Host, _Stanza) -> Acc.
--spec filter_other({term(), [stanza()]}, binary(), stanza())
- -> {stop, {term(), [stanza()]}}.
+-spec filter_other({ejabberd_c2s:state(), [stanza()]}, binary(), stanza())
+ -> {stop, {ejabberd_c2s:state(), [stanza()]}}.
filter_other({C2SState, _OutStanzas}, Host, Stanza) ->
?DEBUG("Won't add stanza to CSI queue", []),
queue_take(Stanza, Host, C2SState).
--spec flush_queue({term(), [stanza()]}, binary()) -> {term(), [stanza()]}.
+-spec flush_queue({ejabberd_c2s:state(), [stanza()]}, binary())
+ -> {ejabberd_c2s:state(), [stanza()]}.
flush_queue({C2SState, _OutStanzas}, Host) ->
?DEBUG("Going to flush CSI queue", []),
undefined;
get_pep_node(#message{} = Msg) ->
case xmpp:get_subtag(Msg, #pubsub_event{}) of
- #pubsub_event{items = [#pubsub_event_item{node = Node}]} ->
+ #pubsub_event{items = [#pubsub_event_items{node = Node}]} ->
Node;
_ ->
undefined
end.
%%%-----------------------------------------------------------------------
-
+-spec adhoc_sm_items(empty | {error, error()} | {result, [disco_item()]},
+ jid(), jid(), binary()) -> {error, error()} |
+ {result, [disco_item()]} |
+ empty.
adhoc_sm_items(Acc, From, #jid{lserver = LServer} = To,
Lang) ->
case acl:match_rule(LServer, configure, From) of
%%%-----------------------------------------------------------------------
+-spec adhoc_local_items(empty | {error, error()} | {result, [disco_item()]},
+ jid(), jid(), binary()) -> {error, error()} |
+ {result, [disco_item()]} |
+ empty.
adhoc_local_items(Acc, From,
#jid{lserver = LServer, server = Server} = To, Lang) ->
case acl:match_rule(LServer, configure, From) of
allow -> adhoc_local_commands(From, To, Request)
end).
+-spec adhoc_local_commands(adhoc_command(), jid(), jid(), adhoc_command()) ->
+ adhoc_command() | {error, error()}.
adhoc_local_commands(Acc, From,
#jid{lserver = LServer} = To,
#adhoc_command{node = Node, lang = Lang} = Request) ->
get_value(Field, XData) -> hd(get_values(Field, XData)).
get_values(Field, XData) ->
- [_|_] = Values = xmpp_util:get_xdata_values(Field, XData),
- Values.
+ xmpp_util:get_xdata_values(Field, XData).
search_running_node(SNode) ->
search_running_node(SNode,
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
+-spec adhoc_sm_commands(adhoc_command(), jid(), jid(), adhoc_command()) -> adhoc_command().
adhoc_sm_commands(_Acc, From,
#jid{user = User, server = Server, lserver = LServer},
#adhoc_command{lang = Lang, node = <<"config">>,
%%% Support for: XEP-0157 Contact Addresses for XMPP Services
--spec get_info([xdata()], binary(), module(), binary(), binary()) -> [xdata()].
-get_info(_A, Host, Mod, Node, _Lang) when Node == <<"">> ->
+-spec get_info([xdata()], binary(), module(), binary(), binary()) -> [xdata()];
+ ([xdata()], jid(), jid(), binary(), binary()) -> [xdata()].
+get_info(_A, Host, Mod, Node, _Lang) when is_atom(Mod), Node == <<"">> ->
Module = case Mod of
undefined -> ?MODULE;
_ -> Mod
Proc = gen_mod:get_module_proc(Host, ?MODULE),
gen_server:start_link({local, Proc}, ?MODULE, [Host, Opts], []).
+-spec c2s_auth_result(boolean(), binary(), binary(),
+ {inet:ip_address(), non_neg_integer()}) -> ok.
c2s_auth_result(false, _User, LServer, {Addr, _Port}) ->
case is_whitelisted(LServer, Addr) of
true ->
ets:insert(failed_auth, {Addr, N+1, UnbanTS, MaxFailures});
[] ->
ets:insert(failed_auth, {Addr, 1, UnbanTS, MaxFailures})
- end
+ end,
+ ok
end;
c2s_auth_result(true, _User, _Server, _AddrPort) ->
ok.
+-spec check_bl_c2s({true, binary(), binary()} | false,
+ {inet:ip_address(), non_neg_integer()},
+ binary()) -> {stop, {true, binary(), binary()}} | false.
check_bl_c2s(_Acc, Addr, Lang) ->
case ets:lookup(failed_auth, Addr) of
[{Addr, N, TS, MaxFailures}] when N >= MaxFailures ->
{slot_timed_out,
Slot}),
NewState = add_slot(Slot, Size, Timer, State),
- Slot = mk_slot(Slot, State, XMLNS),
- {xmpp:make_iq_result(IQ, Slot), NewState};
+ NewSlot = mk_slot(Slot, State, XMLNS),
+ {xmpp:make_iq_result(IQ, NewSlot), NewState};
{ok, PutURL, GetURL} ->
Slot = mk_slot(PutURL, GetURL, XMLNS),
xmpp:make_iq_result(IQ, Slot);
NewSlots = maps:remove(Slot, Slots),
State#state{slots = NewSlots}.
--spec mk_slot(slot() | binary(), state() | binary(), binary()) -> xmlel().
+-spec mk_slot(slot(), state(), binary()) -> upload_slot();
+ (binary(), binary(), binary()) -> upload_slot().
mk_slot(Slot, #state{put_url = PutPrefix, get_url = GetPrefix}, XMLNS) ->
PutURL = str:join([PutPrefix | Slot], <<$/>>),
GetURL = str:join([GetPrefix | Slot], <<$/>>),
+ mk_slot(PutURL, GetURL, XMLNS);
+mk_slot(PutURL, GetURL, XMLNS) ->
#upload_slot{get = GetURL, put = PutURL, xmlns = XMLNS}.
-spec make_user_string(jid(), sha1 | node) -> binary().
%% Return: false: IP not blacklisted
%% true: IP is blacklisted
%% IPV4 IP tuple:
+-spec is_ip_in_c2s_blacklist(
+ {true, binary(), binary()} | false,
+ {inet:ip_address(), non_neg_integer()},
+ binary()) -> {stop, {true, binary(), binary()}} | false.
is_ip_in_c2s_blacklist(_Val, IP, Lang) when is_tuple(IP) ->
BinaryIP = jlib:ip_to_list(IP),
case ets:lookup(bl_c2s, BinaryIP) of
-callback init(binary(), gen_mod:opts()) -> any().
-callback import(binary(), #irc_custom{}) -> ok | pass.
--callback get_data(binary(), binary(), {binary(), binary()}) ->
- error | empty | irc_data().
--callback set_data(binary(), binary(), {binary(), binary()}, irc_data()) ->
- {atomic, any()}.
+-callback get_data(binary(), binary(), jid()) -> error | empty | irc_data().
+-callback set_data(binary(), binary(), jid(), irc_data()) -> {atomic, any()}.
%%====================================================================
%% API
[From, <<"MODE">>, <<$#, Chan/binary>>, <<"+o">>, Nick
| _] ->
process_mode_o(StateData, Chan, From, Nick,
- <<"admin">>, <<"moderator">>),
+ admin, moderator),
StateData;
[From, <<"MODE">>, <<$#, Chan/binary>>, <<"-o">>, Nick
| _] ->
process_mode_o(StateData, Chan, From, Nick,
- <<"member">>, <<"participant">>),
+ member, participant),
StateData;
[From, <<"KICK">>, <<$#, Chan/binary>>, Nick | _] ->
process_kick(StateData, Chan, From, Nick, String),
end,
{User2, Affiliation, Role} = case User1 of
<<$@, U2/binary>> ->
- {U2, <<"admin">>, <<"moderator">>};
+ {U2, admin, moderator};
<<$+, U2/binary>> ->
- {U2, <<"member">>, <<"participant">>};
+ {U2, member, participant};
<<$%, U2/binary>> ->
- {U2, <<"admin">>, <<"moderator">>};
+ {U2, admin, moderator};
<<$&, U2/binary>> ->
- {U2, <<"admin">>, <<"moderator">>};
+ {U2, admin, moderator};
<<$~, U2/binary>> ->
- {U2, <<"admin">>, <<"moderator">>};
- _ -> {User1, <<"member">>, <<"participant">>}
+ {U2, admin, moderator};
+ _ -> {User1, member, participant}
end,
ejabberd_router:route(
jid:make(iolist_to_binary([Chan, <<"%">>, StateData#state.server]),
iq_admin(StateData, Channel, From, To,
#iq{type = Type, sub_els = [SubEl]} = IQ) ->
try process_iq_admin(StateData, Channel, Type, SubEl) of
- ignore ->
- ignore;
{result, Result} ->
ejabberd_router:route(To, From, xmpp:make_iq_result(IQ, Result));
{error, Error} ->
depends(_Host, _Opts) ->
[].
+-spec remove_user(binary(), binary()) -> ok.
remove_user(User, Server) ->
LUser = jid:nodeprep(User),
LServer = jid:nameprep(Server),
Mod = gen_mod:db_mod(LServer, ?MODULE),
- Mod:remove_user(LUser, LServer).
+ Mod:remove_user(LUser, LServer),
+ ok.
+-spec remove_room(binary(), binary(), binary()) -> ok.
remove_room(LServer, Name, Host) ->
LName = jid:nodeprep(Name),
LHost = jid:nameprep(Host),
Mod = gen_mod:db_mod(LServer, ?MODULE),
- Mod:remove_room(LServer, LName, LHost).
+ Mod:remove_room(LServer, LName, LHost),
+ ok.
get_room_config(X, RoomState, _From, Lang) ->
Config = RoomState#state.config,
end;
_ ->
true
- end;
- _ ->
- false
+ end
end;
should_archive_muc(_) ->
false.
-include("ejabberd.hrl").
-include("logger.hrl").
--include("jid.hrl").
-
--define(HOOKS, [offline_message_hook,
- sm_register_connection_hook, sm_remove_connection_hook,
- user_send_packet, user_receive_packet,
- s2s_send_packet, s2s_receive_packet,
- remove_user, register_user]).
+-include("xmpp.hrl").
-export([start/2, stop/1, send_metrics/4, opt_type/1, mod_opt_type/1,
depends/2]).
%%====================================================================
start(Host, _Opts) ->
- [ejabberd_hooks:add(Hook, Host, ?MODULE, Hook, 20)
- || Hook <- ?HOOKS].
+ ejabberd_hooks:add(offline_message_hook, Host, ?MODULE, offline_message_hook, 20),
+ ejabberd_hooks:add(sm_register_connection_hook, Host, ?MODULE, sm_register_connection_hook, 20),
+ ejabberd_hooks:add(sm_remove_connection_hook, Host, ?MODULE, sm_remove_connection_hook, 20),
+ ejabberd_hooks:add(user_send_packet, Host, ?MODULE, user_send_packet, 20),
+ ejabberd_hooks:add(user_receive_packet, Host, ?MODULE, user_receive_packet, 20),
+ ejabberd_hooks:add(s2s_send_packet, Host, ?MODULE, s2s_send_packet, 20),
+ ejabberd_hooks:add(s2s_receive_packet, Host, ?MODULE, s2s_receive_packet, 20),
+ ejabberd_hooks:add(remove_user, Host, ?MODULE, remove_user, 20),
+ ejabberd_hooks:add(register_user, Host, ?MODULE, register_user, 20).
stop(Host) ->
- [ejabberd_hooks:delete(Hook, Host, ?MODULE, Hook, 20)
- || Hook <- ?HOOKS].
+ ejabberd_hooks:delete(offline_message_hook, Host, ?MODULE, offline_message_hook, 20),
+ ejabberd_hooks:delete(sm_register_connection_hook, Host, ?MODULE, sm_register_connection_hook, 20),
+ ejabberd_hooks:delete(sm_remove_connection_hook, Host, ?MODULE, sm_remove_connection_hook, 20),
+ ejabberd_hooks:delete(user_send_packet, Host, ?MODULE, user_send_packet, 20),
+ ejabberd_hooks:delete(user_receive_packet, Host, ?MODULE, user_receive_packet, 20),
+ ejabberd_hooks:delete(s2s_send_packet, Host, ?MODULE, s2s_send_packet, 20),
+ ejabberd_hooks:delete(s2s_receive_packet, Host, ?MODULE, s2s_receive_packet, 20),
+ ejabberd_hooks:delete(remove_user, Host, ?MODULE, remove_user, 20),
+ ejabberd_hooks:delete(register_user, Host, ?MODULE, register_user, 20).
depends(_Host, _Opts) ->
[].
%%====================================================================
%% Hooks handlers
%%====================================================================
-
+-spec offline_message_hook(jid(), jid(), message()) -> any().
offline_message_hook(_From, #jid{lserver=LServer}, _Packet) ->
push(LServer, offline_message).
+-spec sm_register_connection_hook(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> any().
sm_register_connection_hook(_SID, #jid{lserver=LServer}, _Info) ->
push(LServer, sm_register_connection).
+
+-spec sm_remove_connection_hook(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> any().
sm_remove_connection_hook(_SID, #jid{lserver=LServer}, _Info) ->
push(LServer, sm_remove_connection).
push(LServer, user_receive_packet),
Packet.
+-spec s2s_send_packet(jid(), jid(), stanza()) -> any().
s2s_send_packet(#jid{lserver=LServer}, _To, _Packet) ->
push(LServer, s2s_send_packet).
+
+-spec s2s_receive_packet(jid(), jid(), stanza()) -> any().
s2s_receive_packet(_From, #jid{lserver=LServer}, _Packet) ->
push(LServer, s2s_receive_packet).
+-spec remove_user(binary(), binary()) -> any().
remove_user(_User, Server) ->
push(jid:nameprep(Server), remove_user).
+
+-spec register_user(binary(), binary()) -> any().
register_user(_User, Server) ->
push(jid:nameprep(Server), register_user).
supervisor:delete_child(ejabberd_sup, Proc),
ok.
+-spec disco_features({error, error()} | {result, [binary()]} | empty,
+ jid(), jid(), binary(), binary()) -> {result, [binary()]}.
disco_features(_Acc, _From, _To, _Node, _Lang) ->
{result, [?NS_MIX_0]}.
Acc ++ [#identity{category = <<"conference">>,
type = <<"mix">>}].
+-spec disco_info([xdata()], binary(), module(), binary(), binary()) -> [xdata()];
+ ([xdata()], jid(), jid(), binary(), binary()) -> [xdata()].
disco_info(_Acc, _From, To, _Node, _Lang) when is_atom(To) ->
[#xdata{type = result,
fields = [#xdata_field{var = <<"FORM_TYPE">>,
Err -> Err
end.
+get_config_opt_name(Pos) ->
+ Fs = [config|record_info(fields, config)],
+ lists:nth(Pos, Fs).
+
-define(SET_BOOL_XOPT(Opt, Val),
case Val of
<<"0">> ->
- set_xoption(Opts, Config#config{Opt = false}, ServerHost, Lang);
+ set_xoption(Opts, setelement(Opt, Config, false), ServerHost, Lang);
<<"false">> ->
- set_xoption(Opts, Config#config{Opt = false}, ServerHost, Lang);
- <<"1">> -> set_xoption(Opts, Config#config{Opt = true}, ServerHost, Lang);
+ set_xoption(Opts, setelement(Opt, Config, false), ServerHost, Lang);
+ <<"1">> -> set_xoption(Opts, setelement(Opt, Config, true), ServerHost, Lang);
<<"true">> ->
- set_xoption(Opts, Config#config{Opt = true}, ServerHost, Lang);
+ set_xoption(Opts, setelement(Opt, Config, true), ServerHost, Lang);
_ ->
Txt = <<"Value of '~s' should be boolean">>,
- ErrTxt = iolist_to_binary(io_lib:format(Txt, [Opt])),
+ OptName = get_config_opt_name(Opt),
+ ErrTxt = iolist_to_binary(io_lib:format(Txt, [OptName])),
{error, xmpp:err_bad_request(ErrTxt, Lang)}
end).
-define(SET_NAT_XOPT(Opt, Val),
case catch binary_to_integer(Val) of
I when is_integer(I), I > 0 ->
- set_xoption(Opts, Config#config{Opt = I}, ServerHost, Lang);
+ set_xoption(Opts, setelement(Opt, Config, I), ServerHost, Lang);
_ ->
Txt = <<"Value of '~s' should be integer">>,
- ErrTxt = iolist_to_binary(io_lib:format(Txt, [Opt])),
+ OptName = get_config_opt_name(Opt),
+ ErrTxt = iolist_to_binary(io_lib:format(Txt, [OptName])),
{error, xmpp:err_bad_request(ErrTxt, Lang)}
end).
[Val] -> Val;
_ when is_atom(Vals) -> Vals
end,
- set_xoption(Opts, Config#config{Opt = V}, ServerHost, Lang)
+ set_xoption(Opts, setelement(Opt, Config, V), ServerHost, Lang)
catch _:_ ->
Txt = <<"Incorrect value of option '~s'">>,
- ErrTxt = iolist_to_binary(io_lib:format(Txt, [Opt])),
+ OptName = get_config_opt_name(Opt),
+ ErrTxt = iolist_to_binary(io_lib:format(Txt, [OptName])),
{error, xmpp:err_bad_request(ErrTxt, Lang)}
end).
(_, Set1) -> Set1
end,
(?SETS):empty(), Vals),
- set_xoption(Opts, Config#config{Opt = Set}, ServerHost, Lang)
+ set_xoption(Opts, setelement(Opt, Config, Set), ServerHost, Lang)
end).
-spec set_xoption([{binary(), [binary()]}], #config{},
set_xoption([{<<"muc#roomconfig_roomname">>, Vals}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_STRING_XOPT(title, Vals);
+ ?SET_STRING_XOPT(#config.title, Vals);
set_xoption([{<<"muc#roomconfig_roomdesc">>, Vals}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_STRING_XOPT(description, Vals);
+ ?SET_STRING_XOPT(#config.description, Vals);
set_xoption([{<<"muc#roomconfig_changesubject">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_change_subj, Val);
+ ?SET_BOOL_XOPT(#config.allow_change_subj, Val);
set_xoption([{<<"allow_query_users">>, [Val]} | Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_query_users, Val);
+ ?SET_BOOL_XOPT(#config.allow_query_users, Val);
set_xoption([{<<"allow_private_messages">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_private_messages, Val);
+ ?SET_BOOL_XOPT(#config.allow_private_messages, Val);
set_xoption([{<<"allow_private_messages_from_visitors">>,
[Val]}
| Opts],
Config, ServerHost, Lang) ->
case Val of
<<"anyone">> ->
- ?SET_STRING_XOPT(allow_private_messages_from_visitors,
+ ?SET_STRING_XOPT(#config.allow_private_messages_from_visitors,
anyone);
<<"moderators">> ->
- ?SET_STRING_XOPT(allow_private_messages_from_visitors,
+ ?SET_STRING_XOPT(#config.allow_private_messages_from_visitors,
moderators);
<<"nobody">> ->
- ?SET_STRING_XOPT(allow_private_messages_from_visitors,
+ ?SET_STRING_XOPT(#config.allow_private_messages_from_visitors,
nobody);
_ ->
Txt = <<"Value of 'allow_private_messages_from_visitors' "
[Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_visitor_status, Val);
+ ?SET_BOOL_XOPT(#config.allow_visitor_status, Val);
set_xoption([{<<"muc#roomconfig_allowvisitornickchange">>,
[Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_visitor_nickchange, Val);
+ ?SET_BOOL_XOPT(#config.allow_visitor_nickchange, Val);
set_xoption([{<<"muc#roomconfig_publicroom">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(public, Val);
+ ?SET_BOOL_XOPT(#config.public, Val);
set_xoption([{<<"public_list">>, [Val]} | Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(public_list, Val);
+ ?SET_BOOL_XOPT(#config.public_list, Val);
set_xoption([{<<"muc#roomconfig_persistentroom">>,
[Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(persistent, Val);
+ ?SET_BOOL_XOPT(#config.persistent, Val);
set_xoption([{<<"muc#roomconfig_moderatedroom">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(moderated, Val);
+ ?SET_BOOL_XOPT(#config.moderated, Val);
set_xoption([{<<"members_by_default">>, [Val]} | Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(members_by_default, Val);
+ ?SET_BOOL_XOPT(#config.members_by_default, Val);
set_xoption([{<<"muc#roomconfig_membersonly">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(members_only, Val);
+ ?SET_BOOL_XOPT(#config.members_only, Val);
set_xoption([{<<"captcha_protected">>, [Val]} | Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(captcha_protected, Val);
+ ?SET_BOOL_XOPT(#config.captcha_protected, Val);
set_xoption([{<<"muc#roomconfig_allowinvites">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_user_invites, Val);
+ ?SET_BOOL_XOPT(#config.allow_user_invites, Val);
set_xoption([{<<"muc#roomconfig_allow_subscription">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_subscription, Val);
+ ?SET_BOOL_XOPT(#config.allow_subscription, Val);
set_xoption([{<<"muc#roomconfig_passwordprotectedroom">>,
[Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(password_protected, Val);
+ ?SET_BOOL_XOPT(#config.password_protected, Val);
set_xoption([{<<"muc#roomconfig_roomsecret">>, Vals}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_STRING_XOPT(password, Vals);
+ ?SET_STRING_XOPT(#config.password, Vals);
set_xoption([{<<"anonymous">>, [Val]} | Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(anonymous, Val);
+ ?SET_BOOL_XOPT(#config.anonymous, Val);
set_xoption([{<<"muc#roomconfig_presencebroadcast">>, Vals} | Opts],
Config, ServerHost, Lang) ->
Roles =
[Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(allow_voice_requests, Val);
+ ?SET_BOOL_XOPT(#config.allow_voice_requests, Val);
set_xoption([{<<"muc#roomconfig_voicerequestmininterval">>,
[Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_NAT_XOPT(voice_request_min_interval, Val);
+ ?SET_NAT_XOPT(#config.voice_request_min_interval, Val);
set_xoption([{<<"muc#roomconfig_whois">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
case Val of
<<"moderators">> ->
- ?SET_BOOL_XOPT(anonymous,
+ ?SET_BOOL_XOPT(#config.anonymous,
(iolist_to_binary(integer_to_list(1))));
<<"anyone">> ->
- ?SET_BOOL_XOPT(anonymous,
+ ?SET_BOOL_XOPT(#config.anonymous,
(iolist_to_binary(integer_to_list(0))));
_ ->
Txt = <<"Value of 'muc#roomconfig_whois' should be "
| Opts],
Config, ServerHost, Lang) ->
case Val of
- <<"none">> -> ?SET_STRING_XOPT(max_users, none);
- _ -> ?SET_NAT_XOPT(max_users, Val)
+ <<"none">> -> ?SET_STRING_XOPT(#config.max_users, none);
+ _ -> ?SET_NAT_XOPT(#config.max_users, Val)
end;
set_xoption([{<<"muc#roomconfig_enablelogging">>, [Val]}
| Opts],
Config, ServerHost, Lang) ->
- ?SET_BOOL_XOPT(logging, Val);
+ ?SET_BOOL_XOPT(#config.logging, Val);
set_xoption([{<<"muc#roomconfig_captcha_whitelist">>,
Vals}
| Opts],
Config, ServerHost, Lang) ->
JIDs = [jid:from_string(Val) || Val <- Vals],
- ?SET_JIDMULTI_XOPT(captcha_whitelist, JIDs);
+ ?SET_JIDMULTI_XOPT(#config.captcha_whitelist, JIDs);
set_xoption([{<<"FORM_TYPE">>, _} | Opts], Config, ServerHost, Lang) ->
set_xoption(Opts, Config, ServerHost, Lang);
set_xoption([{Opt, Vals} | Opts], Config, ServerHost, Lang) ->
end,
set_opts(Opts, NSD).
--define(MAKE_CONFIG_OPT(Opt), {Opt, Config#config.Opt}).
+-define(MAKE_CONFIG_OPT(Opt),
+ {get_config_opt_name(Opt), element(Opt, Config)}).
-spec make_opts(state()) -> [{atom(), any()}].
make_opts(StateData) ->
(_, _, Acc) ->
Acc
end, [], StateData#state.users),
- [?MAKE_CONFIG_OPT(title), ?MAKE_CONFIG_OPT(description),
- ?MAKE_CONFIG_OPT(allow_change_subj),
- ?MAKE_CONFIG_OPT(allow_query_users),
- ?MAKE_CONFIG_OPT(allow_private_messages),
- ?MAKE_CONFIG_OPT(allow_private_messages_from_visitors),
- ?MAKE_CONFIG_OPT(allow_visitor_status),
- ?MAKE_CONFIG_OPT(allow_visitor_nickchange),
- ?MAKE_CONFIG_OPT(public), ?MAKE_CONFIG_OPT(public_list),
- ?MAKE_CONFIG_OPT(persistent),
- ?MAKE_CONFIG_OPT(moderated),
- ?MAKE_CONFIG_OPT(members_by_default),
- ?MAKE_CONFIG_OPT(members_only),
- ?MAKE_CONFIG_OPT(allow_user_invites),
- ?MAKE_CONFIG_OPT(password_protected),
- ?MAKE_CONFIG_OPT(captcha_protected),
- ?MAKE_CONFIG_OPT(password), ?MAKE_CONFIG_OPT(anonymous),
- ?MAKE_CONFIG_OPT(logging), ?MAKE_CONFIG_OPT(max_users),
- ?MAKE_CONFIG_OPT(allow_voice_requests),
- ?MAKE_CONFIG_OPT(mam),
- ?MAKE_CONFIG_OPT(voice_request_min_interval),
- ?MAKE_CONFIG_OPT(vcard),
+ [?MAKE_CONFIG_OPT(#config.title), ?MAKE_CONFIG_OPT(#config.description),
+ ?MAKE_CONFIG_OPT(#config.allow_change_subj),
+ ?MAKE_CONFIG_OPT(#config.allow_query_users),
+ ?MAKE_CONFIG_OPT(#config.allow_private_messages),
+ ?MAKE_CONFIG_OPT(#config.allow_private_messages_from_visitors),
+ ?MAKE_CONFIG_OPT(#config.allow_visitor_status),
+ ?MAKE_CONFIG_OPT(#config.allow_visitor_nickchange),
+ ?MAKE_CONFIG_OPT(#config.public), ?MAKE_CONFIG_OPT(#config.public_list),
+ ?MAKE_CONFIG_OPT(#config.persistent),
+ ?MAKE_CONFIG_OPT(#config.moderated),
+ ?MAKE_CONFIG_OPT(#config.members_by_default),
+ ?MAKE_CONFIG_OPT(#config.members_only),
+ ?MAKE_CONFIG_OPT(#config.allow_user_invites),
+ ?MAKE_CONFIG_OPT(#config.password_protected),
+ ?MAKE_CONFIG_OPT(#config.captcha_protected),
+ ?MAKE_CONFIG_OPT(#config.password), ?MAKE_CONFIG_OPT(#config.anonymous),
+ ?MAKE_CONFIG_OPT(#config.logging), ?MAKE_CONFIG_OPT(#config.max_users),
+ ?MAKE_CONFIG_OPT(#config.allow_voice_requests),
+ ?MAKE_CONFIG_OPT(#config.mam),
+ ?MAKE_CONFIG_OPT(#config.voice_request_min_interval),
+ ?MAKE_CONFIG_OPT(#config.vcard),
{captcha_whitelist,
(?SETS):to_list((StateData#state.config)#config.captcha_whitelist)},
{affiliations,
get_sm_items(Acc, _From, _To, _Node, _Lang) ->
Acc.
--spec get_info([xdata()], jid(), jid(), binary(), binary()) -> [xdata()].
+-spec get_info([xdata()], binary(), module(), binary(), binary()) -> [xdata()];
+ ([xdata()], jid(), jid(), binary(), binary()) -> [xdata()].
get_info(_Acc, #jid{luser = U, lserver = S, lresource = R},
#jid{luser = U, lserver = S}, ?NS_FLEX_OFFLINE, _Lang) ->
N = jlib:integer_to_binary(count_offline_messages(U, S)),
Mod = gen_mod:db_mod(LServer, ?MODULE),
Mod:remove_old_messages(Days, LServer).
+-spec remove_user(binary(), binary()) -> ok.
remove_user(User, Server) ->
LUser = jid:nodeprep(User),
LServer = jid:nameprep(Server),
Mod = gen_mod:db_mod(LServer, ?MODULE),
- Mod:remove_user(LUser, LServer).
+ Mod:remove_user(LUser, LServer),
+ ok.
%% Helper functions:
Txt = <<"Ping query is incorrect">>,
xmpp:make_error(IQ, xmpp:err_bad_request(Txt, Lang)).
--spec user_online(ejabberd_sm:sid(), jid(), any()) -> ok.
+-spec user_online(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> ok.
user_online(_SID, JID, _Info) ->
start_ping(JID#jid.lserver, JID).
--spec user_offline(ejabberd_sm:sid(), jid(), any()) -> ok.
+-spec user_offline(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> ok.
user_offline(_SID, JID, _Info) ->
stop_ping(JID#jid.lserver, JID).
group -> lists:member(Value, Groups)
end.
+-spec remove_user(binary(), binary()) -> any().
remove_user(User, Server) ->
LUser = jid:nodeprep(User),
LServer = jid:nameprep(Server),
Mod = gen_mod:db_mod(LServer, ?MODULE),
Mod:get_all_data(LUser, LServer).
+-spec remove_user(binary(), binary()) -> any().
remove_user(User, Server) ->
LUser = jid:nodeprep(User),
LServer = jid:nameprep(Server),
%% presence hooks handling functions
%%
+-spec caps_add(jid(), jid(), [binary()]) -> ok.
caps_add(#jid{luser = U, lserver = S, lresource = R}, #jid{lserver = Host} = JID, _Features)
when Host =/= S ->
%% When a remote contact goes online while the local user is offline, the
caps_add(_From, _To, _Feature) ->
ok.
+-spec caps_update(jid(), jid(), [binary()]) -> ok.
caps_update(#jid{luser = U, lserver = S, lresource = R}, #jid{lserver = Host} = JID, _Features) ->
presence(Host, {presence, U, S, [R], JID}).
+-spec presence_probe(jid(), jid(), pid()) -> ok.
presence_probe(#jid{luser = U, lserver = S, lresource = R} = JID, JID, Pid) ->
presence(S, {presence, JID, Pid}),
presence(S, {presence, U, S, [R], JID});
undefined -> init_send_loop(ServerHost);
Pid -> {Pid, undefined}
end,
- SendLoop ! Presence.
+ SendLoop ! Presence,
+ ok.
%% -------
%% subscription hooks handling functions
%%
+-spec out_subscription(
+ binary(), binary(), jid(),
+ subscribed | unsubscribed | subscribe | unsubscribe) -> boolean().
out_subscription(User, Server, JID, subscribed) ->
Owner = jid:make(User, Server, <<>>),
{PUser, PServer, PResource} = jid:tolower(JID),
%% user remove hook handling function
%%
+-spec remove_user(binary(), binary()) -> ok.
remove_user(User, Server) ->
LUser = jid:nodeprep(User),
LServer = jid:nameprep(Server),
Affs)
end,
plugins(Host))
- end).
+ end),
+ ok.
handle_call(server_host, _From, State) ->
{reply, State#state.server_host, State};
attrs = [{<<"type">>, <<"replyto">>}, {<<"jid">>, Jid}]}
|| Jid <- Jids].
+-spec on_user_offline(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> ok.
on_user_offline(_, JID, _) ->
{User, Server, Resource} = jid:tolower(JID),
case user_resources(User, Server) of
[] -> purge_offline({User, Server, Resource});
- _ -> true
+ _ -> ok
end.
purge_offline(LJID) ->
depends(_Host, _Opts) ->
[].
+-spec stream_feature_register([xmpp_element()], binary()) -> [xmpp_element()].
stream_feature_register(Acc, Host) ->
AF = gen_mod:get_module_opt(Host, ?MODULE, access_from,
fun(A) -> A end,
Acc
end.
+-spec unauthenticated_iq_register(empty | iq(), binary(), iq(),
+ {inet:ip_address(), non_neg_integer()}) ->
+ empty | iq().
unauthenticated_iq_register(_Acc, Server,
#iq{sub_els = [#register{}]} = IQ, IP) ->
Address = case IP of
process_subscription(in, User, Server, JID, Type,
Reason).
+-spec out_subscription(
+ binary(), binary(), jid(),
+ subscribed | unsubscribed | subscribe | unsubscribe) -> boolean().
out_subscription(User, Server, JID, Type) ->
process_subscription(out, User, Server, JID, Type, <<"">>).
in_auto_reply(both, none, unsubscribe) -> unsubscribed;
in_auto_reply(_, _, _) -> none.
+-spec remove_user(binary(), binary()) -> ok.
remove_user(User, Server) ->
LUser = jid:nodeprep(User),
LServer = jid:nameprep(Server),
send_unsubscription_to_rosteritems(LUser, LServer),
Mod = gen_mod:db_mod(LServer, ?MODULE),
- Mod:remove_user(LUser, LServer).
+ Mod:remove_user(LUser, LServer),
+ ok.
%% For each contact with Subscription:
%% Both or From, send a "unsubscribed" presence stanza;
_Reason) ->
process_subscription(in, User, Server, JID, Type, Acc).
+-spec out_subscription(
+ binary(), binary(), jid(),
+ subscribed | unsubscribed | subscribe | unsubscribe) -> boolean().
out_subscription(UserFrom, ServerFrom, JIDTo,
unsubscribed) ->
#jid{luser = UserTo, lserver = ServerTo} = JIDTo,
broadcast_subscription(U, S, {LUser, LServer, <<"">>}, Subscription)
end, Members).
+-spec register_user(binary(), binary()) -> ok.
register_user(User, Server) ->
Groups = get_user_groups({User, Server}),
[push_user_to_displayed(User, Server, Group, Server,
both, displayed_to_groups(Group, Server))
- || Group <- Groups].
+ || Group <- Groups],
+ ok.
+-spec remove_user(binary(), binary()) -> ok.
remove_user(User, Server) ->
push_user_to_members(User, Server, remove).
groups = [GroupName]},
push_item(User, Server, Item).
+-spec user_available(jid()) -> ok.
user_available(New) ->
LUser = New#jid.luser,
LServer = New#jid.lserver,
_ -> ok
end.
+-spec unset_presence(binary(), binary(), binary(), binary()) -> ok.
unset_presence(LUser, LServer, Resource, Status) ->
Resources = ejabberd_sm:get_user_resources(LUser,
LServer),
_Reason) ->
process_subscription(in, User, Server, JID, Type, Acc).
+-spec out_subscription(
+ binary(), binary(), jid(),
+ subscribed | unsubscribed | subscribe | unsubscribe) -> boolean().
out_subscription(User, Server, JID, Type) ->
process_subscription(out, User, Server, JID, Type,
false).
%%====================================================================
%% Hooks
%%====================================================================
-
+-spec update_presence(presence(), binary(), binary()) -> presence().
update_presence(#presence{type = undefined} = Packet, User, Host) ->
presence_with_xupdate(Packet, User, Host);
update_presence(Packet, _User, _Host) -> Packet.
+-spec vcard_set(binary(), binary(), xmlel()) -> ok.
vcard_set(LUser, LServer, VCARD) ->
US = {LUser, LServer},
case fxml:get_path_s(VCARD,
?MODULE, user_offline, 75),
ok.
+-spec user_offline(ejabberd_sm:sid(), jid(), ejabberd_sm:info()) -> _.
user_offline(_SID, #jid{luser=LUser,lserver=LServer}, _Info) ->
mod_pubsub:remove_user(LUser, LServer).
get_type(#presence{type = T}) -> T;
get_type(#xmlel{attrs = Attrs}) -> fxml:get_attr_s(<<"type">>, Attrs).
--spec get_lang(iq() | message() | presence()) -> binary().
+-spec get_lang(iq() | message() | presence() | xmlel()) -> binary().
get_lang(#iq{lang = L}) -> L;
get_lang(#message{lang = L}) -> L;
get_lang(#presence{lang = L}) -> L;
dec_bool(<<"true">>) -> true;
dec_bool(<<"1">>) -> true.
+nameprep(S) ->
+ case jid:nameprep(S) of
+ error -> erlang:error(badarg);
+ S1 -> S1
+ end.
+
resourceprep(R) ->
case jid:resourceprep(R) of
error -> erlang:error(badarg);
{missing_attr, <<"from">>, <<"db:verify">>,
__TopXMLNS}});
decode_db_verify_attr_from(__TopXMLNS, _val) ->
- case catch dec_jid(_val) of
+ case catch nameprep(_val) of
{'EXIT', _} ->
erlang:error({xmpp_codec,
{bad_attr_value, <<"from">>, <<"db:verify">>,
end.
encode_db_verify_attr_from(_val, _acc) ->
- [{<<"from">>, enc_jid(_val)} | _acc].
+ [{<<"from">>, nameprep(_val)} | _acc].
decode_db_verify_attr_to(__TopXMLNS, undefined) ->
erlang:error({xmpp_codec,
{missing_attr, <<"to">>, <<"db:verify">>, __TopXMLNS}});
decode_db_verify_attr_to(__TopXMLNS, _val) ->
- case catch dec_jid(_val) of
+ case catch nameprep(_val) of
{'EXIT', _} ->
erlang:error({xmpp_codec,
{bad_attr_value, <<"to">>, <<"db:verify">>,
end.
encode_db_verify_attr_to(_val, _acc) ->
- [{<<"to">>, enc_jid(_val)} | _acc].
+ [{<<"to">>, nameprep(_val)} | _acc].
decode_db_verify_attr_id(__TopXMLNS, undefined) ->
erlang:error({xmpp_codec,
{missing_attr, <<"from">>, <<"db:result">>,
__TopXMLNS}});
decode_db_result_attr_from(__TopXMLNS, _val) ->
- case catch dec_jid(_val) of
+ case catch nameprep(_val) of
{'EXIT', _} ->
erlang:error({xmpp_codec,
{bad_attr_value, <<"from">>, <<"db:result">>,
end.
encode_db_result_attr_from(_val, _acc) ->
- [{<<"from">>, enc_jid(_val)} | _acc].
+ [{<<"from">>, nameprep(_val)} | _acc].
decode_db_result_attr_to(__TopXMLNS, undefined) ->
erlang:error({xmpp_codec,
{missing_attr, <<"to">>, <<"db:result">>, __TopXMLNS}});
decode_db_result_attr_to(__TopXMLNS, _val) ->
- case catch dec_jid(_val) of
+ case catch nameprep(_val) of
{'EXIT', _} ->
erlang:error({xmpp_codec,
{bad_attr_value, <<"to">>, <<"db:result">>,
end.
encode_db_result_attr_to(_val, _acc) ->
- [{<<"to">>, enc_jid(_val)} | _acc].
+ [{<<"to">>, nameprep(_val)} | _acc].
decode_db_result_attr_type(__TopXMLNS, undefined) ->
undefined;
result = {db_result, '$from', '$to', '$type', '$key', '$_els'},
cdata = #cdata{default = <<"">>, label = '$key'},
attrs = [#attr{name = <<"from">>, required = true,
- dec = {dec_jid, []}, enc = {enc_jid, []}},
+ dec = {nameprep, []}, enc = {nameprep, []}},
#attr{name = <<"to">>, required = true,
- dec = {dec_jid, []}, enc = {enc_jid, []}},
+ dec = {nameprep, []}, enc = {nameprep, []}},
#attr{name = <<"type">>,
dec = {dec_enum, [[valid, invalid, error]]},
enc = {enc_enum, []}}]}).
result = {db_verify, '$from', '$to', '$id', '$type', '$key', '$_els'},
cdata = #cdata{default = <<"">>, label = '$key'},
attrs = [#attr{name = <<"from">>, required = true,
- dec = {dec_jid, []}, enc = {enc_jid, []}},
+ dec = {nameprep, []}, enc = {nameprep, []}},
#attr{name = <<"to">>, required = true,
- dec = {dec_jid, []}, enc = {enc_jid, []}},
+ dec = {nameprep, []}, enc = {nameprep, []}},
#attr{name = <<"id">>, required = true},
#attr{name = <<"type">>,
dec = {dec_enum, [[valid, invalid, error]]},
R1
end.
+-spec nameprep(_) -> binary().
+nameprep(S) ->
+ case jid:nameprep(S) of
+ error ->
+ erlang:error(badarg);
+ S1 ->
+ S1
+ end.
+
-spec dec_bool(_) -> boolean().
dec_bool(<<"false">>) -> false;
dec_bool(<<"0">>) -> false;
enc_ip(Addr) ->
list_to_binary(inet_parse:ntoa(Addr)).
--spec re:split(_, _) -> binary().
+-spec re:split(_, _) -> [binary()].
-spec base64:decode(_) -> binary().
-spec dec_host_port(_) -> binary() | inet:ip_address() |
projects / ejabberd / commitdiff