1212

Committed 18 Nov 2025 12:37PM UTC coverage: 33.784% (+0.003%) from 33.781%

Build # 1212

Build Type

push

github

Committed by

badlop

Commit Message

mod_conversejs: Improve link to conversejs in WebAdmin (#4495)

Until now, the WebAdmin menu included a link to the first request handler
with mod_conversejs that the admin configured in ejabberd.yml
That link included the authentication credentials hashed as URI arguments
if using HTTPS. Then process/2 extracted those arguments and passed them
as autologin options to Converse.

From now, mod_conversejs automatically adds a request_handler nested in
webadmin subpath. The webadmin menu links to that converse URI; this allows
to access the HTTP auth credentials, no need to explicitly pass them.
process/2 extracts this HTTP auth and passes autologin options to Converse.
Now scram password storage is supported too.

This minimum configuration allows WebAdmin to access Converse:

listen:
  -
    port: 5443
    module: ejabberd_http
    tls: true
    request_handlers:
      /admin: ejabberd_web_admin
      /ws: ejabberd_http_ws
modules:
  mod_conversejs:
    conversejs_resources: "/home/conversejs/12.0.0/dist"

Run Details

0 of 12 new or added lines in 1 file covered. (0.0%)

11290 existing lines in 174 files now uncovered.

15515 of 45924 relevant lines covered (33.78%)

1277.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.48

/src/mod_client_state.erl

%%%----------------------------------------------------------------------
%%% File    : mod_client_state.erl
%%% Author  : Holger Weiss <holger@zedat.fu-berlin.de>
%%% Purpose : Filter stanzas sent to inactive clients (XEP-0352)
%%% Created : 11 Sep 2014 by Holger Weiss <holger@zedat.fu-berlin.de>
%%%
%%%
%%% ejabberd, Copyright (C) 2014-2025   ProcessOne
%%%
%%% This program is free software; you can redistribute it and/or
%%% modify it under the terms of the GNU General Public License as
%%% published by the Free Software Foundation; either version 2 of the
%%% License, or (at your option) any later version.
%%%
%%% This program is distributed in the hope that it will be useful,
%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
%%% General Public License for more details.
%%%
%%% You should have received a copy of the GNU General Public License along
%%% with this program; if not, write to the Free Software Foundation, Inc.,
%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
%%%
%%%----------------------------------------------------------------------

-module(mod_client_state).
-author('holger@zedat.fu-berlin.de').
-protocol({xep, 85, '2.1', '2.1.0', "complete", ""}).
-protocol({xep, 352, '0.1', '14.12', "complete", ""}).

-behaviour(gen_mod).

%% gen_mod callbacks.
-export([start/2, stop/1, reload/3, mod_opt_type/1, depends/2, mod_options/1]).
-export([mod_doc/0]).

%% ejabberd_hooks callbacks.
-export([filter_presence/1, filter_chat_states/1,
         filter_pep/1, filter_other/1,
         c2s_stream_started/2, add_stream_feature/2,
         c2s_authenticated_packet/2, csi_activity/2,
         c2s_copy_session/2, c2s_session_resumed/1]).

-include("logger.hrl").
-include_lib("xmpp/include/xmpp.hrl").
-include("translate.hrl").

-define(CSI_QUEUE_MAX, 100).

-type csi_type() :: presence | chatstate | {pep, binary()}.
-type csi_queue() :: {non_neg_integer(), #{csi_key() => csi_element()}}.
-type csi_timestamp() :: {non_neg_integer(), erlang:timestamp()}.
-type csi_key() :: {ljid(), csi_type()}.
-type csi_element() :: {csi_timestamp(), stanza()}.
-type c2s_state() :: ejabberd_c2s:state().
-type filter_acc() :: {stanza() | drop, c2s_state()}.

%%--------------------------------------------------------------------
%% gen_mod callbacks.
%%--------------------------------------------------------------------
-spec start(binary(), gen_mod:opts()) -> ok.
start(Host, Opts) ->
    QueuePresence = mod_client_state_opt:queue_presence(Opts),
    QueueChatStates = mod_client_state_opt:queue_chat_states(Opts),
    QueuePEP = mod_client_state_opt:queue_pep(Opts),
    if QueuePresence; QueueChatStates; QueuePEP ->
           register_hooks(Host),
           if QueuePresence ->
                  ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,
                                     filter_presence, 50);
              true -> ok
           end,
           if QueueChatStates ->
                  ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,
                                     filter_chat_states, 50);
              true -> ok
           end,
           if QueuePEP ->
                  ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,
                                     filter_pep, 50);
              true -> ok
           end;
       true -> ok
    end.

-spec stop(binary()) -> ok.
stop(Host) ->
    QueuePresence = mod_client_state_opt:queue_presence(Host),
    QueueChatStates = mod_client_state_opt:queue_chat_states(Host),
    QueuePEP = mod_client_state_opt:queue_pep(Host),
    if QueuePresence; QueueChatStates; QueuePEP ->
           unregister_hooks(Host),
           if QueuePresence ->
                  ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,
                                        filter_presence, 50);
              true -> ok
           end,
           if QueueChatStates ->
                  ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,
                                        filter_chat_states, 50);
              true -> ok
           end,
           if QueuePEP ->
                  ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,
                                        filter_pep, 50);
              true -> ok
           end;
       true -> ok
    end.

