2003-03-23 21:08:44 +01:00
|
|
|
%%%----------------------------------------------------------------------
|
|
|
|
%%% File : mod_muc_room.erl
|
2007-12-24 14:57:53 +01:00
|
|
|
%%% Author : Alexey Shchepin <alexey@process-one.net>
|
2003-03-23 21:08:44 +01:00
|
|
|
%%% Purpose : MUC room stuff
|
2007-12-24 14:57:53 +01:00
|
|
|
%%% Created : 19 Mar 2003 by Alexey Shchepin <alexey@process-one.net>
|
|
|
|
%%%
|
|
|
|
%%%
|
2018-01-05 21:18:58 +01:00
|
|
|
%%% ejabberd, Copyright (C) 2002-2018 ProcessOne
|
2007-12-24 14:57:53 +01:00
|
|
|
%%%
|
|
|
|
%%% 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.
|
2009-01-12 15:44:42 +01:00
|
|
|
%%%
|
2014-02-22 11:27:40 +01:00
|
|
|
%%% 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.
|
2007-12-24 14:57:53 +01:00
|
|
|
%%%
|
2003-03-23 21:08:44 +01:00
|
|
|
%%%----------------------------------------------------------------------
|
|
|
|
|
|
|
|
-module(mod_muc_room).
|
2013-03-14 10:33:02 +01:00
|
|
|
|
2007-12-24 14:57:53 +01:00
|
|
|
-author('alexey@process-one.net').
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2017-08-05 19:58:21 +02:00
|
|
|
-behaviour(p1_fsm).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
|
|
|
%% External exports
|
2017-03-10 13:12:43 +01:00
|
|
|
-export([start_link/10,
|
|
|
|
start_link/8,
|
|
|
|
start/10,
|
|
|
|
start/8,
|
2015-08-06 12:33:39 +02:00
|
|
|
get_role/2,
|
2015-12-24 13:01:33 +01:00
|
|
|
get_affiliation/2,
|
|
|
|
is_occupant_or_admin/2,
|
2018-02-16 06:28:33 +01:00
|
|
|
route/2,
|
|
|
|
expand_opts/1,
|
2018-10-25 01:22:57 +02:00
|
|
|
config_fields/0]).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
|
|
|
%% gen_fsm callbacks
|
|
|
|
-export([init/1,
|
|
|
|
normal_state/2,
|
|
|
|
handle_event/3,
|
|
|
|
handle_sync_event/4,
|
|
|
|
handle_info/3,
|
|
|
|
terminate/3,
|
|
|
|
code_change/4]).
|
|
|
|
|
2013-04-08 11:12:54 +02:00
|
|
|
-include("logger.hrl").
|
2016-07-25 12:50:30 +02:00
|
|
|
-include("xmpp.hrl").
|
2018-11-29 10:16:12 +01:00
|
|
|
-include("translate.hrl").
|
2008-12-02 20:23:12 +01:00
|
|
|
-include("mod_muc_room.hrl").
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2007-08-29 19:54:45 +02:00
|
|
|
-define(MAX_USERS_DEFAULT_LIST,
|
|
|
|
[5, 10, 20, 30, 50, 100, 200, 500, 1000, 2000, 5000]).
|
2007-08-28 16:35:50 +02:00
|
|
|
|
2015-05-08 13:09:13 +02:00
|
|
|
-define(DEFAULT_MAX_USERS_PRESENCE,1000).
|
|
|
|
|
2003-09-19 20:22:44 +02:00
|
|
|
%-define(DBGFSM, true).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
|
|
|
-ifdef(DBGFSM).
|
2013-03-14 10:33:02 +01:00
|
|
|
|
2003-03-23 21:08:44 +01:00
|
|
|
-define(FSMOPTS, [{debug, [trace]}]).
|
2013-03-14 10:33:02 +01:00
|
|
|
|
2003-03-23 21:08:44 +01:00
|
|
|
-else.
|
2013-03-14 10:33:02 +01:00
|
|
|
|
2003-03-23 21:08:44 +01:00
|
|
|
-define(FSMOPTS, []).
|
2013-03-14 10:33:02 +01:00
|
|
|
|
2003-03-23 21:08:44 +01:00
|
|
|
-endif.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-type state() :: #state{}.
|
|
|
|
-type fsm_stop() :: {stop, normal, state()}.
|
|
|
|
-type fsm_next() :: {next_state, normal_state, state()}.
|
|
|
|
-type fsm_transition() :: fsm_stop() | fsm_next().
|
|
|
|
|
|
|
|
-export_type([state/0]).
|
|
|
|
|
2016-11-24 12:44:09 +01:00
|
|
|
-callback set_affiliation(binary(), binary(), binary(), jid(), affiliation(),
|
|
|
|
binary()) -> ok | {error, any()}.
|
|
|
|
-callback set_affiliations(binary(), binary(), binary(),
|
2018-11-15 12:13:45 +01:00
|
|
|
map()) -> ok | {error, any()}.
|
2016-11-24 12:44:09 +01:00
|
|
|
-callback get_affiliation(binary(), binary(), binary(),
|
|
|
|
binary(), binary()) -> {ok, affiliation()} | {error, any()}.
|
2018-11-15 12:13:45 +01:00
|
|
|
-callback get_affiliations(binary(), binary(), binary()) -> {ok, map()} | {error, any()}.
|
2016-11-24 12:44:09 +01:00
|
|
|
-callback search_affiliation(binary(), binary(), binary(), affiliation()) ->
|
|
|
|
{ok, [{ljid(), {affiliation(), binary()}}]} | {error, any()}.
|
|
|
|
|
2003-03-23 21:08:44 +01:00
|
|
|
%%%----------------------------------------------------------------------
|
|
|
|
%%% API
|
|
|
|
%%%----------------------------------------------------------------------
|
2007-09-01 23:05:04 +02:00
|
|
|
start(Host, ServerHost, Access, Room, HistorySize, RoomShaper,
|
2017-03-10 13:12:43 +01:00
|
|
|
Creator, Nick, DefRoomOpts, QueueType) ->
|
2017-08-05 19:58:21 +02:00
|
|
|
p1_fsm:start(?MODULE, [Host, ServerHost, Access, Room, HistorySize,
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomShaper, Creator, Nick, DefRoomOpts, QueueType],
|
2015-11-04 16:24:35 +01:00
|
|
|
?FSMOPTS).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2017-03-10 13:12:43 +01:00
|
|
|
start(Host, ServerHost, Access, Room, HistorySize, RoomShaper, Opts, QueueType) ->
|
2017-08-05 19:58:21 +02:00
|
|
|
p1_fsm:start(?MODULE, [Host, ServerHost, Access, Room, HistorySize,
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomShaper, Opts, QueueType],
|
2015-11-04 16:24:35 +01:00
|
|
|
?FSMOPTS).
|
2006-02-02 06:00:27 +01:00
|
|
|
|
2007-09-01 23:05:04 +02:00
|
|
|
start_link(Host, ServerHost, Access, Room, HistorySize, RoomShaper,
|
2017-03-10 13:12:43 +01:00
|
|
|
Creator, Nick, DefRoomOpts, QueueType) ->
|
2017-08-05 19:58:21 +02:00
|
|
|
p1_fsm:start_link(?MODULE, [Host, ServerHost, Access, Room, HistorySize,
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomShaper, Creator, Nick, DefRoomOpts, QueueType],
|
2006-02-03 04:28:15 +01:00
|
|
|
?FSMOPTS).
|
2006-02-02 06:00:27 +01:00
|
|
|
|
2017-03-10 13:12:43 +01:00
|
|
|
start_link(Host, ServerHost, Access, Room, HistorySize, RoomShaper, Opts, QueueType) ->
|
2017-08-05 19:58:21 +02:00
|
|
|
p1_fsm:start_link(?MODULE, [Host, ServerHost, Access, Room, HistorySize,
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomShaper, Opts, QueueType],
|
2006-02-03 04:28:15 +01:00
|
|
|
?FSMOPTS).
|
2003-03-25 22:03:35 +01:00
|
|
|
|
2003-03-23 21:08:44 +01:00
|
|
|
%%%----------------------------------------------------------------------
|
|
|
|
%%% Callback functions from gen_fsm
|
|
|
|
%%%----------------------------------------------------------------------
|
|
|
|
|
2015-10-07 00:06:58 +02:00
|
|
|
init([Host, ServerHost, Access, Room, HistorySize,
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomShaper, Creator, _Nick, DefRoomOpts, QueueType]) ->
|
2008-02-28 01:30:23 +01:00
|
|
|
process_flag(trap_exit, true),
|
2018-07-05 08:31:55 +02:00
|
|
|
Shaper = ejabberd_shaper:new(RoomShaper),
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomQueue = room_queue_new(ServerHost, Shaper, QueueType),
|
2003-03-23 21:08:44 +01:00
|
|
|
State = set_affiliation(Creator, owner,
|
2015-10-07 00:06:58 +02:00
|
|
|
#state{host = Host, server_host = ServerHost,
|
|
|
|
access = Access, room = Room,
|
2017-03-10 13:12:43 +01:00
|
|
|
history = lqueue_new(HistorySize, QueueType),
|
2017-02-25 08:01:01 +01:00
|
|
|
jid = jid:make(Room, Host),
|
2015-10-07 00:06:58 +02:00
|
|
|
just_created = true,
|
2017-03-10 13:12:43 +01:00
|
|
|
room_queue = RoomQueue,
|
2015-10-07 00:06:58 +02:00
|
|
|
room_shaper = Shaper}),
|
2007-08-02 04:30:25 +02:00
|
|
|
State1 = set_opts(DefRoomOpts, State),
|
2016-06-26 08:08:37 +02:00
|
|
|
store_room(State1),
|
2015-10-07 00:06:58 +02:00
|
|
|
?INFO_MSG("Created MUC room ~s@~s by ~s",
|
2017-02-26 08:07:12 +01:00
|
|
|
[Room, Host, jid:encode(Creator)]),
|
2009-12-29 15:43:24 +01:00
|
|
|
add_to_log(room_existence, created, State1),
|
|
|
|
add_to_log(room_existence, started, State1),
|
2007-08-02 04:30:25 +02:00
|
|
|
{ok, normal_state, State1};
|
2017-03-10 13:12:43 +01:00
|
|
|
init([Host, ServerHost, Access, Room, HistorySize, RoomShaper, Opts, QueueType]) ->
|
2008-02-28 01:30:23 +01:00
|
|
|
process_flag(trap_exit, true),
|
2018-07-05 08:31:55 +02:00
|
|
|
Shaper = ejabberd_shaper:new(RoomShaper),
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomQueue = room_queue_new(ServerHost, Shaper, QueueType),
|
2003-03-25 22:03:35 +01:00
|
|
|
State = set_opts(Opts, #state{host = Host,
|
2005-06-20 05:18:13 +02:00
|
|
|
server_host = ServerHost,
|
2004-05-17 22:36:41 +02:00
|
|
|
access = Access,
|
2003-10-07 22:31:44 +02:00
|
|
|
room = Room,
|
2017-03-10 13:12:43 +01:00
|
|
|
history = lqueue_new(HistorySize, QueueType),
|
2017-02-25 08:01:01 +01:00
|
|
|
jid = jid:make(Room, Host),
|
2017-03-10 13:12:43 +01:00
|
|
|
room_queue = RoomQueue,
|
2007-09-01 23:05:04 +02:00
|
|
|
room_shaper = Shaper}),
|
2009-12-29 15:43:24 +01:00
|
|
|
add_to_log(room_existence, started, State),
|
2003-03-23 21:08:44 +01:00
|
|
|
{ok, normal_state, State}.
|
|
|
|
|
2017-02-16 09:00:26 +01:00
|
|
|
normal_state({route, <<"">>,
|
|
|
|
#message{from = From, type = Type, lang = Lang} = Packet},
|
|
|
|
StateData) ->
|
2008-06-13 20:55:26 +02:00
|
|
|
case is_user_online(From, StateData) orelse
|
2016-09-08 15:39:34 +02:00
|
|
|
is_subscriber(From, StateData) orelse
|
2016-07-25 12:50:30 +02:00
|
|
|
is_user_allowed_message_nonparticipant(From, StateData) of
|
|
|
|
true when Type == groupchat ->
|
|
|
|
Activity = get_user_activity(From, StateData),
|
|
|
|
Now = p1_time_compat:system_time(micro_seconds),
|
|
|
|
MinMessageInterval = trunc(gen_mod:get_module_opt(
|
|
|
|
StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, min_message_interval)
|
|
|
|
* 1000000),
|
2016-07-25 12:50:30 +02:00
|
|
|
Size = element_size(Packet),
|
|
|
|
{MessageShaper, MessageShaperInterval} =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:update(Activity#activity.message_shaper, Size),
|
2016-07-25 12:50:30 +02:00
|
|
|
if Activity#activity.message /= undefined ->
|
|
|
|
ErrText = <<"Traffic rate limit is exceeded">>,
|
2016-11-25 09:41:24 +01:00
|
|
|
Err = xmpp:err_resource_constraint(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2015-08-06 12:33:39 +02:00
|
|
|
{next_state, normal_state, StateData};
|
2016-07-25 12:50:30 +02:00
|
|
|
Now >= Activity#activity.message_time + MinMessageInterval,
|
|
|
|
MessageShaperInterval == 0 ->
|
|
|
|
{RoomShaper, RoomShaperInterval} =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:update(StateData#state.room_shaper, Size),
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomQueueEmpty = case StateData#state.room_queue of
|
|
|
|
undefined -> true;
|
|
|
|
RQ -> p1_queue:is_empty(RQ)
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
if RoomShaperInterval == 0, RoomQueueEmpty ->
|
|
|
|
NewActivity = Activity#activity{
|
|
|
|
message_time = Now,
|
|
|
|
message_shaper = MessageShaper},
|
|
|
|
StateData1 = store_user_activity(From,
|
|
|
|
NewActivity,
|
|
|
|
StateData),
|
|
|
|
StateData2 = StateData1#state{room_shaper =
|
|
|
|
RoomShaper},
|
2017-02-24 19:25:25 +01:00
|
|
|
process_groupchat_message(Packet,
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData2);
|
2016-06-26 08:08:37 +02:00
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData1 = if RoomQueueEmpty ->
|
|
|
|
erlang:send_after(RoomShaperInterval,
|
|
|
|
self(),
|
|
|
|
process_room_queue),
|
|
|
|
StateData#state{room_shaper =
|
|
|
|
RoomShaper};
|
|
|
|
true -> StateData
|
|
|
|
end,
|
|
|
|
NewActivity = Activity#activity{
|
|
|
|
message_time = Now,
|
|
|
|
message_shaper = MessageShaper,
|
|
|
|
message = Packet},
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomQueue = p1_queue:in({message, From},
|
|
|
|
StateData#state.room_queue),
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData2 = store_user_activity(From,
|
|
|
|
NewActivity,
|
|
|
|
StateData1),
|
|
|
|
StateData3 = StateData2#state{room_queue = RoomQueue},
|
|
|
|
{next_state, normal_state, StateData3}
|
2015-08-06 12:33:39 +02:00
|
|
|
end;
|
2016-07-25 12:50:30 +02:00
|
|
|
true ->
|
|
|
|
MessageInterval = (Activity#activity.message_time +
|
|
|
|
MinMessageInterval - Now) div 1000,
|
|
|
|
Interval = lists:max([MessageInterval,
|
|
|
|
MessageShaperInterval]),
|
|
|
|
erlang:send_after(Interval, self(),
|
|
|
|
{process_user_message, From}),
|
|
|
|
NewActivity = Activity#activity{
|
|
|
|
message = Packet,
|
|
|
|
message_shaper = MessageShaper},
|
|
|
|
StateData1 = store_user_activity(From, NewActivity, StateData),
|
|
|
|
{next_state, normal_state, StateData1}
|
|
|
|
end;
|
|
|
|
true when Type == error ->
|
|
|
|
case is_user_online(From, StateData) of
|
|
|
|
true ->
|
|
|
|
ErrorText = <<"It is not allowed to send error messages to the"
|
|
|
|
" room. The participant (~s) has sent an error "
|
|
|
|
"message (~s) and got kicked from the room">>,
|
|
|
|
NewState = expulse_participant(Packet, From, StateData,
|
|
|
|
translate:translate(Lang,
|
|
|
|
ErrorText)),
|
|
|
|
close_room_if_temporary_and_empty(NewState);
|
2015-08-06 12:33:39 +02:00
|
|
|
_ ->
|
|
|
|
{next_state, normal_state, StateData}
|
2016-07-25 12:50:30 +02:00
|
|
|
end;
|
|
|
|
true when Type == chat ->
|
|
|
|
ErrText = <<"It is not allowed to send private messages "
|
|
|
|
"to the conference">>,
|
|
|
|
Err = xmpp:err_not_acceptable(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
{next_state, normal_state, StateData};
|
|
|
|
true when Type == normal ->
|
|
|
|
{next_state, normal_state,
|
|
|
|
try xmpp:decode_els(Packet) of
|
|
|
|
Pkt -> process_normal_message(From, Pkt, StateData)
|
|
|
|
catch _:{xmpp_codec, Why} ->
|
2017-11-14 07:02:43 +01:00
|
|
|
Txt = xmpp:io_format_error(Why),
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_bad_request(Txt, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData
|
|
|
|
end};
|
|
|
|
true ->
|
|
|
|
ErrText = <<"Improper message type">>,
|
|
|
|
Err = xmpp:err_not_acceptable(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
{next_state, normal_state, StateData};
|
|
|
|
false when Type /= error ->
|
2016-10-17 12:37:23 +02:00
|
|
|
handle_roommessage_from_nonparticipant(Packet, StateData, From),
|
|
|
|
{next_state, normal_state, StateData};
|
2016-07-25 12:50:30 +02:00
|
|
|
false ->
|
|
|
|
{next_state, normal_state, StateData}
|
2003-03-23 21:08:44 +01:00
|
|
|
end;
|
2017-02-16 09:00:26 +01:00
|
|
|
normal_state({route, <<"">>,
|
|
|
|
#iq{from = From, type = Type, lang = Lang, sub_els = [_]} = IQ0},
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData) when Type == get; Type == set ->
|
|
|
|
try
|
|
|
|
case ejabberd_hooks:run_fold(
|
|
|
|
muc_process_iq,
|
|
|
|
StateData#state.server_host,
|
|
|
|
xmpp:set_from_to(xmpp:decode_els(IQ0),
|
|
|
|
From, StateData#state.jid),
|
|
|
|
[StateData]) of
|
|
|
|
ignore ->
|
|
|
|
{next_state, normal_state, StateData};
|
|
|
|
#iq{type = T} = IQRes when T == error; T == result ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route(IQRes),
|
2016-07-25 12:50:30 +02:00
|
|
|
{next_state, normal_state, StateData};
|
|
|
|
#iq{sub_els = [SubEl]} = IQ ->
|
|
|
|
Res1 = case xmpp:get_ns(SubEl) of
|
|
|
|
?NS_MUC_ADMIN ->
|
|
|
|
process_iq_admin(From, IQ, StateData);
|
|
|
|
?NS_MUC_OWNER ->
|
|
|
|
process_iq_owner(From, IQ, StateData);
|
2018-02-12 15:37:36 +01:00
|
|
|
?NS_DISCO_INFO ->
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_disco_info(From, IQ, StateData);
|
|
|
|
?NS_DISCO_ITEMS ->
|
|
|
|
process_iq_disco_items(From, IQ, StateData);
|
|
|
|
?NS_VCARD ->
|
|
|
|
process_iq_vcard(From, IQ, StateData);
|
|
|
|
?NS_MUCSUB ->
|
|
|
|
process_iq_mucsub(From, IQ, StateData);
|
|
|
|
?NS_CAPTCHA ->
|
|
|
|
process_iq_captcha(From, IQ, StateData);
|
|
|
|
_ ->
|
2016-10-17 12:37:23 +02:00
|
|
|
Txt = <<"The feature requested is not "
|
|
|
|
"supported by the conference">>,
|
|
|
|
{error, xmpp:err_service_unavailable(Txt, Lang)}
|
2016-07-25 12:50:30 +02:00
|
|
|
end,
|
|
|
|
{IQRes, NewStateData} =
|
|
|
|
case Res1 of
|
|
|
|
{result, Res, SD} ->
|
|
|
|
{xmpp:make_iq_result(IQ, Res), SD};
|
|
|
|
{result, Res} ->
|
|
|
|
{xmpp:make_iq_result(IQ, Res), StateData};
|
|
|
|
{ignore, SD} ->
|
|
|
|
{ignore, SD};
|
|
|
|
{error, Error} ->
|
|
|
|
{xmpp:make_error(IQ0, Error), StateData}
|
|
|
|
end,
|
|
|
|
if IQRes /= ignore ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route(IQRes);
|
2016-07-25 12:50:30 +02:00
|
|
|
true ->
|
|
|
|
ok
|
|
|
|
end,
|
|
|
|
case NewStateData of
|
2016-10-17 12:37:23 +02:00
|
|
|
stop ->
|
|
|
|
{stop, normal, StateData};
|
|
|
|
_ when NewStateData#state.just_created ->
|
|
|
|
close_room_if_temporary_and_empty(NewStateData);
|
|
|
|
_ ->
|
|
|
|
{next_state, normal_state, NewStateData}
|
2016-07-25 12:50:30 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
catch _:{xmpp_codec, Why} ->
|
2017-11-14 07:02:43 +01:00
|
|
|
ErrTxt = xmpp:io_format_error(Why),
|
2016-11-25 09:41:24 +01:00
|
|
|
Err = xmpp:err_bad_request(ErrTxt, Lang),
|
2017-12-19 07:15:35 +01:00
|
|
|
ejabberd_router:route_error(IQ0, Err),
|
|
|
|
{next_state, normal_state, StateData}
|
2016-07-25 12:50:30 +02:00
|
|
|
end;
|
2017-02-16 09:00:26 +01:00
|
|
|
normal_state({route, <<"">>, #iq{} = IQ}, StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_bad_request(),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(IQ, Err),
|
2016-10-17 12:37:23 +02:00
|
|
|
case StateData#state.just_created of
|
|
|
|
true -> {stop, normal, StateData};
|
|
|
|
false -> {next_state, normal_state, StateData}
|
|
|
|
end;
|
2017-02-16 09:00:26 +01:00
|
|
|
normal_state({route, Nick, #presence{from = From} = Packet}, StateData) ->
|
2007-09-01 23:05:04 +02:00
|
|
|
Activity = get_user_activity(From, StateData),
|
2015-12-04 15:08:43 +01:00
|
|
|
Now = p1_time_compat:system_time(micro_seconds),
|
2007-06-25 18:43:42 +02:00
|
|
|
MinPresenceInterval =
|
2013-03-14 10:33:02 +01:00
|
|
|
trunc(gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, min_presence_interval)
|
|
|
|
* 1000000),
|
2016-07-25 12:50:30 +02:00
|
|
|
if (Now >= Activity#activity.presence_time + MinPresenceInterval)
|
|
|
|
and (Activity#activity.presence == undefined) ->
|
|
|
|
NewActivity = Activity#activity{presence_time = Now},
|
|
|
|
StateData1 = store_user_activity(From, NewActivity,
|
|
|
|
StateData),
|
2017-02-24 19:25:25 +01:00
|
|
|
process_presence(Nick, Packet, StateData1);
|
2013-03-14 10:33:02 +01:00
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
if Activity#activity.presence == undefined ->
|
|
|
|
Interval = (Activity#activity.presence_time +
|
|
|
|
MinPresenceInterval - Now) div 1000,
|
|
|
|
erlang:send_after(Interval, self(),
|
|
|
|
{process_user_presence, From});
|
|
|
|
true -> ok
|
|
|
|
end,
|
|
|
|
NewActivity = Activity#activity{presence = {Nick, Packet}},
|
|
|
|
StateData1 = store_user_activity(From, NewActivity,
|
|
|
|
StateData),
|
|
|
|
{next_state, normal_state, StateData1}
|
2003-06-30 14:24:35 +02:00
|
|
|
end;
|
2017-02-16 09:00:26 +01:00
|
|
|
normal_state({route, ToNick,
|
|
|
|
#message{from = From, type = Type, lang = Lang} = Packet},
|
2003-03-23 21:08:44 +01:00
|
|
|
StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
case decide_fate_message(Packet, From, StateData) of
|
|
|
|
{expulse_sender, Reason} ->
|
|
|
|
?DEBUG(Reason, []),
|
|
|
|
ErrorText = <<"It is not allowed to send error messages to the"
|
|
|
|
" room. The participant (~s) has sent an error "
|
|
|
|
"message (~s) and got kicked from the room">>,
|
|
|
|
NewState = expulse_participant(Packet, From, StateData,
|
|
|
|
translate:translate(Lang, ErrorText)),
|
|
|
|
{next_state, normal_state, NewState};
|
|
|
|
forget_message ->
|
|
|
|
{next_state, normal_state, StateData};
|
|
|
|
continue_delivery ->
|
|
|
|
case {(StateData#state.config)#config.allow_private_messages,
|
2016-11-12 11:27:15 +01:00
|
|
|
is_user_online(From, StateData) orelse
|
|
|
|
is_subscriber(From, StateData)} of
|
2016-07-25 12:50:30 +02:00
|
|
|
{true, true} when Type == groupchat ->
|
|
|
|
ErrText = <<"It is not allowed to send private messages "
|
|
|
|
"of type \"groupchat\"">>,
|
|
|
|
Err = xmpp:err_bad_request(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err);
|
2016-07-25 12:50:30 +02:00
|
|
|
{true, true} ->
|
|
|
|
case find_jids_by_nick(ToNick, StateData) of
|
|
|
|
[] ->
|
|
|
|
ErrText = <<"Recipient is not in the conference room">>,
|
|
|
|
Err = xmpp:err_item_not_found(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err);
|
2013-03-14 10:33:02 +01:00
|
|
|
ToJIDs ->
|
|
|
|
SrcIsVisitor = is_visitor(From, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
DstIsModerator = is_moderator(hd(ToJIDs), StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
PmFromVisitors =
|
|
|
|
(StateData#state.config)#config.allow_private_messages_from_visitors,
|
|
|
|
if SrcIsVisitor == false;
|
|
|
|
PmFromVisitors == anyone;
|
|
|
|
(PmFromVisitors == moderators) and
|
2016-07-25 12:50:30 +02:00
|
|
|
DstIsModerator ->
|
2016-09-08 15:39:34 +02:00
|
|
|
{FromNick, _} = get_participant_data(From, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
FromNickJID =
|
|
|
|
jid:replace_resource(StateData#state.jid,
|
|
|
|
FromNick),
|
|
|
|
X = #muc_user{},
|
2017-02-16 09:00:26 +01:00
|
|
|
PrivMsg = xmpp:set_from(
|
|
|
|
xmpp:set_subtag(Packet, X),
|
|
|
|
FromNickJID),
|
|
|
|
[ejabberd_router:route(xmpp:set_to(PrivMsg, ToJID))
|
2016-07-25 12:50:30 +02:00
|
|
|
|| ToJID <- ToJIDs];
|
2013-03-14 10:33:02 +01:00
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
ErrText = <<"It is not allowed to send private messages">>,
|
|
|
|
Err = xmpp:err_forbidden(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err)
|
2008-01-29 15:49:08 +01:00
|
|
|
end
|
2016-07-25 12:50:30 +02:00
|
|
|
end;
|
|
|
|
{true, false} ->
|
|
|
|
ErrText = <<"Only occupants are allowed to send messages "
|
|
|
|
"to the conference">>,
|
|
|
|
Err = xmpp:err_not_acceptable(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err);
|
2016-07-25 12:50:30 +02:00
|
|
|
{false, _} ->
|
|
|
|
ErrText = <<"It is not allowed to send private messages">>,
|
|
|
|
Err = xmpp:err_forbidden(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err)
|
2016-07-25 12:50:30 +02:00
|
|
|
end,
|
2013-03-14 10:33:02 +01:00
|
|
|
{next_state, normal_state, StateData}
|
2008-01-29 15:49:08 +01:00
|
|
|
end;
|
2017-02-16 09:00:26 +01:00
|
|
|
normal_state({route, ToNick,
|
2018-11-29 10:16:12 +01:00
|
|
|
#iq{from = From, lang = Lang} = Packet},
|
|
|
|
#state{config = #config{allow_query_users = AllowQuery}} = StateData) ->
|
|
|
|
try maps:get(jid:tolower(From), StateData#state.users) of
|
|
|
|
#user{nick = FromNick} when AllowQuery orelse ToNick == FromNick ->
|
2016-07-25 12:50:30 +02:00
|
|
|
case find_jid_by_nick(ToNick, StateData) of
|
|
|
|
false ->
|
|
|
|
ErrText = <<"Recipient is not in the conference room">>,
|
|
|
|
Err = xmpp:err_item_not_found(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err);
|
2017-11-10 16:02:22 +01:00
|
|
|
To ->
|
|
|
|
FromJID = jid:replace_resource(StateData#state.jid, FromNick),
|
2018-11-29 10:16:12 +01:00
|
|
|
case direct_iq_type(Packet) of
|
|
|
|
vcard ->
|
2017-11-10 16:02:22 +01:00
|
|
|
ejabberd_router:route_iq(
|
2018-11-29 10:16:12 +01:00
|
|
|
xmpp:set_from_to(Packet, FromJID, jid:remove_resource(To)),
|
|
|
|
Packet, self());
|
|
|
|
ping when ToNick == FromNick ->
|
|
|
|
%% Self-ping optimization from XEP-0410
|
|
|
|
ejabberd_router:route(xmpp:make_iq_result(Packet));
|
|
|
|
response ->
|
|
|
|
ejabberd_router:route(xmpp:set_from_to(Packet, FromJID, To));
|
|
|
|
#stanza_error{} = Err ->
|
|
|
|
ejabberd_router:route_error(Packet, Err);
|
|
|
|
_OtherRequest ->
|
|
|
|
ejabberd_router:route_iq(
|
|
|
|
xmpp:set_from_to(Packet, FromJID, To), Packet, self())
|
2017-11-10 16:02:22 +01:00
|
|
|
end
|
2016-07-25 12:50:30 +02:00
|
|
|
end;
|
|
|
|
_ ->
|
|
|
|
ErrText = <<"Queries to the conference members are "
|
|
|
|
"not allowed in this room">>,
|
|
|
|
Err = xmpp:err_not_allowed(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err)
|
2018-11-29 10:16:12 +01:00
|
|
|
catch _:{badkey, _} ->
|
|
|
|
ErrText = <<"Only occupants are allowed to send queries "
|
|
|
|
"to the conference">>,
|
|
|
|
Err = xmpp:err_not_acceptable(ErrText, Lang),
|
|
|
|
ejabberd_router:route_error(Packet, Err)
|
2003-03-25 22:03:35 +01:00
|
|
|
end,
|
2003-03-23 21:08:44 +01:00
|
|
|
{next_state, normal_state, StateData};
|
2006-01-19 03:17:31 +01:00
|
|
|
normal_state(_Event, StateData) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
{next_state, normal_state, StateData}.
|
|
|
|
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_event({service_message, Msg}, _StateName,
|
|
|
|
StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
MessagePkt = #message{type = groupchat, body = xmpp:mk_text(Msg)},
|
2016-06-26 08:08:37 +02:00
|
|
|
send_wrapped_multiple(
|
2015-04-08 14:01:16 +02:00
|
|
|
StateData#state.jid,
|
2016-09-07 09:33:37 +02:00
|
|
|
get_users_and_subscribers(StateData),
|
2016-06-26 08:08:37 +02:00
|
|
|
MessagePkt,
|
|
|
|
?NS_MUCSUB_NODES_MESSAGES,
|
|
|
|
StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
NSD = add_message_to_history(<<"">>,
|
|
|
|
StateData#state.jid, MessagePkt, StateData),
|
2003-05-18 18:41:15 +02:00
|
|
|
{next_state, normal_state, NSD};
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_event({destroy, Reason}, _StateName,
|
|
|
|
StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, undefined, stop} =
|
|
|
|
destroy_room(#muc_destroy{xmlns = ?NS_MUC_OWNER, reason = Reason},
|
|
|
|
StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
?INFO_MSG("Destroyed MUC room ~s with reason: ~p",
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(StateData#state.jid), Reason]),
|
2009-12-29 15:43:24 +01:00
|
|
|
add_to_log(room_existence, destroyed, StateData),
|
2010-02-02 12:49:49 +01:00
|
|
|
{stop, shutdown, StateData};
|
2007-02-19 10:45:58 +01:00
|
|
|
handle_event(destroy, StateName, StateData) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
?INFO_MSG("Destroyed MUC room ~s",
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(StateData#state.jid)]),
|
2017-08-21 15:57:48 +02:00
|
|
|
handle_event({destroy, <<"">>}, StateName, StateData);
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_event({set_affiliations, Affiliations},
|
|
|
|
StateName, StateData) ->
|
2018-04-23 10:35:43 +02:00
|
|
|
NewStateData = set_affiliations(Affiliations, StateData),
|
|
|
|
{next_state, StateName, NewStateData};
|
2004-05-17 22:36:41 +02:00
|
|
|
handle_event(_Event, StateName, StateData) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
{next_state, StateName, StateData}.
|
|
|
|
|
2015-12-02 01:50:30 +01:00
|
|
|
handle_sync_event({get_disco_item, Filter, JID, Lang}, _From, StateName, StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
Len = maps:size(StateData#state.nicks),
|
2015-12-02 01:50:30 +01:00
|
|
|
Reply = case (Filter == all) or (Filter == Len) or ((Filter /= 0) and (Len /= 0)) of
|
|
|
|
true ->
|
|
|
|
get_roomdesc_reply(JID, StateData,
|
|
|
|
get_roomdesc_tail(StateData, Lang));
|
|
|
|
false ->
|
|
|
|
false
|
|
|
|
end,
|
2010-06-23 09:44:35 +02:00
|
|
|
{reply, Reply, StateName, StateData};
|
2015-12-02 01:50:30 +01:00
|
|
|
%% This clause is only for backwards compatibility
|
|
|
|
handle_sync_event({get_disco_item, JID, Lang}, From, StateName, StateData) ->
|
|
|
|
handle_sync_event({get_disco_item, any, JID, Lang}, From, StateName, StateData);
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_sync_event(get_config, _From, StateName,
|
|
|
|
StateData) ->
|
|
|
|
{reply, {ok, StateData#state.config}, StateName,
|
|
|
|
StateData};
|
|
|
|
handle_sync_event(get_state, _From, StateName,
|
|
|
|
StateData) ->
|
2007-02-19 17:56:06 +01:00
|
|
|
{reply, {ok, StateData}, StateName, StateData};
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_sync_event({change_config, Config}, _From,
|
|
|
|
StateName, StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, undefined, NSD} = change_config(Config, StateData),
|
2007-02-19 17:56:06 +01:00
|
|
|
{reply, {ok, NSD#state.config}, StateName, NSD};
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_sync_event({change_state, NewStateData}, _From,
|
|
|
|
StateName, _StateData) ->
|
2008-05-16 20:05:03 +02:00
|
|
|
{reply, {ok, NewStateData}, StateName, NewStateData};
|
2015-02-25 16:31:27 +01:00
|
|
|
handle_sync_event({process_item_change, Item, UJID}, _From, StateName, StateData) ->
|
2016-10-17 12:37:23 +02:00
|
|
|
case process_item_change(Item, StateData, UJID) of
|
|
|
|
{error, _} = Err ->
|
|
|
|
{reply, Err, StateName, StateData};
|
|
|
|
NSD ->
|
|
|
|
{reply, {ok, NSD}, StateName, NSD}
|
|
|
|
end;
|
2016-09-06 16:55:18 +02:00
|
|
|
handle_sync_event(get_subscribers, _From, StateName, StateData) ->
|
2016-09-07 09:33:37 +02:00
|
|
|
JIDs = lists:map(fun jid:make/1,
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:keys(StateData#state.subscribers)),
|
2016-09-06 16:55:18 +02:00
|
|
|
{reply, {ok, JIDs}, StateName, StateData};
|
2016-08-09 12:36:43 +02:00
|
|
|
handle_sync_event({muc_subscribe, From, Nick, Nodes}, _From,
|
|
|
|
StateName, StateData) ->
|
2018-07-05 10:51:49 +02:00
|
|
|
IQ = #iq{type = set, id = p1_rand:get_string(),
|
2016-11-12 11:27:15 +01:00
|
|
|
from = From, sub_els = [#muc_subscribe{nick = Nick,
|
|
|
|
events = Nodes}]},
|
2016-08-09 12:36:43 +02:00
|
|
|
Config = StateData#state.config,
|
|
|
|
CaptchaRequired = Config#config.captcha_protected,
|
|
|
|
PasswordProtected = Config#config.password_protected,
|
|
|
|
TmpConfig = Config#config{captcha_protected = false,
|
|
|
|
password_protected = false},
|
|
|
|
TmpState = StateData#state{config = TmpConfig},
|
2016-11-12 11:27:15 +01:00
|
|
|
case process_iq_mucsub(From, IQ, TmpState) of
|
|
|
|
{result, #muc_subscribe{events = NewNodes}, NewState} ->
|
2016-08-09 12:36:43 +02:00
|
|
|
NewConfig = (NewState#state.config)#config{
|
|
|
|
captcha_protected = CaptchaRequired,
|
|
|
|
password_protected = PasswordProtected},
|
2016-11-12 11:27:15 +01:00
|
|
|
{reply, {ok, NewNodes}, StateName,
|
2016-08-09 12:36:43 +02:00
|
|
|
NewState#state{config = NewConfig}};
|
|
|
|
{ignore, NewState} ->
|
|
|
|
NewConfig = (NewState#state.config)#config{
|
|
|
|
captcha_protected = CaptchaRequired,
|
|
|
|
password_protected = PasswordProtected},
|
2017-02-18 07:36:27 +01:00
|
|
|
{reply, {error, <<"Request is ignored">>},
|
2016-08-09 12:36:43 +02:00
|
|
|
NewState#state{config = NewConfig}};
|
|
|
|
{error, Err} ->
|
|
|
|
{reply, {error, get_error_text(Err)}, StateName, StateData}
|
|
|
|
end;
|
|
|
|
handle_sync_event({muc_unsubscribe, From}, _From, StateName, StateData) ->
|
2018-07-05 10:51:49 +02:00
|
|
|
IQ = #iq{type = set, id = p1_rand:get_string(),
|
2016-11-12 11:27:15 +01:00
|
|
|
from = From, sub_els = [#muc_unsubscribe{}]},
|
|
|
|
case process_iq_mucsub(From, IQ, StateData) of
|
2016-08-09 12:36:43 +02:00
|
|
|
{result, _, NewState} ->
|
|
|
|
{reply, ok, StateName, NewState};
|
|
|
|
{ignore, NewState} ->
|
2017-02-18 07:36:27 +01:00
|
|
|
{reply, {error, <<"Request is ignored">>}, NewState};
|
2016-08-09 12:36:43 +02:00
|
|
|
{error, Err} ->
|
|
|
|
{reply, {error, get_error_text(Err)}, StateName, StateData}
|
|
|
|
end;
|
2016-09-19 13:46:01 +02:00
|
|
|
handle_sync_event({is_subscribed, From}, _From, StateName, StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
IsSubs = try maps:get(jid:split(From), StateData#state.subscribers) of
|
|
|
|
#subscriber{nodes = Nodes} -> {true, Nodes}
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} -> false
|
2018-11-15 12:13:45 +01:00
|
|
|
end,
|
2016-09-19 13:46:01 +02:00
|
|
|
{reply, IsSubs, StateName, StateData};
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_sync_event(_Event, _From, StateName,
|
|
|
|
StateData) ->
|
|
|
|
Reply = ok, {reply, Reply, StateName, StateData}.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2004-05-17 22:36:41 +02:00
|
|
|
code_change(_OldVsn, StateName, StateData, _Extra) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
{ok, StateName, StateData}.
|
|
|
|
|
2007-09-01 23:05:04 +02:00
|
|
|
handle_info({process_user_presence, From}, normal_state = _StateName, StateData) ->
|
2017-03-10 13:12:43 +01:00
|
|
|
RoomQueueEmpty = p1_queue:is_empty(StateData#state.room_queue),
|
|
|
|
RoomQueue = p1_queue:in({presence, From}, StateData#state.room_queue),
|
2008-04-27 21:06:34 +02:00
|
|
|
StateData1 = StateData#state{room_queue = RoomQueue},
|
2013-03-14 10:33:02 +01:00
|
|
|
if RoomQueueEmpty ->
|
|
|
|
StateData2 = prepare_room_queue(StateData1),
|
|
|
|
{next_state, normal_state, StateData2};
|
|
|
|
true -> {next_state, normal_state, StateData1}
|
2008-04-27 21:06:34 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_info({process_user_message, From},
|
|
|
|
normal_state = _StateName, StateData) ->
|
|
|
|
RoomQueueEmpty =
|
2017-03-10 13:12:43 +01:00
|
|
|
p1_queue:is_empty(StateData#state.room_queue),
|
|
|
|
RoomQueue = p1_queue:in({message, From},
|
|
|
|
StateData#state.room_queue),
|
2008-04-27 21:06:34 +02:00
|
|
|
StateData1 = StateData#state{room_queue = RoomQueue},
|
2013-03-14 10:33:02 +01:00
|
|
|
if RoomQueueEmpty ->
|
|
|
|
StateData2 = prepare_room_queue(StateData1),
|
|
|
|
{next_state, normal_state, StateData2};
|
|
|
|
true -> {next_state, normal_state, StateData1}
|
2008-04-27 21:06:34 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_info(process_room_queue,
|
|
|
|
normal_state = StateName, StateData) ->
|
2017-03-10 13:12:43 +01:00
|
|
|
case p1_queue:out(StateData#state.room_queue) of
|
2013-03-14 10:33:02 +01:00
|
|
|
{{value, {message, From}}, RoomQueue} ->
|
|
|
|
Activity = get_user_activity(From, StateData),
|
|
|
|
Packet = Activity#activity.message,
|
|
|
|
NewActivity = Activity#activity{message = undefined},
|
|
|
|
StateData1 = store_user_activity(From, NewActivity,
|
|
|
|
StateData),
|
|
|
|
StateData2 = StateData1#state{room_queue = RoomQueue},
|
|
|
|
StateData3 = prepare_room_queue(StateData2),
|
2017-02-24 19:25:25 +01:00
|
|
|
process_groupchat_message(Packet, StateData3);
|
2013-03-14 10:33:02 +01:00
|
|
|
{{value, {presence, From}}, RoomQueue} ->
|
|
|
|
Activity = get_user_activity(From, StateData),
|
|
|
|
{Nick, Packet} = Activity#activity.presence,
|
|
|
|
NewActivity = Activity#activity{presence = undefined},
|
|
|
|
StateData1 = store_user_activity(From, NewActivity,
|
|
|
|
StateData),
|
|
|
|
StateData2 = StateData1#state{room_queue = RoomQueue},
|
|
|
|
StateData3 = prepare_room_queue(StateData2),
|
2017-02-24 19:25:25 +01:00
|
|
|
process_presence(Nick, Packet, StateData3);
|
2013-03-14 10:33:02 +01:00
|
|
|
{empty, _} -> {next_state, StateName, StateData}
|
2007-09-01 23:05:04 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_info({captcha_succeed, From}, normal_state,
|
|
|
|
StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
NewState = case maps:get(From, StateData#state.robots, passed) of
|
|
|
|
{Nick, Packet} ->
|
|
|
|
Robots = maps:put(From, passed, StateData#state.robots),
|
|
|
|
add_new_user(From, Nick, Packet,
|
|
|
|
StateData#state{robots = Robots});
|
|
|
|
passed ->
|
|
|
|
StateData
|
2009-03-13 17:01:46 +01:00
|
|
|
end,
|
|
|
|
{next_state, normal_state, NewState};
|
2013-03-14 10:33:02 +01:00
|
|
|
handle_info({captcha_failed, From}, normal_state,
|
|
|
|
StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
NewState = case maps:get(From, StateData#state.robots, passed) of
|
|
|
|
{_Nick, Packet} ->
|
|
|
|
Robots = maps:remove(From, StateData#state.robots),
|
|
|
|
Txt = <<"The CAPTCHA verification has failed">>,
|
|
|
|
Lang = xmpp:get_lang(Packet),
|
|
|
|
Err = xmpp:err_not_authorized(Txt, Lang),
|
|
|
|
ejabberd_router:route_error(Packet, Err),
|
|
|
|
StateData#state{robots = Robots};
|
|
|
|
passed ->
|
|
|
|
StateData
|
2009-03-13 17:01:46 +01:00
|
|
|
end,
|
|
|
|
{next_state, normal_state, NewState};
|
2013-06-19 13:30:31 +02:00
|
|
|
handle_info(shutdown, _StateName, StateData) ->
|
|
|
|
{stop, shutdown, StateData};
|
2017-11-10 16:02:22 +01:00
|
|
|
handle_info({iq_reply, #iq{type = Type, sub_els = Els},
|
|
|
|
#iq{from = From, to = To} = IQ}, StateName, StateData) ->
|
|
|
|
ejabberd_router:route(
|
|
|
|
xmpp:set_from_to(
|
|
|
|
IQ#iq{type = Type, sub_els = Els},
|
|
|
|
To, From)),
|
|
|
|
{next_state, StateName, StateData};
|
|
|
|
handle_info({iq_reply, timeout, IQ}, StateName, StateData) ->
|
2017-11-11 07:30:19 +01:00
|
|
|
Txt = <<"Request has timed out">>,
|
2017-11-10 16:02:22 +01:00
|
|
|
Err = xmpp:err_recipient_unavailable(Txt, IQ#iq.lang),
|
|
|
|
ejabberd_router:route_error(IQ, Err),
|
|
|
|
{next_state, StateName, StateData};
|
2018-07-08 13:52:12 +02:00
|
|
|
handle_info(config_reloaded, StateName, StateData) ->
|
|
|
|
Max = gen_mod:get_module_opt(StateData#state.server_host,
|
|
|
|
mod_muc, history_size),
|
|
|
|
History1 = StateData#state.history,
|
|
|
|
Q1 = History1#lqueue.queue,
|
|
|
|
Q2 = case p1_queue:len(Q1) of
|
|
|
|
Len when Len > Max ->
|
|
|
|
lqueue_cut(Q1, Len-Max);
|
|
|
|
_ ->
|
|
|
|
Q1
|
|
|
|
end,
|
|
|
|
History2 = History1#lqueue{queue = Q2, max = Max},
|
|
|
|
{next_state, StateName, StateData#state{history = History2}};
|
2004-05-17 22:36:41 +02:00
|
|
|
handle_info(_Info, StateName, StateData) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
{next_state, StateName, StateData}.
|
|
|
|
|
2009-12-30 02:25:35 +01:00
|
|
|
terminate(Reason, _StateName, StateData) ->
|
2009-12-29 15:43:24 +01:00
|
|
|
?INFO_MSG("Stopping MUC room ~s@~s",
|
|
|
|
[StateData#state.room, StateData#state.host]),
|
2009-12-30 02:25:35 +01:00
|
|
|
ReasonT = case Reason of
|
2013-03-14 10:33:02 +01:00
|
|
|
shutdown ->
|
|
|
|
<<"You are being removed from the room "
|
|
|
|
"because of a system shutdown">>;
|
|
|
|
_ -> <<"Room terminates">>
|
2009-12-30 02:25:35 +01:00
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
Packet = #presence{
|
|
|
|
type = unavailable,
|
|
|
|
sub_els = [#muc_user{items = [#muc_item{affiliation = none,
|
|
|
|
reason = ReasonT,
|
|
|
|
role = none}],
|
2017-12-06 16:50:45 +01:00
|
|
|
status_codes = [332,110]}]},
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(LJID, Info, _) ->
|
|
|
|
Nick = Info#user.nick,
|
|
|
|
case Reason of
|
|
|
|
shutdown ->
|
|
|
|
send_wrapped(jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
Info#user.jid, Packet,
|
|
|
|
?NS_MUCSUB_NODES_PARTICIPANTS,
|
|
|
|
StateData);
|
|
|
|
_ -> ok
|
|
|
|
end,
|
|
|
|
tab_remove_online_user(LJID, StateData)
|
|
|
|
end, [], get_users_and_subscribers(StateData)),
|
2009-12-29 15:43:24 +01:00
|
|
|
add_to_log(room_existence, stopped, StateData),
|
2012-04-27 11:52:05 +02:00
|
|
|
mod_muc:room_destroyed(StateData#state.host, StateData#state.room, self(),
|
|
|
|
StateData#state.server_host),
|
2003-03-23 21:08:44 +01:00
|
|
|
ok.
|
|
|
|
|
|
|
|
%%%----------------------------------------------------------------------
|
|
|
|
%%% Internal functions
|
|
|
|
%%%----------------------------------------------------------------------
|
2017-02-16 09:00:26 +01:00
|
|
|
-spec route(pid(), stanza()) -> ok.
|
|
|
|
route(Pid, Packet) ->
|
|
|
|
#jid{lresource = Nick} = xmpp:get_to(Packet),
|
2017-08-05 19:58:21 +02:00
|
|
|
p1_fsm:send_event(Pid, {route, Nick, Packet}).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2017-02-24 19:25:25 +01:00
|
|
|
-spec process_groupchat_message(message(), state()) -> fsm_next().
|
|
|
|
process_groupchat_message(#message{from = From, lang = Lang} = Packet, StateData) ->
|
2016-09-07 09:33:37 +02:00
|
|
|
IsSubscriber = is_subscriber(From, StateData),
|
|
|
|
case is_user_online(From, StateData) orelse IsSubscriber orelse
|
2013-03-14 10:33:02 +01:00
|
|
|
is_user_allowed_message_nonparticipant(From, StateData)
|
|
|
|
of
|
|
|
|
true ->
|
2016-09-07 09:33:37 +02:00
|
|
|
{FromNick, Role} = get_participant_data(From, StateData),
|
2016-06-26 08:08:37 +02:00
|
|
|
if (Role == moderator) or (Role == participant) or IsSubscriber or
|
2013-03-14 10:33:02 +01:00
|
|
|
((StateData#state.config)#config.moderated == false) ->
|
2016-06-26 08:08:37 +02:00
|
|
|
Subject = check_subject(Packet),
|
|
|
|
{NewStateData1, IsAllowed} = case Subject of
|
2017-11-13 09:25:35 +01:00
|
|
|
[] -> {StateData, true};
|
2016-06-26 08:08:37 +02:00
|
|
|
_ ->
|
2013-03-14 10:33:02 +01:00
|
|
|
case
|
|
|
|
can_change_subject(Role,
|
2016-10-20 20:34:48 +02:00
|
|
|
IsSubscriber,
|
2013-03-14 10:33:02 +01:00
|
|
|
StateData)
|
|
|
|
of
|
|
|
|
true ->
|
|
|
|
NSD =
|
|
|
|
StateData#state{subject
|
|
|
|
=
|
|
|
|
Subject,
|
|
|
|
subject_author
|
|
|
|
=
|
|
|
|
FromNick},
|
2016-06-26 08:08:37 +02:00
|
|
|
store_room(NSD),
|
2013-03-14 10:33:02 +01:00
|
|
|
{NSD, true};
|
|
|
|
_ -> {StateData, false}
|
|
|
|
end
|
|
|
|
end,
|
|
|
|
case IsAllowed of
|
|
|
|
true ->
|
2015-06-26 21:33:32 +02:00
|
|
|
case
|
2015-08-04 21:16:45 +02:00
|
|
|
ejabberd_hooks:run_fold(muc_filter_message,
|
2015-06-26 21:33:32 +02:00
|
|
|
StateData#state.server_host,
|
|
|
|
Packet,
|
2017-02-24 19:25:25 +01:00
|
|
|
[StateData, FromNick])
|
2015-06-26 21:33:32 +02:00
|
|
|
of
|
|
|
|
drop ->
|
|
|
|
{next_state, normal_state, StateData};
|
2015-09-25 17:00:00 +02:00
|
|
|
NewPacket1 ->
|
2018-09-06 12:40:05 +02:00
|
|
|
NewPacket = xmpp:put_meta(xmpp:remove_subtag(NewPacket1, #nick{}),
|
|
|
|
muc_sender_real_jid, From),
|
2017-11-13 09:25:35 +01:00
|
|
|
Node = if Subject == [] -> ?NS_MUCSUB_NODES_MESSAGES;
|
2016-06-26 08:08:37 +02:00
|
|
|
true -> ?NS_MUCSUB_NODES_SUBJECT
|
|
|
|
end,
|
|
|
|
send_wrapped_multiple(
|
|
|
|
jid:replace_resource(StateData#state.jid, FromNick),
|
2016-09-07 09:33:37 +02:00
|
|
|
get_users_and_subscribers(StateData),
|
2016-06-26 08:08:37 +02:00
|
|
|
NewPacket, Node, NewStateData1),
|
2015-10-07 00:06:58 +02:00
|
|
|
NewStateData2 = case has_body_or_subject(NewPacket) of
|
2015-06-26 21:33:32 +02:00
|
|
|
true ->
|
|
|
|
add_message_to_history(FromNick, From,
|
2015-08-06 12:33:39 +02:00
|
|
|
NewPacket,
|
2015-06-26 21:33:32 +02:00
|
|
|
NewStateData1);
|
|
|
|
false ->
|
|
|
|
NewStateData1
|
|
|
|
end,
|
|
|
|
{next_state, normal_state, NewStateData2}
|
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
_ ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = case (StateData#state.config)#config.allow_change_subj of
|
2013-03-14 10:33:02 +01:00
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
xmpp:err_forbidden(
|
|
|
|
<<"Only moderators and participants are "
|
|
|
|
"allowed to change the subject in this "
|
|
|
|
"room">>, Lang);
|
2013-03-14 10:33:02 +01:00
|
|
|
_ ->
|
2016-07-25 12:50:30 +02:00
|
|
|
xmpp:err_forbidden(
|
|
|
|
<<"Only moderators are allowed to change "
|
|
|
|
"the subject in this room">>, Lang)
|
2013-03-14 10:33:02 +01:00
|
|
|
end,
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2013-03-14 10:33:02 +01:00
|
|
|
{next_state, normal_state, StateData}
|
|
|
|
end;
|
|
|
|
true ->
|
|
|
|
ErrText = <<"Visitors are not allowed to send messages "
|
|
|
|
"to all occupants">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_forbidden(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2013-03-14 10:33:02 +01:00
|
|
|
{next_state, normal_state, StateData}
|
|
|
|
end;
|
|
|
|
false ->
|
2016-07-25 12:50:30 +02:00
|
|
|
ErrText = <<"Only occupants are allowed to send messages "
|
|
|
|
"to the conference">>,
|
|
|
|
Err = xmpp:err_not_acceptable(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2013-03-14 10:33:02 +01:00
|
|
|
{next_state, normal_state, StateData}
|
2007-06-25 18:43:42 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec process_normal_message(jid(), message(), state()) -> state().
|
|
|
|
process_normal_message(From, #message{lang = Lang} = Pkt, StateData) ->
|
2016-10-07 09:31:03 +02:00
|
|
|
Action = lists:foldl(
|
|
|
|
fun(_, {error, _} = Err) ->
|
|
|
|
Err;
|
2017-01-19 15:26:08 +01:00
|
|
|
(_, {ok, _} = Result) ->
|
|
|
|
Result;
|
|
|
|
(#muc_user{invites = [_|_] = Invites}, _) ->
|
|
|
|
case check_invitation(From, Invites, Lang, StateData) of
|
|
|
|
ok ->
|
|
|
|
{ok, Invites};
|
|
|
|
{error, _} = Err ->
|
|
|
|
Err
|
|
|
|
end;
|
2016-10-07 09:31:03 +02:00
|
|
|
(#xdata{type = submit, fields = Fs}, _) ->
|
|
|
|
try {ok, muc_request:decode(Fs)}
|
|
|
|
catch _:{muc_request, Why} ->
|
|
|
|
Txt = muc_request:format_error(Why),
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)}
|
|
|
|
end;
|
|
|
|
(_, Acc) ->
|
|
|
|
Acc
|
|
|
|
end, ok, xmpp:get_els(Pkt)),
|
|
|
|
case Action of
|
2017-01-19 15:26:08 +01:00
|
|
|
{ok, [#muc_invite{}|_] = Invitations} ->
|
|
|
|
lists:foldl(
|
|
|
|
fun(Invitation, AccState) ->
|
2018-09-21 16:37:52 +02:00
|
|
|
process_invitation(From, Pkt, Invitation, Lang, AccState)
|
2017-01-19 15:26:08 +01:00
|
|
|
end, StateData, Invitations);
|
2016-10-07 09:31:03 +02:00
|
|
|
{ok, [{role, participant}]} ->
|
|
|
|
process_voice_request(From, Pkt, StateData);
|
|
|
|
{ok, VoiceApproval} ->
|
|
|
|
process_voice_approval(From, Pkt, VoiceApproval, StateData);
|
|
|
|
{error, Err} ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Pkt, Err),
|
2016-10-07 09:31:03 +02:00
|
|
|
StateData;
|
|
|
|
ok ->
|
|
|
|
StateData
|
|
|
|
end.
|
|
|
|
|
2018-09-21 16:37:52 +02:00
|
|
|
-spec process_invitation(jid(), message(), muc_invite(), binary(), state()) -> state().
|
|
|
|
process_invitation(From, Pkt, Invitation, Lang, StateData) ->
|
|
|
|
IJID = route_invitation(From, Pkt, Invitation, Lang, StateData),
|
2017-01-19 15:26:08 +01:00
|
|
|
Config = StateData#state.config,
|
|
|
|
case Config#config.members_only of
|
|
|
|
true ->
|
|
|
|
case get_affiliation(IJID, StateData) of
|
|
|
|
none ->
|
|
|
|
NSD = set_affiliation(IJID, member, StateData),
|
|
|
|
send_affiliation(IJID, member, StateData),
|
|
|
|
store_room(NSD),
|
|
|
|
NSD;
|
|
|
|
_ ->
|
2016-10-07 09:31:03 +02:00
|
|
|
StateData
|
2017-01-19 15:26:08 +01:00
|
|
|
end;
|
|
|
|
false ->
|
|
|
|
StateData
|
2016-10-07 09:31:03 +02:00
|
|
|
end.
|
|
|
|
|
|
|
|
-spec process_voice_request(jid(), message(), state()) -> state().
|
|
|
|
process_voice_request(From, Pkt, StateData) ->
|
|
|
|
Lang = xmpp:get_lang(Pkt),
|
|
|
|
case (StateData#state.config)#config.allow_voice_requests of
|
|
|
|
true ->
|
|
|
|
MinInterval = (StateData#state.config)#config.voice_request_min_interval,
|
|
|
|
BareFrom = jid:remove_resource(jid:tolower(From)),
|
|
|
|
NowPriority = -p1_time_compat:system_time(micro_seconds),
|
|
|
|
CleanPriority = NowPriority + MinInterval * 1000000,
|
|
|
|
Times = clean_treap(StateData#state.last_voice_request_time,
|
|
|
|
CleanPriority),
|
|
|
|
case treap:lookup(BareFrom, Times) of
|
|
|
|
error ->
|
|
|
|
Times1 = treap:insert(BareFrom,
|
|
|
|
NowPriority,
|
|
|
|
true, Times),
|
|
|
|
NSD = StateData#state{last_voice_request_time = Times1},
|
|
|
|
send_voice_request(From, Lang, NSD),
|
|
|
|
NSD;
|
|
|
|
{ok, _, _} ->
|
|
|
|
ErrText = <<"Please, wait for a while before sending "
|
|
|
|
"new voice request">>,
|
2016-10-17 12:37:23 +02:00
|
|
|
Err = xmpp:err_resource_constraint(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Pkt, Err),
|
2016-10-07 09:31:03 +02:00
|
|
|
StateData#state{last_voice_request_time = Times}
|
2016-07-25 12:50:30 +02:00
|
|
|
end;
|
2016-10-07 09:31:03 +02:00
|
|
|
false ->
|
|
|
|
ErrText = <<"Voice requests are disabled in this conference">>,
|
|
|
|
Err = xmpp:err_forbidden(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Pkt, Err),
|
2016-10-07 09:31:03 +02:00
|
|
|
StateData
|
|
|
|
end.
|
|
|
|
|
|
|
|
-spec process_voice_approval(jid(), message(), [muc_request:property()], state()) -> state().
|
|
|
|
process_voice_approval(From, Pkt, VoiceApproval, StateData) ->
|
|
|
|
Lang = xmpp:get_lang(Pkt),
|
|
|
|
case is_moderator(From, StateData) of
|
|
|
|
true ->
|
|
|
|
case lists:keyfind(jid, 1, VoiceApproval) of
|
|
|
|
{_, TargetJid} ->
|
|
|
|
Allow = proplists:get_bool(request_allow, VoiceApproval),
|
|
|
|
case is_visitor(TargetJid, StateData) of
|
|
|
|
true when Allow ->
|
|
|
|
Reason = <<>>,
|
|
|
|
NSD = set_role(TargetJid, participant, StateData),
|
|
|
|
catch send_new_presence(
|
|
|
|
TargetJid, Reason, NSD, StateData),
|
|
|
|
NSD;
|
|
|
|
_ ->
|
|
|
|
StateData
|
2016-07-25 12:50:30 +02:00
|
|
|
end;
|
2016-10-07 09:31:03 +02:00
|
|
|
false ->
|
|
|
|
ErrText = <<"Failed to extract JID from your voice "
|
|
|
|
"request approval">>,
|
|
|
|
Err = xmpp:err_bad_request(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Pkt, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData
|
|
|
|
end;
|
2016-10-07 09:31:03 +02:00
|
|
|
false ->
|
|
|
|
ErrText = <<"Only moderators can approve voice requests">>,
|
|
|
|
Err = xmpp:err_not_allowed(ErrText, Lang),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Pkt, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData
|
|
|
|
end.
|
|
|
|
|
2018-11-29 10:16:12 +01:00
|
|
|
-spec direct_iq_type(iq()) -> vcard | ping | request | response | stanza_error().
|
|
|
|
direct_iq_type(#iq{type = T, sub_els = SubEls, lang = Lang}) when T == get; T == set ->
|
|
|
|
case SubEls of
|
|
|
|
[El] ->
|
|
|
|
case xmpp:get_ns(El) of
|
|
|
|
?NS_VCARD when T == get -> vcard;
|
|
|
|
?NS_PING when T == get -> ping;
|
|
|
|
_ -> request
|
|
|
|
end;
|
|
|
|
[] ->
|
|
|
|
xmpp:err_bad_request(?T("No child elements found"), Lang);
|
|
|
|
[_|_] ->
|
|
|
|
xmpp:err_bad_request(?T("Too many child elements"), Lang)
|
|
|
|
end;
|
|
|
|
direct_iq_type(#iq{}) ->
|
|
|
|
response.
|
2017-11-10 16:02:22 +01:00
|
|
|
|
2008-06-13 20:55:26 +02:00
|
|
|
%% @doc Check if this non participant can send message to room.
|
|
|
|
%%
|
|
|
|
%% XEP-0045 v1.23:
|
|
|
|
%% 7.9 Sending a Message to All Occupants
|
|
|
|
%% an implementation MAY allow users with certain privileges
|
|
|
|
%% (e.g., a room owner, room admin, or service-level admin)
|
|
|
|
%% to send messages to the room even if those users are not occupants.
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_user_allowed_message_nonparticipant(jid(), state()) -> boolean().
|
2013-03-14 10:33:02 +01:00
|
|
|
is_user_allowed_message_nonparticipant(JID,
|
|
|
|
StateData) ->
|
2008-07-17 19:32:11 +02:00
|
|
|
case get_service_affiliation(JID, StateData) of
|
2013-03-14 10:33:02 +01:00
|
|
|
owner -> true;
|
|
|
|
_ -> false
|
2008-06-13 20:55:26 +02:00
|
|
|
end.
|
|
|
|
|
|
|
|
%% @doc Get information of this participant, or default values.
|
|
|
|
%% If the JID is not a participant, return values for a service message.
|
2016-11-12 11:27:15 +01:00
|
|
|
-spec get_participant_data(jid(), state()) -> {binary(), role()}.
|
2008-06-13 20:55:26 +02:00
|
|
|
get_participant_data(From, StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(jid:tolower(From), StateData#state.users) of
|
|
|
|
#user{nick = FromNick, role = Role} ->
|
|
|
|
{FromNick, Role}
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(jid:tolower(jid:remove_resource(From)),
|
|
|
|
StateData#state.subscribers) of
|
|
|
|
#subscriber{nick = FromNick} ->
|
|
|
|
{FromNick, none}
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2016-09-08 15:39:34 +02:00
|
|
|
{<<"">>, moderator}
|
|
|
|
end
|
2008-06-13 20:55:26 +02:00
|
|
|
end.
|
|
|
|
|
2017-02-24 19:25:25 +01:00
|
|
|
-spec process_presence(binary(), presence(), state()) -> fsm_transition().
|
|
|
|
process_presence(Nick, #presence{from = From, type = Type0} = Packet0, StateData) ->
|
2015-08-04 20:13:00 +02:00
|
|
|
IsOnline = is_user_online(From, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
if Type0 == available;
|
|
|
|
IsOnline and ((Type0 == unavailable) or (Type0 == error)) ->
|
2015-08-04 20:13:00 +02:00
|
|
|
case ejabberd_hooks:run_fold(muc_filter_presence,
|
|
|
|
StateData#state.server_host,
|
|
|
|
Packet0,
|
2017-02-24 19:25:25 +01:00
|
|
|
[StateData, Nick]) of
|
2015-08-04 20:13:00 +02:00
|
|
|
drop ->
|
|
|
|
{next_state, normal_state, StateData};
|
2016-07-25 12:50:30 +02:00
|
|
|
#presence{} = Packet ->
|
|
|
|
close_room_if_temporary_and_empty(
|
2017-02-24 19:25:25 +01:00
|
|
|
do_process_presence(Nick, Packet, StateData))
|
2015-08-04 20:13:00 +02:00
|
|
|
end;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{next_state, normal_state, StateData}
|
2015-08-04 20:13:00 +02:00
|
|
|
end.
|
2014-05-05 13:50:52 +02:00
|
|
|
|
2017-02-24 19:25:25 +01:00
|
|
|
-spec do_process_presence(binary(), presence(), state()) -> state().
|
|
|
|
do_process_presence(Nick, #presence{from = From, type = available, lang = Lang} = Packet,
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData) ->
|
|
|
|
case is_user_online(From, StateData) of
|
|
|
|
false ->
|
|
|
|
add_new_user(From, Nick, Packet, StateData);
|
|
|
|
true ->
|
|
|
|
case is_nick_change(From, Nick, StateData) of
|
|
|
|
true ->
|
|
|
|
case {nick_collision(From, Nick, StateData),
|
|
|
|
mod_muc:can_use_nick(StateData#state.server_host,
|
|
|
|
StateData#state.host,
|
|
|
|
From, Nick),
|
|
|
|
{(StateData#state.config)#config.allow_visitor_nickchange,
|
|
|
|
is_visitor(From, StateData)}} of
|
|
|
|
{_, _, {false, true}} ->
|
2017-12-09 21:13:20 +01:00
|
|
|
Packet1 = Packet#presence{sub_els = [#muc{}]},
|
2016-07-25 12:50:30 +02:00
|
|
|
ErrText = <<"Visitors are not allowed to change their "
|
|
|
|
"nicknames in this room">>,
|
|
|
|
Err = xmpp:err_not_allowed(ErrText, Lang),
|
2017-12-09 21:13:20 +01:00
|
|
|
ejabberd_router:route_error(Packet1, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData;
|
|
|
|
{true, _, _} ->
|
2017-12-09 21:13:20 +01:00
|
|
|
Packet1 = Packet#presence{sub_els = [#muc{}]},
|
2016-07-25 12:50:30 +02:00
|
|
|
ErrText = <<"That nickname is already in use by another "
|
|
|
|
"occupant">>,
|
|
|
|
Err = xmpp:err_conflict(ErrText, Lang),
|
2017-12-09 21:13:20 +01:00
|
|
|
ejabberd_router:route_error(Packet1, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData;
|
|
|
|
{_, false, _} ->
|
2017-12-09 21:13:20 +01:00
|
|
|
Packet1 = Packet#presence{sub_els = [#muc{}]},
|
2016-07-25 12:50:30 +02:00
|
|
|
ErrText = <<"That nickname is registered by another "
|
|
|
|
"person">>,
|
|
|
|
Err = xmpp:err_conflict(ErrText, Lang),
|
2017-12-09 21:13:20 +01:00
|
|
|
ejabberd_router:route_error(Packet1, Err),
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData;
|
|
|
|
_ ->
|
|
|
|
change_nick(From, Nick, StateData)
|
|
|
|
end;
|
2016-11-12 11:27:15 +01:00
|
|
|
false ->
|
|
|
|
Stanza = maybe_strip_status_from_presence(
|
|
|
|
From, Packet, StateData),
|
|
|
|
NewState = add_user_presence(From, Stanza,
|
|
|
|
StateData),
|
2017-10-09 16:59:22 +02:00
|
|
|
case xmpp:has_subtag(Packet, #muc{}) of
|
|
|
|
true ->
|
|
|
|
send_initial_presences_and_messages(
|
|
|
|
From, Nick, Packet, NewState, StateData);
|
|
|
|
false ->
|
|
|
|
send_new_presence(From, NewState, StateData)
|
|
|
|
end,
|
2016-11-12 11:27:15 +01:00
|
|
|
NewState
|
2016-07-25 12:50:30 +02:00
|
|
|
end
|
|
|
|
end;
|
2017-02-24 19:25:25 +01:00
|
|
|
do_process_presence(Nick, #presence{from = From, type = unavailable} = Packet,
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData) ->
|
|
|
|
NewPacket = case {(StateData#state.config)#config.allow_visitor_status,
|
|
|
|
is_visitor(From, StateData)} of
|
|
|
|
{false, true} ->
|
|
|
|
strip_status(Packet);
|
|
|
|
_ -> Packet
|
|
|
|
end,
|
|
|
|
NewState = add_user_presence_un(From, NewPacket, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
case maps:get(Nick, StateData#state.nicks, []) of
|
|
|
|
[_, _ | _] ->
|
2017-09-28 10:56:46 +02:00
|
|
|
Aff = get_affiliation(From, StateData),
|
|
|
|
Item = #muc_item{affiliation = Aff, role = none, jid = From},
|
|
|
|
Pres = xmpp:set_subtag(
|
|
|
|
Packet, #muc_user{items = [Item],
|
|
|
|
status_codes = [110]}),
|
|
|
|
send_wrapped(jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
From, Pres, ?NS_MUCSUB_NODES_PRESENCE, StateData);
|
|
|
|
_ ->
|
|
|
|
send_new_presence(From, NewState, StateData)
|
2016-07-25 12:50:30 +02:00
|
|
|
end,
|
|
|
|
Reason = xmpp:get_text(NewPacket#presence.status),
|
2016-11-12 11:27:15 +01:00
|
|
|
remove_online_user(From, NewState, Reason);
|
2017-02-24 19:25:25 +01:00
|
|
|
do_process_presence(_Nick, #presence{from = From, type = error, lang = Lang} = Packet,
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData) ->
|
|
|
|
ErrorText = <<"It is not allowed to send error messages to the"
|
|
|
|
" room. The participant (~s) has sent an error "
|
|
|
|
"message (~s) and got kicked from the room">>,
|
|
|
|
expulse_participant(Packet, From, StateData,
|
|
|
|
translate:translate(Lang, ErrorText)).
|
|
|
|
|
|
|
|
-spec maybe_strip_status_from_presence(jid(), presence(),
|
|
|
|
state()) -> presence().
|
2016-06-26 08:08:37 +02:00
|
|
|
maybe_strip_status_from_presence(From, Packet, StateData) ->
|
|
|
|
case {(StateData#state.config)#config.allow_visitor_status,
|
|
|
|
is_visitor(From, StateData)} of
|
|
|
|
{false, true} ->
|
|
|
|
strip_status(Packet);
|
|
|
|
_Allowed -> Packet
|
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec close_room_if_temporary_and_empty(state()) -> fsm_transition().
|
2014-05-05 13:50:52 +02:00
|
|
|
close_room_if_temporary_and_empty(StateData1) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
case not (StateData1#state.config)#config.persistent
|
2018-11-15 12:13:45 +01:00
|
|
|
andalso maps:size(StateData1#state.users) == 0
|
|
|
|
andalso maps:size(StateData1#state.subscribers) == 0 of
|
2013-03-14 10:33:02 +01:00
|
|
|
true ->
|
|
|
|
?INFO_MSG("Destroyed MUC room ~s because it's temporary "
|
|
|
|
"and empty",
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(StateData1#state.jid)]),
|
2014-05-05 13:50:52 +02:00
|
|
|
add_to_log(room_existence, destroyed, StateData1),
|
2013-03-14 10:33:02 +01:00
|
|
|
{stop, normal, StateData1};
|
|
|
|
_ -> {next_state, normal_state, StateData1}
|
2007-06-25 18:43:42 +02:00
|
|
|
end.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2018-11-15 12:13:45 +01:00
|
|
|
-spec get_users_and_subscribers(state()) -> map().
|
2016-09-07 09:33:37 +02:00
|
|
|
get_users_and_subscribers(StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
OnlineSubscribers = maps:fold(
|
2016-09-07 09:33:37 +02:00
|
|
|
fun(LJID, _, Acc) ->
|
|
|
|
LBareJID = jid:remove_resource(LJID),
|
|
|
|
case is_subscriber(LBareJID, StateData) of
|
|
|
|
true ->
|
|
|
|
?SETS:add_element(LBareJID, Acc);
|
|
|
|
false ->
|
|
|
|
Acc
|
|
|
|
end
|
|
|
|
end, ?SETS:new(), StateData#state.users),
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
2016-09-07 09:33:37 +02:00
|
|
|
fun(LBareJID, #subscriber{nick = Nick}, Acc) ->
|
|
|
|
case ?SETS:is_element(LBareJID, OnlineSubscribers) of
|
|
|
|
false ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:put(LBareJID,
|
|
|
|
#user{jid = jid:make(LBareJID),
|
|
|
|
nick = Nick,
|
|
|
|
role = none,
|
|
|
|
last_presence = undefined},
|
|
|
|
Acc);
|
2016-09-07 09:33:37 +02:00
|
|
|
true ->
|
|
|
|
Acc
|
|
|
|
end
|
|
|
|
end, StateData#state.users, StateData#state.subscribers).
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_user_online(jid(), state()) -> boolean().
|
2003-03-23 21:08:44 +01:00
|
|
|
is_user_online(JID, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:is_key(LJID, StateData#state.users).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_subscriber(jid(), state()) -> boolean().
|
2016-06-26 08:08:37 +02:00
|
|
|
is_subscriber(JID, StateData) ->
|
2016-09-07 09:33:37 +02:00
|
|
|
LJID = jid:tolower(jid:remove_resource(JID)),
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:is_key(LJID, StateData#state.subscribers).
|
2016-06-26 08:08:37 +02:00
|
|
|
|
2010-03-29 20:51:04 +02:00
|
|
|
%% Check if the user is occupant of the room, or at least is an admin or owner.
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_occupant_or_admin(jid(), state()) -> boolean().
|
2010-03-29 20:51:04 +02:00
|
|
|
is_occupant_or_admin(JID, StateData) ->
|
2010-03-29 20:51:24 +02:00
|
|
|
FAffiliation = get_affiliation(JID, StateData),
|
|
|
|
FRole = get_role(JID, StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
case FRole /= none orelse
|
2013-06-21 11:43:23 +02:00
|
|
|
FAffiliation == member orelse
|
2013-03-14 10:33:02 +01:00
|
|
|
FAffiliation == admin orelse FAffiliation == owner
|
|
|
|
of
|
|
|
|
true -> true;
|
|
|
|
_ -> false
|
2010-03-29 20:51:24 +02:00
|
|
|
end.
|
2009-12-01 21:00:15 +01:00
|
|
|
|
2008-01-29 15:49:08 +01:00
|
|
|
%% Decide the fate of the message and its sender
|
|
|
|
%% Returns: continue_delivery | forget_message | {expulse_sender, Reason}
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec decide_fate_message(message(), jid(), state()) ->
|
|
|
|
continue_delivery | forget_message |
|
|
|
|
{expulse_sender, binary()}.
|
2016-07-31 07:51:47 +02:00
|
|
|
decide_fate_message(#message{type = error} = Msg,
|
2016-07-25 12:50:30 +02:00
|
|
|
From, StateData) ->
|
2016-07-31 07:51:47 +02:00
|
|
|
Err = xmpp:get_error(Msg),
|
2016-07-25 12:50:30 +02:00
|
|
|
PD = case check_error_kick(Err) of
|
2013-03-14 10:33:02 +01:00
|
|
|
%% If this is an error stanza and its condition matches a criteria
|
|
|
|
true ->
|
2016-10-17 12:37:23 +02:00
|
|
|
Reason = str:format("This participant is considered a ghost "
|
|
|
|
"and is expulsed: ~s",
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(From)]),
|
2013-03-14 10:33:02 +01:00
|
|
|
{expulse_sender, Reason};
|
|
|
|
false -> continue_delivery
|
2008-01-29 19:37:45 +01:00
|
|
|
end,
|
|
|
|
case PD of
|
2013-03-14 10:33:02 +01:00
|
|
|
{expulse_sender, R} ->
|
|
|
|
case is_user_online(From, StateData) of
|
|
|
|
true -> {expulse_sender, R};
|
|
|
|
false -> forget_message
|
|
|
|
end;
|
|
|
|
Other -> Other
|
2008-01-29 15:49:08 +01:00
|
|
|
end;
|
2016-07-25 12:50:30 +02:00
|
|
|
decide_fate_message(_, _, _) -> continue_delivery.
|
2008-01-29 15:49:08 +01:00
|
|
|
|
|
|
|
%% Check if the elements of this error stanza indicate
|
|
|
|
%% that the sender is a dead participant.
|
|
|
|
%% If so, return true to kick the participant.
|
2016-09-08 16:08:48 +02:00
|
|
|
-spec check_error_kick(stanza_error()) -> boolean().
|
|
|
|
check_error_kick(#stanza_error{reason = Reason}) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
case Reason of
|
|
|
|
#gone{} -> true;
|
|
|
|
'internal-server-error' -> true;
|
|
|
|
'item-not-found' -> true;
|
|
|
|
'jid-malformed' -> true;
|
|
|
|
'recipient-unavailable' -> true;
|
|
|
|
#redirect{} -> true;
|
|
|
|
'remote-server-not-found' -> true;
|
|
|
|
'remote-server-timeout' -> true;
|
|
|
|
'service-unavailable' -> true;
|
|
|
|
_ -> false
|
|
|
|
end;
|
|
|
|
check_error_kick(undefined) ->
|
|
|
|
false.
|
2013-03-14 10:33:02 +01:00
|
|
|
|
2016-09-08 16:08:48 +02:00
|
|
|
-spec get_error_condition(stanza_error()) -> string().
|
|
|
|
get_error_condition(#stanza_error{reason = Reason}) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
case Reason of
|
|
|
|
#gone{} -> "gone";
|
|
|
|
#redirect{} -> "redirect";
|
|
|
|
Atom -> atom_to_list(Atom)
|
|
|
|
end;
|
|
|
|
get_error_condition(undefined) ->
|
|
|
|
"undefined".
|
2008-02-09 11:38:47 +01:00
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec get_error_text(stanza_error()) -> binary().
|
|
|
|
get_error_text(#stanza_error{text = Txt}) ->
|
2017-10-13 19:48:21 +02:00
|
|
|
xmpp:get_text(Txt).
|
2016-08-09 12:36:43 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec make_reason(stanza(), jid(), state(), binary()) -> binary().
|
2015-12-23 19:34:23 +01:00
|
|
|
make_reason(Packet, From, StateData, Reason1) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = FromNick} = maps:get(jid:tolower(From), StateData#state.users),
|
2016-07-25 12:50:30 +02:00
|
|
|
Condition = get_error_condition(xmpp:get_error(Packet)),
|
2016-10-17 12:37:23 +02:00
|
|
|
str:format(Reason1, [FromNick, Condition]).
|
2015-12-23 19:34:23 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec expulse_participant(stanza(), jid(), state(), binary()) ->
|
|
|
|
state().
|
2008-02-09 11:38:47 +01:00
|
|
|
expulse_participant(Packet, From, StateData, Reason1) ->
|
2015-12-23 19:34:23 +01:00
|
|
|
Reason2 = make_reason(Packet, From, StateData, Reason1),
|
2013-03-14 10:33:02 +01:00
|
|
|
NewState = add_user_presence_un(From,
|
2016-07-25 12:50:30 +02:00
|
|
|
#presence{type = unavailable,
|
|
|
|
status = xmpp:mk_text(Reason2)},
|
2013-03-14 10:33:02 +01:00
|
|
|
StateData),
|
2017-09-26 18:01:54 +02:00
|
|
|
LJID = jid:tolower(From),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = Nick} = maps:get(LJID, StateData#state.users),
|
|
|
|
case maps:get(Nick, StateData#state.nicks, []) of
|
|
|
|
[_, _ | _] ->
|
2017-10-13 08:17:22 +02:00
|
|
|
Aff = get_affiliation(From, StateData),
|
|
|
|
Item = #muc_item{affiliation = Aff, role = none, jid = From},
|
|
|
|
Pres = xmpp:set_subtag(
|
|
|
|
Packet, #muc_user{items = [Item],
|
|
|
|
status_codes = [110]}),
|
|
|
|
send_wrapped(jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
From, Pres, ?NS_MUCSUB_NODES_PRESENCE, StateData);
|
|
|
|
_ ->
|
|
|
|
send_new_presence(From, NewState, StateData)
|
2017-09-26 18:01:54 +02:00
|
|
|
end,
|
2016-09-07 09:33:37 +02:00
|
|
|
remove_online_user(From, NewState).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2017-11-27 11:07:10 +01:00
|
|
|
-spec get_owners(state()) -> [jid:jid()].
|
|
|
|
get_owners(StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
2017-11-27 11:07:10 +01:00
|
|
|
fun(LJID, owner, Acc) ->
|
|
|
|
[jid:make(LJID)|Acc];
|
|
|
|
(LJID, {owner, _}, Acc) ->
|
|
|
|
[jid:make(LJID)|Acc];
|
|
|
|
(_, _, Acc) ->
|
|
|
|
Acc
|
|
|
|
end, [], StateData#state.affiliations).
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec set_affiliation(jid(), affiliation(), state()) -> state().
|
2003-03-23 21:08:44 +01:00
|
|
|
set_affiliation(JID, Affiliation, StateData) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
set_affiliation(JID, Affiliation, StateData, <<"">>).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec set_affiliation(jid(), affiliation(), state(), binary()) -> state().
|
2018-04-23 10:35:43 +02:00
|
|
|
set_affiliation(JID, Affiliation,
|
|
|
|
#state{config = #config{persistent = false}} = StateData,
|
|
|
|
Reason) ->
|
|
|
|
set_affiliation_fallback(JID, Affiliation, StateData, Reason);
|
2011-09-05 12:53:01 +02:00
|
|
|
set_affiliation(JID, Affiliation, StateData, Reason) ->
|
2018-04-23 10:35:43 +02:00
|
|
|
ServerHost = StateData#state.server_host,
|
|
|
|
Room = StateData#state.room,
|
|
|
|
Host = StateData#state.host,
|
|
|
|
Mod = gen_mod:db_mod(ServerHost, mod_muc),
|
|
|
|
case Mod:set_affiliation(ServerHost, Room, Host, JID, Affiliation, Reason) of
|
|
|
|
ok ->
|
|
|
|
StateData;
|
|
|
|
{error, _} ->
|
|
|
|
set_affiliation_fallback(JID, Affiliation, StateData, Reason)
|
|
|
|
end.
|
|
|
|
|
|
|
|
-spec set_affiliation_fallback(jid(), affiliation(), state(), binary()) -> state().
|
|
|
|
set_affiliation_fallback(JID, Affiliation, StateData, Reason) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:remove_resource(jid:tolower(JID)),
|
2005-05-04 01:07:14 +02:00
|
|
|
Affiliations = case Affiliation of
|
2018-04-23 10:35:43 +02:00
|
|
|
none ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:remove(LJID, StateData#state.affiliations);
|
2018-04-23 10:35:43 +02:00
|
|
|
_ ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:put(LJID, {Affiliation, Reason},
|
|
|
|
StateData#state.affiliations)
|
2005-05-04 01:07:14 +02:00
|
|
|
end,
|
|
|
|
StateData#state{affiliations = Affiliations}.
|
|
|
|
|
2018-11-15 12:13:45 +01:00
|
|
|
-spec set_affiliations(map(), state()) -> state().
|
2018-04-23 10:35:43 +02:00
|
|
|
set_affiliations(Affiliations,
|
|
|
|
#state{config = #config{persistent = false}} = StateData) ->
|
|
|
|
set_affiliations_fallback(Affiliations, StateData);
|
|
|
|
set_affiliations(Affiliations, StateData) ->
|
|
|
|
Room = StateData#state.room,
|
|
|
|
Host = StateData#state.host,
|
|
|
|
ServerHost = StateData#state.server_host,
|
|
|
|
Mod = gen_mod:db_mod(ServerHost, mod_muc),
|
|
|
|
case Mod:set_affiliations(ServerHost, Room, Host, Affiliations) of
|
|
|
|
ok ->
|
|
|
|
StateData;
|
|
|
|
{error, _} ->
|
|
|
|
set_affiliations_fallback(Affiliations, StateData)
|
|
|
|
end.
|
|
|
|
|
2018-11-15 12:13:45 +01:00
|
|
|
-spec set_affiliations_fallback(map(), state()) -> state().
|
2018-04-23 10:35:43 +02:00
|
|
|
set_affiliations_fallback(Affiliations, StateData) ->
|
|
|
|
StateData#state{affiliations = Affiliations}.
|
|
|
|
|
2018-04-24 11:07:10 +02:00
|
|
|
-spec get_affiliation(ljid() | jid(), state()) -> affiliation().
|
|
|
|
get_affiliation(#jid{} = JID, StateData) ->
|
2018-04-23 10:35:43 +02:00
|
|
|
case get_service_affiliation(JID, StateData) of
|
|
|
|
owner ->
|
|
|
|
owner;
|
|
|
|
none ->
|
|
|
|
case do_get_affiliation(JID, StateData) of
|
|
|
|
{Affiliation, _Reason} -> Affiliation;
|
|
|
|
Affiliation -> Affiliation
|
|
|
|
end
|
2018-04-24 11:07:10 +02:00
|
|
|
end;
|
|
|
|
get_affiliation(LJID, StateData) ->
|
|
|
|
get_affiliation(jid:make(LJID), StateData).
|
2018-04-23 10:35:43 +02:00
|
|
|
|
|
|
|
-spec do_get_affiliation(jid(), state()) -> affiliation().
|
|
|
|
do_get_affiliation(JID, #state{config = #config{persistent = false}} = StateData) ->
|
|
|
|
do_get_affiliation_fallback(JID, StateData);
|
|
|
|
do_get_affiliation(JID, StateData) ->
|
|
|
|
Room = StateData#state.room,
|
|
|
|
Host = StateData#state.host,
|
|
|
|
LServer = JID#jid.lserver,
|
|
|
|
LUser = JID#jid.luser,
|
|
|
|
ServerHost = StateData#state.server_host,
|
|
|
|
Mod = gen_mod:db_mod(ServerHost, mod_muc),
|
|
|
|
case Mod:get_affiliation(ServerHost, Room, Host, LUser, LServer) of
|
|
|
|
{error, _} ->
|
|
|
|
do_get_affiliation_fallback(JID, StateData);
|
|
|
|
{ok, Affiliation} ->
|
|
|
|
Affiliation
|
|
|
|
end.
|
|
|
|
|
|
|
|
-spec do_get_affiliation_fallback(jid(), state()) -> affiliation().
|
|
|
|
do_get_affiliation_fallback(JID, StateData) ->
|
|
|
|
LJID = jid:tolower(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(LJID, StateData#state.affiliations)
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
BareLJID = jid:remove_resource(LJID),
|
|
|
|
try maps:get(BareLJID, StateData#state.affiliations)
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
DomainLJID = setelement(1, LJID, <<"">>),
|
|
|
|
try maps:get(DomainLJID, StateData#state.affiliations)
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
DomainBareLJID = jid:remove_resource(DomainLJID),
|
|
|
|
try maps:get(DomainBareLJID, StateData#state.affiliations)
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} -> none
|
2018-04-23 10:35:43 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end.
|
|
|
|
|
2018-11-15 12:13:45 +01:00
|
|
|
-spec get_affiliations(state()) -> map().
|
2018-04-23 10:35:43 +02:00
|
|
|
get_affiliations(#state{config = #config{persistent = false}} = StateData) ->
|
|
|
|
get_affiliations_callback(StateData);
|
|
|
|
get_affiliations(StateData) ->
|
|
|
|
Room = StateData#state.room,
|
|
|
|
Host = StateData#state.host,
|
|
|
|
ServerHost = StateData#state.server_host,
|
|
|
|
Mod = gen_mod:db_mod(ServerHost, mod_muc),
|
|
|
|
case Mod:get_affiliations(ServerHost, Room, Host) of
|
|
|
|
{error, _} ->
|
|
|
|
get_affiliations_callback(StateData);
|
|
|
|
{ok, Affiliations} ->
|
|
|
|
Affiliations
|
2003-03-23 21:08:44 +01:00
|
|
|
end.
|
|
|
|
|
2018-11-15 12:13:45 +01:00
|
|
|
-spec get_affiliations_callback(state()) -> map().
|
2018-04-23 10:35:43 +02:00
|
|
|
get_affiliations_callback(StateData) ->
|
|
|
|
StateData#state.affiliations.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_service_affiliation(jid(), state()) -> owner | none.
|
2007-08-29 19:54:45 +02:00
|
|
|
get_service_affiliation(JID, StateData) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
{_AccessRoute, _AccessCreate, AccessAdmin,
|
|
|
|
_AccessPersistent} =
|
2007-08-29 19:54:45 +02:00
|
|
|
StateData#state.access,
|
2013-03-14 10:33:02 +01:00
|
|
|
case acl:match_rule(StateData#state.server_host,
|
|
|
|
AccessAdmin, JID)
|
|
|
|
of
|
|
|
|
allow -> owner;
|
|
|
|
_ -> none
|
2007-08-29 19:54:45 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec set_role(jid(), role(), state()) -> state().
|
2003-03-23 21:08:44 +01:00
|
|
|
set_role(JID, Role, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2003-04-13 21:22:46 +02:00
|
|
|
LJIDs = case LJID of
|
2013-03-14 10:33:02 +01:00
|
|
|
{U, S, <<"">>} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(fun (J, _, Js) ->
|
|
|
|
case J of
|
|
|
|
{U, S, _} -> [J | Js];
|
|
|
|
_ -> Js
|
|
|
|
end
|
|
|
|
end, [], StateData#state.users);
|
2009-08-21 15:22:18 +02:00
|
|
|
_ ->
|
2018-11-15 12:13:45 +01:00
|
|
|
case maps:is_key(LJID, StateData#state.users) of
|
2013-03-14 10:33:02 +01:00
|
|
|
true -> [LJID];
|
|
|
|
_ -> []
|
|
|
|
end
|
|
|
|
end,
|
2018-11-15 12:13:45 +01:00
|
|
|
{Users, Nicks} =
|
|
|
|
case Role of
|
|
|
|
none ->
|
|
|
|
lists:foldl(
|
|
|
|
fun (J, {Us, Ns}) ->
|
|
|
|
NewNs = try maps:get(J, Us) of
|
|
|
|
#user{nick = Nick} ->
|
|
|
|
maps:remove(Nick, Ns)
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
Ns
|
|
|
|
end,
|
|
|
|
{maps:remove(J, Us), NewNs}
|
|
|
|
end,
|
|
|
|
{StateData#state.users, StateData#state.nicks}, LJIDs);
|
|
|
|
_ ->
|
|
|
|
{lists:foldl(
|
|
|
|
fun (J, Us) ->
|
|
|
|
User = maps:get(J, Us),
|
|
|
|
if User#user.last_presence == undefined ->
|
|
|
|
Us;
|
|
|
|
true ->
|
|
|
|
maps:put(J, User#user{role = Role}, Us)
|
|
|
|
end
|
|
|
|
end, StateData#state.users, LJIDs),
|
|
|
|
StateData#state.nicks}
|
|
|
|
end,
|
2009-08-21 15:22:18 +02:00
|
|
|
StateData#state{users = Users, nicks = Nicks}.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_role(jid(), state()) -> role().
|
2003-03-23 21:08:44 +01:00
|
|
|
get_role(JID, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(LJID, StateData#state.users) of
|
|
|
|
#user{role = Role} -> Role
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} -> none
|
2003-03-23 21:08:44 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_default_role(affiliation(), state()) -> role().
|
2003-03-23 21:08:44 +01:00
|
|
|
get_default_role(Affiliation, StateData) ->
|
|
|
|
case Affiliation of
|
2013-03-14 10:33:02 +01:00
|
|
|
owner -> moderator;
|
|
|
|
admin -> moderator;
|
|
|
|
member -> participant;
|
|
|
|
outcast -> none;
|
|
|
|
none ->
|
|
|
|
case (StateData#state.config)#config.members_only of
|
|
|
|
true -> none;
|
|
|
|
_ ->
|
|
|
|
case (StateData#state.config)#config.members_by_default
|
|
|
|
of
|
|
|
|
true -> participant;
|
|
|
|
_ -> visitor
|
|
|
|
end
|
|
|
|
end
|
2003-03-23 21:08:44 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_visitor(jid(), state()) -> boolean().
|
2008-07-23 14:31:55 +02:00
|
|
|
is_visitor(Jid, StateData) ->
|
2008-08-24 01:17:17 +02:00
|
|
|
get_role(Jid, StateData) =:= visitor.
|
2008-07-23 14:31:55 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_moderator(jid(), state()) -> boolean().
|
2011-07-11 17:33:26 +02:00
|
|
|
is_moderator(Jid, StateData) ->
|
|
|
|
get_role(Jid, StateData) =:= moderator.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_max_users(state()) -> non_neg_integer().
|
2007-08-29 19:54:45 +02:00
|
|
|
get_max_users(StateData) ->
|
|
|
|
MaxUsers = (StateData#state.config)#config.max_users,
|
|
|
|
ServiceMaxUsers = get_service_max_users(StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
if MaxUsers =< ServiceMaxUsers -> MaxUsers;
|
|
|
|
true -> ServiceMaxUsers
|
2007-08-29 19:54:45 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_service_max_users(state()) -> pos_integer().
|
2007-08-29 19:54:45 +02:00
|
|
|
get_service_max_users(StateData) ->
|
|
|
|
gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, max_users).
|
2007-08-29 19:54:45 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_max_users_admin_threshold(state()) -> pos_integer().
|
2007-08-29 19:54:45 +02:00
|
|
|
get_max_users_admin_threshold(StateData) ->
|
|
|
|
gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, max_users_admin_threshold).
|
2007-08-29 19:54:45 +02:00
|
|
|
|
2018-07-05 08:31:55 +02:00
|
|
|
-spec room_queue_new(binary(), ejabberd_shaper:shaper(), _) -> p1_queue:queue().
|
2017-03-10 13:12:43 +01:00
|
|
|
room_queue_new(ServerHost, Shaper, QueueType) ->
|
|
|
|
HaveRoomShaper = Shaper /= none,
|
|
|
|
HaveMessageShaper = gen_mod:get_module_opt(
|
2018-01-23 08:54:52 +01:00
|
|
|
ServerHost, mod_muc,
|
|
|
|
user_message_shaper) /= none,
|
2017-03-10 13:12:43 +01:00
|
|
|
HavePresenceShaper = gen_mod:get_module_opt(
|
2018-01-23 08:54:52 +01:00
|
|
|
ServerHost, mod_muc,
|
|
|
|
user_presence_shaper) /= none,
|
2017-03-10 13:12:43 +01:00
|
|
|
HaveMinMessageInterval = gen_mod:get_module_opt(
|
2018-01-23 08:54:52 +01:00
|
|
|
ServerHost, mod_muc,
|
|
|
|
min_message_interval) /= 0,
|
2017-03-10 13:12:43 +01:00
|
|
|
HaveMinPresenceInterval = gen_mod:get_module_opt(
|
2018-01-23 08:54:52 +01:00
|
|
|
ServerHost, mod_muc,
|
|
|
|
min_presence_interval) /= 0,
|
2017-03-10 13:12:43 +01:00
|
|
|
if HaveRoomShaper or HaveMessageShaper or HavePresenceShaper
|
|
|
|
or HaveMinMessageInterval or HaveMinPresenceInterval ->
|
|
|
|
p1_queue:new(QueueType);
|
|
|
|
true ->
|
|
|
|
undefined
|
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_user_activity(jid(), state()) -> #activity{}.
|
2007-09-01 23:05:04 +02:00
|
|
|
get_user_activity(JID, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
case treap:lookup(jid:tolower(JID),
|
2013-03-14 10:33:02 +01:00
|
|
|
StateData#state.activity)
|
|
|
|
of
|
|
|
|
{ok, _P, A} -> A;
|
|
|
|
error ->
|
|
|
|
MessageShaper =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:new(gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, user_message_shaper)),
|
2013-03-14 10:33:02 +01:00
|
|
|
PresenceShaper =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:new(gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, user_presence_shaper)),
|
2013-03-14 10:33:02 +01:00
|
|
|
#activity{message_shaper = MessageShaper,
|
|
|
|
presence_shaper = PresenceShaper}
|
2007-09-01 23:05:04 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec store_user_activity(jid(), #activity{}, state()) -> state().
|
2008-11-28 17:06:39 +01:00
|
|
|
store_user_activity(JID, UserActivity, StateData) ->
|
|
|
|
MinMessageInterval =
|
2014-11-15 22:35:56 +01:00
|
|
|
trunc(gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, min_message_interval)
|
|
|
|
* 1000),
|
2008-11-28 17:06:39 +01:00
|
|
|
MinPresenceInterval =
|
2014-11-15 22:35:56 +01:00
|
|
|
trunc(gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, min_presence_interval)
|
|
|
|
* 1000),
|
2015-11-24 16:44:13 +01:00
|
|
|
Key = jid:tolower(JID),
|
2015-12-04 15:08:43 +01:00
|
|
|
Now = p1_time_compat:system_time(micro_seconds),
|
2013-03-14 10:33:02 +01:00
|
|
|
Activity1 = clean_treap(StateData#state.activity,
|
|
|
|
{1, -Now}),
|
|
|
|
Activity = case treap:lookup(Key, Activity1) of
|
|
|
|
{ok, _P, _A} -> treap:delete(Key, Activity1);
|
|
|
|
error -> Activity1
|
|
|
|
end,
|
|
|
|
StateData1 = case MinMessageInterval == 0 andalso
|
|
|
|
MinPresenceInterval == 0 andalso
|
|
|
|
UserActivity#activity.message_shaper == none andalso
|
|
|
|
UserActivity#activity.presence_shaper == none
|
|
|
|
andalso
|
|
|
|
UserActivity#activity.message == undefined andalso
|
|
|
|
UserActivity#activity.presence == undefined
|
|
|
|
of
|
|
|
|
true -> StateData#state{activity = Activity};
|
|
|
|
false ->
|
|
|
|
case UserActivity#activity.message == undefined andalso
|
|
|
|
UserActivity#activity.presence == undefined
|
|
|
|
of
|
|
|
|
true ->
|
|
|
|
{_, MessageShaperInterval} =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:update(UserActivity#activity.message_shaper,
|
2013-03-14 10:33:02 +01:00
|
|
|
100000),
|
|
|
|
{_, PresenceShaperInterval} =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:update(UserActivity#activity.presence_shaper,
|
2013-03-14 10:33:02 +01:00
|
|
|
100000),
|
|
|
|
Delay = lists:max([MessageShaperInterval,
|
|
|
|
PresenceShaperInterval,
|
2014-11-15 22:35:56 +01:00
|
|
|
MinMessageInterval,
|
|
|
|
MinPresenceInterval])
|
2013-03-14 10:33:02 +01:00
|
|
|
* 1000,
|
|
|
|
Priority = {1, -(Now + Delay)},
|
|
|
|
StateData#state{activity =
|
|
|
|
treap:insert(Key, Priority,
|
|
|
|
UserActivity,
|
|
|
|
Activity)};
|
|
|
|
false ->
|
|
|
|
Priority = {0, 0},
|
|
|
|
StateData#state{activity =
|
|
|
|
treap:insert(Key, Priority,
|
|
|
|
UserActivity,
|
|
|
|
Activity)}
|
|
|
|
end
|
|
|
|
end,
|
2008-11-28 17:06:39 +01:00
|
|
|
StateData1.
|
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec clean_treap(treap:treap(), integer() | {1, integer()}) -> treap:treap().
|
2008-11-28 17:06:39 +01:00
|
|
|
clean_treap(Treap, CleanPriority) ->
|
|
|
|
case treap:is_empty(Treap) of
|
2013-03-14 10:33:02 +01:00
|
|
|
true -> Treap;
|
|
|
|
false ->
|
|
|
|
{_Key, Priority, _Value} = treap:get_root(Treap),
|
|
|
|
if Priority > CleanPriority ->
|
|
|
|
clean_treap(treap:delete_root(Treap), CleanPriority);
|
|
|
|
true -> Treap
|
|
|
|
end
|
2008-11-28 17:06:39 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec prepare_room_queue(state()) -> state().
|
2007-09-01 23:05:04 +02:00
|
|
|
prepare_room_queue(StateData) ->
|
2017-03-10 13:12:43 +01:00
|
|
|
case p1_queue:out(StateData#state.room_queue) of
|
2013-03-14 10:33:02 +01:00
|
|
|
{{value, {message, From}}, _RoomQueue} ->
|
|
|
|
Activity = get_user_activity(From, StateData),
|
|
|
|
Packet = Activity#activity.message,
|
|
|
|
Size = element_size(Packet),
|
|
|
|
{RoomShaper, RoomShaperInterval} =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:update(StateData#state.room_shaper, Size),
|
2013-03-14 10:33:02 +01:00
|
|
|
erlang:send_after(RoomShaperInterval, self(),
|
|
|
|
process_room_queue),
|
|
|
|
StateData#state{room_shaper = RoomShaper};
|
|
|
|
{{value, {presence, From}}, _RoomQueue} ->
|
|
|
|
Activity = get_user_activity(From, StateData),
|
|
|
|
{_Nick, Packet} = Activity#activity.presence,
|
|
|
|
Size = element_size(Packet),
|
|
|
|
{RoomShaper, RoomShaperInterval} =
|
2018-07-05 08:31:55 +02:00
|
|
|
ejabberd_shaper:update(StateData#state.room_shaper, Size),
|
2013-03-14 10:33:02 +01:00
|
|
|
erlang:send_after(RoomShaperInterval, self(),
|
|
|
|
process_room_queue),
|
|
|
|
StateData#state{room_shaper = RoomShaper};
|
|
|
|
{empty, _} -> StateData
|
2007-09-01 23:05:04 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec update_online_user(jid(), #user{}, state()) -> state().
|
2016-09-07 09:33:37 +02:00
|
|
|
update_online_user(JID, #user{nick = Nick} = User, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2018-11-09 13:21:35 +01:00
|
|
|
add_to_log(join, Nick, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
Nicks1 = try maps:get(LJID, StateData#state.users) of
|
|
|
|
#user{nick = OldNick} ->
|
2016-06-26 08:08:37 +02:00
|
|
|
case lists:delete(
|
2018-11-15 12:13:45 +01:00
|
|
|
LJID, maps:get(OldNick, StateData#state.nicks)) of
|
2016-06-26 08:08:37 +02:00
|
|
|
[] ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:remove(OldNick, StateData#state.nicks);
|
2016-06-26 08:08:37 +02:00
|
|
|
LJIDs ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:put(OldNick, LJIDs, StateData#state.nicks)
|
|
|
|
end
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData#state.nicks
|
|
|
|
end,
|
2018-11-15 12:13:45 +01:00
|
|
|
Nicks = maps:update_with(Nick,
|
|
|
|
fun (LJIDs) -> [LJID|LJIDs -- [LJID]] end,
|
|
|
|
[LJID], Nicks1),
|
|
|
|
Users = maps:update_with(LJID,
|
|
|
|
fun(U) ->
|
|
|
|
U#user{nick = Nick}
|
|
|
|
end, User, StateData#state.users),
|
2016-06-26 08:08:37 +02:00
|
|
|
NewStateData = StateData#state{users = Users, nicks = Nicks},
|
2018-11-15 12:13:45 +01:00
|
|
|
case {maps:get(LJID, StateData#state.users, error),
|
|
|
|
maps:get(LJID, NewStateData#state.users, error)} of
|
|
|
|
{#user{nick = Old}, #user{nick = New}} when Old /= New ->
|
2016-06-26 08:08:37 +02:00
|
|
|
send_nick_changing(JID, Old, NewStateData, true, true);
|
|
|
|
_ ->
|
|
|
|
ok
|
|
|
|
end,
|
|
|
|
NewStateData.
|
|
|
|
|
2016-09-07 09:33:37 +02:00
|
|
|
set_subscriber(JID, Nick, Nodes, StateData) ->
|
|
|
|
BareJID = jid:remove_resource(JID),
|
2016-09-12 13:41:33 +02:00
|
|
|
LBareJID = jid:tolower(BareJID),
|
2018-11-15 12:13:45 +01:00
|
|
|
Subscribers = maps:put(LBareJID,
|
|
|
|
#subscriber{jid = BareJID,
|
|
|
|
nick = Nick,
|
|
|
|
nodes = Nodes},
|
|
|
|
StateData#state.subscribers),
|
|
|
|
Nicks = maps:put(Nick, [LBareJID], StateData#state.subscriber_nicks),
|
2016-09-12 13:41:33 +02:00
|
|
|
NewStateData = StateData#state{subscribers = Subscribers,
|
|
|
|
subscriber_nicks = Nicks},
|
2017-10-31 14:00:41 +01:00
|
|
|
store_room(NewStateData, [{add_subscription, BareJID, Nick, Nodes}]),
|
2018-11-15 12:13:45 +01:00
|
|
|
case not maps:is_key(LBareJID, StateData#state.subscribers) of
|
2017-10-30 12:05:18 +01:00
|
|
|
true ->
|
2017-10-30 17:54:55 +01:00
|
|
|
send_subscriptions_change_notifications(BareJID, Nick, subscribe, NewStateData);
|
2017-10-30 12:05:18 +01:00
|
|
|
_ ->
|
|
|
|
ok
|
|
|
|
end,
|
2016-09-07 09:33:37 +02:00
|
|
|
NewStateData.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-11-12 11:27:15 +01:00
|
|
|
-spec add_online_user(jid(), binary(), role(), state()) -> state().
|
2016-09-07 09:33:37 +02:00
|
|
|
add_online_user(JID, Nick, Role, StateData) ->
|
2007-12-03 11:47:42 +01:00
|
|
|
tab_add_online_user(JID, StateData),
|
2016-09-07 09:33:37 +02:00
|
|
|
User = #user{jid = JID, nick = Nick, role = Role},
|
|
|
|
update_online_user(JID, User, StateData).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-11-12 11:27:15 +01:00
|
|
|
-spec remove_online_user(jid(), state()) -> state().
|
2016-09-07 09:33:37 +02:00
|
|
|
remove_online_user(JID, StateData) ->
|
|
|
|
remove_online_user(JID, StateData, <<"">>).
|
2006-03-14 05:26:15 +01:00
|
|
|
|
2016-11-12 11:27:15 +01:00
|
|
|
-spec remove_online_user(jid(), state(), binary()) -> state().
|
2016-09-07 09:33:37 +02:00
|
|
|
remove_online_user(JID, StateData, Reason) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = Nick} = maps:get(LJID, StateData#state.users),
|
2006-03-14 05:26:15 +01:00
|
|
|
add_to_log(leave, {Nick, Reason}, StateData),
|
2007-12-03 11:47:42 +01:00
|
|
|
tab_remove_online_user(JID, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
Users = maps:remove(LJID, StateData#state.users),
|
|
|
|
Nicks = try maps:get(Nick, StateData#state.nicks) of
|
|
|
|
[LJID] ->
|
|
|
|
maps:remove(Nick, StateData#state.nicks);
|
|
|
|
U ->
|
|
|
|
maps:put(Nick, U -- [LJID], StateData#state.nicks)
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
StateData#state.nicks
|
2009-08-21 15:22:18 +02:00
|
|
|
end,
|
2011-09-26 10:13:40 +02:00
|
|
|
StateData#state{users = Users, nicks = Nicks}.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec filter_presence(presence()) -> presence().
|
|
|
|
filter_presence(Presence) ->
|
|
|
|
Els = lists:filter(
|
|
|
|
fun(El) ->
|
|
|
|
XMLNS = xmpp:get_ns(El),
|
|
|
|
case catch binary:part(XMLNS, 0, size(?NS_MUC)) of
|
|
|
|
?NS_MUC -> false;
|
|
|
|
_ -> true
|
|
|
|
end
|
|
|
|
end, xmpp:get_els(Presence)),
|
|
|
|
xmpp:set_els(Presence, Els).
|
|
|
|
|
|
|
|
-spec strip_status(presence()) -> presence().
|
|
|
|
strip_status(Presence) ->
|
|
|
|
Presence#presence{status = []}.
|
|
|
|
|
|
|
|
-spec add_user_presence(jid(), presence(), state()) -> state().
|
2003-03-23 21:08:44 +01:00
|
|
|
add_user_presence(JID, Presence, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2003-03-23 21:08:44 +01:00
|
|
|
FPresence = filter_presence(Presence),
|
2018-11-15 12:13:45 +01:00
|
|
|
Users = maps:update_with(LJID,
|
|
|
|
fun (#user{} = User) ->
|
|
|
|
User#user{last_presence = FPresence}
|
|
|
|
end, StateData#state.users),
|
2003-03-23 21:08:44 +01:00
|
|
|
StateData#state{users = Users}.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec add_user_presence_un(jid(), presence(), state()) -> state().
|
2003-03-23 21:08:44 +01:00
|
|
|
add_user_presence_un(JID, Presence, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2003-03-23 21:08:44 +01:00
|
|
|
FPresence = filter_presence(Presence),
|
2018-11-15 12:13:45 +01:00
|
|
|
Users = maps:update_with(LJID,
|
|
|
|
fun (#user{} = User) ->
|
|
|
|
User#user{last_presence = FPresence,
|
|
|
|
role = none}
|
|
|
|
end, StateData#state.users),
|
2003-03-23 21:08:44 +01:00
|
|
|
StateData#state{users = Users}.
|
|
|
|
|
2011-08-23 21:53:30 +02:00
|
|
|
%% Find and return a list of the full JIDs of the users of Nick.
|
|
|
|
%% Return jid record.
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec find_jids_by_nick(binary(), state()) -> [jid()].
|
2011-08-23 21:53:30 +02:00
|
|
|
find_jids_by_nick(Nick, StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
Users = case maps:get(Nick, StateData#state.nicks, []) of
|
|
|
|
[] -> maps:get(Nick, StateData#state.subscriber_nicks, []);
|
|
|
|
Us -> Us
|
|
|
|
end,
|
|
|
|
[jid:make(LJID) || LJID <- Users].
|
2011-08-23 21:53:30 +02:00
|
|
|
|
2009-08-21 15:22:18 +02:00
|
|
|
%% Find and return the full JID of the user of Nick with
|
|
|
|
%% highest-priority presence. Return jid record.
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec find_jid_by_nick(binary(), state()) -> jid() | false.
|
2003-03-23 21:08:44 +01:00
|
|
|
find_jid_by_nick(Nick, StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(Nick, StateData#state.nicks) of
|
|
|
|
[User] -> jid:make(User);
|
|
|
|
[FirstUser | Users] ->
|
|
|
|
#user{last_presence = FirstPresence} =
|
|
|
|
maps:get(FirstUser, StateData#state.users),
|
|
|
|
{LJID, _} = lists:foldl(
|
|
|
|
fun(Compare, {HighestUser, HighestPresence}) ->
|
|
|
|
#user{last_presence = P1} =
|
|
|
|
maps:get(Compare, StateData#state.users),
|
|
|
|
case higher_presence(P1, HighestPresence) of
|
|
|
|
true -> {Compare, P1};
|
|
|
|
false -> {HighestUser, HighestPresence}
|
|
|
|
end
|
|
|
|
end, {FirstUser, FirstPresence}, Users),
|
|
|
|
jid:make(LJID)
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
false
|
2009-08-21 15:22:18 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec higher_presence(undefined | presence(),
|
|
|
|
undefined | presence()) -> boolean().
|
2016-06-26 08:08:37 +02:00
|
|
|
higher_presence(Pres1, Pres2) when Pres1 /= undefined, Pres2 /= undefined ->
|
2009-08-21 15:22:18 +02:00
|
|
|
Pri1 = get_priority_from_presence(Pres1),
|
|
|
|
Pri2 = get_priority_from_presence(Pres2),
|
2016-06-26 08:08:37 +02:00
|
|
|
Pri1 > Pri2;
|
|
|
|
higher_presence(Pres1, Pres2) ->
|
|
|
|
Pres1 > Pres2.
|
2009-08-21 15:22:18 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_priority_from_presence(presence()) -> integer().
|
|
|
|
get_priority_from_presence(#presence{priority = Prio}) ->
|
|
|
|
case Prio of
|
|
|
|
undefined -> 0;
|
|
|
|
_ -> Prio
|
2009-08-21 15:22:18 +02:00
|
|
|
end.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec find_nick_by_jid(jid(), state()) -> binary().
|
|
|
|
find_nick_by_jid(JID, StateData) ->
|
|
|
|
LJID = jid:tolower(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = Nick} = maps:get(LJID, StateData#state.users),
|
2013-03-14 10:33:02 +01:00
|
|
|
Nick.
|
2011-07-28 19:40:46 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_nick_change(jid(), binary(), state()) -> boolean().
|
2003-03-23 21:08:44 +01:00
|
|
|
is_nick_change(JID, Nick, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2003-03-23 21:08:44 +01:00
|
|
|
case Nick of
|
2013-03-14 10:33:02 +01:00
|
|
|
<<"">> -> false;
|
|
|
|
_ ->
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = OldNick} = maps:get(LJID, StateData#state.users),
|
2013-03-14 10:33:02 +01:00
|
|
|
Nick /= OldNick
|
2003-03-23 21:08:44 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec nick_collision(jid(), binary(), state()) -> boolean().
|
2009-08-21 15:22:18 +02:00
|
|
|
nick_collision(User, Nick, StateData) ->
|
2016-09-12 13:41:33 +02:00
|
|
|
UserOfNick = case find_jid_by_nick(Nick, StateData) of
|
|
|
|
false ->
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(Nick, StateData#state.subscriber_nicks) of
|
|
|
|
[J] -> J
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} -> false
|
2016-09-12 13:41:33 +02:00
|
|
|
end;
|
|
|
|
J -> J
|
|
|
|
end,
|
2015-10-07 00:06:58 +02:00
|
|
|
(UserOfNick /= false andalso
|
2015-11-24 16:44:13 +01:00
|
|
|
jid:remove_resource(jid:tolower(UserOfNick))
|
|
|
|
/= jid:remove_resource(jid:tolower(User))).
|
2009-08-21 15:22:18 +02:00
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec add_new_user(jid(), binary(), presence(), state()) -> state();
|
|
|
|
(jid(), binary(), iq(), state()) -> {error, stanza_error()} |
|
|
|
|
{ignore, state()} |
|
|
|
|
{result, muc_subscribe(), state()}.
|
2016-07-25 12:50:30 +02:00
|
|
|
add_new_user(From, Nick, Packet, StateData) ->
|
|
|
|
Lang = xmpp:get_lang(Packet),
|
2007-08-29 19:54:45 +02:00
|
|
|
MaxUsers = get_max_users(StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
MaxAdminUsers = MaxUsers +
|
|
|
|
get_max_users_admin_threshold(StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
NUsers = maps:size(StateData#state.users),
|
2007-05-16 12:13:04 +02:00
|
|
|
Affiliation = get_affiliation(From, StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
ServiceAffiliation = get_service_affiliation(From,
|
|
|
|
StateData),
|
2017-01-13 10:03:39 +01:00
|
|
|
NConferences = tab_count_user(From, StateData),
|
2013-03-14 10:33:02 +01:00
|
|
|
MaxConferences =
|
|
|
|
gen_mod:get_module_opt(StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, max_user_conferences),
|
2009-08-21 15:22:18 +02:00
|
|
|
Collision = nick_collision(From, Nick, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
IsSubscribeRequest = not is_record(Packet, presence),
|
2007-12-03 11:47:42 +01:00
|
|
|
case {(ServiceAffiliation == owner orelse
|
2016-05-25 12:44:05 +02:00
|
|
|
((Affiliation == admin orelse Affiliation == owner)
|
|
|
|
andalso NUsers < MaxAdminUsers)
|
2013-03-14 10:33:02 +01:00
|
|
|
orelse NUsers < MaxUsers)
|
|
|
|
andalso NConferences < MaxConferences,
|
2009-08-21 15:22:18 +02:00
|
|
|
Collision,
|
2013-03-14 10:33:02 +01:00
|
|
|
mod_muc:can_use_nick(StateData#state.server_host,
|
|
|
|
StateData#state.host, From, Nick),
|
|
|
|
get_default_role(Affiliation, StateData)}
|
|
|
|
of
|
2016-04-05 12:09:44 +02:00
|
|
|
{false, _, _, _} when NUsers >= MaxUsers orelse NUsers >= MaxAdminUsers ->
|
|
|
|
Txt = <<"Too many users in this conference">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_resource_constraint(Txt, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2016-04-05 12:09:44 +02:00
|
|
|
{false, _, _, _} when NConferences >= MaxConferences ->
|
|
|
|
Txt = <<"You have joined too many conferences">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_resource_constraint(Txt, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
{false, _, _, _} ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_service_unavailable(),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
{_, _, _, none} ->
|
2016-06-26 08:08:37 +02:00
|
|
|
Err = case Affiliation of
|
|
|
|
outcast ->
|
|
|
|
ErrText = <<"You have been banned from this room">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
xmpp:err_forbidden(ErrText, Lang);
|
2016-06-26 08:08:37 +02:00
|
|
|
_ ->
|
|
|
|
ErrText = <<"Membership is required to enter this room">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
xmpp:err_registration_required(ErrText, Lang)
|
2016-06-26 08:08:37 +02:00
|
|
|
end,
|
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
{_, true, _, _} ->
|
|
|
|
ErrText = <<"That nickname is already in use by another occupant">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_conflict(ErrText, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
{_, _, false, _} ->
|
|
|
|
ErrText = <<"That nickname is registered by another person">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_conflict(ErrText, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
{_, _, _, Role} ->
|
|
|
|
case check_password(ServiceAffiliation, Affiliation,
|
2016-07-25 12:50:30 +02:00
|
|
|
Packet, From, StateData)
|
2013-03-14 10:33:02 +01:00
|
|
|
of
|
|
|
|
true ->
|
2016-06-26 08:08:37 +02:00
|
|
|
Nodes = get_subscription_nodes(Packet),
|
|
|
|
NewStateData =
|
|
|
|
if not IsSubscribeRequest ->
|
|
|
|
NewState = add_user_presence(
|
|
|
|
From, Packet,
|
|
|
|
add_online_user(From, Nick, Role,
|
2016-09-07 09:33:37 +02:00
|
|
|
StateData)),
|
2017-10-09 16:59:22 +02:00
|
|
|
send_initial_presences_and_messages(
|
|
|
|
From, Nick, Packet, NewState, StateData),
|
2016-06-26 08:08:37 +02:00
|
|
|
NewState;
|
|
|
|
true ->
|
2016-09-07 09:33:37 +02:00
|
|
|
set_subscriber(From, Nick, Nodes, StateData)
|
2016-06-26 08:08:37 +02:00
|
|
|
end,
|
|
|
|
ResultState =
|
|
|
|
case NewStateData#state.just_created of
|
|
|
|
true ->
|
|
|
|
NewStateData#state{just_created = false};
|
|
|
|
false ->
|
2018-11-15 12:13:45 +01:00
|
|
|
Robots = maps:remove(From, StateData#state.robots),
|
2016-06-26 08:08:37 +02:00
|
|
|
NewStateData#state{robots = Robots}
|
|
|
|
end,
|
|
|
|
if not IsSubscribeRequest -> ResultState;
|
2016-07-25 12:50:30 +02:00
|
|
|
true -> {result, subscribe_result(Packet), ResultState}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2017-02-18 07:36:27 +01:00
|
|
|
need_password ->
|
2013-03-14 10:33:02 +01:00
|
|
|
ErrText = <<"A password is required to enter this room">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_not_authorized(ErrText, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
captcha_required ->
|
2016-07-25 12:50:30 +02:00
|
|
|
SID = xmpp:get_id(Packet),
|
2013-03-14 10:33:02 +01:00
|
|
|
RoomJID = StateData#state.jid,
|
2015-11-24 16:44:13 +01:00
|
|
|
To = jid:replace_resource(RoomJID, Nick),
|
2013-03-14 10:33:02 +01:00
|
|
|
Limiter = {From#jid.luser, From#jid.lserver},
|
|
|
|
case ejabberd_captcha:create_captcha(SID, RoomJID, To,
|
|
|
|
Lang, Limiter, From)
|
2016-06-26 08:08:37 +02:00
|
|
|
of
|
2016-07-28 14:10:41 +02:00
|
|
|
{ok, ID, Body, CaptchaEls} ->
|
2017-02-16 09:00:26 +01:00
|
|
|
MsgPkt = #message{from = RoomJID,
|
|
|
|
to = From,
|
|
|
|
id = ID, body = Body,
|
2016-07-28 14:10:41 +02:00
|
|
|
sub_els = CaptchaEls},
|
2018-11-15 12:13:45 +01:00
|
|
|
Robots = maps:put(From, {Nick, Packet},
|
|
|
|
StateData#state.robots),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route(MsgPkt),
|
2016-06-26 08:08:37 +02:00
|
|
|
NewState = StateData#state{robots = Robots},
|
|
|
|
if not IsSubscribeRequest ->
|
|
|
|
NewState;
|
|
|
|
true ->
|
|
|
|
{ignore, NewState}
|
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
{error, limit} ->
|
|
|
|
ErrText = <<"Too many CAPTCHA requests">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_resource_constraint(ErrText, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2013-03-14 10:33:02 +01:00
|
|
|
_ ->
|
|
|
|
ErrText = <<"Unable to generate a CAPTCHA">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_internal_server_error(ErrText, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end
|
2013-03-14 10:33:02 +01:00
|
|
|
end;
|
|
|
|
_ ->
|
|
|
|
ErrText = <<"Incorrect password">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
Err = xmpp:err_not_authorized(ErrText, Lang),
|
2016-06-26 08:08:37 +02:00
|
|
|
if not IsSubscribeRequest ->
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err),
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData;
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, Err}
|
2016-06-26 08:08:37 +02:00
|
|
|
end
|
2013-03-14 10:33:02 +01:00
|
|
|
end
|
2003-08-15 21:17:12 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec check_password(affiliation(), affiliation(),
|
2017-02-18 07:36:27 +01:00
|
|
|
presence() | iq(), jid(), state()) ->
|
|
|
|
boolean() | need_password | captcha_required.
|
2016-07-25 12:50:30 +02:00
|
|
|
check_password(owner, _Affiliation, _Packet, _From,
|
2013-03-14 10:33:02 +01:00
|
|
|
_StateData) ->
|
2009-02-16 16:57:02 +01:00
|
|
|
%% Don't check pass if user is owner in MUC service (access_admin option)
|
2003-08-15 21:17:12 +02:00
|
|
|
true;
|
2016-07-25 12:50:30 +02:00
|
|
|
check_password(_ServiceAffiliation, Affiliation, Packet,
|
2013-03-14 10:33:02 +01:00
|
|
|
From, StateData) ->
|
|
|
|
case (StateData#state.config)#config.password_protected
|
|
|
|
of
|
|
|
|
false -> check_captcha(Affiliation, From, StateData);
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Pass = extract_password(Packet),
|
2013-03-14 10:33:02 +01:00
|
|
|
case Pass of
|
2017-02-18 07:36:27 +01:00
|
|
|
false -> need_password;
|
2013-03-14 10:33:02 +01:00
|
|
|
_ ->
|
|
|
|
case (StateData#state.config)#config.password of
|
|
|
|
Pass -> true;
|
|
|
|
_ -> false
|
|
|
|
end
|
|
|
|
end
|
2003-08-15 21:17:12 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec check_captcha(affiliation(), jid(), state()) -> true | captcha_required.
|
2009-03-13 17:01:46 +01:00
|
|
|
check_captcha(Affiliation, From, StateData) ->
|
2009-05-26 13:53:58 +02:00
|
|
|
case (StateData#state.config)#config.captcha_protected
|
2013-03-14 10:33:02 +01:00
|
|
|
andalso ejabberd_captcha:is_feature_available()
|
|
|
|
of
|
|
|
|
true when Affiliation == none ->
|
2018-11-15 12:13:45 +01:00
|
|
|
case maps:get(From, StateData#state.robots, error) of
|
|
|
|
passed -> true;
|
|
|
|
_ ->
|
2013-03-14 10:33:02 +01:00
|
|
|
WList =
|
|
|
|
(StateData#state.config)#config.captcha_whitelist,
|
|
|
|
#jid{luser = U, lserver = S, lresource = R} = From,
|
|
|
|
case (?SETS):is_element({U, S, R}, WList) of
|
|
|
|
true -> true;
|
|
|
|
false ->
|
|
|
|
case (?SETS):is_element({U, S, <<"">>}, WList) of
|
|
|
|
true -> true;
|
|
|
|
false ->
|
|
|
|
case (?SETS):is_element({<<"">>, S, <<"">>}, WList)
|
|
|
|
of
|
|
|
|
true -> true;
|
|
|
|
false -> captcha_required
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end;
|
|
|
|
_ -> true
|
2009-03-13 17:01:46 +01:00
|
|
|
end.
|
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec extract_password(presence() | iq()) -> binary() | false.
|
|
|
|
extract_password(#presence{} = Pres) ->
|
|
|
|
case xmpp:get_subtag(Pres, #muc{}) of
|
|
|
|
#muc{password = Password} when is_binary(Password) ->
|
2016-12-02 16:18:22 +01:00
|
|
|
Password;
|
2017-02-18 07:36:27 +01:00
|
|
|
_ ->
|
|
|
|
false
|
|
|
|
end;
|
|
|
|
extract_password(#iq{} = IQ) ->
|
|
|
|
case xmpp:get_subtag(IQ, #muc_subscribe{}) of
|
|
|
|
#muc_subscribe{password = Password} when Password /= <<"">> ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Password;
|
|
|
|
_ ->
|
|
|
|
false
|
|
|
|
end.
|
2003-08-15 21:17:12 +02:00
|
|
|
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec get_history(binary(), stanza(), state()) -> lqueue().
|
|
|
|
get_history(Nick, Packet, #state{history = History}) ->
|
|
|
|
case xmpp:get_subtag(Packet, #muc{}) of
|
|
|
|
#muc{history = #muc_history{} = MUCHistory} ->
|
|
|
|
Now = p1_time_compat:timestamp(),
|
|
|
|
Q = History#lqueue.queue,
|
2017-03-10 13:12:43 +01:00
|
|
|
filter_history(Q, Now, Nick, MUCHistory);
|
2016-10-17 12:37:23 +02:00
|
|
|
_ ->
|
2017-03-10 13:12:43 +01:00
|
|
|
p1_queue:to_list(History#lqueue.queue)
|
2004-02-15 21:10:40 +01:00
|
|
|
end.
|
|
|
|
|
2017-03-10 13:12:43 +01:00
|
|
|
-spec filter_history(p1_queue:queue(), erlang:timestamp(),
|
|
|
|
binary(), muc_history()) -> list().
|
|
|
|
filter_history(Queue, Now, Nick,
|
|
|
|
#muc_history{since = Since,
|
|
|
|
seconds = Seconds,
|
|
|
|
maxstanzas = MaxStanzas,
|
|
|
|
maxchars = MaxChars}) ->
|
|
|
|
{History, _, _} =
|
|
|
|
lists:foldr(
|
|
|
|
fun({_, _, _, TimeStamp, Size} = Elem,
|
|
|
|
{Elems, NumStanzas, NumChars} = Acc) ->
|
|
|
|
NowDiff = timer:now_diff(Now, TimeStamp) div 1000000,
|
|
|
|
Chars = Size + byte_size(Nick) + 1,
|
|
|
|
if (NumStanzas < MaxStanzas) andalso
|
|
|
|
(TimeStamp > Since) andalso
|
|
|
|
(NowDiff =< Seconds) andalso
|
|
|
|
(NumChars + Chars =< MaxChars) ->
|
|
|
|
{[Elem|Elems], NumStanzas + 1, NumChars + Chars};
|
|
|
|
true ->
|
|
|
|
Acc
|
|
|
|
end
|
|
|
|
end, {[], 0, 0}, p1_queue:to_list(Queue)),
|
|
|
|
History.
|
2004-02-15 21:10:40 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec is_room_overcrowded(state()) -> boolean().
|
2015-05-08 13:09:13 +02:00
|
|
|
is_room_overcrowded(StateData) ->
|
2017-04-30 18:01:47 +02:00
|
|
|
MaxUsersPresence = gen_mod:get_module_opt(
|
|
|
|
StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, max_users_presence),
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:size(StateData#state.users) > MaxUsersPresence.
|
2015-05-08 13:09:13 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec presence_broadcast_allowed(jid(), state()) -> boolean().
|
2015-11-12 17:51:20 +01:00
|
|
|
presence_broadcast_allowed(JID, StateData) ->
|
|
|
|
Role = get_role(JID, StateData),
|
|
|
|
lists:member(Role, (StateData#state.config)#config.presence_broadcast).
|
|
|
|
|
2017-10-09 16:59:22 +02:00
|
|
|
-spec send_initial_presences_and_messages(
|
|
|
|
jid(), binary(), presence(), state(), state()) -> ok.
|
|
|
|
send_initial_presences_and_messages(From, Nick, Presence, NewState, OldState) ->
|
2018-02-12 15:37:36 +01:00
|
|
|
send_self_presence(From, NewState),
|
2017-10-09 16:59:22 +02:00
|
|
|
send_existing_presences(From, NewState),
|
|
|
|
send_initial_presence(From, NewState, OldState),
|
|
|
|
History = get_history(Nick, Presence, NewState),
|
|
|
|
send_history(From, History, NewState),
|
|
|
|
send_subject(From, OldState).
|
|
|
|
|
2018-02-12 15:37:36 +01:00
|
|
|
-spec send_self_presence(jid(), state()) -> ok.
|
|
|
|
send_self_presence(JID, State) ->
|
|
|
|
AvatarHash = (State#state.config)#config.vcard_xupdate,
|
|
|
|
DiscoInfo = make_disco_info(JID, State),
|
2018-09-14 00:18:17 +02:00
|
|
|
Extras = iq_disco_info_extras(<<"en">>, State, true),
|
|
|
|
DiscoInfo1 = DiscoInfo#disco_info{xdata = [Extras]},
|
|
|
|
DiscoHash = mod_caps:compute_disco_hash(DiscoInfo1, sha),
|
2018-02-12 15:37:36 +01:00
|
|
|
Els1 = [#caps{hash = <<"sha-1">>,
|
2018-06-14 13:00:47 +02:00
|
|
|
node = ejabberd_config:get_uri(),
|
2018-02-12 15:37:36 +01:00
|
|
|
version = DiscoHash}],
|
|
|
|
Els2 = if is_binary(AvatarHash) ->
|
|
|
|
[#vcard_xupdate{hash = AvatarHash}|Els1];
|
|
|
|
true ->
|
|
|
|
Els1
|
|
|
|
end,
|
|
|
|
ejabberd_router:route(#presence{from = State#state.jid, to = JID,
|
2018-07-05 10:51:49 +02:00
|
|
|
id = p1_rand:get_string(),
|
2018-02-12 15:37:36 +01:00
|
|
|
sub_els = Els2}).
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_initial_presence(jid(), state(), state()) -> ok.
|
2016-02-08 20:10:20 +01:00
|
|
|
send_initial_presence(NJID, StateData, OldStateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
send_new_presence(NJID, <<"">>, true, StateData, OldStateData).
|
2016-02-08 20:10:20 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_update_presence(jid(), state(), state()) -> ok.
|
2015-12-08 19:24:39 +01:00
|
|
|
send_update_presence(JID, StateData, OldStateData) ->
|
|
|
|
send_update_presence(JID, <<"">>, StateData, OldStateData).
|
2008-07-30 20:24:08 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_update_presence(jid(), binary(), state(), state()) -> ok.
|
2015-12-08 19:24:39 +01:00
|
|
|
send_update_presence(JID, Reason, StateData, OldStateData) ->
|
2015-05-08 13:09:13 +02:00
|
|
|
case is_room_overcrowded(StateData) of
|
|
|
|
true -> ok;
|
2015-12-08 19:24:39 +01:00
|
|
|
false -> send_update_presence1(JID, Reason, StateData, OldStateData)
|
2015-05-08 13:09:13 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_update_presence1(jid(), binary(), state(), state()) -> ok.
|
2015-12-08 19:24:39 +01:00
|
|
|
send_update_presence1(JID, Reason, StateData, OldStateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2003-04-13 21:22:46 +02:00
|
|
|
LJIDs = case LJID of
|
2013-03-14 10:33:02 +01:00
|
|
|
{U, S, <<"">>} ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(fun (J, _, Js) ->
|
|
|
|
case J of
|
|
|
|
{U, S, _} -> [J | Js];
|
|
|
|
_ -> Js
|
|
|
|
end
|
|
|
|
end, [], StateData#state.users);
|
2013-03-14 10:33:02 +01:00
|
|
|
_ ->
|
2018-11-15 12:13:45 +01:00
|
|
|
case maps:is_key(LJID, StateData#state.users) of
|
2013-03-14 10:33:02 +01:00
|
|
|
true -> [LJID];
|
|
|
|
_ -> []
|
|
|
|
end
|
2003-04-13 21:22:46 +02:00
|
|
|
end,
|
2013-03-14 10:33:02 +01:00
|
|
|
lists:foreach(fun (J) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
send_new_presence(J, Reason, false, StateData,
|
|
|
|
OldStateData)
|
2013-03-14 10:33:02 +01:00
|
|
|
end,
|
|
|
|
LJIDs).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_new_presence(jid(), state(), state()) -> ok.
|
2015-11-12 17:51:20 +01:00
|
|
|
send_new_presence(NJID, StateData, OldStateData) ->
|
2016-02-08 20:10:20 +01:00
|
|
|
send_new_presence(NJID, <<"">>, false, StateData, OldStateData).
|
2008-07-30 20:24:08 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_new_presence(jid(), binary(), state(), state()) -> ok.
|
2015-11-12 17:51:20 +01:00
|
|
|
send_new_presence(NJID, Reason, StateData, OldStateData) ->
|
2016-02-08 20:10:20 +01:00
|
|
|
send_new_presence(NJID, Reason, false, StateData, OldStateData).
|
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec is_ra_changed(jid(), boolean(), state(), state()) -> boolean().
|
2016-06-26 08:08:37 +02:00
|
|
|
is_ra_changed(_, _IsInitialPresence = true, _, _) ->
|
|
|
|
false;
|
2017-02-18 07:36:27 +01:00
|
|
|
is_ra_changed(JID, _IsInitialPresence = false, NewStateData, OldStateData) ->
|
|
|
|
NewRole = get_role(JID, NewStateData),
|
2016-06-26 08:08:37 +02:00
|
|
|
NewAff = get_affiliation(JID, NewStateData),
|
2017-02-18 07:36:27 +01:00
|
|
|
OldRole = get_role(JID, OldStateData),
|
2016-06-26 08:08:37 +02:00
|
|
|
OldAff = get_affiliation(JID, OldStateData),
|
|
|
|
if (NewRole == none) and (NewAff == OldAff) ->
|
|
|
|
%% A user is leaving the room;
|
|
|
|
false;
|
|
|
|
true ->
|
|
|
|
(NewRole /= OldRole) or (NewAff /= OldAff)
|
|
|
|
end.
|
|
|
|
|
2018-11-15 12:13:45 +01:00
|
|
|
-spec send_new_presence(jid(), binary(), boolean(), state(), state()) -> ok.
|
|
|
|
send_new_presence(NJID, Reason, IsInitialPresence, StateData, OldStateData) ->
|
2015-12-08 19:24:39 +01:00
|
|
|
LNJID = jid:tolower(NJID),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = Nick} = maps:get(LNJID, StateData#state.users),
|
2009-08-21 15:22:18 +02:00
|
|
|
LJID = find_jid_by_nick(Nick, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{jid = RealJID, role = Role0,
|
|
|
|
last_presence = Presence0} = UserInfo =
|
|
|
|
maps:get(jid:tolower(LJID), StateData#state.users),
|
2015-12-08 19:24:39 +01:00
|
|
|
{Role1, Presence1} =
|
|
|
|
case presence_broadcast_allowed(NJID, StateData) of
|
|
|
|
true -> {Role0, Presence0};
|
2016-07-25 12:50:30 +02:00
|
|
|
false -> {none, #presence{type = unavailable}}
|
2015-12-08 19:24:39 +01:00
|
|
|
end,
|
2009-08-21 15:22:18 +02:00
|
|
|
Affiliation = get_affiliation(LJID, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
UserMap =
|
|
|
|
case is_room_overcrowded(StateData) orelse
|
|
|
|
(not (presence_broadcast_allowed(NJID, StateData) orelse
|
|
|
|
presence_broadcast_allowed(NJID, OldStateData))) of
|
2015-12-08 19:24:39 +01:00
|
|
|
true ->
|
2018-11-15 12:13:45 +01:00
|
|
|
#{LNJID => UserInfo};
|
2015-12-08 19:24:39 +01:00
|
|
|
false ->
|
2018-11-15 12:13:45 +01:00
|
|
|
get_users_and_subscribers(StateData)
|
2015-12-08 19:24:39 +01:00
|
|
|
end,
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(LUJID, Info, _) ->
|
2016-10-17 12:37:23 +02:00
|
|
|
IsSelfPresence = LNJID == LUJID,
|
|
|
|
{Role, Presence} = if IsSelfPresence -> {Role0, Presence0};
|
2016-06-26 08:08:37 +02:00
|
|
|
true -> {Role1, Presence1}
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
Item0 = #muc_item{affiliation = Affiliation,
|
|
|
|
role = Role},
|
|
|
|
Item1 = case Info#user.role == moderator orelse
|
|
|
|
(StateData#state.config)#config.anonymous
|
2016-10-17 12:37:23 +02:00
|
|
|
== false orelse IsSelfPresence of
|
2016-07-25 12:50:30 +02:00
|
|
|
true -> Item0#muc_item{jid = RealJID};
|
|
|
|
false -> Item0
|
|
|
|
end,
|
2016-08-05 07:41:08 +02:00
|
|
|
Item = Item1#muc_item{reason = Reason},
|
2016-10-17 12:37:23 +02:00
|
|
|
StatusCodes = status_codes(IsInitialPresence, IsSelfPresence,
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData),
|
|
|
|
Pres = if Presence == undefined -> #presence{};
|
2016-06-26 08:08:37 +02:00
|
|
|
true -> Presence
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
Packet = xmpp:set_subtag(
|
|
|
|
Pres, #muc_user{items = [Item],
|
|
|
|
status_codes = StatusCodes}),
|
2016-06-26 08:08:37 +02:00
|
|
|
Node1 = case is_ra_changed(NJID, IsInitialPresence, StateData, OldStateData) of
|
|
|
|
true -> ?NS_MUCSUB_NODES_AFFILIATIONS;
|
2016-07-07 15:42:41 +02:00
|
|
|
false -> ?NS_MUCSUB_NODES_PRESENCE
|
2016-06-26 08:08:37 +02:00
|
|
|
end,
|
|
|
|
send_wrapped(jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
Info#user.jid, Packet, Node1, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
Type = xmpp:get_type(Packet),
|
2016-09-07 09:33:37 +02:00
|
|
|
IsSubscriber = is_subscriber(Info#user.jid, StateData),
|
2016-06-26 08:08:37 +02:00
|
|
|
IsOccupant = Info#user.last_presence /= undefined,
|
|
|
|
if (IsSubscriber and not IsOccupant) and
|
2016-07-25 12:50:30 +02:00
|
|
|
(IsInitialPresence or (Type == unavailable)) ->
|
2016-06-26 08:08:37 +02:00
|
|
|
Node2 = ?NS_MUCSUB_NODES_PARTICIPANTS,
|
|
|
|
send_wrapped(jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
Info#user.jid, Packet, Node2, StateData);
|
|
|
|
true ->
|
|
|
|
ok
|
|
|
|
end
|
2018-11-15 12:13:45 +01:00
|
|
|
end, ok, UserMap).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_existing_presences(jid(), state()) -> ok.
|
2003-03-23 21:08:44 +01:00
|
|
|
send_existing_presences(ToJID, StateData) ->
|
2015-05-08 13:09:13 +02:00
|
|
|
case is_room_overcrowded(StateData) of
|
|
|
|
true -> ok;
|
|
|
|
false -> send_existing_presences1(ToJID, StateData)
|
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_existing_presences1(jid(), state()) -> ok.
|
2015-05-08 13:09:13 +02:00
|
|
|
send_existing_presences1(ToJID, StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LToJID = jid:tolower(ToJID),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{jid = RealToJID, role = Role} = maps:get(LToJID, StateData#state.users),
|
|
|
|
maps:fold(
|
|
|
|
fun(FromNick, _Users, _) ->
|
2016-06-26 08:08:37 +02:00
|
|
|
LJID = find_jid_by_nick(FromNick, StateData),
|
|
|
|
#user{jid = FromJID, role = FromRole,
|
|
|
|
last_presence = Presence} =
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:get(jid:tolower(LJID), StateData#state.users),
|
2016-06-26 08:08:37 +02:00
|
|
|
PresenceBroadcast =
|
|
|
|
lists:member(
|
|
|
|
FromRole, (StateData#state.config)#config.presence_broadcast),
|
|
|
|
case {RealToJID, PresenceBroadcast} of
|
|
|
|
{FromJID, _} -> ok;
|
|
|
|
{_, false} -> ok;
|
|
|
|
_ ->
|
|
|
|
FromAffiliation = get_affiliation(LJID, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
Item0 = #muc_item{affiliation = FromAffiliation,
|
|
|
|
role = FromRole},
|
|
|
|
Item = case Role == moderator orelse
|
|
|
|
(StateData#state.config)#config.anonymous
|
|
|
|
== false of
|
|
|
|
true -> Item0#muc_item{jid = FromJID};
|
|
|
|
false -> Item0
|
|
|
|
end,
|
|
|
|
Packet = xmpp:set_subtag(
|
|
|
|
Presence, #muc_user{items = [Item]}),
|
2016-06-26 08:08:37 +02:00
|
|
|
send_wrapped(jid:replace_resource(StateData#state.jid, FromNick),
|
2016-07-07 15:42:41 +02:00
|
|
|
RealToJID, Packet, ?NS_MUCSUB_NODES_PRESENCE, StateData)
|
2016-06-26 08:08:37 +02:00
|
|
|
end
|
2018-11-15 12:13:45 +01:00
|
|
|
end, ok, StateData#state.nicks).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec set_nick(jid(), binary(), state()) -> state().
|
2016-06-26 08:08:37 +02:00
|
|
|
set_nick(JID, Nick, State) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = OldNick} = maps:get(LJID, State#state.users),
|
|
|
|
Users = maps:update_with(LJID,
|
|
|
|
fun (#user{} = User) -> User#user{nick = Nick} end,
|
|
|
|
State#state.users),
|
|
|
|
OldNickUsers = maps:get(OldNick, State#state.nicks),
|
|
|
|
NewNickUsers = maps:get(Nick, State#state.nicks, []),
|
2013-03-14 10:33:02 +01:00
|
|
|
Nicks = case OldNickUsers of
|
2016-06-26 08:08:37 +02:00
|
|
|
[LJID] ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:put(Nick, [LJID | NewNickUsers -- [LJID]],
|
|
|
|
maps:remove(OldNick, State#state.nicks));
|
2016-06-26 08:08:37 +02:00
|
|
|
[_ | _] ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:put(Nick, [LJID | NewNickUsers -- [LJID]],
|
|
|
|
maps:put(OldNick, OldNickUsers -- [LJID],
|
|
|
|
State#state.nicks))
|
2013-03-14 10:33:02 +01:00
|
|
|
end,
|
2016-06-26 08:08:37 +02:00
|
|
|
State#state{users = Users, nicks = Nicks}.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec change_nick(jid(), binary(), state()) -> state().
|
2016-06-26 08:08:37 +02:00
|
|
|
change_nick(JID, Nick, StateData) ->
|
|
|
|
LJID = jid:tolower(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = OldNick} = maps:get(LJID, StateData#state.users),
|
|
|
|
OldNickUsers = maps:get(OldNick, StateData#state.nicks),
|
|
|
|
NewNickUsers = maps:get(Nick, StateData#state.nicks, []),
|
2016-06-26 08:08:37 +02:00
|
|
|
SendOldUnavailable = length(OldNickUsers) == 1,
|
|
|
|
SendNewAvailable = SendOldUnavailable orelse NewNickUsers == [],
|
|
|
|
NewStateData = set_nick(JID, Nick, StateData),
|
2015-11-12 17:51:20 +01:00
|
|
|
case presence_broadcast_allowed(JID, NewStateData) of
|
|
|
|
true ->
|
|
|
|
send_nick_changing(JID, OldNick, NewStateData,
|
|
|
|
SendOldUnavailable, SendNewAvailable);
|
|
|
|
false -> ok
|
|
|
|
end,
|
2006-03-14 05:26:15 +01:00
|
|
|
add_to_log(nickchange, {OldNick, Nick}, StateData),
|
2003-03-23 21:08:44 +01:00
|
|
|
NewStateData.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_nick_changing(jid(), binary(), state(), boolean(), boolean()) -> ok.
|
2009-08-21 15:22:18 +02:00
|
|
|
send_nick_changing(JID, OldNick, StateData,
|
2013-03-14 10:33:02 +01:00
|
|
|
SendOldUnavailable, SendNewAvailable) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{jid = RealJID, nick = Nick, role = Role,
|
|
|
|
last_presence = Presence} =
|
|
|
|
maps:get(jid:tolower(JID), StateData#state.users),
|
2003-03-23 21:08:44 +01:00
|
|
|
Affiliation = get_affiliation(JID, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(LJID, Info, _) when Presence /= undefined ->
|
2016-10-17 12:37:23 +02:00
|
|
|
IsSelfPresence = LJID == jid:tolower(JID),
|
2016-07-25 12:50:30 +02:00
|
|
|
Item0 = #muc_item{affiliation = Affiliation, role = Role},
|
2016-10-17 12:37:23 +02:00
|
|
|
Item = case Info#user.role == moderator orelse
|
|
|
|
(StateData#state.config)#config.anonymous
|
|
|
|
== false orelse IsSelfPresence of
|
|
|
|
true -> Item0#muc_item{jid = RealJID};
|
|
|
|
false -> Item0
|
|
|
|
end,
|
|
|
|
Status110 = case IsSelfPresence of
|
2016-07-25 12:50:30 +02:00
|
|
|
true -> [110];
|
|
|
|
false -> []
|
2013-03-14 10:33:02 +01:00
|
|
|
end,
|
2016-10-17 12:37:23 +02:00
|
|
|
Packet1 = #presence{
|
|
|
|
type = unavailable,
|
|
|
|
sub_els = [#muc_user{
|
|
|
|
items = [Item#muc_item{nick = Nick}],
|
|
|
|
status_codes = [303|Status110]}]},
|
2016-07-25 12:50:30 +02:00
|
|
|
Packet2 = xmpp:set_subtag(Presence,
|
2016-10-17 12:37:23 +02:00
|
|
|
#muc_user{items = [Item],
|
2016-07-25 12:50:30 +02:00
|
|
|
status_codes = Status110}),
|
|
|
|
if SendOldUnavailable ->
|
|
|
|
send_wrapped(
|
|
|
|
jid:replace_resource(StateData#state.jid, OldNick),
|
|
|
|
Info#user.jid, Packet1, ?NS_MUCSUB_NODES_PRESENCE,
|
|
|
|
StateData);
|
|
|
|
true -> ok
|
|
|
|
end,
|
|
|
|
if SendNewAvailable ->
|
|
|
|
send_wrapped(
|
|
|
|
jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
Info#user.jid, Packet2, ?NS_MUCSUB_NODES_PRESENCE,
|
|
|
|
StateData);
|
|
|
|
true -> ok
|
|
|
|
end;
|
2018-11-15 12:13:45 +01:00
|
|
|
(_, _, _) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
ok
|
2018-11-15 12:13:45 +01:00
|
|
|
end, ok, get_users_and_subscribers(StateData)).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec maybe_send_affiliation(jid(), affiliation(), state()) -> ok.
|
2016-05-20 01:28:16 +02:00
|
|
|
maybe_send_affiliation(JID, Affiliation, StateData) ->
|
|
|
|
LJID = jid:tolower(JID),
|
2016-09-07 09:33:37 +02:00
|
|
|
Users = get_users_and_subscribers(StateData),
|
2016-05-20 01:28:16 +02:00
|
|
|
IsOccupant = case LJID of
|
2018-11-15 12:13:45 +01:00
|
|
|
{LUser, LServer, <<"">>} ->
|
|
|
|
#{} /= maps:filter(
|
|
|
|
fun({U, S, _}, _) ->
|
|
|
|
U == LUser andalso
|
|
|
|
S == LServer
|
|
|
|
end, Users);
|
|
|
|
{_LUser, _LServer, _LResource} ->
|
|
|
|
maps:is_key(LJID, Users)
|
2016-05-20 01:28:16 +02:00
|
|
|
end,
|
|
|
|
case IsOccupant of
|
|
|
|
true ->
|
|
|
|
ok; % The new affiliation is published via presence.
|
|
|
|
false ->
|
2016-10-17 12:37:23 +02:00
|
|
|
send_affiliation(JID, Affiliation, StateData)
|
2016-05-20 01:28:16 +02:00
|
|
|
end.
|
|
|
|
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec send_affiliation(jid(), affiliation(), state()) -> ok.
|
|
|
|
send_affiliation(JID, Affiliation, StateData) ->
|
|
|
|
Item = #muc_item{jid = JID,
|
2016-07-25 12:50:30 +02:00
|
|
|
affiliation = Affiliation,
|
|
|
|
role = none},
|
2018-07-05 10:51:49 +02:00
|
|
|
Message = #message{id = p1_rand:get_string(),
|
2016-07-25 12:50:30 +02:00
|
|
|
sub_els = [#muc_user{items = [Item]}]},
|
2016-09-07 09:33:37 +02:00
|
|
|
Users = get_users_and_subscribers(StateData),
|
2016-05-20 01:28:16 +02:00
|
|
|
Recipients = case (StateData#state.config)#config.anonymous of
|
|
|
|
true ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:filter(fun(_, #user{role = moderator}) ->
|
|
|
|
true;
|
|
|
|
(_, _) ->
|
|
|
|
false
|
|
|
|
end, Users);
|
2016-05-20 01:28:16 +02:00
|
|
|
false ->
|
2016-09-07 09:33:37 +02:00
|
|
|
Users
|
2016-05-20 01:28:16 +02:00
|
|
|
end,
|
2016-09-07 09:33:37 +02:00
|
|
|
send_wrapped_multiple(StateData#state.jid, Recipients, Message,
|
|
|
|
?NS_MUCSUB_NODES_AFFILIATIONS, StateData).
|
2016-05-20 01:28:16 +02:00
|
|
|
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec status_codes(boolean(), boolean(), state()) -> [pos_integer()].
|
|
|
|
status_codes(IsInitialPresence, _IsSelfPresence = true, StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
S0 = [110],
|
|
|
|
case IsInitialPresence of
|
|
|
|
true ->
|
|
|
|
S1 = case StateData#state.just_created of
|
|
|
|
true -> [201|S0];
|
|
|
|
false -> S0
|
|
|
|
end,
|
|
|
|
S2 = case (StateData#state.config)#config.anonymous of
|
|
|
|
true -> S1;
|
|
|
|
false -> [100|S1]
|
|
|
|
end,
|
|
|
|
S3 = case (StateData#state.config)#config.logging of
|
|
|
|
true -> [170|S2];
|
|
|
|
false -> S2
|
|
|
|
end,
|
|
|
|
S3;
|
|
|
|
false -> S0
|
|
|
|
end;
|
2016-10-17 12:37:23 +02:00
|
|
|
status_codes(_IsInitialPresence, _IsSelfPresence = false, _StateData) -> [].
|
2016-02-08 20:10:20 +01:00
|
|
|
|
2017-03-10 13:12:43 +01:00
|
|
|
-spec lqueue_new(non_neg_integer(), ram | file) -> lqueue().
|
|
|
|
lqueue_new(Max, Type) ->
|
|
|
|
#lqueue{queue = p1_queue:new(Type), max = Max}.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec lqueue_in(term(), lqueue()) -> lqueue().
|
2006-09-05 17:53:54 +02:00
|
|
|
%% If the message queue limit is set to 0, do not store messages.
|
2013-03-14 10:33:02 +01:00
|
|
|
lqueue_in(_Item, LQ = #lqueue{max = 0}) -> LQ;
|
2006-09-05 17:53:54 +02:00
|
|
|
%% Otherwise, rotate messages in the queue store.
|
2017-03-10 13:12:43 +01:00
|
|
|
lqueue_in(Item, #lqueue{queue = Q1, max = Max}) ->
|
|
|
|
Len = p1_queue:len(Q1),
|
|
|
|
Q2 = p1_queue:in(Item, Q1),
|
2013-03-14 10:33:02 +01:00
|
|
|
if Len >= Max ->
|
|
|
|
Q3 = lqueue_cut(Q2, Len - Max + 1),
|
2017-03-10 13:12:43 +01:00
|
|
|
#lqueue{queue = Q3, max = Max};
|
|
|
|
true -> #lqueue{queue = Q2, max = Max}
|
2003-03-23 21:08:44 +01:00
|
|
|
end.
|
|
|
|
|
2017-03-10 13:12:43 +01:00
|
|
|
-spec lqueue_cut(p1_queue:queue(), non_neg_integer()) -> p1_queue:queue().
|
2013-03-14 10:33:02 +01:00
|
|
|
lqueue_cut(Q, 0) -> Q;
|
2003-03-23 21:08:44 +01:00
|
|
|
lqueue_cut(Q, N) ->
|
2017-03-10 13:12:43 +01:00
|
|
|
{_, Q1} = p1_queue:out(Q),
|
|
|
|
lqueue_cut(Q1, N - 1).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec add_message_to_history(binary(), jid(), message(), state()) -> state().
|
2009-06-30 18:51:25 +02:00
|
|
|
add_message_to_history(FromNick, FromJID, Packet, StateData) ->
|
2006-03-14 05:26:15 +01:00
|
|
|
add_to_log(text, {FromNick, Packet}, StateData),
|
2016-10-17 12:37:23 +02:00
|
|
|
case check_subject(Packet) of
|
2017-11-13 09:25:35 +01:00
|
|
|
[] ->
|
2016-10-17 12:37:23 +02:00
|
|
|
TimeStamp = p1_time_compat:timestamp(),
|
|
|
|
AddrPacket = case (StateData#state.config)#config.anonymous of
|
|
|
|
true -> Packet;
|
|
|
|
false ->
|
|
|
|
Addresses = #addresses{
|
|
|
|
list = [#address{type = ofrom,
|
|
|
|
jid = FromJID}]},
|
|
|
|
xmpp:set_subtag(Packet, Addresses)
|
|
|
|
end,
|
2018-10-25 01:05:45 +02:00
|
|
|
TSPacket = misc:add_delay_info(
|
2016-10-17 12:37:23 +02:00
|
|
|
AddrPacket, StateData#state.jid, TimeStamp),
|
|
|
|
SPacket = xmpp:set_from_to(
|
|
|
|
TSPacket,
|
|
|
|
jid:replace_resource(StateData#state.jid, FromNick),
|
|
|
|
StateData#state.jid),
|
|
|
|
Size = element_size(SPacket),
|
|
|
|
Q1 = lqueue_in({FromNick, TSPacket, false,
|
|
|
|
TimeStamp, Size},
|
|
|
|
StateData#state.history),
|
|
|
|
StateData#state{history = Q1};
|
|
|
|
_ ->
|
|
|
|
StateData
|
|
|
|
end.
|
|
|
|
|
2017-03-10 13:12:43 +01:00
|
|
|
-spec send_history(jid(), list(), state()) -> ok.
|
2016-10-17 12:37:23 +02:00
|
|
|
send_history(JID, History, StateData) ->
|
|
|
|
lists:foreach(
|
|
|
|
fun({Nick, Packet, _HaveSubject, _TimeStamp, _Size}) ->
|
|
|
|
ejabberd_router:route(
|
2017-02-16 09:00:26 +01:00
|
|
|
xmpp:set_from_to(
|
|
|
|
Packet,
|
|
|
|
jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
JID))
|
2017-03-10 13:12:43 +01:00
|
|
|
end, History).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_subject(jid(), state()) -> ok.
|
2015-11-25 00:05:24 +01:00
|
|
|
send_subject(JID, #state{subject_author = Nick} = StateData) ->
|
2016-10-17 12:37:23 +02:00
|
|
|
Subject = case StateData#state.subject of
|
2017-11-13 09:25:35 +01:00
|
|
|
[] -> [#text{}];
|
|
|
|
[_|_] = S -> S
|
2016-10-17 12:37:23 +02:00
|
|
|
end,
|
2017-02-16 09:00:26 +01:00
|
|
|
Packet = #message{from = jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
to = JID, type = groupchat, subject = Subject},
|
|
|
|
ejabberd_router:route(Packet).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2017-11-13 09:25:35 +01:00
|
|
|
-spec check_subject(message()) -> [text()].
|
2016-10-17 12:37:23 +02:00
|
|
|
check_subject(#message{subject = [_|_] = Subj, body = [],
|
|
|
|
thread = undefined}) ->
|
2017-11-13 09:25:35 +01:00
|
|
|
Subj;
|
2016-10-17 12:37:23 +02:00
|
|
|
check_subject(_) ->
|
2017-11-13 09:25:35 +01:00
|
|
|
[].
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-11-12 11:27:15 +01:00
|
|
|
-spec can_change_subject(role(), boolean(), state()) -> boolean().
|
2016-10-20 20:34:48 +02:00
|
|
|
can_change_subject(Role, IsSubscriber, StateData) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
case (StateData#state.config)#config.allow_change_subj
|
|
|
|
of
|
2016-10-20 20:34:48 +02:00
|
|
|
true -> Role == moderator orelse Role == participant orelse IsSubscriber == true;
|
2013-03-14 10:33:02 +01:00
|
|
|
_ -> Role == moderator
|
2003-03-26 21:51:18 +01:00
|
|
|
end.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
% Admin stuff
|
|
|
|
|
2016-09-08 16:08:48 +02:00
|
|
|
-spec process_iq_admin(jid(), iq(), #state{}) -> {error, stanza_error()} |
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, undefined, #state{}} |
|
|
|
|
{result, muc_admin()}.
|
|
|
|
process_iq_admin(_From, #iq{lang = Lang, sub_els = [#muc_admin{items = []}]},
|
|
|
|
_StateData) ->
|
|
|
|
Txt = <<"No 'item' element found">>,
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)};
|
|
|
|
process_iq_admin(From, #iq{type = set, lang = Lang,
|
|
|
|
sub_els = [#muc_admin{items = Items}]},
|
|
|
|
StateData) ->
|
2004-03-02 22:16:55 +01:00
|
|
|
process_admin_items_set(From, Items, Lang, StateData);
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_admin(From, #iq{type = get, lang = Lang,
|
|
|
|
sub_els = [#muc_admin{items = [Item]}]},
|
|
|
|
StateData) ->
|
|
|
|
FAffiliation = get_affiliation(From, StateData),
|
|
|
|
FRole = get_role(From, StateData),
|
|
|
|
case Item of
|
|
|
|
#muc_item{role = undefined, affiliation = undefined} ->
|
|
|
|
Txt = <<"Neither 'role' nor 'affiliation' attribute found">>,
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)};
|
|
|
|
#muc_item{role = undefined, affiliation = Affiliation} ->
|
|
|
|
if (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) or
|
|
|
|
((FAffiliation == member) and
|
|
|
|
not (StateData#state.config)#config.anonymous) ->
|
|
|
|
Items = items_with_affiliation(Affiliation, StateData),
|
|
|
|
{result, #muc_admin{items = Items}};
|
|
|
|
true ->
|
|
|
|
ErrText = <<"Administrator privileges required">>,
|
|
|
|
{error, xmpp:err_forbidden(ErrText, Lang)}
|
|
|
|
end;
|
|
|
|
#muc_item{role = Role} ->
|
|
|
|
if FRole == moderator ->
|
|
|
|
Items = items_with_role(Role, StateData),
|
|
|
|
{result, #muc_admin{items = Items}};
|
|
|
|
true ->
|
|
|
|
ErrText = <<"Moderator privileges required">>,
|
|
|
|
{error, xmpp:err_forbidden(ErrText, Lang)}
|
|
|
|
end
|
|
|
|
end;
|
|
|
|
process_iq_admin(_From, #iq{type = get, lang = Lang}, _StateData) ->
|
|
|
|
ErrText = <<"Too many <item/> elements">>,
|
|
|
|
{error, xmpp:err_bad_request(ErrText, Lang)}.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec items_with_role(role(), state()) -> [muc_item()].
|
2003-03-23 21:08:44 +01:00
|
|
|
items_with_role(SRole, StateData) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
lists:map(fun ({_, U}) -> user_to_item(U, StateData)
|
|
|
|
end,
|
|
|
|
search_role(SRole, StateData)).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec items_with_affiliation(affiliation(), state()) -> [muc_item()].
|
2003-03-23 21:08:44 +01:00
|
|
|
items_with_affiliation(SAffiliation, StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
lists:map(
|
|
|
|
fun({JID, {Affiliation, Reason}}) ->
|
2016-10-17 12:37:23 +02:00
|
|
|
#muc_item{affiliation = Affiliation, jid = jid:make(JID),
|
2016-08-05 07:41:08 +02:00
|
|
|
reason = Reason};
|
2016-07-25 12:50:30 +02:00
|
|
|
({JID, Affiliation}) ->
|
2016-10-17 12:37:23 +02:00
|
|
|
#muc_item{affiliation = Affiliation, jid = jid:make(JID)}
|
2016-07-25 12:50:30 +02:00
|
|
|
end,
|
|
|
|
search_affiliation(SAffiliation, StateData)).
|
2013-03-14 10:33:02 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec user_to_item(#user{}, state()) -> muc_item().
|
2013-03-14 10:33:02 +01:00
|
|
|
user_to_item(#user{role = Role, nick = Nick, jid = JID},
|
|
|
|
StateData) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
Affiliation = get_affiliation(JID, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
#muc_item{role = Role,
|
|
|
|
affiliation = Affiliation,
|
|
|
|
nick = Nick,
|
|
|
|
jid = JID}.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec search_role(role(), state()) -> [{ljid(), #user{}}].
|
2003-03-23 21:08:44 +01:00
|
|
|
search_role(Role, StateData) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
lists:filter(fun ({_, #user{role = R}}) -> Role == R
|
|
|
|
end,
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:to_list(StateData#state.users)).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec search_affiliation(affiliation(), state()) ->
|
2018-04-23 10:35:43 +02:00
|
|
|
[{ljid(),
|
|
|
|
affiliation() | {affiliation(), binary()}}].
|
|
|
|
search_affiliation(Affiliation,
|
|
|
|
#state{config = #config{persistent = false}} = StateData) ->
|
|
|
|
search_affiliation_fallback(Affiliation, StateData);
|
2003-03-23 21:08:44 +01:00
|
|
|
search_affiliation(Affiliation, StateData) ->
|
2018-04-23 10:35:43 +02:00
|
|
|
Room = StateData#state.room,
|
|
|
|
Host = StateData#state.host,
|
|
|
|
ServerHost = StateData#state.server_host,
|
|
|
|
Mod = gen_mod:db_mod(ServerHost, mod_muc),
|
|
|
|
case Mod:search_affiliation(ServerHost, Room, Host, Affiliation) of
|
|
|
|
{ok, AffiliationList} ->
|
|
|
|
AffiliationList;
|
|
|
|
{error, _} ->
|
|
|
|
search_affiliation_fallback(Affiliation, StateData)
|
|
|
|
end.
|
|
|
|
|
|
|
|
-spec search_affiliation_fallback(affiliation(), state()) ->
|
|
|
|
[{ljid(),
|
|
|
|
affiliation() | {affiliation(), binary()}}].
|
|
|
|
search_affiliation_fallback(Affiliation, StateData) ->
|
|
|
|
lists:filter(
|
|
|
|
fun({_, A}) ->
|
|
|
|
case A of
|
|
|
|
{A1, _Reason} -> Affiliation == A1;
|
|
|
|
_ -> Affiliation == A
|
|
|
|
end
|
2018-11-15 12:13:45 +01:00
|
|
|
end, maps:to_list(StateData#state.affiliations)).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-08-05 07:41:08 +02:00
|
|
|
-spec process_admin_items_set(jid(), [muc_item()], binary(),
|
2016-07-25 12:50:30 +02:00
|
|
|
#state{}) -> {result, undefined, #state{}} |
|
2016-09-08 16:08:48 +02:00
|
|
|
{error, stanza_error()}.
|
2004-03-02 22:16:55 +01:00
|
|
|
process_admin_items_set(UJID, Items, Lang, StateData) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
UAffiliation = get_affiliation(UJID, StateData),
|
|
|
|
URole = get_role(UJID, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
case catch find_changed_items(UJID, UAffiliation, URole,
|
|
|
|
Items, Lang, StateData, [])
|
2013-03-14 10:33:02 +01:00
|
|
|
of
|
|
|
|
{result, Res} ->
|
|
|
|
?INFO_MSG("Processing MUC admin query from ~s in "
|
|
|
|
"room ~s:~n ~p",
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(UJID),
|
|
|
|
jid:encode(StateData#state.jid), Res]),
|
2016-10-17 12:37:23 +02:00
|
|
|
case lists:foldl(process_item_change(UJID),
|
|
|
|
StateData, lists:flatten(Res)) of
|
|
|
|
{error, _} = Err ->
|
|
|
|
Err;
|
|
|
|
NSD ->
|
|
|
|
store_room(NSD),
|
|
|
|
{result, undefined, NSD}
|
|
|
|
end;
|
|
|
|
{error, Err} -> {error, Err}
|
2003-03-23 21:08:44 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec process_item_change(jid()) -> function().
|
2015-02-25 16:31:27 +01:00
|
|
|
process_item_change(UJID) ->
|
2016-10-17 12:37:23 +02:00
|
|
|
fun(_, {error, _} = Err) ->
|
|
|
|
Err;
|
|
|
|
(Item, SD) ->
|
|
|
|
process_item_change(Item, SD, UJID)
|
2015-02-25 16:31:27 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-type admin_action() :: {jid(), affiliation | role,
|
|
|
|
affiliation() | role(), binary()}.
|
|
|
|
|
2017-06-21 15:44:09 +02:00
|
|
|
-spec process_item_change(admin_action(), state(), undefined | jid()) -> state() | {error, stanza_error()}.
|
2016-07-25 12:50:30 +02:00
|
|
|
process_item_change(Item, SD, UJID) ->
|
|
|
|
try case Item of
|
|
|
|
{JID, affiliation, owner, _} when JID#jid.luser == <<"">> ->
|
|
|
|
%% If the provided JID does not have username,
|
|
|
|
%% forget the affiliation completely
|
|
|
|
SD;
|
|
|
|
{JID, role, none, Reason} ->
|
2016-10-17 12:37:23 +02:00
|
|
|
send_kickban_presence(UJID, JID, Reason, 307, SD),
|
2016-07-25 12:50:30 +02:00
|
|
|
set_role(JID, none, SD);
|
|
|
|
{JID, affiliation, none, Reason} ->
|
|
|
|
case (SD#state.config)#config.members_only of
|
|
|
|
true ->
|
2016-10-17 12:37:23 +02:00
|
|
|
send_kickban_presence(UJID, JID, Reason, 321, none, SD),
|
2016-07-25 12:50:30 +02:00
|
|
|
maybe_send_affiliation(JID, none, SD),
|
|
|
|
SD1 = set_affiliation(JID, none, SD),
|
|
|
|
set_role(JID, none, SD1);
|
|
|
|
_ ->
|
|
|
|
SD1 = set_affiliation(JID, none, SD),
|
2016-10-17 12:37:23 +02:00
|
|
|
send_update_presence(JID, Reason, SD1, SD),
|
2016-07-25 12:50:30 +02:00
|
|
|
maybe_send_affiliation(JID, none, SD1),
|
|
|
|
SD1
|
|
|
|
end;
|
|
|
|
{JID, affiliation, outcast, Reason} ->
|
2016-10-17 12:37:23 +02:00
|
|
|
send_kickban_presence(UJID, JID, Reason, 301, outcast, SD),
|
2016-07-25 12:50:30 +02:00
|
|
|
maybe_send_affiliation(JID, outcast, SD),
|
|
|
|
set_affiliation(JID, outcast, set_role(JID, none, SD), Reason);
|
|
|
|
{JID, affiliation, A, Reason} when (A == admin) or (A == owner) ->
|
|
|
|
SD1 = set_affiliation(JID, A, SD, Reason),
|
|
|
|
SD2 = set_role(JID, moderator, SD1),
|
|
|
|
send_update_presence(JID, Reason, SD2, SD),
|
|
|
|
maybe_send_affiliation(JID, A, SD2),
|
|
|
|
SD2;
|
|
|
|
{JID, affiliation, member, Reason} ->
|
|
|
|
SD1 = set_affiliation(JID, member, SD, Reason),
|
|
|
|
SD2 = set_role(JID, participant, SD1),
|
|
|
|
send_update_presence(JID, Reason, SD2, SD),
|
|
|
|
maybe_send_affiliation(JID, member, SD2),
|
|
|
|
SD2;
|
|
|
|
{JID, role, Role, Reason} ->
|
|
|
|
SD1 = set_role(JID, Role, SD),
|
2016-10-17 12:37:23 +02:00
|
|
|
send_new_presence(JID, Reason, SD1, SD),
|
2016-07-25 12:50:30 +02:00
|
|
|
SD1;
|
|
|
|
{JID, affiliation, A, _Reason} ->
|
|
|
|
SD1 = set_affiliation(JID, A, SD),
|
|
|
|
send_update_presence(JID, SD1, SD),
|
|
|
|
maybe_send_affiliation(JID, A, SD1),
|
|
|
|
SD1
|
|
|
|
end
|
|
|
|
catch E:R ->
|
2017-06-21 15:44:09 +02:00
|
|
|
FromSuffix = case UJID of
|
|
|
|
#jid{} ->
|
|
|
|
JidString = jid:encode(UJID),
|
|
|
|
<<" from ", JidString/binary>>;
|
|
|
|
undefined ->
|
|
|
|
<<"">>
|
|
|
|
end,
|
2018-09-01 18:37:26 +02:00
|
|
|
St = erlang:get_stacktrace(),
|
2017-06-21 15:44:09 +02:00
|
|
|
?ERROR_MSG("failed to set item ~p~s: ~p",
|
2018-09-01 18:37:26 +02:00
|
|
|
[Item, FromSuffix, {E, {R, St}}]),
|
2016-10-17 12:37:23 +02:00
|
|
|
{error, xmpp:err_internal_server_error()}
|
2015-02-25 16:31:27 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec find_changed_items(jid(), affiliation(), role(),
|
|
|
|
[muc_item()], binary(), state(), [admin_action()]) ->
|
|
|
|
{result, [admin_action()]}.
|
2013-03-14 10:33:02 +01:00
|
|
|
find_changed_items(_UJID, _UAffiliation, _URole, [],
|
|
|
|
_Lang, _StateData, Res) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
{result, Res};
|
2016-07-25 12:50:30 +02:00
|
|
|
find_changed_items(_UJID, _UAffiliation, _URole,
|
2017-02-18 07:36:27 +01:00
|
|
|
[#muc_item{jid = undefined, nick = <<"">>}|_],
|
2016-07-25 12:50:30 +02:00
|
|
|
Lang, _StateData, _Res) ->
|
|
|
|
Txt = <<"Neither 'jid' nor 'nick' attribute found">>,
|
|
|
|
throw({error, xmpp:err_bad_request(Txt, Lang)});
|
|
|
|
find_changed_items(_UJID, _UAffiliation, _URole,
|
|
|
|
[#muc_item{role = undefined, affiliation = undefined}|_],
|
|
|
|
Lang, _StateData, _Res) ->
|
|
|
|
Txt = <<"Neither 'role' nor 'affiliation' attribute found">>,
|
|
|
|
throw({error, xmpp:err_bad_request(Txt, Lang)});
|
2003-03-23 21:08:44 +01:00
|
|
|
find_changed_items(UJID, UAffiliation, URole,
|
2016-08-05 07:41:08 +02:00
|
|
|
[#muc_item{jid = J, nick = Nick, reason = Reason,
|
2016-07-25 12:50:30 +02:00
|
|
|
role = Role, affiliation = Affiliation}|Items],
|
2004-03-02 22:16:55 +01:00
|
|
|
Lang, StateData, Res) ->
|
2017-10-30 13:27:37 +01:00
|
|
|
[JID | _] = JIDs =
|
2016-07-25 12:50:30 +02:00
|
|
|
if J /= undefined ->
|
|
|
|
[J];
|
2016-08-05 07:41:08 +02:00
|
|
|
Nick /= <<"">> ->
|
2016-07-25 12:50:30 +02:00
|
|
|
case find_jids_by_nick(Nick, StateData) of
|
|
|
|
[] ->
|
2017-09-23 23:08:01 +02:00
|
|
|
ErrText = {<<"Nickname ~s does not exist in the room">>,
|
|
|
|
[Nick]},
|
2016-07-25 12:50:30 +02:00
|
|
|
throw({error, xmpp:err_not_acceptable(ErrText, Lang)});
|
|
|
|
JIDList ->
|
|
|
|
JIDList
|
2013-03-14 10:33:02 +01:00
|
|
|
end
|
2016-07-25 12:50:30 +02:00
|
|
|
end,
|
|
|
|
{RoleOrAff, RoleOrAffValue} = if Role == undefined ->
|
|
|
|
{affiliation, Affiliation};
|
|
|
|
true ->
|
|
|
|
{role, Role}
|
|
|
|
end,
|
|
|
|
TAffiliation = get_affiliation(JID, StateData),
|
|
|
|
TRole = get_role(JID, StateData),
|
|
|
|
ServiceAf = get_service_affiliation(JID, StateData),
|
2018-09-20 11:14:11 +02:00
|
|
|
UIsSubscriber = is_subscriber(UJID, StateData),
|
|
|
|
URole1 = case {URole, UIsSubscriber} of
|
|
|
|
{none, true} -> subscriber;
|
|
|
|
{UR, _} -> UR
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
CanChangeRA = case can_change_ra(UAffiliation,
|
2018-09-20 11:14:11 +02:00
|
|
|
URole1,
|
2016-07-25 12:50:30 +02:00
|
|
|
TAffiliation,
|
|
|
|
TRole, RoleOrAff, RoleOrAffValue,
|
|
|
|
ServiceAf) of
|
|
|
|
nothing -> nothing;
|
|
|
|
true -> true;
|
|
|
|
check_owner ->
|
|
|
|
case search_affiliation(owner, StateData) of
|
|
|
|
[{OJID, _}] ->
|
|
|
|
jid:remove_resource(OJID)
|
|
|
|
/=
|
|
|
|
jid:tolower(jid:remove_resource(UJID));
|
|
|
|
_ -> true
|
|
|
|
end;
|
|
|
|
_ -> false
|
|
|
|
end,
|
|
|
|
case CanChangeRA of
|
|
|
|
nothing ->
|
|
|
|
find_changed_items(UJID, UAffiliation, URole,
|
|
|
|
Items, Lang, StateData,
|
|
|
|
Res);
|
|
|
|
true ->
|
2016-10-17 12:37:23 +02:00
|
|
|
MoreRes = case RoleOrAff of
|
|
|
|
affiliation ->
|
|
|
|
[{jid:remove_resource(Jidx),
|
|
|
|
RoleOrAff, RoleOrAffValue, Reason}
|
|
|
|
|| Jidx <- JIDs];
|
|
|
|
role ->
|
|
|
|
[{Jidx, RoleOrAff, RoleOrAffValue, Reason}
|
|
|
|
|| Jidx <- JIDs]
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
find_changed_items(UJID, UAffiliation, URole,
|
|
|
|
Items, Lang, StateData,
|
2017-02-18 07:36:27 +01:00
|
|
|
MoreRes ++ Res);
|
2016-07-25 12:50:30 +02:00
|
|
|
false ->
|
|
|
|
Txt = <<"Changing role/affiliation is not allowed">>,
|
|
|
|
throw({error, xmpp:err_not_allowed(Txt, Lang)})
|
|
|
|
end.
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec can_change_ra(affiliation(), role(), affiliation(), role(),
|
2017-02-18 07:36:27 +01:00
|
|
|
affiliation, affiliation(), affiliation()) -> boolean() | nothing | check_owner;
|
2016-07-25 12:50:30 +02:00
|
|
|
(affiliation(), role(), affiliation(), role(),
|
2017-02-18 07:36:27 +01:00
|
|
|
role, role(), affiliation()) -> boolean() | nothing | check_owner.
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, owner, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, owner, owner) ->
|
|
|
|
%% A room owner tries to add as persistent owner a
|
|
|
|
%% participant that is already owner because he is MUC admin
|
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, _TAffiliation,
|
|
|
|
_TRole, _RoleorAffiliation, _Value, owner) ->
|
2011-04-17 17:03:07 +02:00
|
|
|
%% Nobody can decrease MUC admin's role/affiliation
|
|
|
|
false;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, TAffiliation,
|
|
|
|
_TRole, affiliation, Value, _ServiceAf)
|
|
|
|
when TAffiliation == Value ->
|
2003-03-23 21:08:44 +01:00
|
|
|
nothing;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, _TAffiliation,
|
|
|
|
TRole, role, Value, _ServiceAf)
|
|
|
|
when TRole == Value ->
|
2003-03-23 21:08:44 +01:00
|
|
|
nothing;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, outcast, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, none, _ServiceAf)
|
2013-03-14 10:33:02 +01:00
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, outcast, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, member, _ServiceAf)
|
2013-03-14 10:33:02 +01:00
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2005-05-02 23:59:39 +02:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, outcast, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, admin, _ServiceAf) ->
|
2005-05-02 23:59:39 +02:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, outcast, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, owner, _ServiceAf) ->
|
2005-05-02 23:59:39 +02:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, none, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, outcast, _ServiceAf)
|
2013-03-14 10:33:02 +01:00
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, none, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, member, _ServiceAf)
|
2013-03-14 10:33:02 +01:00
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, none, _TRole, affiliation,
|
|
|
|
admin, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, none, _TRole, affiliation,
|
|
|
|
owner, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, member, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, outcast, _ServiceAf)
|
2013-03-14 10:33:02 +01:00
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, member, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, none, _ServiceAf)
|
2013-03-14 10:33:02 +01:00
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, member, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, admin, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, member, _TRole,
|
2008-07-17 19:32:11 +02:00
|
|
|
affiliation, owner, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, admin, _TRole, affiliation,
|
|
|
|
_Affiliation, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, owner, _TRole, affiliation,
|
|
|
|
_Affiliation, _ServiceAf) ->
|
2006-03-06 03:30:15 +01:00
|
|
|
check_owner;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, _TAffiliation,
|
|
|
|
_TRole, affiliation, _Value, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
false;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, moderator, _TAffiliation,
|
|
|
|
visitor, role, none, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2018-09-24 11:20:10 +02:00
|
|
|
can_change_ra(FAffiliation, subscriber, _TAffiliation,
|
|
|
|
visitor, role, none, _ServiceAf)
|
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, moderator, _TAffiliation,
|
|
|
|
visitor, role, participant, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2018-09-20 11:14:11 +02:00
|
|
|
can_change_ra(FAffiliation, subscriber, _TAffiliation,
|
|
|
|
visitor, role, participant, _ServiceAf)
|
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, _TAffiliation,
|
|
|
|
visitor, role, moderator, _ServiceAf)
|
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, moderator, _TAffiliation,
|
|
|
|
participant, role, none, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2018-09-24 11:20:10 +02:00
|
|
|
can_change_ra(FAffiliation, subscriber, _TAffiliation,
|
|
|
|
participant, role, none, _ServiceAf)
|
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, moderator, _TAffiliation,
|
|
|
|
participant, role, visitor, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2018-09-20 11:14:11 +02:00
|
|
|
can_change_ra(FAffiliation, subscriber, _TAffiliation,
|
|
|
|
participant, role, visitor, _ServiceAf)
|
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(FAffiliation, _FRole, _TAffiliation,
|
|
|
|
participant, role, moderator, _ServiceAf)
|
|
|
|
when (FAffiliation == owner) or
|
|
|
|
(FAffiliation == admin) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, owner, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, visitor, _ServiceAf) ->
|
2005-05-02 23:59:39 +02:00
|
|
|
false;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, _TAffiliation, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, visitor, _ServiceAf) ->
|
2005-05-02 23:59:39 +02:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, admin, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, visitor, _ServiceAf) ->
|
2005-05-02 23:59:39 +02:00
|
|
|
false;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(admin, _FRole, _TAffiliation, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, visitor, _ServiceAf) ->
|
2005-05-02 23:59:39 +02:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, owner, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, participant, _ServiceAf) ->
|
2004-01-17 21:26:57 +01:00
|
|
|
false;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(owner, _FRole, _TAffiliation, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, participant, _ServiceAf) ->
|
2004-01-17 21:26:57 +01:00
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, admin, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, participant, _ServiceAf) ->
|
2004-01-17 21:26:57 +01:00
|
|
|
false;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(admin, _FRole, _TAffiliation, moderator,
|
2008-07-17 19:32:11 +02:00
|
|
|
role, participant, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
true;
|
2018-09-25 10:27:17 +02:00
|
|
|
can_change_ra(owner, moderator, TAffiliation,
|
|
|
|
moderator, role, none, _ServiceAf)
|
|
|
|
when TAffiliation /= owner ->
|
|
|
|
true;
|
2018-09-25 10:43:38 +02:00
|
|
|
can_change_ra(owner, subscriber, TAffiliation,
|
|
|
|
moderator, role, none, _ServiceAf)
|
|
|
|
when TAffiliation /= owner ->
|
|
|
|
true;
|
2018-09-25 10:27:17 +02:00
|
|
|
can_change_ra(admin, moderator, TAffiliation,
|
|
|
|
moderator, role, none, _ServiceAf)
|
|
|
|
when (TAffiliation /= owner) and
|
2018-09-25 10:43:38 +02:00
|
|
|
(TAffiliation /= admin) ->
|
|
|
|
true;
|
|
|
|
can_change_ra(admin, subscriber, TAffiliation,
|
|
|
|
moderator, role, none, _ServiceAf)
|
|
|
|
when (TAffiliation /= owner) and
|
2018-09-25 10:27:17 +02:00
|
|
|
(TAffiliation /= admin) ->
|
|
|
|
true;
|
2013-03-14 10:33:02 +01:00
|
|
|
can_change_ra(_FAffiliation, _FRole, _TAffiliation,
|
|
|
|
_TRole, role, _Value, _ServiceAf) ->
|
2003-03-23 21:08:44 +01:00
|
|
|
false.
|
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec send_kickban_presence(undefined | jid(), jid(), binary(),
|
2016-07-25 12:50:30 +02:00
|
|
|
pos_integer(), state()) -> ok.
|
2013-04-24 11:00:04 +02:00
|
|
|
send_kickban_presence(UJID, JID, Reason, Code, StateData) ->
|
2010-11-16 00:03:09 +01:00
|
|
|
NewAffiliation = get_affiliation(JID, StateData),
|
2013-04-24 11:00:04 +02:00
|
|
|
send_kickban_presence(UJID, JID, Reason, Code, NewAffiliation,
|
2013-03-14 10:33:02 +01:00
|
|
|
StateData).
|
2010-11-16 00:03:09 +01:00
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec send_kickban_presence(undefined | jid(), jid(), binary(), pos_integer(),
|
2016-07-25 12:50:30 +02:00
|
|
|
affiliation(), state()) -> ok.
|
2013-04-24 11:00:04 +02:00
|
|
|
send_kickban_presence(UJID, JID, Reason, Code, NewAffiliation,
|
2013-03-14 10:33:02 +01:00
|
|
|
StateData) ->
|
2015-11-24 16:44:13 +01:00
|
|
|
LJID = jid:tolower(JID),
|
2003-04-13 21:22:46 +02:00
|
|
|
LJIDs = case LJID of
|
2018-11-15 12:13:45 +01:00
|
|
|
{U, S, <<"">>} ->
|
|
|
|
maps:fold(fun (J, _, Js) ->
|
|
|
|
case J of
|
|
|
|
{U, S, _} -> [J | Js];
|
|
|
|
_ -> Js
|
|
|
|
end
|
|
|
|
end, [], StateData#state.users);
|
|
|
|
_ ->
|
|
|
|
case maps:is_key(LJID, StateData#state.users) of
|
|
|
|
true -> [LJID];
|
|
|
|
_ -> []
|
|
|
|
end
|
2003-04-13 21:22:46 +02:00
|
|
|
end,
|
2013-03-14 10:33:02 +01:00
|
|
|
lists:foreach(fun (J) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{nick = Nick} = maps:get(J, StateData#state.users),
|
2006-03-14 05:26:15 +01:00
|
|
|
add_to_log(kickban, {Nick, Reason, Code}, StateData),
|
2007-12-03 11:47:42 +01:00
|
|
|
tab_remove_online_user(J, StateData),
|
2013-04-24 11:00:04 +02:00
|
|
|
send_kickban_presence1(UJID, J, Reason, Code,
|
2013-03-14 10:33:02 +01:00
|
|
|
NewAffiliation, StateData)
|
|
|
|
end,
|
|
|
|
LJIDs).
|
2003-04-13 21:22:46 +02:00
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec send_kickban_presence1(undefined | jid(), jid(), binary(), pos_integer(),
|
2016-07-25 12:50:30 +02:00
|
|
|
affiliation(), state()) -> ok.
|
2013-04-24 11:00:04 +02:00
|
|
|
send_kickban_presence1(MJID, UJID, Reason, Code, Affiliation,
|
2013-03-14 10:33:02 +01:00
|
|
|
StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
#user{jid = RealJID, nick = Nick} = maps:get(jid:tolower(UJID), StateData#state.users),
|
2016-06-03 00:08:58 +02:00
|
|
|
ActorNick = get_actor_nick(MJID, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(LJID, Info, _) ->
|
2016-10-17 12:37:23 +02:00
|
|
|
IsSelfPresence = jid:tolower(UJID) == LJID,
|
2016-07-25 12:50:30 +02:00
|
|
|
Item0 = #muc_item{affiliation = Affiliation,
|
|
|
|
role = none},
|
|
|
|
Item1 = case Info#user.role == moderator orelse
|
|
|
|
(StateData#state.config)#config.anonymous
|
2016-10-17 12:37:23 +02:00
|
|
|
== false orelse IsSelfPresence of
|
2016-07-25 12:50:30 +02:00
|
|
|
true -> Item0#muc_item{jid = RealJID};
|
|
|
|
false -> Item0
|
|
|
|
end,
|
2016-08-05 07:41:08 +02:00
|
|
|
Item2 = Item1#muc_item{reason = Reason},
|
2016-07-25 12:50:30 +02:00
|
|
|
Item = case ActorNick of
|
|
|
|
<<"">> -> Item2;
|
|
|
|
_ -> Item2#muc_item{actor = #muc_actor{nick = ActorNick}}
|
|
|
|
end,
|
2016-10-17 12:37:23 +02:00
|
|
|
Codes = if IsSelfPresence -> [110, Code];
|
|
|
|
true -> [Code]
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
Packet = #presence{type = unavailable,
|
|
|
|
sub_els = [#muc_user{items = [Item],
|
2016-10-17 12:37:23 +02:00
|
|
|
status_codes = Codes}]},
|
2016-07-25 12:50:30 +02:00
|
|
|
RoomJIDNick = jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
send_wrapped(RoomJIDNick, Info#user.jid, Packet,
|
|
|
|
?NS_MUCSUB_NODES_AFFILIATIONS, StateData),
|
2016-09-07 09:33:37 +02:00
|
|
|
IsSubscriber = is_subscriber(Info#user.jid, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
IsOccupant = Info#user.last_presence /= undefined,
|
|
|
|
if (IsSubscriber and not IsOccupant) ->
|
|
|
|
send_wrapped(RoomJIDNick, Info#user.jid, Packet,
|
|
|
|
?NS_MUCSUB_NODES_PARTICIPANTS, StateData);
|
|
|
|
true ->
|
|
|
|
ok
|
|
|
|
end
|
2018-11-15 12:13:45 +01:00
|
|
|
end, ok, get_users_and_subscribers(StateData)).
|
2003-03-23 21:08:44 +01:00
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec get_actor_nick(undefined | jid(), state()) -> binary().
|
|
|
|
get_actor_nick(undefined, _StateData) ->
|
2016-06-03 00:08:58 +02:00
|
|
|
<<"">>;
|
|
|
|
get_actor_nick(MJID, StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(jid:tolower(MJID), StateData#state.users) of
|
|
|
|
#user{nick = ActorNick} -> ActorNick
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} -> <<"">>
|
2016-06-03 00:08:58 +02:00
|
|
|
end.
|
|
|
|
|
2017-01-19 09:12:27 +01:00
|
|
|
convert_legacy_fields(Fs) ->
|
|
|
|
lists:map(
|
|
|
|
fun(#xdata_field{var = Var} = F) ->
|
|
|
|
NewVar = case Var of
|
|
|
|
<<"muc#roomconfig_allowvisitorstatus">> ->
|
|
|
|
<<"allow_visitor_status">>;
|
|
|
|
<<"muc#roomconfig_allowvisitornickchange">> ->
|
|
|
|
<<"allow_visitor_nickchange">>;
|
|
|
|
<<"muc#roomconfig_allowvoicerequests">> ->
|
|
|
|
<<"allow_voice_requests">>;
|
|
|
|
<<"muc#roomconfig_allow_subscription">> ->
|
|
|
|
<<"allow_subscription">>;
|
|
|
|
<<"muc#roomconfig_voicerequestmininterval">> ->
|
|
|
|
<<"voice_request_min_interval">>;
|
|
|
|
<<"muc#roomconfig_captcha_whitelist">> ->
|
|
|
|
<<"captcha_whitelist">>;
|
2017-01-19 14:42:04 +01:00
|
|
|
<<"muc#roomconfig_mam">> ->
|
|
|
|
<<"mam">>;
|
2017-01-19 09:12:27 +01:00
|
|
|
_ ->
|
|
|
|
Var
|
|
|
|
end,
|
|
|
|
F#xdata_field{var = NewVar}
|
|
|
|
end, Fs).
|
|
|
|
|
2003-03-25 22:03:35 +01:00
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
% Owner stuff
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec process_iq_owner(jid(), iq(), state()) ->
|
|
|
|
{result, undefined | muc_owner()} |
|
|
|
|
{result, undefined | muc_owner(), state() | stop} |
|
2016-09-08 16:08:48 +02:00
|
|
|
{error, stanza_error()}.
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_owner(From, #iq{type = set, lang = Lang,
|
|
|
|
sub_els = [#muc_owner{destroy = Destroy,
|
|
|
|
config = Config,
|
|
|
|
items = Items}]},
|
|
|
|
StateData) ->
|
2003-03-25 22:03:35 +01:00
|
|
|
FAffiliation = get_affiliation(From, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
if FAffiliation /= owner ->
|
|
|
|
ErrText = <<"Owner privileges required">>,
|
|
|
|
{error, xmpp:err_forbidden(ErrText, Lang)};
|
|
|
|
Destroy /= undefined, Config == undefined, Items == [] ->
|
|
|
|
?INFO_MSG("Destroyed MUC room ~s by the owner ~s",
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(StateData#state.jid), jid:encode(From)]),
|
2016-07-25 12:50:30 +02:00
|
|
|
add_to_log(room_existence, destroyed, StateData),
|
|
|
|
destroy_room(Destroy, StateData);
|
|
|
|
Config /= undefined, Destroy == undefined, Items == [] ->
|
|
|
|
case Config of
|
|
|
|
#xdata{type = cancel} ->
|
|
|
|
{result, undefined};
|
2016-10-17 12:37:23 +02:00
|
|
|
#xdata{type = submit, fields = Fs} ->
|
2017-01-19 09:12:27 +01:00
|
|
|
Fs1 = convert_legacy_fields(Fs),
|
|
|
|
try muc_roomconfig:decode(Fs1) of
|
2016-10-17 12:37:23 +02:00
|
|
|
Options ->
|
|
|
|
case is_allowed_log_change(Options, StateData, From) andalso
|
|
|
|
is_allowed_persistent_change(Options, StateData, From) andalso
|
|
|
|
is_allowed_room_name_desc_limits(Options, StateData) andalso
|
|
|
|
is_password_settings_correct(Options, StateData) of
|
|
|
|
true ->
|
|
|
|
set_config(Options, StateData, Lang);
|
|
|
|
false ->
|
|
|
|
{error, xmpp:err_not_acceptable()}
|
|
|
|
end
|
|
|
|
catch _:{muc_roomconfig, Why} ->
|
|
|
|
Txt = muc_roomconfig:format_error(Why),
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)}
|
2016-07-25 12:50:30 +02:00
|
|
|
end;
|
|
|
|
_ ->
|
|
|
|
Txt = <<"Incorrect data form">>,
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)}
|
|
|
|
end;
|
|
|
|
Items /= [], Config == undefined, Destroy == undefined ->
|
|
|
|
process_admin_items_set(From, Items, Lang, StateData);
|
|
|
|
true ->
|
|
|
|
{error, xmpp:err_bad_request()}
|
2003-03-25 22:03:35 +01:00
|
|
|
end;
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_owner(From, #iq{type = get, lang = Lang,
|
|
|
|
sub_els = [#muc_owner{destroy = Destroy,
|
|
|
|
config = Config,
|
|
|
|
items = Items}]},
|
|
|
|
StateData) ->
|
2003-03-25 22:03:35 +01:00
|
|
|
FAffiliation = get_affiliation(From, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
if FAffiliation /= owner ->
|
|
|
|
ErrText = <<"Owner privileges required">>,
|
|
|
|
{error, xmpp:err_forbidden(ErrText, Lang)};
|
|
|
|
Destroy == undefined, Config == undefined ->
|
|
|
|
case Items of
|
|
|
|
[] ->
|
|
|
|
{result,
|
|
|
|
#muc_owner{config = get_config(Lang, StateData, From)}};
|
|
|
|
[#muc_item{affiliation = undefined}] ->
|
|
|
|
Txt = <<"No 'affiliation' attribute found">>,
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)};
|
|
|
|
[#muc_item{affiliation = Affiliation}] ->
|
|
|
|
Items = items_with_affiliation(Affiliation, StateData),
|
|
|
|
{result, #muc_owner{items = Items}};
|
|
|
|
[_|_] ->
|
|
|
|
Txt = <<"Too many <item/> elements">>,
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)}
|
|
|
|
end;
|
|
|
|
true ->
|
|
|
|
{error, xmpp:err_bad_request()}
|
2003-03-25 22:03:35 +01:00
|
|
|
end.
|
|
|
|
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec is_allowed_log_change(muc_roomconfig:result(), state(), jid()) -> boolean().
|
|
|
|
is_allowed_log_change(Options, StateData, From) ->
|
|
|
|
case proplists:is_defined(enablelogging, Options) of
|
2016-07-25 12:50:30 +02:00
|
|
|
false -> true;
|
|
|
|
true ->
|
|
|
|
allow ==
|
|
|
|
mod_muc_log:check_access_log(StateData#state.server_host,
|
|
|
|
From)
|
2006-03-14 05:26:15 +01:00
|
|
|
end.
|
2003-03-25 22:03:35 +01:00
|
|
|
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec is_allowed_persistent_change(muc_roomconfig:result(), state(), jid()) -> boolean().
|
|
|
|
is_allowed_persistent_change(Options, StateData, From) ->
|
|
|
|
case proplists:is_defined(persistentroom, Options) of
|
2013-03-14 10:33:02 +01:00
|
|
|
false -> true;
|
|
|
|
true ->
|
|
|
|
{_AccessRoute, _AccessCreate, _AccessAdmin,
|
|
|
|
AccessPersistent} =
|
|
|
|
StateData#state.access,
|
|
|
|
allow ==
|
|
|
|
acl:match_rule(StateData#state.server_host,
|
|
|
|
AccessPersistent, From)
|
2007-06-20 13:25:19 +02:00
|
|
|
end.
|
2003-03-25 22:03:35 +01:00
|
|
|
|
2009-04-22 14:05:10 +02:00
|
|
|
%% Check if the Room Name and Room Description defined in the Data Form
|
|
|
|
%% are conformant to the configured limits
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec is_allowed_room_name_desc_limits(muc_roomconfig:result(), state()) -> boolean().
|
|
|
|
is_allowed_room_name_desc_limits(Options, StateData) ->
|
|
|
|
RoomName = proplists:get_value(roomname, Options, <<"">>),
|
|
|
|
RoomDesc = proplists:get_value(roomdesc, Options, <<"">>),
|
|
|
|
MaxRoomName = gen_mod:get_module_opt(
|
|
|
|
StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, max_room_name),
|
2016-10-17 12:37:23 +02:00
|
|
|
MaxRoomDesc = gen_mod:get_module_opt(
|
|
|
|
StateData#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, max_room_desc),
|
2016-10-17 12:37:23 +02:00
|
|
|
(byte_size(RoomName) =< MaxRoomName)
|
|
|
|
andalso (byte_size(RoomDesc) =< MaxRoomDesc).
|
2009-04-22 14:05:10 +02:00
|
|
|
|
2009-08-15 22:09:05 +02:00
|
|
|
%% Return false if:
|
|
|
|
%% "the password for a password-protected room is blank"
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec is_password_settings_correct(muc_roomconfig:result(), state()) -> boolean().
|
|
|
|
is_password_settings_correct(Options, StateData) ->
|
2009-08-15 22:09:05 +02:00
|
|
|
Config = StateData#state.config,
|
|
|
|
OldProtected = Config#config.password_protected,
|
|
|
|
OldPassword = Config#config.password,
|
2016-10-17 12:37:23 +02:00
|
|
|
NewProtected = proplists:get_value(passwordprotectedroom, Options),
|
|
|
|
NewPassword = proplists:get_value(roomsecret, Options),
|
|
|
|
case {OldProtected, NewProtected, OldPassword, NewPassword} of
|
|
|
|
{true, undefined, <<"">>, undefined} -> false;
|
|
|
|
{true, undefined, _, <<"">>} -> false;
|
|
|
|
{_, true, <<"">>, undefined} -> false;
|
|
|
|
{_, true, _, <<"">>} -> false;
|
|
|
|
_ -> true
|
2009-08-15 22:09:05 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_default_room_maxusers(state()) -> non_neg_integer().
|
2008-11-26 16:10:38 +01:00
|
|
|
get_default_room_maxusers(RoomState) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
DefRoomOpts =
|
|
|
|
gen_mod:get_module_opt(RoomState#state.server_host,
|
2018-01-23 08:54:52 +01:00
|
|
|
mod_muc, default_room_options),
|
2008-11-26 16:10:38 +01:00
|
|
|
RoomState2 = set_opts(DefRoomOpts, RoomState),
|
|
|
|
(RoomState2#state.config)#config.max_users.
|
2003-03-25 22:03:35 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_config(binary(), state(), jid()) -> xdata().
|
2006-03-14 05:26:15 +01:00
|
|
|
get_config(Lang, StateData, From) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{_AccessRoute, _AccessCreate, _AccessAdmin, AccessPersistent} =
|
2013-03-14 10:33:02 +01:00
|
|
|
StateData#state.access,
|
2007-08-29 19:54:45 +02:00
|
|
|
ServiceMaxUsers = get_service_max_users(StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
DefaultRoomMaxUsers = get_default_room_maxusers(StateData),
|
2003-03-25 22:03:35 +01:00
|
|
|
Config = StateData#state.config,
|
2017-02-18 07:36:27 +01:00
|
|
|
MaxUsersRoom = get_max_users(StateData),
|
2016-10-17 12:37:23 +02:00
|
|
|
Title = str:format(
|
|
|
|
translate:translate(Lang, <<"Configuration of room ~s">>),
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(StateData#state.jid)]),
|
2016-10-07 09:31:03 +02:00
|
|
|
Fs = [{roomname, Config#config.title},
|
2018-05-30 07:11:58 +02:00
|
|
|
{roomdesc, Config#config.description},
|
|
|
|
{lang, Config#config.lang}] ++
|
2016-07-25 12:50:30 +02:00
|
|
|
case acl:match_rule(StateData#state.server_host, AccessPersistent, From) of
|
2016-10-07 09:31:03 +02:00
|
|
|
allow -> [{persistentroom, Config#config.persistent}];
|
2016-07-25 12:50:30 +02:00
|
|
|
deny -> []
|
|
|
|
end ++
|
2016-10-07 09:31:03 +02:00
|
|
|
[{publicroom, Config#config.public},
|
|
|
|
{public_list, Config#config.public_list},
|
|
|
|
{passwordprotectedroom, Config#config.password_protected},
|
|
|
|
{roomsecret, case Config#config.password_protected of
|
|
|
|
true -> Config#config.password;
|
|
|
|
false -> <<"">>
|
|
|
|
end},
|
2017-02-18 07:36:27 +01:00
|
|
|
{maxusers, MaxUsersRoom,
|
2016-10-07 09:31:03 +02:00
|
|
|
[if is_integer(ServiceMaxUsers) -> [];
|
|
|
|
true -> [{<<"No limit">>, <<"none">>}]
|
|
|
|
end] ++ [{integer_to_binary(N), N}
|
|
|
|
|| N <- lists:usort([ServiceMaxUsers,
|
|
|
|
DefaultRoomMaxUsers,
|
2017-02-18 07:36:27 +01:00
|
|
|
MaxUsersRoom
|
2016-10-07 09:31:03 +02:00
|
|
|
| ?MAX_USERS_DEFAULT_LIST]),
|
|
|
|
N =< ServiceMaxUsers]},
|
|
|
|
{whois, if Config#config.anonymous -> moderators;
|
|
|
|
true -> anyone
|
|
|
|
end},
|
|
|
|
{presencebroadcast, Config#config.presence_broadcast},
|
|
|
|
{membersonly, Config#config.members_only},
|
|
|
|
{moderatedroom, Config#config.moderated},
|
|
|
|
{members_by_default, Config#config.members_by_default},
|
|
|
|
{changesubject, Config#config.allow_change_subj},
|
|
|
|
{allow_private_messages, Config#config.allow_private_messages},
|
|
|
|
{allow_private_messages_from_visitors,
|
|
|
|
Config#config.allow_private_messages_from_visitors},
|
|
|
|
{allow_query_users, Config#config.allow_query_users},
|
|
|
|
{allowinvites, Config#config.allow_user_invites},
|
|
|
|
{allow_visitor_status, Config#config.allow_visitor_status},
|
|
|
|
{allow_visitor_nickchange, Config#config.allow_visitor_nickchange},
|
|
|
|
{allow_voice_requests, Config#config.allow_voice_requests},
|
|
|
|
{allow_subscription, Config#config.allow_subscription},
|
2017-11-27 11:07:10 +01:00
|
|
|
{voice_request_min_interval, Config#config.voice_request_min_interval},
|
|
|
|
{pubsub, Config#config.pubsub}]
|
2016-07-25 12:50:30 +02:00
|
|
|
++
|
|
|
|
case ejabberd_captcha:is_feature_available() of
|
2016-10-07 09:31:03 +02:00
|
|
|
true -> [{captcha_protected, Config#config.captcha_protected}];
|
2016-07-25 12:50:30 +02:00
|
|
|
false -> []
|
|
|
|
end ++
|
2016-10-07 09:31:03 +02:00
|
|
|
[{captcha_whitelist,
|
|
|
|
lists:map(fun jid:make/1, ?SETS:to_list(Config#config.captcha_whitelist))}]
|
2016-07-25 12:50:30 +02:00
|
|
|
++
|
|
|
|
case mod_muc_log:check_access_log(StateData#state.server_host, From) of
|
2016-10-07 09:31:03 +02:00
|
|
|
allow -> [{enablelogging, Config#config.logging}];
|
2016-07-25 12:50:30 +02:00
|
|
|
deny -> []
|
|
|
|
end,
|
|
|
|
Fields = ejabberd_hooks:run_fold(get_room_config,
|
|
|
|
StateData#state.server_host,
|
|
|
|
Fs,
|
|
|
|
[StateData, From, Lang]),
|
2016-10-07 09:31:03 +02:00
|
|
|
#xdata{type = form, title = Title,
|
2017-03-20 07:57:11 +01:00
|
|
|
fields = muc_roomconfig:encode(Fields, Lang)}.
|
2016-07-25 12:50:30 +02:00
|
|
|
|
2016-10-17 12:37:23 +02:00
|
|
|
-spec set_config(muc_roomconfig:result(), state(), binary()) ->
|
|
|
|
{error, stanza_error()} | {result, undefined, state()}.
|
|
|
|
set_config(Options, StateData, Lang) ->
|
2016-10-07 09:31:03 +02:00
|
|
|
try
|
|
|
|
#config{} = Config = set_config(Options, StateData#state.config,
|
|
|
|
StateData#state.server_host, Lang),
|
|
|
|
{result, _, NSD} = Res = change_config(Config, StateData),
|
|
|
|
Type = case {(StateData#state.config)#config.logging,
|
|
|
|
Config#config.logging}
|
|
|
|
of
|
|
|
|
{true, false} -> roomconfig_change_disabledlogging;
|
|
|
|
{false, true} -> roomconfig_change_enabledlogging;
|
|
|
|
{_, _} -> roomconfig_change
|
|
|
|
end,
|
|
|
|
Users = [{U#user.jid, U#user.nick, U#user.role}
|
2018-11-15 12:13:45 +01:00
|
|
|
|| U <- maps:values(StateData#state.users)],
|
2016-10-07 09:31:03 +02:00
|
|
|
add_to_log(Type, Users, NSD),
|
|
|
|
Res
|
2016-10-17 12:37:23 +02:00
|
|
|
catch _:{badmatch, {error, #stanza_error{}} = Err} ->
|
2016-10-07 09:31:03 +02:00
|
|
|
Err
|
2003-03-25 22:03:35 +01:00
|
|
|
end.
|
|
|
|
|
2016-08-09 09:56:32 +02:00
|
|
|
get_config_opt_name(Pos) ->
|
|
|
|
Fs = [config|record_info(fields, config)],
|
|
|
|
lists:nth(Pos, Fs).
|
|
|
|
|
2016-10-07 09:31:03 +02:00
|
|
|
-spec set_config([muc_roomconfig:property()], #config{},
|
2016-09-08 16:08:48 +02:00
|
|
|
binary(), binary()) -> #config{} | {error, stanza_error()}.
|
2016-10-07 09:31:03 +02:00
|
|
|
set_config(Opts, Config, ServerHost, Lang) ->
|
|
|
|
lists:foldl(
|
|
|
|
fun(_, {error, _} = Err) -> Err;
|
|
|
|
({roomname, Title}, C) -> C#config{title = Title};
|
|
|
|
({roomdesc, Desc}, C) -> C#config{description = Desc};
|
|
|
|
({changesubject, V}, C) -> C#config{allow_change_subj = V};
|
|
|
|
({allow_query_users, V}, C) -> C#config{allow_query_users = V};
|
|
|
|
({allow_private_messages, V}, C) ->
|
|
|
|
C#config{allow_private_messages = V};
|
|
|
|
({allow_private_messages_from_visitors, V}, C) ->
|
|
|
|
C#config{allow_private_messages_from_visitors = V};
|
|
|
|
({allow_visitor_status, V}, C) -> C#config{allow_visitor_status = V};
|
|
|
|
({allow_visitor_nickchange, V}, C) ->
|
|
|
|
C#config{allow_visitor_nickchange = V};
|
|
|
|
({publicroom, V}, C) -> C#config{public = V};
|
|
|
|
({public_list, V}, C) -> C#config{public_list = V};
|
|
|
|
({persistentroom, V}, C) -> C#config{persistent = V};
|
|
|
|
({moderatedroom, V}, C) -> C#config{moderated = V};
|
|
|
|
({members_by_default, V}, C) -> C#config{members_by_default = V};
|
|
|
|
({membersonly, V}, C) -> C#config{members_only = V};
|
|
|
|
({captcha_protected, V}, C) -> C#config{captcha_protected = V};
|
|
|
|
({allowinvites, V}, C) -> C#config{allow_user_invites = V};
|
|
|
|
({allow_subscription, V}, C) -> C#config{allow_subscription = V};
|
|
|
|
({passwordprotectedroom, V}, C) -> C#config{password_protected = V};
|
|
|
|
({roomsecret, V}, C) -> C#config{password = V};
|
|
|
|
({anonymous, V}, C) -> C#config{anonymous = V};
|
|
|
|
({presencebroadcast, V}, C) -> C#config{presence_broadcast = V};
|
|
|
|
({allow_voice_requests, V}, C) -> C#config{allow_voice_requests = V};
|
|
|
|
({voice_request_min_interval, V}, C) ->
|
|
|
|
C#config{voice_request_min_interval = V};
|
|
|
|
({whois, moderators}, C) -> C#config{anonymous = true};
|
|
|
|
({whois, anyone}, C) -> C#config{anonymous = false};
|
|
|
|
({maxusers, V}, C) -> C#config{max_users = V};
|
|
|
|
({enablelogging, V}, C) -> C#config{logging = V};
|
2017-11-27 11:07:10 +01:00
|
|
|
({pubsub, V}, C) -> C#config{pubsub = V};
|
2018-05-30 07:11:58 +02:00
|
|
|
({lang, L}, C) -> C#config{lang = L};
|
2016-10-07 09:31:03 +02:00
|
|
|
({captcha_whitelist, Js}, C) ->
|
|
|
|
LJIDs = [jid:tolower(J) || J <- Js],
|
|
|
|
C#config{captcha_whitelist = ?SETS:from_list(LJIDs)};
|
|
|
|
({O, V} = Opt, C) ->
|
|
|
|
case ejabberd_hooks:run_fold(set_room_option,
|
|
|
|
ServerHost,
|
|
|
|
{0, undefined},
|
|
|
|
[Opt, Lang]) of
|
|
|
|
{0, undefined} ->
|
|
|
|
?ERROR_MSG("set_room_option hook failed for "
|
|
|
|
"option '~s' with value ~p", [O, V]),
|
2016-11-26 08:05:22 +01:00
|
|
|
Txt = {<<"Failed to process option '~s'">>, [O]},
|
2016-10-07 09:31:03 +02:00
|
|
|
{error, xmpp:err_internal_server_error(Txt, Lang)};
|
|
|
|
{Pos, Val} ->
|
|
|
|
setelement(Pos, C, Val)
|
|
|
|
end
|
|
|
|
end, Config, Opts).
|
2003-03-25 22:03:35 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec change_config(#config{}, state()) -> {result, undefined, state()}.
|
2003-03-25 22:03:35 +01:00
|
|
|
change_config(Config, StateData) ->
|
2015-07-02 00:36:16 +02:00
|
|
|
send_config_change_info(Config, StateData),
|
2018-04-23 10:35:43 +02:00
|
|
|
StateData0 = StateData#state{config = Config},
|
|
|
|
StateData1 = remove_subscriptions(StateData0),
|
|
|
|
StateData2 =
|
|
|
|
case {(StateData#state.config)#config.persistent,
|
|
|
|
Config#config.persistent} of
|
|
|
|
{WasPersistent, true} ->
|
|
|
|
if not WasPersistent ->
|
|
|
|
set_affiliations(StateData1#state.affiliations,
|
|
|
|
StateData1);
|
|
|
|
true ->
|
|
|
|
ok
|
|
|
|
end,
|
|
|
|
store_room(StateData1),
|
|
|
|
StateData1;
|
|
|
|
{true, false} ->
|
|
|
|
Affiliations = get_affiliations(StateData),
|
|
|
|
mod_muc:forget_room(StateData1#state.server_host,
|
|
|
|
StateData1#state.host,
|
|
|
|
StateData1#state.room),
|
|
|
|
StateData1#state{affiliations = Affiliations};
|
|
|
|
{false, false} ->
|
|
|
|
StateData1
|
|
|
|
end,
|
2006-02-06 06:12:54 +01:00
|
|
|
case {(StateData#state.config)#config.members_only,
|
2018-04-23 10:35:43 +02:00
|
|
|
Config#config.members_only} of
|
|
|
|
{false, true} ->
|
|
|
|
StateData3 = remove_nonmembers(StateData2),
|
|
|
|
{result, undefined, StateData3};
|
|
|
|
_ ->
|
|
|
|
{result, undefined, StateData2}
|
2006-02-06 06:12:54 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_config_change_info(#config{}, state()) -> ok.
|
2015-07-02 00:36:16 +02:00
|
|
|
send_config_change_info(Config, #state{config = Config}) -> ok;
|
|
|
|
send_config_change_info(New, #state{config = Old} = StateData) ->
|
|
|
|
Codes = case {Old#config.logging, New#config.logging} of
|
2016-07-25 12:50:30 +02:00
|
|
|
{false, true} -> [170];
|
|
|
|
{true, false} -> [171];
|
2015-07-02 00:36:16 +02:00
|
|
|
_ -> []
|
|
|
|
end
|
|
|
|
++
|
|
|
|
case {Old#config.anonymous, New#config.anonymous} of
|
2016-07-25 12:50:30 +02:00
|
|
|
{true, false} -> [172];
|
|
|
|
{false, true} -> [173];
|
2015-07-02 00:36:16 +02:00
|
|
|
_ -> []
|
|
|
|
end
|
|
|
|
++
|
|
|
|
case Old#config{anonymous = New#config.anonymous,
|
|
|
|
logging = New#config.logging} of
|
|
|
|
New -> [];
|
2016-07-25 12:50:30 +02:00
|
|
|
_ -> [104]
|
2015-07-02 00:36:16 +02:00
|
|
|
end,
|
2016-10-17 12:37:23 +02:00
|
|
|
if Codes /= [] ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(_LJID, #user{jid = JID}, _) ->
|
2018-02-12 15:37:36 +01:00
|
|
|
send_self_presence(JID, StateData#state{config = New})
|
2018-11-15 12:13:45 +01:00
|
|
|
end, ok, StateData#state.users),
|
2016-10-17 12:37:23 +02:00
|
|
|
Message = #message{type = groupchat,
|
2018-07-05 10:51:49 +02:00
|
|
|
id = p1_rand:get_string(),
|
2016-10-17 12:37:23 +02:00
|
|
|
sub_els = [#muc_user{status_codes = Codes}]},
|
|
|
|
send_wrapped_multiple(StateData#state.jid,
|
2018-11-15 12:13:45 +01:00
|
|
|
get_users_and_subscribers(StateData),
|
2016-10-17 12:37:23 +02:00
|
|
|
Message,
|
|
|
|
?NS_MUCSUB_NODES_CONFIG,
|
|
|
|
StateData);
|
|
|
|
true ->
|
|
|
|
ok
|
|
|
|
end.
|
2015-07-02 00:36:16 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec remove_nonmembers(state()) -> state().
|
2006-02-06 06:12:54 +01:00
|
|
|
remove_nonmembers(StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(_LJID, #user{jid = JID}, SD) ->
|
|
|
|
Affiliation = get_affiliation(JID, SD),
|
|
|
|
case Affiliation of
|
|
|
|
none ->
|
|
|
|
catch send_kickban_presence(undefined, JID, <<"">>, 322, SD),
|
|
|
|
set_role(JID, none, SD);
|
|
|
|
_ -> SD
|
|
|
|
end
|
|
|
|
end, StateData, get_users_and_subscribers(StateData)).
|
2003-03-25 22:03:35 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec set_opts([{atom(), any()}], state()) -> state().
|
2018-02-12 15:37:36 +01:00
|
|
|
set_opts([], StateData) ->
|
|
|
|
set_vcard_xupdate(StateData);
|
2003-03-25 22:03:35 +01:00
|
|
|
set_opts([{Opt, Val} | Opts], StateData) ->
|
|
|
|
NSD = case Opt of
|
2013-03-14 10:33:02 +01:00
|
|
|
title ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{title =
|
|
|
|
Val}};
|
|
|
|
description ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{description
|
|
|
|
= Val}};
|
|
|
|
allow_change_subj ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_change_subj
|
|
|
|
= Val}};
|
|
|
|
allow_query_users ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_query_users
|
|
|
|
= Val}};
|
|
|
|
allow_private_messages ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_private_messages
|
|
|
|
= Val}};
|
|
|
|
allow_private_messages_from_visitors ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_private_messages_from_visitors
|
|
|
|
= Val}};
|
|
|
|
allow_visitor_nickchange ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_visitor_nickchange
|
|
|
|
= Val}};
|
|
|
|
allow_visitor_status ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_visitor_status
|
|
|
|
= Val}};
|
|
|
|
public ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{public =
|
|
|
|
Val}};
|
|
|
|
public_list ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{public_list
|
|
|
|
= Val}};
|
|
|
|
persistent ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{persistent =
|
|
|
|
Val}};
|
|
|
|
moderated ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{moderated =
|
|
|
|
Val}};
|
|
|
|
members_by_default ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{members_by_default
|
|
|
|
= Val}};
|
|
|
|
members_only ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{members_only
|
|
|
|
= Val}};
|
|
|
|
allow_user_invites ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_user_invites
|
|
|
|
= Val}};
|
|
|
|
password_protected ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{password_protected
|
|
|
|
= Val}};
|
|
|
|
captcha_protected ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{captcha_protected
|
|
|
|
= Val}};
|
|
|
|
password ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{password =
|
|
|
|
Val}};
|
|
|
|
anonymous ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{anonymous =
|
|
|
|
Val}};
|
2015-11-12 17:51:20 +01:00
|
|
|
presence_broadcast ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{presence_broadcast =
|
|
|
|
Val}};
|
2013-03-14 10:33:02 +01:00
|
|
|
logging ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{logging =
|
|
|
|
Val}};
|
2015-08-06 12:33:39 +02:00
|
|
|
mam ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{mam = Val}};
|
2013-03-14 10:33:02 +01:00
|
|
|
captcha_whitelist ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{captcha_whitelist
|
|
|
|
=
|
|
|
|
(?SETS):from_list(Val)}};
|
|
|
|
allow_voice_requests ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_voice_requests
|
|
|
|
= Val}};
|
|
|
|
voice_request_min_interval ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{voice_request_min_interval
|
|
|
|
= Val}};
|
|
|
|
max_users ->
|
|
|
|
ServiceMaxUsers = get_service_max_users(StateData),
|
|
|
|
MaxUsers = if Val =< ServiceMaxUsers -> Val;
|
|
|
|
true -> ServiceMaxUsers
|
|
|
|
end,
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{max_users =
|
|
|
|
MaxUsers}};
|
2014-05-04 21:11:05 +02:00
|
|
|
vcard ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{vcard =
|
|
|
|
Val}};
|
2018-02-12 15:37:36 +01:00
|
|
|
vcard_xupdate ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{vcard_xupdate =
|
|
|
|
Val}};
|
2017-11-27 11:07:10 +01:00
|
|
|
pubsub ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{pubsub = Val}};
|
2016-06-26 08:08:37 +02:00
|
|
|
allow_subscription ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{allow_subscription = Val}};
|
2018-05-30 07:11:58 +02:00
|
|
|
lang ->
|
|
|
|
StateData#state{config =
|
|
|
|
(StateData#state.config)#config{lang = Val}};
|
2016-06-26 08:08:37 +02:00
|
|
|
subscribers ->
|
2017-01-31 19:18:19 +01:00
|
|
|
{Subscribers, Nicks} =
|
|
|
|
lists:foldl(
|
|
|
|
fun({JID, Nick, Nodes}, {SubAcc, NickAcc}) ->
|
|
|
|
BareJID = jid:remove_resource(JID),
|
2018-11-15 12:13:45 +01:00
|
|
|
{maps:put(
|
|
|
|
jid:tolower(BareJID),
|
|
|
|
#subscriber{jid = BareJID,
|
|
|
|
nick = Nick,
|
|
|
|
nodes = Nodes},
|
|
|
|
SubAcc),
|
|
|
|
maps:put(Nick, [jid:tolower(BareJID)], NickAcc)}
|
|
|
|
end, {#{}, #{}}, Val),
|
2017-01-31 19:18:19 +01:00
|
|
|
StateData#state{subscribers = Subscribers,
|
|
|
|
subscriber_nicks = Nicks};
|
2013-03-14 10:33:02 +01:00
|
|
|
affiliations ->
|
2018-11-15 12:13:45 +01:00
|
|
|
StateData#state{affiliations = maps:from_list(Val)};
|
2017-11-13 09:25:35 +01:00
|
|
|
subject ->
|
|
|
|
Subj = if Val == <<"">> -> [];
|
|
|
|
is_binary(Val) -> [#text{data = Val}];
|
|
|
|
is_list(Val) -> Val
|
|
|
|
end,
|
|
|
|
StateData#state{subject = Subj};
|
2013-03-14 10:33:02 +01:00
|
|
|
subject_author -> StateData#state{subject_author = Val};
|
|
|
|
_ -> StateData
|
2003-03-25 22:03:35 +01:00
|
|
|
end,
|
|
|
|
set_opts(Opts, NSD).
|
|
|
|
|
2018-02-12 15:37:36 +01:00
|
|
|
set_vcard_xupdate(#state{config =
|
|
|
|
#config{vcard = VCardRaw,
|
|
|
|
vcard_xupdate = undefined} = Config} = State)
|
|
|
|
when VCardRaw /= <<"">> ->
|
|
|
|
case fxml_stream:parse_element(VCardRaw) of
|
|
|
|
{error, _} ->
|
|
|
|
State;
|
|
|
|
El ->
|
|
|
|
Hash = mod_vcard_xupdate:compute_hash(El),
|
|
|
|
State#state{config = Config#config{vcard_xupdate = Hash}}
|
|
|
|
end;
|
|
|
|
set_vcard_xupdate(State) ->
|
|
|
|
State.
|
|
|
|
|
2016-08-09 09:56:32 +02:00
|
|
|
-define(MAKE_CONFIG_OPT(Opt),
|
|
|
|
{get_config_opt_name(Opt), element(Opt, Config)}).
|
2003-03-25 22:03:35 +01:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec make_opts(state()) -> [{atom(), any()}].
|
2003-03-25 22:03:35 +01:00
|
|
|
make_opts(StateData) ->
|
|
|
|
Config = StateData#state.config,
|
2018-11-15 12:13:45 +01:00
|
|
|
Subscribers = maps:fold(
|
2016-09-07 09:33:37 +02:00
|
|
|
fun(_LJID, Sub, Acc) ->
|
|
|
|
[{Sub#subscriber.jid,
|
|
|
|
Sub#subscriber.nick,
|
|
|
|
Sub#subscriber.nodes}|Acc]
|
|
|
|
end, [], StateData#state.subscribers),
|
2016-08-09 09:56:32 +02:00
|
|
|
[?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),
|
2016-11-12 11:27:15 +01:00
|
|
|
?MAKE_CONFIG_OPT(#config.allow_subscription),
|
2016-08-09 09:56:32 +02:00
|
|
|
?MAKE_CONFIG_OPT(#config.mam),
|
2016-11-16 13:35:50 +01:00
|
|
|
?MAKE_CONFIG_OPT(#config.presence_broadcast),
|
2016-08-09 09:56:32 +02:00
|
|
|
?MAKE_CONFIG_OPT(#config.voice_request_min_interval),
|
|
|
|
?MAKE_CONFIG_OPT(#config.vcard),
|
2018-02-12 15:37:36 +01:00
|
|
|
?MAKE_CONFIG_OPT(#config.vcard_xupdate),
|
2017-11-27 11:07:10 +01:00
|
|
|
?MAKE_CONFIG_OPT(#config.pubsub),
|
2018-05-30 07:11:58 +02:00
|
|
|
?MAKE_CONFIG_OPT(#config.lang),
|
2011-02-16 11:14:39 +01:00
|
|
|
{captcha_whitelist,
|
2013-03-14 10:33:02 +01:00
|
|
|
(?SETS):to_list((StateData#state.config)#config.captcha_whitelist)},
|
|
|
|
{affiliations,
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:to_list(StateData#state.affiliations)},
|
2003-05-15 20:16:13 +02:00
|
|
|
{subject, StateData#state.subject},
|
2016-06-26 08:08:37 +02:00
|
|
|
{subject_author, StateData#state.subject_author},
|
|
|
|
{subscribers, Subscribers}].
|
2003-03-27 21:55:09 +01:00
|
|
|
|
2018-02-16 06:28:33 +01:00
|
|
|
expand_opts(CompactOpts) ->
|
|
|
|
DefConfig = #config{},
|
|
|
|
Fields = record_info(fields, config),
|
|
|
|
{_, Opts1} =
|
|
|
|
lists:foldl(
|
|
|
|
fun(Field, {Pos, Opts}) ->
|
|
|
|
case lists:keyfind(Field, 1, CompactOpts) of
|
|
|
|
false ->
|
|
|
|
DefV = element(Pos, DefConfig),
|
|
|
|
DefVal = case (?SETS):is_set(DefV) of
|
|
|
|
true -> (?SETS):to_list(DefV);
|
|
|
|
false -> DefV
|
|
|
|
end,
|
|
|
|
{Pos+1, [{Field, DefVal}|Opts]};
|
|
|
|
{_, Val} ->
|
|
|
|
{Pos+1, [{Field, Val}|Opts]}
|
|
|
|
end
|
|
|
|
end, {2, []}, Fields),
|
|
|
|
SubjectAuthor = proplists:get_value(subject_author, CompactOpts, <<"">>),
|
|
|
|
Subject = proplists:get_value(subject, CompactOpts, <<"">>),
|
|
|
|
Subscribers = proplists:get_value(subscribers, CompactOpts, []),
|
|
|
|
[{subject, Subject},
|
|
|
|
{subject_author, SubjectAuthor},
|
|
|
|
{subscribers, Subscribers}
|
|
|
|
| lists:reverse(Opts1)].
|
|
|
|
|
|
|
|
config_fields() ->
|
|
|
|
[subject, subject_author, subscribers | record_info(fields, config)].
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec destroy_room(muc_destroy(), state()) -> {result, undefined, stop}.
|
2006-01-19 03:17:31 +01:00
|
|
|
destroy_room(DEl, StateData) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Destroy = DEl#muc_destroy{xmlns = ?NS_MUC_USER},
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(_LJID, Info, _) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Nick = Info#user.nick,
|
|
|
|
Item = #muc_item{affiliation = none,
|
|
|
|
role = none},
|
|
|
|
Packet = #presence{
|
|
|
|
type = unavailable,
|
|
|
|
sub_els = [#muc_user{items = [Item],
|
|
|
|
destroy = Destroy}]},
|
|
|
|
send_wrapped(jid:replace_resource(StateData#state.jid, Nick),
|
|
|
|
Info#user.jid, Packet,
|
|
|
|
?NS_MUCSUB_NODES_CONFIG, StateData)
|
2018-11-15 12:13:45 +01:00
|
|
|
end, ok, get_users_and_subscribers(StateData)),
|
2004-10-08 22:40:29 +02:00
|
|
|
case (StateData#state.config)#config.persistent of
|
2013-03-14 10:33:02 +01:00
|
|
|
true ->
|
|
|
|
mod_muc:forget_room(StateData#state.server_host,
|
2018-09-17 12:28:39 +02:00
|
|
|
StateData#state.host, StateData#state.room);
|
2013-03-14 10:33:02 +01:00
|
|
|
false -> ok
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, undefined, stop}.
|
2003-03-27 21:55:09 +01:00
|
|
|
|
2003-03-27 15:06:17 +01:00
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
% Disco
|
|
|
|
|
2004-01-17 21:26:57 +01:00
|
|
|
-define(CONFIG_OPT_TO_FEATURE(Opt, Fiftrue, Fiffalse),
|
2013-03-14 10:33:02 +01:00
|
|
|
case Opt of
|
2016-07-25 12:50:30 +02:00
|
|
|
true -> Fiftrue;
|
|
|
|
false -> Fiffalse
|
2013-03-14 10:33:02 +01:00
|
|
|
end).
|
2004-01-17 21:26:57 +01:00
|
|
|
|
2018-02-12 15:37:36 +01:00
|
|
|
-spec make_disco_info(jid(), state()) -> disco_info().
|
|
|
|
make_disco_info(_From, StateData) ->
|
2004-01-17 21:26:57 +01:00
|
|
|
Config = StateData#state.config,
|
2018-11-29 08:35:03 +01:00
|
|
|
Feats = [?NS_VCARD, ?NS_MUC, ?NS_DISCO_INFO, ?NS_DISCO_ITEMS,
|
2016-07-25 12:50:30 +02:00
|
|
|
?CONFIG_OPT_TO_FEATURE((Config#config.public),
|
|
|
|
<<"muc_public">>, <<"muc_hidden">>),
|
|
|
|
?CONFIG_OPT_TO_FEATURE((Config#config.persistent),
|
|
|
|
<<"muc_persistent">>, <<"muc_temporary">>),
|
|
|
|
?CONFIG_OPT_TO_FEATURE((Config#config.members_only),
|
|
|
|
<<"muc_membersonly">>, <<"muc_open">>),
|
|
|
|
?CONFIG_OPT_TO_FEATURE((Config#config.anonymous),
|
|
|
|
<<"muc_semianonymous">>, <<"muc_nonanonymous">>),
|
|
|
|
?CONFIG_OPT_TO_FEATURE((Config#config.moderated),
|
|
|
|
<<"muc_moderated">>, <<"muc_unmoderated">>),
|
|
|
|
?CONFIG_OPT_TO_FEATURE((Config#config.password_protected),
|
|
|
|
<<"muc_passwordprotected">>, <<"muc_unsecured">>)]
|
|
|
|
++ case Config#config.allow_subscription of
|
|
|
|
true -> [?NS_MUCSUB];
|
|
|
|
false -> []
|
|
|
|
end
|
|
|
|
++ case {gen_mod:is_loaded(StateData#state.server_host, mod_mam),
|
|
|
|
Config#config.mam} of
|
|
|
|
{true, true} ->
|
2017-11-15 00:18:25 +01:00
|
|
|
[?NS_MAM_TMP, ?NS_MAM_0, ?NS_MAM_1, ?NS_MAM_2, ?NS_SID_0];
|
2016-07-25 12:50:30 +02:00
|
|
|
_ ->
|
|
|
|
[]
|
|
|
|
end,
|
2018-02-12 15:37:36 +01:00
|
|
|
#disco_info{identities = [#identity{category = <<"conference">>,
|
|
|
|
type = <<"text">>,
|
|
|
|
name = get_title(StateData)}],
|
|
|
|
features = Feats}.
|
|
|
|
|
|
|
|
-spec process_iq_disco_info(jid(), iq(), state()) ->
|
|
|
|
{result, disco_info()} | {error, stanza_error()}.
|
|
|
|
process_iq_disco_info(_From, #iq{type = set, lang = Lang}, _StateData) ->
|
|
|
|
Txt = <<"Value 'set' of 'type' attribute is not allowed">>,
|
|
|
|
{error, xmpp:err_not_allowed(Txt, Lang)};
|
|
|
|
process_iq_disco_info(From, #iq{type = get, lang = Lang,
|
|
|
|
sub_els = [#disco_info{node = <<>>}]},
|
|
|
|
StateData) ->
|
|
|
|
DiscoInfo = make_disco_info(From, StateData),
|
2018-06-01 08:07:16 +02:00
|
|
|
Extras = iq_disco_info_extras(Lang, StateData, false),
|
2018-02-12 15:37:36 +01:00
|
|
|
{result, DiscoInfo#disco_info{xdata = [Extras]}};
|
|
|
|
process_iq_disco_info(From, #iq{type = get, lang = Lang,
|
|
|
|
sub_els = [#disco_info{node = Node}]},
|
|
|
|
StateData) ->
|
|
|
|
try
|
|
|
|
true = mod_caps:is_valid_node(Node),
|
|
|
|
DiscoInfo = make_disco_info(From, StateData),
|
2018-06-01 08:07:16 +02:00
|
|
|
Extras = iq_disco_info_extras(Lang, StateData, true),
|
2018-09-14 00:18:17 +02:00
|
|
|
DiscoInfo1 = DiscoInfo#disco_info{xdata = [Extras]},
|
|
|
|
Hash = mod_caps:compute_disco_hash(DiscoInfo1, sha),
|
|
|
|
Node = <<(ejabberd_config:get_uri())/binary, $#, Hash/binary>>,
|
|
|
|
{result, DiscoInfo1#disco_info{node = Node}}
|
2018-02-12 15:37:36 +01:00
|
|
|
catch _:{badmatch, _} ->
|
|
|
|
Txt = <<"Invalid node name">>,
|
|
|
|
{error, xmpp:err_item_not_found(Txt, Lang)}
|
|
|
|
end.
|
2016-07-25 12:50:30 +02:00
|
|
|
|
2018-06-01 08:07:16 +02:00
|
|
|
-spec iq_disco_info_extras(binary(), state(), boolean()) -> xdata().
|
|
|
|
iq_disco_info_extras(Lang, StateData, Static) ->
|
2018-06-19 13:02:45 +02:00
|
|
|
Config = StateData#state.config,
|
|
|
|
AllowPM = case Config#config.allow_private_messages of
|
|
|
|
false -> none;
|
|
|
|
true ->
|
|
|
|
case Config#config.allow_private_messages_from_visitors of
|
|
|
|
nobody -> participants;
|
|
|
|
_ -> anyone
|
|
|
|
end
|
|
|
|
end,
|
|
|
|
Fs1 = [{roomname, Config#config.title},
|
|
|
|
{description, Config#config.description},
|
2018-05-30 07:11:58 +02:00
|
|
|
{contactjid, get_owners(StateData)},
|
2018-06-19 13:02:45 +02:00
|
|
|
{changesubject, Config#config.allow_change_subj},
|
|
|
|
{allowinvites, Config#config.allow_user_invites},
|
|
|
|
{allowpm, AllowPM},
|
|
|
|
{lang, Config#config.lang}],
|
|
|
|
Fs2 = case Config#config.pubsub of
|
2017-11-27 11:07:10 +01:00
|
|
|
Node when is_binary(Node), Node /= <<"">> ->
|
|
|
|
[{pubsub, Node}|Fs1];
|
|
|
|
_ ->
|
|
|
|
Fs1
|
|
|
|
end,
|
2018-06-01 08:07:16 +02:00
|
|
|
Fs3 = case Static of
|
|
|
|
false ->
|
2018-11-15 12:13:45 +01:00
|
|
|
[{occupants, maps:size(StateData#state.nicks)}|Fs2];
|
2018-06-01 08:07:16 +02:00
|
|
|
true ->
|
|
|
|
Fs2
|
|
|
|
end,
|
2016-07-25 12:50:30 +02:00
|
|
|
#xdata{type = result,
|
2018-06-01 08:07:16 +02:00
|
|
|
fields = muc_roominfo:encode(Fs3, Lang)}.
|
2016-07-25 12:50:30 +02:00
|
|
|
|
|
|
|
-spec process_iq_disco_items(jid(), iq(), state()) ->
|
2016-09-08 16:08:48 +02:00
|
|
|
{error, stanza_error()} | {result, disco_items()}.
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_disco_items(_From, #iq{type = set, lang = Lang}, _StateData) ->
|
2016-04-05 12:09:44 +02:00
|
|
|
Txt = <<"Value 'set' of 'type' attribute is not allowed">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, xmpp:err_not_allowed(Txt, Lang)};
|
2016-10-17 12:37:23 +02:00
|
|
|
process_iq_disco_items(From, #iq{type = get}, StateData) ->
|
2010-03-29 20:51:24 +02:00
|
|
|
case (StateData#state.config)#config.public_list of
|
2013-03-14 10:33:02 +01:00
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, get_mucroom_disco_items(StateData)};
|
2013-03-14 10:33:02 +01:00
|
|
|
_ ->
|
|
|
|
case is_occupant_or_admin(From, StateData) of
|
|
|
|
true ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, get_mucroom_disco_items(StateData)};
|
2016-04-05 12:09:44 +02:00
|
|
|
_ ->
|
2016-10-17 12:37:23 +02:00
|
|
|
%% If the list of occupants is private,
|
|
|
|
%% the room MUST return an empty <query/> element
|
|
|
|
%% (http://xmpp.org/extensions/xep-0045.html#disco-roomitems)
|
|
|
|
{result, #disco_items{}}
|
2013-03-14 10:33:02 +01:00
|
|
|
end
|
2010-03-29 20:51:24 +02:00
|
|
|
end.
|
2003-03-27 15:06:17 +01:00
|
|
|
|
2016-09-08 16:08:48 +02:00
|
|
|
-spec process_iq_captcha(jid(), iq(), state()) -> {error, stanza_error()} |
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, undefined}.
|
|
|
|
process_iq_captcha(_From, #iq{type = get, lang = Lang}, _StateData) ->
|
2016-04-05 12:09:44 +02:00
|
|
|
Txt = <<"Value 'get' of 'type' attribute is not allowed">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, xmpp:err_not_allowed(Txt, Lang)};
|
|
|
|
process_iq_captcha(_From, #iq{type = set, lang = Lang, sub_els = [SubEl]},
|
|
|
|
_StateData) ->
|
2009-03-13 17:01:46 +01:00
|
|
|
case ejabberd_captcha:process_reply(SubEl) of
|
2016-07-25 12:50:30 +02:00
|
|
|
ok -> {result, undefined};
|
2016-04-05 12:09:44 +02:00
|
|
|
{error, malformed} ->
|
|
|
|
Txt = <<"Incorrect CAPTCHA submit">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)};
|
2016-04-05 12:09:44 +02:00
|
|
|
_ ->
|
|
|
|
Txt = <<"The CAPTCHA verification has failed">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, xmpp:err_not_allowed(Txt, Lang)}
|
2009-03-13 17:01:46 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec process_iq_vcard(jid(), iq(), state()) ->
|
|
|
|
{result, vcard_temp() | xmlel()} |
|
|
|
|
{result, undefined, state()} |
|
2016-09-08 16:08:48 +02:00
|
|
|
{error, stanza_error()}.
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_vcard(_From, #iq{type = get}, StateData) ->
|
2014-05-04 21:11:05 +02:00
|
|
|
#state{config = #config{vcard = VCardRaw}} = StateData,
|
2016-02-03 19:03:17 +01:00
|
|
|
case fxml_stream:parse_element(VCardRaw) of
|
2016-07-25 12:50:30 +02:00
|
|
|
#xmlel{} = VCard ->
|
|
|
|
{result, VCard};
|
2014-05-04 21:11:05 +02:00
|
|
|
{error, _} ->
|
2016-10-17 12:37:23 +02:00
|
|
|
{error, xmpp:err_item_not_found()}
|
2014-05-04 21:11:05 +02:00
|
|
|
end;
|
2018-02-12 15:37:36 +01:00
|
|
|
process_iq_vcard(From, #iq{type = set, lang = Lang, sub_els = [Pkt]},
|
2016-07-25 12:50:30 +02:00
|
|
|
StateData) ->
|
2014-05-04 21:11:05 +02:00
|
|
|
case get_affiliation(From, StateData) of
|
|
|
|
owner ->
|
2018-02-12 15:37:36 +01:00
|
|
|
SubEl = xmpp:encode(Pkt),
|
|
|
|
VCardRaw = fxml:element_to_binary(SubEl),
|
|
|
|
Hash = mod_vcard_xupdate:compute_hash(SubEl),
|
2014-05-04 21:11:05 +02:00
|
|
|
Config = StateData#state.config,
|
2018-02-12 15:37:36 +01:00
|
|
|
NewConfig = Config#config{vcard = VCardRaw, vcard_xupdate = Hash},
|
2014-05-04 21:11:05 +02:00
|
|
|
change_config(NewConfig, StateData);
|
|
|
|
_ ->
|
|
|
|
ErrText = <<"Owner privileges required">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, xmpp:err_forbidden(ErrText, Lang)}
|
2014-05-04 21:11:05 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec process_iq_mucsub(jid(), iq(), state()) ->
|
2017-02-18 07:36:27 +01:00
|
|
|
{error, stanza_error()} |
|
|
|
|
{result, undefined | muc_subscribe() | muc_subscriptions(), state()} |
|
|
|
|
{ignore, state()}.
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_mucsub(_From, #iq{type = set, lang = Lang,
|
|
|
|
sub_els = [#muc_subscribe{}]},
|
2016-12-26 21:15:52 +01:00
|
|
|
#state{just_created = false, config = #config{allow_subscription = false}}) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, xmpp:err_not_allowed(<<"Subscriptions are not allowed">>, Lang)};
|
2017-04-26 01:30:12 +02:00
|
|
|
process_iq_mucsub(From,
|
|
|
|
#iq{type = set, lang = Lang,
|
|
|
|
sub_els = [#muc_subscribe{jid = #jid{} = SubJid} = Mucsub]},
|
|
|
|
StateData) ->
|
|
|
|
FAffiliation = get_affiliation(From, StateData),
|
|
|
|
FRole = get_role(From, StateData),
|
|
|
|
if FRole == moderator; FAffiliation == owner; FAffiliation == admin ->
|
|
|
|
process_iq_mucsub(SubJid,
|
|
|
|
#iq{type = set, lang = Lang,
|
|
|
|
sub_els = [Mucsub#muc_subscribe{jid = undefined}]},
|
|
|
|
StateData);
|
|
|
|
true ->
|
|
|
|
Txt = <<"Moderator privileges required">>,
|
|
|
|
{error, xmpp:err_forbidden(Txt, Lang)}
|
|
|
|
end;
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_mucsub(From,
|
2016-06-26 08:08:37 +02:00
|
|
|
#iq{type = set, lang = Lang,
|
2016-07-25 12:50:30 +02:00
|
|
|
sub_els = [#muc_subscribe{nick = Nick}]} = Packet,
|
|
|
|
StateData) ->
|
2016-11-12 11:27:15 +01:00
|
|
|
LBareJID = jid:tolower(jid:remove_resource(From)),
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(LBareJID, StateData#state.subscribers) of
|
|
|
|
#subscriber{nick = Nick1} when Nick1 /= Nick ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Nodes = get_subscription_nodes(Packet),
|
|
|
|
case {nick_collision(From, Nick, StateData),
|
|
|
|
mod_muc:can_use_nick(StateData#state.server_host,
|
|
|
|
StateData#state.host,
|
|
|
|
From, Nick)} of
|
|
|
|
{true, _} ->
|
|
|
|
ErrText = <<"That nickname is already in use by another occupant">>,
|
|
|
|
{error, xmpp:err_conflict(ErrText, Lang)};
|
|
|
|
{_, false} ->
|
|
|
|
ErrText = <<"That nickname is registered by another person">>,
|
|
|
|
{error, xmpp:err_conflict(ErrText, Lang)};
|
|
|
|
_ ->
|
2016-09-07 09:33:37 +02:00
|
|
|
NewStateData = set_subscriber(From, Nick, Nodes, StateData),
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, subscribe_result(Packet), NewStateData}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2018-11-15 12:13:45 +01:00
|
|
|
#subscriber{} ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Nodes = get_subscription_nodes(Packet),
|
2016-11-12 11:27:15 +01:00
|
|
|
NewStateData = set_subscriber(From, Nick, Nodes, StateData),
|
2018-11-15 12:13:45 +01:00
|
|
|
{result, subscribe_result(Packet), NewStateData}
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2017-01-09 15:56:25 +01:00
|
|
|
SD2 = StateData#state{config = (StateData#state.config)#config{allow_subscription = true}},
|
2016-12-26 21:15:52 +01:00
|
|
|
add_new_user(From, Nick, Packet, SD2)
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2017-04-13 22:37:39 +02:00
|
|
|
process_iq_mucsub(From, #iq{type = set, lang = Lang,
|
2017-04-19 22:18:23 +02:00
|
|
|
sub_els = [#muc_unsubscribe{jid = #jid{} = UnsubJid}]},
|
|
|
|
StateData) ->
|
2017-04-13 22:37:39 +02:00
|
|
|
FAffiliation = get_affiliation(From, StateData),
|
|
|
|
FRole = get_role(From, StateData),
|
2017-04-19 22:18:23 +02:00
|
|
|
if FRole == moderator; FAffiliation == owner; FAffiliation == admin ->
|
|
|
|
process_iq_mucsub(UnsubJid,
|
2017-04-26 01:30:12 +02:00
|
|
|
#iq{type = set, lang = Lang,
|
2017-04-19 22:18:23 +02:00
|
|
|
sub_els = [#muc_unsubscribe{jid = undefined}]},
|
|
|
|
StateData);
|
|
|
|
true ->
|
2017-04-13 22:37:39 +02:00
|
|
|
Txt = <<"Moderator privileges required">>,
|
|
|
|
{error, xmpp:err_forbidden(Txt, Lang)}
|
|
|
|
end;
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_mucsub(From, #iq{type = set, sub_els = [#muc_unsubscribe{}]},
|
2016-06-26 08:08:37 +02:00
|
|
|
StateData) ->
|
2016-09-07 09:33:37 +02:00
|
|
|
LBareJID = jid:tolower(jid:remove_resource(From)),
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(LBareJID, StateData#state.subscribers) of
|
|
|
|
#subscriber{nick = Nick} ->
|
|
|
|
Nicks = maps:remove(Nick, StateData#state.subscriber_nicks),
|
|
|
|
Subscribers = maps:remove(LBareJID, StateData#state.subscribers),
|
2016-09-12 13:41:33 +02:00
|
|
|
NewStateData = StateData#state{subscribers = Subscribers,
|
|
|
|
subscriber_nicks = Nicks},
|
2017-10-31 14:00:41 +01:00
|
|
|
store_room(NewStateData, [{del_subscription, LBareJID}]),
|
2017-10-30 17:54:55 +01:00
|
|
|
send_subscriptions_change_notifications(LBareJID, Nick, unsubscribe, StateData),
|
2016-12-01 22:09:57 +01:00
|
|
|
NewStateData2 = case close_room_if_temporary_and_empty(NewStateData) of
|
|
|
|
{stop, normal, _} -> stop;
|
|
|
|
{next_state, normal_state, SD} -> SD
|
|
|
|
end,
|
2018-11-15 12:13:45 +01:00
|
|
|
{result, undefined, NewStateData2}
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2016-07-25 12:50:30 +02:00
|
|
|
{result, undefined, StateData}
|
2016-06-26 08:08:37 +02:00
|
|
|
end;
|
2016-11-12 11:27:15 +01:00
|
|
|
process_iq_mucsub(From, #iq{type = get, lang = Lang,
|
|
|
|
sub_els = [#muc_subscriptions{}]},
|
2016-09-06 18:06:02 +02:00
|
|
|
StateData) ->
|
|
|
|
FAffiliation = get_affiliation(From, StateData),
|
|
|
|
FRole = get_role(From, StateData),
|
|
|
|
if FRole == moderator; FAffiliation == owner; FAffiliation == admin ->
|
2018-11-15 12:13:45 +01:00
|
|
|
Subs = maps:fold(
|
2018-08-10 17:46:47 +02:00
|
|
|
fun(_, #subscriber{jid = J, nodes = Nodes}, Acc) ->
|
|
|
|
[#muc_subscription{jid = J, events = Nodes}|Acc]
|
2016-09-07 09:33:37 +02:00
|
|
|
end, [], StateData#state.subscribers),
|
2018-08-10 17:46:47 +02:00
|
|
|
{result, #muc_subscriptions{list = Subs}, StateData};
|
2016-09-06 18:06:02 +02:00
|
|
|
true ->
|
|
|
|
Txt = <<"Moderator privileges required">>,
|
2016-11-12 11:27:15 +01:00
|
|
|
{error, xmpp:err_forbidden(Txt, Lang)}
|
2016-09-06 18:06:02 +02:00
|
|
|
end;
|
2016-07-25 12:50:30 +02:00
|
|
|
process_iq_mucsub(_From, #iq{type = get, lang = Lang}, _StateData) ->
|
2016-06-26 08:08:37 +02:00
|
|
|
Txt = <<"Value 'get' of 'type' attribute is not allowed">>,
|
2016-07-25 12:50:30 +02:00
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)}.
|
2016-06-26 08:08:37 +02:00
|
|
|
|
|
|
|
remove_subscriptions(StateData) ->
|
|
|
|
if not (StateData#state.config)#config.allow_subscription ->
|
2018-11-15 12:13:45 +01:00
|
|
|
StateData#state{subscribers = #{},
|
|
|
|
subscriber_nicks = #{}};
|
2016-06-26 08:08:37 +02:00
|
|
|
true ->
|
|
|
|
StateData
|
|
|
|
end.
|
|
|
|
|
2017-02-18 07:36:27 +01:00
|
|
|
-spec get_subscription_nodes(stanza()) -> [binary()].
|
2016-07-25 12:50:30 +02:00
|
|
|
get_subscription_nodes(#iq{sub_els = [#muc_subscribe{events = Nodes}]}) ->
|
|
|
|
lists:filter(
|
|
|
|
fun(Node) ->
|
|
|
|
lists:member(Node, [?NS_MUCSUB_NODES_PRESENCE,
|
|
|
|
?NS_MUCSUB_NODES_MESSAGES,
|
|
|
|
?NS_MUCSUB_NODES_AFFILIATIONS,
|
|
|
|
?NS_MUCSUB_NODES_SUBJECT,
|
|
|
|
?NS_MUCSUB_NODES_CONFIG,
|
2017-10-30 12:05:18 +01:00
|
|
|
?NS_MUCSUB_NODES_PARTICIPANTS,
|
|
|
|
?NS_MUCSUB_NODES_SUBSCRIBERS])
|
2016-07-25 12:50:30 +02:00
|
|
|
end, Nodes);
|
2016-06-26 08:08:37 +02:00
|
|
|
get_subscription_nodes(_) ->
|
|
|
|
[].
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec subscribe_result(iq()) -> muc_subscribe().
|
|
|
|
subscribe_result(#iq{sub_els = [#muc_subscribe{nick = Nick}]} = Packet) ->
|
|
|
|
#muc_subscribe{nick = Nick, events = get_subscription_nodes(Packet)}.
|
2016-06-26 08:08:37 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_title(state()) -> binary().
|
2003-03-27 21:55:09 +01:00
|
|
|
get_title(StateData) ->
|
|
|
|
case (StateData#state.config)#config.title of
|
2013-03-14 10:33:02 +01:00
|
|
|
<<"">> -> StateData#state.room;
|
|
|
|
Name -> Name
|
2003-03-27 21:55:09 +01:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_roomdesc_reply(jid(), state(), binary()) -> {item, binary()} | false.
|
2010-06-23 09:44:35 +02:00
|
|
|
get_roomdesc_reply(JID, StateData, Tail) ->
|
2013-03-14 10:33:02 +01:00
|
|
|
IsOccupantOrAdmin = is_occupant_or_admin(JID,
|
|
|
|
StateData),
|
|
|
|
if (StateData#state.config)#config.public or
|
|
|
|
IsOccupantOrAdmin ->
|
|
|
|
if (StateData#state.config)#config.public_list or
|
|
|
|
IsOccupantOrAdmin ->
|
|
|
|
{item, <<(get_title(StateData))/binary,Tail/binary>>};
|
|
|
|
true -> {item, get_title(StateData)}
|
|
|
|
end;
|
|
|
|
true -> false
|
2010-03-29 20:51:24 +02:00
|
|
|
end.
|
2010-03-29 20:49:52 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_roomdesc_tail(state(), binary()) -> binary().
|
2010-03-29 20:49:52 +02:00
|
|
|
get_roomdesc_tail(StateData, Lang) ->
|
2010-03-29 20:51:24 +02:00
|
|
|
Desc = case (StateData#state.config)#config.public of
|
2013-03-14 10:33:02 +01:00
|
|
|
true -> <<"">>;
|
|
|
|
_ -> translate:translate(Lang, <<"private, ">>)
|
2010-03-29 20:51:24 +02:00
|
|
|
end,
|
2018-11-15 12:13:45 +01:00
|
|
|
Len = maps:size(StateData#state.nicks),
|
2016-10-17 12:37:23 +02:00
|
|
|
<<" (", Desc/binary, (integer_to_binary(Len))/binary, ")">>.
|
2010-03-29 20:49:52 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec get_mucroom_disco_items(state()) -> disco_items().
|
2010-03-29 20:49:52 +02:00
|
|
|
get_mucroom_disco_items(StateData) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
Items = maps:fold(
|
2018-02-21 08:25:15 +01:00
|
|
|
fun(Nick, _, Acc) ->
|
|
|
|
[#disco_item{jid = jid:make(StateData#state.room,
|
|
|
|
StateData#state.host,
|
|
|
|
Nick),
|
|
|
|
name = Nick}|Acc]
|
|
|
|
end, [], StateData#state.nicks),
|
2016-07-25 12:50:30 +02:00
|
|
|
#disco_items{items = Items}.
|
2003-03-27 15:06:17 +01:00
|
|
|
|
2011-07-23 16:13:27 +02:00
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
% Voice request support
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec prepare_request_form(jid(), binary(), binary()) -> message().
|
2011-07-24 11:46:47 +02:00
|
|
|
prepare_request_form(Requester, Nick, Lang) ->
|
2016-07-25 12:50:30 +02:00
|
|
|
Title = translate:translate(Lang, <<"Voice request">>),
|
|
|
|
Instruction = translate:translate(
|
|
|
|
Lang, <<"Either approve or decline the voice request.">>),
|
2016-10-07 09:31:03 +02:00
|
|
|
Fs = muc_request:encode([{role, participant},
|
|
|
|
{jid, Requester},
|
|
|
|
{roomnick, Nick},
|
|
|
|
{request_allow, false}],
|
2017-03-20 07:57:11 +01:00
|
|
|
Lang),
|
2016-07-25 12:50:30 +02:00
|
|
|
#message{type = normal,
|
|
|
|
sub_els = [#xdata{type = form,
|
|
|
|
title = Title,
|
|
|
|
instructions = [Instruction],
|
|
|
|
fields = Fs}]}.
|
|
|
|
|
|
|
|
-spec send_voice_request(jid(), binary(), state()) -> ok.
|
|
|
|
send_voice_request(From, Lang, StateData) ->
|
2011-09-26 08:55:07 +02:00
|
|
|
Moderators = search_role(moderator, StateData),
|
|
|
|
FromNick = find_nick_by_jid(From, StateData),
|
2017-02-16 09:00:26 +01:00
|
|
|
lists:foreach(
|
|
|
|
fun({_, User}) ->
|
|
|
|
ejabberd_router:route(
|
|
|
|
xmpp:set_from_to(
|
|
|
|
prepare_request_form(From, FromNick, Lang),
|
|
|
|
StateData#state.jid, User#user.jid))
|
|
|
|
end, Moderators).
|
2011-09-26 08:55:07 +02:00
|
|
|
|
2003-04-13 21:22:46 +02:00
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
% Invitation support
|
2017-01-19 15:26:08 +01:00
|
|
|
-spec check_invitation(jid(), [muc_invite()], binary(), state()) ->
|
|
|
|
ok | {error, stanza_error()}.
|
|
|
|
check_invitation(From, Invitations, Lang, StateData) ->
|
2003-04-13 21:22:46 +02:00
|
|
|
FAffiliation = get_affiliation(From, StateData),
|
2018-10-17 12:55:31 +02:00
|
|
|
CanInvite = ((StateData#state.config)#config.allow_user_invites
|
|
|
|
and not (StateData#state.config)#config.members_only) orelse
|
2017-01-19 15:26:08 +01:00
|
|
|
FAffiliation == admin orelse FAffiliation == owner,
|
2007-05-03 06:07:29 +02:00
|
|
|
case CanInvite of
|
2017-01-19 15:26:08 +01:00
|
|
|
true ->
|
|
|
|
case lists:all(
|
|
|
|
fun(#muc_invite{to = #jid{}}) -> true;
|
|
|
|
(_) -> false
|
|
|
|
end, Invitations) of
|
|
|
|
true ->
|
|
|
|
ok;
|
|
|
|
false ->
|
|
|
|
Txt = <<"No 'to' attribute found in the invitation">>,
|
|
|
|
{error, xmpp:err_bad_request(Txt, Lang)}
|
|
|
|
end;
|
2016-07-25 12:50:30 +02:00
|
|
|
false ->
|
|
|
|
Txt = <<"Invitations are not allowed in this conference">>,
|
2017-01-19 15:26:08 +01:00
|
|
|
{error, xmpp:err_not_allowed(Txt, Lang)}
|
2003-04-13 21:22:46 +02:00
|
|
|
end.
|
|
|
|
|
2018-09-21 16:37:52 +02:00
|
|
|
-spec route_invitation(jid(), message(), muc_invite(), binary(), state()) -> jid().
|
|
|
|
route_invitation(From, Pkt, Invitation, Lang, StateData) ->
|
2017-01-19 15:26:08 +01:00
|
|
|
#muc_invite{to = JID, reason = Reason} = Invitation,
|
|
|
|
Invite = Invitation#muc_invite{to = undefined, from = From},
|
|
|
|
Password = case (StateData#state.config)#config.password_protected of
|
|
|
|
true ->
|
|
|
|
(StateData#state.config)#config.password;
|
|
|
|
false ->
|
|
|
|
undefined
|
|
|
|
end,
|
|
|
|
XUser = #muc_user{password = Password, invites = [Invite]},
|
|
|
|
XConference = #x_conference{jid = jid:make(StateData#state.room,
|
|
|
|
StateData#state.host),
|
|
|
|
reason = Reason},
|
|
|
|
Body = iolist_to_binary(
|
|
|
|
[io_lib:format(
|
|
|
|
translate:translate(
|
|
|
|
Lang,
|
|
|
|
<<"~s invites you to the room ~s">>),
|
2017-02-26 08:07:12 +01:00
|
|
|
[jid:encode(From),
|
|
|
|
jid:encode({StateData#state.room, StateData#state.host, <<"">>})]),
|
2017-01-19 15:26:08 +01:00
|
|
|
case (StateData#state.config)#config.password_protected of
|
|
|
|
true ->
|
|
|
|
<<", ",
|
|
|
|
(translate:translate(
|
|
|
|
Lang, <<"the password is">>))/binary,
|
|
|
|
" '",
|
|
|
|
((StateData#state.config)#config.password)/binary,
|
|
|
|
"'">>;
|
|
|
|
_ -> <<"">>
|
|
|
|
end,
|
|
|
|
case Reason of
|
|
|
|
<<"">> -> <<"">>;
|
|
|
|
_ -> <<" (", Reason/binary, ") ">>
|
|
|
|
end]),
|
2017-02-16 09:00:26 +01:00
|
|
|
Msg = #message{from = StateData#state.jid,
|
|
|
|
to = JID,
|
|
|
|
type = normal,
|
2017-01-19 15:26:08 +01:00
|
|
|
body = xmpp:mk_text(Body),
|
|
|
|
sub_els = [XUser, XConference]},
|
2018-09-21 16:37:52 +02:00
|
|
|
Msg2 = ejabberd_hooks:run_fold(muc_invite,
|
|
|
|
StateData#state.server_host,
|
|
|
|
Msg,
|
|
|
|
[StateData#state.jid, StateData#state.config,
|
|
|
|
From, JID, Reason, Pkt]),
|
|
|
|
ejabberd_router:route(Msg2),
|
2017-01-19 15:26:08 +01:00
|
|
|
JID.
|
|
|
|
|
2008-02-06 21:30:58 +01:00
|
|
|
%% Handle a message sent to the room by a non-participant.
|
|
|
|
%% If it is a decline, send to the inviter.
|
|
|
|
%% Otherwise, an error message is sent to the sender.
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec handle_roommessage_from_nonparticipant(message(), state(), jid()) -> ok.
|
|
|
|
handle_roommessage_from_nonparticipant(Packet, StateData, From) ->
|
2017-12-11 07:46:26 +01:00
|
|
|
try xmpp:try_subtag(Packet, #muc_user{}) of
|
2016-07-25 12:50:30 +02:00
|
|
|
#muc_user{decline = #muc_decline{to = #jid{} = To} = Decline} = XUser ->
|
|
|
|
NewDecline = Decline#muc_decline{to = undefined, from = From},
|
|
|
|
NewXUser = XUser#muc_user{decline = NewDecline},
|
|
|
|
NewPacket = xmpp:set_subtag(Packet, NewXUser),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route(
|
|
|
|
xmpp:set_from_to(NewPacket, StateData#state.jid, To));
|
2016-07-25 12:50:30 +02:00
|
|
|
_ ->
|
|
|
|
ErrText = <<"Only occupants are allowed to send messages "
|
|
|
|
"to the conference">>,
|
|
|
|
Err = xmpp:err_not_acceptable(ErrText, xmpp:get_lang(Packet)),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route_error(Packet, Err)
|
2017-12-11 07:46:26 +01:00
|
|
|
catch _:{xmpp_codec, Why} ->
|
|
|
|
Txt = xmpp:io_format_error(Why),
|
|
|
|
Err = xmpp:err_bad_request(Txt, xmpp:get_lang(Packet)),
|
|
|
|
ejabberd_router:route_error(Packet, Err)
|
2008-02-06 21:30:58 +01:00
|
|
|
end.
|
|
|
|
|
2006-03-14 05:26:15 +01:00
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
% Logging
|
|
|
|
|
2009-07-21 20:33:56 +02:00
|
|
|
add_to_log(Type, Data, StateData)
|
2013-03-14 10:33:02 +01:00
|
|
|
when Type == roomconfig_change_disabledlogging ->
|
|
|
|
mod_muc_log:add_to_log(StateData#state.server_host,
|
|
|
|
roomconfig_change, Data, StateData#state.jid,
|
|
|
|
make_opts(StateData));
|
2006-03-14 05:26:15 +01:00
|
|
|
add_to_log(Type, Data, StateData) ->
|
|
|
|
case (StateData#state.config)#config.logging of
|
2013-03-14 10:33:02 +01:00
|
|
|
true ->
|
|
|
|
mod_muc_log:add_to_log(StateData#state.server_host,
|
|
|
|
Type, Data, StateData#state.jid,
|
|
|
|
make_opts(StateData));
|
|
|
|
false -> ok
|
2006-03-14 05:26:15 +01:00
|
|
|
end.
|
2007-12-03 11:47:42 +01:00
|
|
|
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
%% Users number checking
|
|
|
|
|
2017-01-13 10:03:39 +01:00
|
|
|
-spec tab_add_online_user(jid(), state()) -> any().
|
2007-12-03 11:47:42 +01:00
|
|
|
tab_add_online_user(JID, StateData) ->
|
|
|
|
Room = StateData#state.room,
|
|
|
|
Host = StateData#state.host,
|
2017-01-13 10:03:39 +01:00
|
|
|
ServerHost = StateData#state.server_host,
|
2017-07-27 17:02:06 +02:00
|
|
|
ejabberd_hooks:run(join_room, ServerHost, [ServerHost, Room, Host, JID]),
|
2017-01-13 10:03:39 +01:00
|
|
|
mod_muc:register_online_user(ServerHost, jid:tolower(JID), Room, Host).
|
2007-12-03 11:47:42 +01:00
|
|
|
|
2017-01-13 10:03:39 +01:00
|
|
|
-spec tab_remove_online_user(jid(), state()) -> any().
|
2007-12-03 11:47:42 +01:00
|
|
|
tab_remove_online_user(JID, StateData) ->
|
|
|
|
Room = StateData#state.room,
|
|
|
|
Host = StateData#state.host,
|
2017-01-13 10:03:39 +01:00
|
|
|
ServerHost = StateData#state.server_host,
|
2017-07-27 17:02:06 +02:00
|
|
|
ejabberd_hooks:run(leave_room, ServerHost, [ServerHost, Room, Host, JID]),
|
2017-01-13 10:03:39 +01:00
|
|
|
mod_muc:unregister_online_user(ServerHost, jid:tolower(JID), Room, Host).
|
2007-12-03 11:47:42 +01:00
|
|
|
|
2017-01-13 10:03:39 +01:00
|
|
|
-spec tab_count_user(jid(), state()) -> non_neg_integer().
|
|
|
|
tab_count_user(JID, StateData) ->
|
|
|
|
ServerHost = StateData#state.server_host,
|
2015-11-24 16:44:13 +01:00
|
|
|
{LUser, LServer, _} = jid:tolower(JID),
|
2017-01-13 10:03:39 +01:00
|
|
|
mod_muc:count_online_rooms_by_user(ServerHost, LUser, LServer).
|
2010-07-01 12:54:01 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec element_size(stanza()) -> non_neg_integer().
|
2010-07-01 12:54:01 +02:00
|
|
|
element_size(El) ->
|
2016-09-24 13:17:21 +02:00
|
|
|
byte_size(fxml:element_to_binary(xmpp:encode(El, ?NS_CLIENT))).
|
2013-06-27 11:50:54 +02:00
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec store_room(state()) -> ok.
|
2016-06-26 08:08:37 +02:00
|
|
|
store_room(StateData) ->
|
2017-10-31 14:00:41 +01:00
|
|
|
store_room(StateData, []).
|
|
|
|
store_room(StateData, ChangesHints) ->
|
2016-06-26 08:08:37 +02:00
|
|
|
if (StateData#state.config)#config.persistent ->
|
|
|
|
mod_muc:store_room(StateData#state.server_host,
|
|
|
|
StateData#state.host, StateData#state.room,
|
2017-10-31 14:00:41 +01:00
|
|
|
make_opts(StateData),
|
|
|
|
ChangesHints);
|
2016-06-26 08:08:37 +02:00
|
|
|
true ->
|
|
|
|
ok
|
|
|
|
end.
|
|
|
|
|
2017-10-30 12:05:18 +01:00
|
|
|
-spec send_subscriptions_change_notifications(jid(), binary(), subscribe|unsubscribe, state()) -> ok.
|
|
|
|
send_subscriptions_change_notifications(From, Nick, Type, State) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(fun(_, #subscriber{nodes = Nodes, jid = JID}, _) ->
|
2017-10-30 12:05:18 +01:00
|
|
|
case lists:member(?NS_MUCSUB_NODES_SUBSCRIBERS, Nodes) of
|
|
|
|
true ->
|
|
|
|
ShowJid = case (State#state.config)#config.anonymous == false orelse
|
|
|
|
get_role(JID, State) == moderator orelse
|
|
|
|
get_default_role(get_affiliation(JID, State), State) == moderator of
|
|
|
|
true -> true;
|
|
|
|
_ -> false
|
|
|
|
end,
|
2017-10-30 13:27:37 +01:00
|
|
|
Payload = case {Type, ShowJid} of
|
2017-10-30 12:05:18 +01:00
|
|
|
{subscribe, true} ->
|
|
|
|
#muc_subscribe{jid = From, nick = Nick};
|
|
|
|
{subscribe, _} ->
|
|
|
|
#muc_subscribe{nick = Nick};
|
|
|
|
{unsubscribe, true} ->
|
|
|
|
#muc_unsubscribe{jid = From, nick = Nick};
|
|
|
|
{unsubscribe, _} ->
|
|
|
|
#muc_unsubscribe{nick = Nick}
|
|
|
|
end,
|
2017-10-30 13:27:37 +01:00
|
|
|
Packet = #message{
|
|
|
|
sub_els = [#ps_event{
|
|
|
|
items = #ps_items{
|
|
|
|
node = ?NS_MUCSUB_NODES_SUBSCRIBERS,
|
|
|
|
items = [#ps_item{
|
2018-07-05 10:51:49 +02:00
|
|
|
id = p1_rand:get_string(),
|
2018-01-25 18:02:47 +01:00
|
|
|
sub_els = [Payload]}]}}]},
|
2017-10-30 13:27:37 +01:00
|
|
|
ejabberd_router:route(xmpp:set_from_to(Packet, From, JID));
|
2017-10-30 12:05:18 +01:00
|
|
|
false ->
|
|
|
|
ok
|
|
|
|
end
|
|
|
|
end, ok, State#state.subscribers).
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec send_wrapped(jid(), jid(), stanza(), binary(), state()) -> ok.
|
2016-06-26 08:08:37 +02:00
|
|
|
send_wrapped(From, To, Packet, Node, State) ->
|
|
|
|
LTo = jid:tolower(To),
|
2016-09-07 09:33:37 +02:00
|
|
|
LBareTo = jid:tolower(jid:remove_resource(To)),
|
2018-11-15 12:13:45 +01:00
|
|
|
IsOffline = case maps:get(LTo, State#state.users, error) of
|
|
|
|
#user{last_presence = undefined} -> true;
|
2016-09-07 09:33:37 +02:00
|
|
|
error -> true;
|
|
|
|
_ -> false
|
|
|
|
end,
|
|
|
|
if IsOffline ->
|
2018-11-15 12:13:45 +01:00
|
|
|
try maps:get(LBareTo, State#state.subscribers) of
|
|
|
|
#subscriber{nodes = Nodes, jid = JID} ->
|
|
|
|
case lists:member(Node, Nodes) of
|
|
|
|
true ->
|
2016-09-07 09:33:37 +02:00
|
|
|
NewPacket = wrap(From, JID, Packet, Node),
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route(
|
|
|
|
xmpp:set_from_to(NewPacket, State#state.jid, JID));
|
2018-11-15 12:13:45 +01:00
|
|
|
false ->
|
|
|
|
ok
|
|
|
|
end
|
2018-11-15 13:07:58 +01:00
|
|
|
catch _:{badkey, _} ->
|
2016-06-26 08:08:37 +02:00
|
|
|
ok
|
|
|
|
end;
|
2016-09-07 09:33:37 +02:00
|
|
|
true ->
|
2018-02-12 15:37:36 +01:00
|
|
|
case Packet of
|
|
|
|
#presence{type = unavailable} ->
|
|
|
|
case xmpp:get_subtag(Packet, #muc_user{}) of
|
|
|
|
#muc_user{destroy = Destroy,
|
|
|
|
status_codes = Codes} ->
|
|
|
|
case Destroy /= undefined orelse
|
|
|
|
(lists:member(110,Codes) andalso
|
|
|
|
not lists:member(303, Codes)) of
|
|
|
|
true ->
|
|
|
|
ejabberd_router:route(
|
|
|
|
#presence{from = State#state.jid, to = To,
|
2018-07-05 10:51:49 +02:00
|
|
|
id = p1_rand:get_string(),
|
2018-02-12 15:37:36 +01:00
|
|
|
type = unavailable});
|
|
|
|
false ->
|
|
|
|
ok
|
|
|
|
end;
|
|
|
|
_ ->
|
|
|
|
false
|
|
|
|
end;
|
|
|
|
_ ->
|
|
|
|
ok
|
|
|
|
end,
|
2017-02-16 09:00:26 +01:00
|
|
|
ejabberd_router:route(xmpp:set_from_to(Packet, From, To))
|
2016-06-26 08:08:37 +02:00
|
|
|
end.
|
|
|
|
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec wrap(jid(), jid(), stanza(), binary()) -> message().
|
2016-06-26 08:08:37 +02:00
|
|
|
wrap(From, To, Packet, Node) ->
|
2018-01-25 18:02:47 +01:00
|
|
|
El = xmpp:set_from_to(Packet, From, To),
|
2016-07-25 12:50:30 +02:00
|
|
|
#message{
|
2016-08-30 08:48:08 +02:00
|
|
|
sub_els = [#ps_event{
|
|
|
|
items = #ps_items{
|
|
|
|
node = Node,
|
|
|
|
items = [#ps_item{
|
2018-07-05 10:51:49 +02:00
|
|
|
id = p1_rand:get_string(),
|
2018-01-25 18:02:47 +01:00
|
|
|
sub_els = [El]}]}}]}.
|
2016-06-26 08:08:37 +02:00
|
|
|
|
2018-11-15 12:13:45 +01:00
|
|
|
-spec send_wrapped_multiple(jid(), map(), stanza(), binary(), state()) -> ok.
|
2016-06-26 08:08:37 +02:00
|
|
|
send_wrapped_multiple(From, Users, Packet, Node, State) ->
|
2018-11-15 12:13:45 +01:00
|
|
|
maps:fold(
|
|
|
|
fun(_, #user{jid = To}, _) ->
|
2016-06-26 08:08:37 +02:00
|
|
|
send_wrapped(From, To, Packet, Node, State)
|
2018-11-15 12:13:45 +01:00
|
|
|
end, ok, Users).
|
2016-06-26 08:08:37 +02:00
|
|
|
|
2013-06-27 11:50:54 +02:00
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
%% Detect messange stanzas that don't have meaninful content
|
2016-07-25 12:50:30 +02:00
|
|
|
-spec has_body_or_subject(message()) -> boolean().
|
|
|
|
has_body_or_subject(#message{body = Body, subject = Subj}) ->
|
|
|
|
Body /= [] orelse Subj /= [].
|