-spec reload(binary(), gen_mod:opts(), gen_mod:opts()) -> ok.
reload(Host, NewOpts, _OldOpts) ->
    QueuePresence = mod_client_state_opt:queue_presence(NewOpts),
    QueueChatStates = mod_client_state_opt:queue_chat_states(NewOpts),
    QueuePEP = mod_client_state_opt:queue_pep(NewOpts),
    if QueuePresence; QueueChatStates; QueuePEP ->
            register_hooks(Host);
       true ->
            unregister_hooks(Host)
    end,
    if QueuePresence ->
            ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,
                               filter_presence, 50);
       true ->
            ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,
                                  filter_presence, 50)
    end,
    if QueueChatStates ->
            ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,
                               filter_chat_states, 50);
       true ->
            ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,
                                  filter_chat_states, 50)
    end,
    if QueuePEP ->
            ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,
                               filter_pep, 50);
       true ->
            ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,
                                  filter_pep, 50)
    end.

-spec mod_opt_type(atom()) -> econf:validator().
mod_opt_type(queue_presence) ->
    econf:bool();
mod_opt_type(queue_chat_states) ->
    econf:bool();
mod_opt_type(queue_pep) ->
    econf:bool().

mod_options(_) ->
    [{queue_presence, true},
     {queue_chat_states, true},
     {queue_pep, true}].

mod_doc() ->
    #{desc =>
          [?T("This module allows for queueing certain types of stanzas "
              "when a client indicates that the user is not actively using "
              "the client right now (see https://xmpp.org/extensions/xep-0352.html"
              "[XEP-0352: Client State Indication]). This can save bandwidth and "
              "resources."), "",
           ?T("A stanza is dropped from the queue if it's effectively obsoleted "
              "by a new one (e.g., a new presence stanza would replace an old "
              "one from the same client). The queue is flushed if a stanza arrives "
              "that won't be queued, or if the queue size reaches a certain limit "
              "(currently 100 stanzas), or if the client becomes active again.")],
      opts =>
          [{queue_presence,
            #{value => "true | false",
              desc =>
                  ?T("While a client is inactive, queue presence stanzas "
                     "that indicate (un)availability. The default value is 'true'.")}},
           {queue_chat_states,
            #{value => "true | false",
              desc =>
                  ?T("Queue \"standalone\" chat state notifications (as defined in "
                     "https://xmpp.org/extensions/xep-0085.html"
                     "[XEP-0085: Chat State Notifications]) while a client "
                     "indicates inactivity. The default value is 'true'.")}},
           {queue_pep,
            #{value => "true | false",
              desc =>
                  ?T("Queue PEP notifications while a client is inactive. "
                     "When the queue is flushed, only the most recent notification "
                     "of a given PEP node is delivered. The default value is 'true'.")}}]}.

-spec depends(binary(), gen_mod:opts()) -> [{module(), hard | soft}].
depends(_Host, _Opts) ->
    [].

-spec register_hooks(binary()) -> ok.
register_hooks(Host) ->
    ejabberd_hooks:add(c2s_stream_started, Host, ?MODULE,
                       c2s_stream_started, 50),
    ejabberd_hooks:add(c2s_post_auth_features, Host, ?MODULE,
                       add_stream_feature, 50),
    ejabberd_hooks:add(c2s_authenticated_packet, Host, ?MODULE,
                       c2s_authenticated_packet, 50),
    ejabberd_hooks:add(csi_activity, Host, ?MODULE,
                       csi_activity, 50),
    ejabberd_hooks:add(c2s_copy_session, Host, ?MODULE,
                       c2s_copy_session, 50),
    ejabberd_hooks:add(c2s_session_resumed, Host, ?MODULE,
                       c2s_session_resumed, 50),
    ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,
                       filter_other, 75).

-spec unregister_hooks(binary()) -> ok.
unregister_hooks(Host) ->
    ejabberd_hooks:delete(c2s_stream_started, Host, ?MODULE,
                          c2s_stream_started, 50),
    ejabberd_hooks:delete(c2s_post_auth_features, Host, ?MODULE,
                          add_stream_feature, 50),
    ejabberd_hooks:delete(c2s_authenticated_packet, Host, ?MODULE,
                          c2s_authenticated_packet, 50),
    ejabberd_hooks:delete(csi_activity, Host, ?MODULE,
                          csi_activity, 50),
    ejabberd_hooks:delete(c2s_copy_session, Host, ?MODULE,
                          c2s_copy_session, 50),
    ejabberd_hooks:delete(c2s_session_resumed, Host, ?MODULE,
                          c2s_session_resumed, 50),
    ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,
                          filter_other, 75).

%%--------------------------------------------------------------------
%% ejabberd_hooks callbacks.
%%--------------------------------------------------------------------
-spec c2s_stream_started(c2s_state(), stream_start()) -> c2s_state().
c2s_stream_started(State, _) ->
    init_csi_state(State).

-spec c2s_authenticated_packet(c2s_state(), xmpp_element()) -> c2s_state().
c2s_authenticated_packet(#{lserver := LServer} = C2SState, #csi{type = active}) ->
    ejabberd_hooks:run_fold(csi_activity, LServer, C2SState, [active]);
c2s_authenticated_packet(#{lserver := LServer} = C2SState, #csi{type = inactive}) ->
    ejabberd_hooks:run_fold(csi_activity, LServer, C2SState, [inactive]);
c2s_authenticated_packet(C2SState, _) ->
    C2SState.

-spec csi_activity(c2s_state(), active | inactive) -> c2s_state().
csi_activity(C2SState, active) ->
    C2SState1 = C2SState#{csi_state => active},
    flush_queue(C2SState1);
csi_activity(C2SState, inactive) ->
    C2SState#{csi_state => inactive}.

-spec c2s_copy_session(c2s_state(), c2s_state()) -> c2s_state().
c2s_copy_session(C2SState, #{csi_queue := Q}) ->
    C2SState#{csi_queue => Q};
c2s_copy_session(C2SState, _) ->
    C2SState.

-spec c2s_session_resumed(c2s_state()) -> c2s_state().
c2s_session_resumed(C2SState) ->
    flush_queue(C2SState).

-spec filter_presence(filter_acc()) -> filter_acc().
filter_presence({#presence{meta = #{csi_resend := true}}, _} = Acc) ->
    Acc;
filter_presence({#presence{to = To, type = Type} = Pres,
                 #{csi_state := inactive} = C2SState})
  when Type == available; Type == unavailable ->
    ?DEBUG("Got availability presence stanza for ~ts", [jid:encode(To)]),
    enqueue_stanza(presence, Pres, C2SState);
filter_presence(Acc) ->
    Acc.

-spec filter_chat_states(filter_acc()) -> filter_acc().
filter_chat_states({#message{meta = #{csi_resend := true}}, _} = Acc) ->
    Acc;
filter_chat_states({#message{from = From, to = To} = Msg,
                    #{csi_state := inactive} = C2SState} = Acc) ->
    case misc:is_standalone_chat_state(Msg) of
        true ->
            case {From, To} of
                {#jid{luser = U, lserver = S}, #jid{luser = U, lserver = S}} ->
                    %% Don't queue (carbon copies of) chat states from other
                    %% resources, as they might be used to sync the state of
                    %% conversations across clients.
                    Acc;
                _ ->
                ?DEBUG("Got standalone chat state notification for ~ts",
                       [jid:encode(To)]),
                    enqueue_stanza(chatstate, Msg, C2SState)
            end;
        false ->
            Acc
    end;
filter_chat_states(Acc) ->
    Acc.

-spec filter_pep(filter_acc()) -> filter_acc().
filter_pep({#message{meta = #{csi_resend := true}}, _} = Acc) ->
    Acc;
filter_pep({#message{to = To} = Msg,
            #{csi_state := inactive} = C2SState} = Acc) ->
    case get_pep_node(Msg) of
        undefined ->
            Acc;
        Node ->
            ?DEBUG("Got PEP notification for ~ts", [jid:encode(To)]),
            enqueue_stanza({pep, Node}, Msg, C2SState)
    end;
filter_pep(Acc) ->
    Acc.

-spec filter_other(filter_acc()) -> filter_acc().
filter_other({Stanza, #{jid := JID} = C2SState} = Acc) when ?is_stanza(Stanza) ->
    case xmpp:get_meta(Stanza) of
        #{csi_resend := true} ->
            Acc;
        _ ->
            ?DEBUG("Won't add stanza for ~ts to CSI queue", [jid:encode(JID)]),
            From = case xmpp:get_from(Stanza) of
                       undefined -> JID;
                       F -> F
                   end,
            C2SState1 = dequeue_sender(From, C2SState),
            {Stanza, C2SState1}
    end;
filter_other(Acc) ->
    Acc.

-spec add_stream_feature([xmpp_element()], binary()) -> [xmpp_element()].
add_stream_feature(Features, Host) ->
    case gen_mod:is_loaded(Host, ?MODULE) of
        true ->
            [#feature_csi{} | Features];
        false ->
            Features
    end.

%%--------------------------------------------------------------------
%% Internal functions.
%%--------------------------------------------------------------------
-spec init_csi_state(c2s_state()) -> c2s_state().
init_csi_state(C2SState) ->
    C2SState#{csi_state => active, csi_queue => queue_new()}.

-spec enqueue_stanza(csi_type(), stanza(), c2s_state()) -> filter_acc().
enqueue_stanza(Type, Stanza, #{csi_state := inactive,
                               csi_queue := Q} = C2SState) ->
    case queue_len(Q) >= ?CSI_QUEUE_MAX of
        true ->
          ?DEBUG("CSI queue too large, going to flush it", []),
            C2SState1 = flush_queue(C2SState),
            enqueue_stanza(Type, Stanza, C2SState1);
        false ->
            From = jid:tolower(xmpp:get_from(Stanza)),
            Q1 = queue_in({From, Type}, Stanza, Q),
            {stop, {drop, C2SState#{csi_queue => Q1}}}
    end;
enqueue_stanza(_Type, Stanza, State) ->
    {Stanza, State}.

-spec dequeue_sender(jid(), c2s_state()) -> c2s_state().
dequeue_sender(#jid{luser = U, lserver = S} = Sender,
               #{jid := JID} = C2SState) ->
    case maps:get(csi_queue, C2SState, undefined) of
        undefined ->
            %% This may happen when the module is (re)loaded in runtime
            init_csi_state(C2SState);
        Q ->
            ?DEBUG("Flushing packets of ~ts@~ts from CSI queue of ~ts",
                   [U, S, jid:encode(JID)]),
            {Elems, Q1} = queue_take(Sender, Q),
            C2SState1 = flush_stanzas(C2SState, Elems),
            C2SState1#{csi_queue => Q1}
    end.

-spec flush_queue(c2s_state()) -> c2s_state().
flush_queue(#{csi_queue := Q, jid := JID} = C2SState) ->
    ?DEBUG("Flushing CSI queue of ~ts", [jid:encode(JID)]),
    C2SState1 = flush_stanzas(C2SState, queue_to_list(Q)),
    C2SState1#{csi_queue => queue_new()}.

-spec flush_stanzas(c2s_state(),
                    [{csi_type(), csi_timestamp(), stanza()}]) -> c2s_state().
flush_stanzas(#{lserver := LServer} = C2SState, Elems) ->
    lists:foldl(
      fun({Time, Stanza}, AccState) ->
              Stanza1 = add_delay_info(Stanza, LServer, Time),
              ejabberd_c2s:send(AccState, Stanza1)
      end, C2SState, Elems).

-spec add_delay_info(stanza(), binary(), csi_timestamp()) -> stanza().
add_delay_info(Stanza, LServer, {_Seq, TimeStamp}) ->
    Stanza1 = misc:add_delay_info(
                Stanza, jid:make(LServer), TimeStamp,
                <<"Client Inactive">>),
    xmpp:put_meta(Stanza1, csi_resend, true).

-spec get_pep_node(message()) -> binary() | undefined.
get_pep_node(#message{from = #jid{luser = <<>>}}) ->
    %% It's not PEP.
    undefined;
get_pep_node(#message{} = Msg) ->
    case xmpp:get_subtag(Msg, #ps_event{}) of
        #ps_event{items = #ps_items{node = Node}} ->
            Node;
        _ ->
            undefined
    end.

%%--------------------------------------------------------------------
%% Queue interface
%%--------------------------------------------------------------------
-spec queue_new() -> csi_queue().
queue_new() ->
    {0, #{}}.

-spec queue_in(csi_key(), stanza(), csi_queue()) -> csi_queue().
queue_in(Key, Stanza, {Seq, Q}) ->
    Seq1 = Seq + 1,
    Time = {Seq1, erlang:timestamp()},
    Q1 = maps:put(Key, {Time, Stanza}, Q),
    {Seq1, Q1}.

-spec queue_take(jid(), csi_queue()) -> {[csi_element()], csi_queue()}.
queue_take(#jid{luser = LUser, lserver = LServer}, {Seq, Q}) ->
    {Vals, Q1} = maps:fold(fun({{U, S, _}, _} = Key, Val, {AccVals, AccQ})
                                   when U == LUser, S == LServer ->
                                   {[Val | AccVals], maps:remove(Key, AccQ)};
                               (_, _, Acc) ->
                                   Acc
                            end, {[], Q}, Q),
    {lists:keysort(1, Vals), {Seq, Q1}}.

-spec queue_len(csi_queue()) -> non_neg_integer().
queue_len({_, Q}) ->
    maps:size(Q).

-spec queue_to_list(csi_queue()) -> [csi_element()].
queue_to_list({_, Q}) ->
    lists:keysort(1, maps:values(Q)).

1	%%%----------------------------------------------------------------------
2	%%% File : mod_client_state.erl
3	%%% Author : Holger Weiss <holger@zedat.fu-berlin.de>
4	%%% Purpose : Filter stanzas sent to inactive clients (XEP-0352)
5	%%% Created : 11 Sep 2014 by Holger Weiss <holger@zedat.fu-berlin.de>
6	%%%
7	%%%
8	%%% ejabberd, Copyright (C) 2014-2025 ProcessOne
9	%%%
10	%%% This program is free software; you can redistribute it and/or
11	%%% modify it under the terms of the GNU General Public License as
12	%%% published by the Free Software Foundation; either version 2 of the
13	%%% License, or (at your option) any later version.
14	%%%
15	%%% This program is distributed in the hope that it will be useful,
16	%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
17	%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18	%%% General Public License for more details.
19	%%%
20	%%% You should have received a copy of the GNU General Public License along
21	%%% with this program; if not, write to the Free Software Foundation, Inc.,
22	%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23	%%%
24	%%%----------------------------------------------------------------------
25
26	-module(mod_client_state).
27	-author('holger@zedat.fu-berlin.de').
28	-protocol({xep, 85, '2.1', '2.1.0', "complete", ""}).
29	-protocol({xep, 352, '0.1', '14.12', "complete", ""}).
30
31	-behaviour(gen_mod).
32
33	%% gen_mod callbacks.
34	-export([start/2, stop/1, reload/3, mod_opt_type/1, depends/2, mod_options/1]).
35	-export([mod_doc/0]).
36
37	%% ejabberd_hooks callbacks.
38	-export([filter_presence/1, filter_chat_states/1,
39	filter_pep/1, filter_other/1,
40	c2s_stream_started/2, add_stream_feature/2,
41	c2s_authenticated_packet/2, csi_activity/2,
42	c2s_copy_session/2, c2s_session_resumed/1]).
43
44	-include("logger.hrl").
45	-include_lib("xmpp/include/xmpp.hrl").
46	-include("translate.hrl").
47
48	-define(CSI_QUEUE_MAX, 100).
49
50	-type csi_type() :: presence \| chatstate \| {pep, binary()}.
51	-type csi_queue() :: {non_neg_integer(), #{csi_key() => csi_element()}}.
52	-type csi_timestamp() :: {non_neg_integer(), erlang:timestamp()}.
53	-type csi_key() :: {ljid(), csi_type()}.
54	-type csi_element() :: {csi_timestamp(), stanza()}.
55	-type c2s_state() :: ejabberd_c2s:state().
56	-type filter_acc() :: {stanza() \| drop, c2s_state()}.
57
58	%%--------------------------------------------------------------------
59	%% gen_mod callbacks.
60	%%--------------------------------------------------------------------
61	-spec start(binary(), gen_mod:opts()) -> ok.
62	start(Host, Opts) ->
UNCOV 63	QueuePresence = mod_client_state_opt:queue_presence(Opts),	2✔
UNCOV 64	QueueChatStates = mod_client_state_opt:queue_chat_states(Opts),	2✔
UNCOV 65	QueuePEP = mod_client_state_opt:queue_pep(Opts),	2✔
UNCOV 66	if QueuePresence; QueueChatStates; QueuePEP ->	2✔
UNCOV 67	register_hooks(Host),	2✔
UNCOV 68	if QueuePresence ->	2✔
UNCOV 69	ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,	2✔
70	filter_presence, 50);
71	true -> ok	×
72	end,
UNCOV 73	if QueueChatStates ->	2✔
UNCOV 74	ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,	2✔
75	filter_chat_states, 50);
76	true -> ok	×
77	end,
UNCOV 78	if QueuePEP ->	2✔
UNCOV 79	ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,	2✔
80	filter_pep, 50);
81	true -> ok	×
82	end;
83	true -> ok	×
84	end.
85
86	-spec stop(binary()) -> ok.
87	stop(Host) ->
UNCOV 88	QueuePresence = mod_client_state_opt:queue_presence(Host),	2✔
UNCOV 89	QueueChatStates = mod_client_state_opt:queue_chat_states(Host),	2✔
UNCOV 90	QueuePEP = mod_client_state_opt:queue_pep(Host),	2✔
UNCOV 91	if QueuePresence; QueueChatStates; QueuePEP ->	2✔
UNCOV 92	unregister_hooks(Host),	2✔
UNCOV 93	if QueuePresence ->	2✔
UNCOV 94	ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,	2✔
95	filter_presence, 50);
96	true -> ok	×
97	end,
UNCOV 98	if QueueChatStates ->	2✔
UNCOV 99	ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,	2✔
100	filter_chat_states, 50);
101	true -> ok	×
102	end,
UNCOV 103	if QueuePEP ->	2✔
UNCOV 104	ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,	2✔
105	filter_pep, 50);
106	true -> ok	×
107	end;
108	true -> ok	×
109	end.
110
111	-spec reload(binary(), gen_mod:opts(), gen_mod:opts()) -> ok.
112	reload(Host, NewOpts, _OldOpts) ->
113	QueuePresence = mod_client_state_opt:queue_presence(NewOpts),	×
114	QueueChatStates = mod_client_state_opt:queue_chat_states(NewOpts),	×
115	QueuePEP = mod_client_state_opt:queue_pep(NewOpts),	×
116	if QueuePresence; QueueChatStates; QueuePEP ->	×
117	register_hooks(Host);	×
118	true ->
119	unregister_hooks(Host)	×
120	end,
121	if QueuePresence ->	×
122	ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,	×
123	filter_presence, 50);
124	true ->
125	ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,	×
126	filter_presence, 50)
127	end,
128	if QueueChatStates ->	×
129	ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,	×
130	filter_chat_states, 50);
131	true ->
132	ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,	×
133	filter_chat_states, 50)
134	end,
135	if QueuePEP ->	×
136	ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,	×
137	filter_pep, 50);
138	true ->
139	ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,	×
140	filter_pep, 50)
141	end.
142
143	-spec mod_opt_type(atom()) -> econf:validator().
144	mod_opt_type(queue_presence) ->
UNCOV 145	econf:bool();	2✔
146	mod_opt_type(queue_chat_states) ->
UNCOV 147	econf:bool();	2✔
148	mod_opt_type(queue_pep) ->
UNCOV 149	econf:bool().	2✔
150
151	mod_options(_) ->
UNCOV 152	[{queue_presence, true},	2✔
153	{queue_chat_states, true},
154	{queue_pep, true}].
155
156	mod_doc() ->
157	#{desc =>	×
158	[?T("This module allows for queueing certain types of stanzas "
159	"when a client indicates that the user is not actively using "
160	"the client right now (see https://xmpp.org/extensions/xep-0352.html"
161	"[XEP-0352: Client State Indication]). This can save bandwidth and "
162	"resources."), "",
163	?T("A stanza is dropped from the queue if it's effectively obsoleted "
164	"by a new one (e.g., a new presence stanza would replace an old "
165	"one from the same client). The queue is flushed if a stanza arrives "
166	"that won't be queued, or if the queue size reaches a certain limit "
167	"(currently 100 stanzas), or if the client becomes active again.")],
168	opts =>
169	[{queue_presence,
170	#{value => "true \| false",
171	desc =>
172	?T("While a client is inactive, queue presence stanzas "
173	"that indicate (un)availability. The default value is 'true'.")}},
174	{queue_chat_states,
175	#{value => "true \| false",
176	desc =>
177	?T("Queue \"standalone\" chat state notifications (as defined in "
178	"https://xmpp.org/extensions/xep-0085.html"
179	"[XEP-0085: Chat State Notifications]) while a client "
180	"indicates inactivity. The default value is 'true'.")}},
181	{queue_pep,
182	#{value => "true \| false",
183	desc =>
184	?T("Queue PEP notifications while a client is inactive. "
185	"When the queue is flushed, only the most recent notification "
186	"of a given PEP node is delivered. The default value is 'true'.")}}]}.
187
188	-spec depends(binary(), gen_mod:opts()) -> [{module(), hard \| soft}].
189	depends(_Host, _Opts) ->
UNCOV 190	[].	2✔
191
192	-spec register_hooks(binary()) -> ok.
193	register_hooks(Host) ->
UNCOV 194	ejabberd_hooks:add(c2s_stream_started, Host, ?MODULE,	2✔
195	c2s_stream_started, 50),
UNCOV 196	ejabberd_hooks:add(c2s_post_auth_features, Host, ?MODULE,	2✔
197	add_stream_feature, 50),
UNCOV 198	ejabberd_hooks:add(c2s_authenticated_packet, Host, ?MODULE,	2✔
199	c2s_authenticated_packet, 50),
UNCOV 200	ejabberd_hooks:add(csi_activity, Host, ?MODULE,	2✔
201	csi_activity, 50),
UNCOV 202	ejabberd_hooks:add(c2s_copy_session, Host, ?MODULE,	2✔
203	c2s_copy_session, 50),
UNCOV 204	ejabberd_hooks:add(c2s_session_resumed, Host, ?MODULE,	2✔
205	c2s_session_resumed, 50),
UNCOV 206	ejabberd_hooks:add(c2s_filter_send, Host, ?MODULE,	2✔
207	filter_other, 75).
208
209	-spec unregister_hooks(binary()) -> ok.
210	unregister_hooks(Host) ->
UNCOV 211	ejabberd_hooks:delete(c2s_stream_started, Host, ?MODULE,	2✔
212	c2s_stream_started, 50),
UNCOV 213	ejabberd_hooks:delete(c2s_post_auth_features, Host, ?MODULE,	2✔
214	add_stream_feature, 50),
UNCOV 215	ejabberd_hooks:delete(c2s_authenticated_packet, Host, ?MODULE,	2✔
216	c2s_authenticated_packet, 50),
UNCOV 217	ejabberd_hooks:delete(csi_activity, Host, ?MODULE,	2✔
218	csi_activity, 50),
UNCOV 219	ejabberd_hooks:delete(c2s_copy_session, Host, ?MODULE,	2✔
220	c2s_copy_session, 50),
UNCOV 221	ejabberd_hooks:delete(c2s_session_resumed, Host, ?MODULE,	2✔
222	c2s_session_resumed, 50),
UNCOV 223	ejabberd_hooks:delete(c2s_filter_send, Host, ?MODULE,	2✔
224	filter_other, 75).
225
226	%%--------------------------------------------------------------------
227	%% ejabberd_hooks callbacks.
228	%%--------------------------------------------------------------------
229	-spec c2s_stream_started(c2s_state(), stream_start()) -> c2s_state().
230	c2s_stream_started(State, _) ->
UNCOV 231	init_csi_state(State).	986✔
232
233	-spec c2s_authenticated_packet(c2s_state(), xmpp_element()) -> c2s_state().
234	c2s_authenticated_packet(#{lserver := LServer} = C2SState, #csi{type = active}) ->
UNCOV 235	ejabberd_hooks:run_fold(csi_activity, LServer, C2SState, [active]);	2✔
236	c2s_authenticated_packet(#{lserver := LServer} = C2SState, #csi{type = inactive}) ->
UNCOV 237	ejabberd_hooks:run_fold(csi_activity, LServer, C2SState, [inactive]);	2✔
238	c2s_authenticated_packet(C2SState, _) ->
UNCOV 239	C2SState.	10,500✔
240
241	-spec csi_activity(c2s_state(), active \| inactive) -> c2s_state().
242	csi_activity(C2SState, active) ->
UNCOV 243	C2SState1 = C2SState#{csi_state => active},	2✔
UNCOV 244	flush_queue(C2SState1);	2✔
245	csi_activity(C2SState, inactive) ->
UNCOV 246	C2SState#{csi_state => inactive}.	2✔
247
248	-spec c2s_copy_session(c2s_state(), c2s_state()) -> c2s_state().
249	c2s_copy_session(C2SState, #{csi_queue := Q}) ->
250	C2SState#{csi_queue => Q};	×
251	c2s_copy_session(C2SState, _) ->
252	C2SState.	×
253
254	-spec c2s_session_resumed(c2s_state()) -> c2s_state().
255	c2s_session_resumed(C2SState) ->
256	flush_queue(C2SState).	×
257
258	-spec filter_presence(filter_acc()) -> filter_acc().
259	filter_presence({#presence{meta = #{csi_resend := true}}, _} = Acc) ->
UNCOV 260	Acc;	2✔
261	filter_presence({#presence{to = To, type = Type} = Pres,
262	#{csi_state := inactive} = C2SState})
263	when Type == available; Type == unavailable ->
UNCOV 264	?DEBUG("Got availability presence stanza for ~ts", [jid:encode(To)]),	4✔
UNCOV 265	enqueue_stanza(presence, Pres, C2SState);	4✔
266	filter_presence(Acc) ->
UNCOV 267	Acc.	11,976✔
268
269	-spec filter_chat_states(filter_acc()) -> filter_acc().
270	filter_chat_states({#message{meta = #{csi_resend := true}}, _} = Acc) ->
UNCOV 271	Acc;	6✔
272	filter_chat_states({#message{from = From, to = To} = Msg,
273	#{csi_state := inactive} = C2SState} = Acc) ->
UNCOV 274	case misc:is_standalone_chat_state(Msg) of	14✔
275	true ->
UNCOV 276	case {From, To} of	4✔
277	{#jid{luser = U, lserver = S}, #jid{luser = U, lserver = S}} ->
278	%% Don't queue (carbon copies of) chat states from other
279	%% resources, as they might be used to sync the state of
280	%% conversations across clients.
281	Acc;	×
282	_ ->
UNCOV 283	?DEBUG("Got standalone chat state notification for ~ts",	4✔
UNCOV 284	[jid:encode(To)]),	4✔
UNCOV 285	enqueue_stanza(chatstate, Msg, C2SState)	4✔
286	end;
287	false ->
UNCOV 288	Acc	10✔
289	end;
290	filter_chat_states(Acc) ->
UNCOV 291	Acc.	11,974✔
292
293	-spec filter_pep(filter_acc()) -> filter_acc().
294	filter_pep({#message{meta = #{csi_resend := true}}, _} = Acc) ->
UNCOV 295	Acc;	6✔
296	filter_pep({#message{to = To} = Msg,
297	#{csi_state := inactive} = C2SState} = Acc) ->
UNCOV 298	case get_pep_node(Msg) of	10✔
299	undefined ->
UNCOV 300	Acc;	2✔
301	Node ->
UNCOV 302	?DEBUG("Got PEP notification for ~ts", [jid:encode(To)]),	8✔
UNCOV 303	enqueue_stanza({pep, Node}, Msg, C2SState)	8✔
304	end;
305	filter_pep(Acc) ->
UNCOV 306	Acc.	11,974✔
307
308	-spec filter_other(filter_acc()) -> filter_acc().
309	filter_other({Stanza, #{jid := JID} = C2SState} = Acc) when ?is_stanza(Stanza) ->
UNCOV 310	case xmpp:get_meta(Stanza) of	11,954✔
311	#{csi_resend := true} ->
UNCOV 312	Acc;	8✔
313	_ ->
UNCOV 314	?DEBUG("Won't add stanza for ~ts to CSI queue", [jid:encode(JID)]),	11,946✔
UNCOV 315	From = case xmpp:get_from(Stanza) of	11,946✔
316	undefined -> JID;	×
UNCOV 317	F -> F	11,946✔
318	end,
UNCOV 319	C2SState1 = dequeue_sender(From, C2SState),	11,946✔
UNCOV 320	{Stanza, C2SState1}	11,946✔
321	end;
322	filter_other(Acc) ->
UNCOV 323	Acc.	24✔
324
325	-spec add_stream_feature([xmpp_element()], binary()) -> [xmpp_element()].
326	add_stream_feature(Features, Host) ->
UNCOV 327	case gen_mod:is_loaded(Host, ?MODULE) of	486✔
328	true ->
UNCOV 329	[#feature_csi{} \| Features];	486✔
330	false ->
331	Features	×
332	end.
333
334	%%--------------------------------------------------------------------
335	%% Internal functions.
336	%%--------------------------------------------------------------------
337	-spec init_csi_state(c2s_state()) -> c2s_state().
338	init_csi_state(C2SState) ->
UNCOV 339	C2SState#{csi_state => active, csi_queue => queue_new()}.	986✔
340
341	-spec enqueue_stanza(csi_type(), stanza(), c2s_state()) -> filter_acc().
342	enqueue_stanza(Type, Stanza, #{csi_state := inactive,
343	csi_queue := Q} = C2SState) ->
UNCOV 344	case queue_len(Q) >= ?CSI_QUEUE_MAX of	16✔
345	true ->
346	?DEBUG("CSI queue too large, going to flush it", []),	×
347	C2SState1 = flush_queue(C2SState),	×
348	enqueue_stanza(Type, Stanza, C2SState1);	×
349	false ->
UNCOV 350	From = jid:tolower(xmpp:get_from(Stanza)),	16✔
UNCOV 351	Q1 = queue_in({From, Type}, Stanza, Q),	16✔
UNCOV 352	{stop, {drop, C2SState#{csi_queue => Q1}}}	16✔
353	end;
354	enqueue_stanza(_Type, Stanza, State) ->
355	{Stanza, State}.	×
356
357	-spec dequeue_sender(jid(), c2s_state()) -> c2s_state().
358	dequeue_sender(#jid{luser = U, lserver = S} = Sender,
359	#{jid := JID} = C2SState) ->
UNCOV 360	case maps:get(csi_queue, C2SState, undefined) of	11,946✔
361	undefined ->
362	%% This may happen when the module is (re)loaded in runtime
363	init_csi_state(C2SState);	×
364	Q ->
UNCOV 365	?DEBUG("Flushing packets of ~ts@~ts from CSI queue of ~ts",	11,946✔
UNCOV 366	[U, S, jid:encode(JID)]),	11,946✔
UNCOV 367	{Elems, Q1} = queue_take(Sender, Q),	11,946✔
UNCOV 368	C2SState1 = flush_stanzas(C2SState, Elems),	11,946✔
UNCOV 369	C2SState1#{csi_queue => Q1}	11,946✔
370	end.
371
372	-spec flush_queue(c2s_state()) -> c2s_state().
373	flush_queue(#{csi_queue := Q, jid := JID} = C2SState) ->
UNCOV 374	?DEBUG("Flushing CSI queue of ~ts", [jid:encode(JID)]),	2✔
UNCOV 375	C2SState1 = flush_stanzas(C2SState, queue_to_list(Q)),	2✔
UNCOV 376	C2SState1#{csi_queue => queue_new()}.	2✔
377
378	-spec flush_stanzas(c2s_state(),
379	[{csi_type(), csi_timestamp(), stanza()}]) -> c2s_state().
380	flush_stanzas(#{lserver := LServer} = C2SState, Elems) ->
UNCOV 381	lists:foldl(	11,948✔
382	fun({Time, Stanza}, AccState) ->
UNCOV 383	Stanza1 = add_delay_info(Stanza, LServer, Time),	8✔
UNCOV 384	ejabberd_c2s:send(AccState, Stanza1)	8✔
385	end, C2SState, Elems).
386
387	-spec add_delay_info(stanza(), binary(), csi_timestamp()) -> stanza().
388	add_delay_info(Stanza, LServer, {_Seq, TimeStamp}) ->
UNCOV 389	Stanza1 = misc:add_delay_info(	8✔
390	Stanza, jid:make(LServer), TimeStamp,
391	<<"Client Inactive">>),
UNCOV 392	xmpp:put_meta(Stanza1, csi_resend, true).	8✔
393
394	-spec get_pep_node(message()) -> binary() \| undefined.
395	get_pep_node(#message{from = #jid{luser = <<>>}}) ->
396	%% It's not PEP.
397	undefined;	×
398	get_pep_node(#message{} = Msg) ->
UNCOV 399	case xmpp:get_subtag(Msg, #ps_event{}) of	10✔
400	#ps_event{items = #ps_items{node = Node}} ->
UNCOV 401	Node;	8✔
402	_ ->
UNCOV 403	undefined	2✔
404	end.
405
406	%%--------------------------------------------------------------------
407	%% Queue interface
408	%%--------------------------------------------------------------------
409	-spec queue_new() -> csi_queue().
410	queue_new() ->
UNCOV 411	{0, #{}}.	988✔
412
413	-spec queue_in(csi_key(), stanza(), csi_queue()) -> csi_queue().
414	queue_in(Key, Stanza, {Seq, Q}) ->
UNCOV 415	Seq1 = Seq + 1,	16✔
UNCOV 416	Time = {Seq1, erlang:timestamp()},	16✔
UNCOV 417	Q1 = maps:put(Key, {Time, Stanza}, Q),	16✔
UNCOV 418	{Seq1, Q1}.	16✔
419
420	-spec queue_take(jid(), csi_queue()) -> {[csi_element()], csi_queue()}.
421	queue_take(#jid{luser = LUser, lserver = LServer}, {Seq, Q}) ->
UNCOV 422	{Vals, Q1} = maps:fold(fun({{U, S, _}, _} = Key, Val, {AccVals, AccQ})	11,946✔
423	when U == LUser, S == LServer ->
UNCOV 424	{[Val \| AccVals], maps:remove(Key, AccQ)};	8✔
425	(_, _, Acc) ->
426	Acc	×
427	end, {[], Q}, Q),
UNCOV 428	{lists:keysort(1, Vals), {Seq, Q1}}.	11,946✔
429
430	-spec queue_len(csi_queue()) -> non_neg_integer().
431	queue_len({_, Q}) ->
UNCOV 432	maps:size(Q).	16✔
433
434	-spec queue_to_list(csi_queue()) -> [csi_element()].
435	queue_to_list({_, Q}) ->
UNCOV 436	lists:keysort(1, maps:values(Q)).	2✔

processone / ejabberd / 1212

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous