./ct_report/coverage/ejabberd_service.COVER.html

1 %%%----------------------------------------------------------------------
2 %%% File : ejabberd_service.erl
3 %%% Author : Alexey Shchepin <alexey@process-one.net>
4 %%% Purpose : External component management (XEP-0114)
5 %%% Created : 6 Dec 2002 by Alexey Shchepin <alexey@process-one.net>
6 %%%
7 %%%
8 %%% ejabberd, Copyright (C) 2002-2011 ProcessOne
9 %%%
10 %%% This program is free software; you can redistribute it and/or
11 %%% modify it under the terms of the GNU General Public License as
12 %%% published by the Free Software Foundation; either version 2 of the
13 %%% License, or (at your option) any later version.
14 %%%
15 %%% This program is distributed in the hope that it will be useful,
16 %%% but WITHOUT ANY WARRANTY; without even the implied warranty of
17 %%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 %%% General Public License for more details.
19 %%%
20 %%% You should have received a copy of the GNU General Public License
21 %%% along with this program; if not, write to the Free Software
22 %%% Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 %%%
24 %%%----------------------------------------------------------------------
25
26 -module(ejabberd_service).
27 -author('alexey@process-one.net').
28 -xep([{xep, 114}, {version, "1.6"}]).
29
30 -behaviour(p1_fsm).
31 -behaviour(mongoose_packet_handler).
32 -behaviour(mongoose_listener).
33
34 %% mongoose_listener API
35 -export([start_listener/1]).
36
37 %% External exports
38 -export([start/2,
39 start_link/2]).
40
41 %% gen_fsm callbacks
42 -export([init/1,
43 wait_for_stream/2,
44 wait_for_handshake/2,
45 stream_established/2,
46 handle_event/3,
47 handle_sync_event/4,
48 code_change/4,
49 handle_info/3,
50 terminate/3,
51 print_state/1]).
52
53 %% packet handler callback
54 -export([process_packet/5]).
55
56 -ignore_xref([print_state/1, start_listener/1, start_link/2, start/2,
57 stream_established/2, wait_for_handshake/2, wait_for_stream/2]).
58
59 -include("mongoose.hrl").
60 -include("jlib.hrl").
61 -include("external_component.hrl").
62
63 -type conflict_behaviour() :: disconnect | kick_old.
64
65 -record(state, {socket,
66 socket_monitor,
67 streamid,
68 password :: string(),
69 host :: binary() | undefined,
70 is_subdomain :: boolean(),
71 hidden_components = false :: boolean(),
72 conflict_behaviour :: conflict_behaviour(),
73 access,
74 check_from,
75 components = [] :: [mongoose_component:external_component()]
76 }).
77 -type state() :: #state{}.
78
79 -type statename() :: wait_for_stream
80 | wait_for_handshake
81 | stream_established.
82 %% FSM handler return value
83 -type fsm_return() :: {'stop', Reason :: 'normal', state()}
84 | {'next_state', statename(), state()}
85 | {'next_state', statename(), state(), Timeout :: integer()}.
86 %-define(DBGFSM, true).
87
88 -ifdef(DBGFSM).
89 -define(FSMOPTS, [{debug, [trace]}]).
90 -else.
91 -define(FSMOPTS, []).
92 -endif.
93
94 -define(STREAM_HEADER,
95 <<"<?xml version='1.0'?>"
96 "<stream:stream "
97 "xmlns:stream='http://etherx.jabber.org/streams' "
98 "xmlns='jabber:component:accept' "
99 "id='~s' from='~s'>">>
100 ).
101
102 -define(INVALID_HEADER_ERR,
103 <<"<stream:stream "
104 "xmlns:stream='http://etherx.jabber.org/streams'>"
105 "<stream:error>Invalid Stream Header</stream:error>"
106 "</stream:stream>">>
107 ).
108
109 -define(INVALID_HANDSHAKE_ERR,
110 <<"<stream:error>"
111 "<not-authorized xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>"
112 "<text xmlns='urn:ietf:params:xml:ns:xmpp-streams' xml:lang='en'>"
113 "Invalid Handshake</text>"
114 "</stream:error>"
115 "</stream:stream>">>
116 ).
117
118 -type socket() :: term().
119 -type options() :: #{access := atom(),
120 shaper_rule := atom(),
121 password := binary(),
122 check_from := boolean(),
123 hidden_components := boolean(),
124 conflict_behaviour := conflict_behaviour(),
125 atom() => any()}.
126
127 %%%----------------------------------------------------------------------
128 %%% API
129 %%%----------------------------------------------------------------------
130 -spec start(socket(), options()) ->
131 {error, _} | {ok, undefined | pid()} | {ok, undefined | pid(), _}.
132 start(Socket, Opts) ->
133 
:-(
 supervisor:start_child(ejabberd_service_sup, [Socket, Opts]).
134
135
136 -spec start_link(socket(), options()) -> ignore | {error, _} | {ok, pid()}.
137 start_link(SockData, Opts) ->
138 
:-(
 p1_fsm:start_link(ejabberd_service, [SockData, Opts],
139 fsm_limit_opts(Opts) ++ ?FSMOPTS).
140
141 -spec start_listener(options()) -> ok.
142 start_listener(Opts) ->
143 5 mongoose_tcp_listener:start_listener(Opts).
144
145 %%%----------------------------------------------------------------------
146 %%% mongoose_packet_handler callback
147 %%%----------------------------------------------------------------------
148
149 -spec process_packet(Acc :: mongoose_acc:t(), From :: jid:jid(), To :: jid:jid(),
150 El :: exml:element(), #{pid := pid()}) -> mongoose_acc:t().
151 process_packet(Acc, _From, _To, _El, #{pid := Pid}) ->
152 
:-(
 Pid ! {route, Acc},
153 
:-(
 Acc.
154
155 %%%----------------------------------------------------------------------
156 %%% Callback functions from gen_fsm
157 %%%----------------------------------------------------------------------
158
159 %%----------------------------------------------------------------------
160 %% Func: init/1
161 %% Returns: {ok, StateName, StateData} |
162 %% {ok, StateName, StateData, Timeout} |
163 %% ignore |
164 %% {stop, StopReason}
165 %%----------------------------------------------------------------------
166 -spec init([socket() | options(), ...]) -> {'ok', 'wait_for_stream', state()}.
167 init([Socket, Opts]) ->
168 
:-(
 ?LOG_INFO(#{what => comp_started,
169 text => <<"External service connected">>,
170 
:-(
 socket => Socket}),
171 
:-(
 #{access := Access, shaper_rule := Shaper, password := Password,
172 check_from := CheckFrom, hidden_components := HiddenComponents,
173 conflict_behaviour := ConflictBehaviour} = Opts,
174 
:-(
 mongoose_transport:change_shaper(Socket, Shaper),
175 
:-(
 SocketMonitor = mongoose_transport:monitor(Socket),
176 
:-(
 {ok, wait_for_stream, #state{socket = Socket,
177 socket_monitor = SocketMonitor,
178 streamid = new_id(),
179 password = Password,
180 access = Access,
181 check_from = CheckFrom,
182 is_subdomain = false,
183 hidden_components = HiddenComponents,
184 conflict_behaviour = ConflictBehaviour
185 }}.
186
187 %%----------------------------------------------------------------------
188 %% Func: StateName/2
189 %% Returns: {next_state, NextStateName, NextStateData} |
190 %% {next_state, NextStateName, NextStateData, Timeout} |
191 %% {stop, Reason, NewStateData}
192 %%----------------------------------------------------------------------
193
194 -spec wait_for_stream(ejabberd:xml_stream_item(), state()) -> fsm_return().
195 wait_for_stream({xmlstreamstart, _Name, Attrs}, StateData) ->
196 
:-(
 case xml:get_attr_s(<<"xmlns">>, Attrs) of
197 <<"jabber:component:accept">> ->
198 %% Note: XEP-0114 requires to check that destination is a Jabber
199 %% component served by this Jabber server.
200 %% However several transports don't respect that,
201 %% so ejabberd doesn't check 'to' attribute (EJAB-717)
202 
:-(
 To = xml:get_attr_s(<<"to">>, Attrs),
203 
:-(
 Header = io_lib:format(?STREAM_HEADER, [StateData#state.streamid, To]),
204 
:-(
 IsSubdomain = case xml:get_attr_s(<<"is_subdomain">>, Attrs) of
205 
:-(
 <<"true">> -> true;
206 
:-(
 _ -> false
207 end,
208 
:-(
 send_text(StateData, list_to_binary(Header)),
209 
:-(
 StateData1 = StateData#state{host = To,
210 is_subdomain = IsSubdomain},
211 
:-(
 {next_state, wait_for_handshake, StateData1};
212 _ ->
213 
:-(
 send_text(StateData, ?INVALID_HEADER_ERR),
214 
:-(
 {stop, normal, StateData}
215 end;
216 wait_for_stream({xmlstreamerror, _}, StateData) ->
217 
:-(
 Header = io_lib:format(?STREAM_HEADER,
218 [<<"none">>, ?MYNAME]),
219 
:-(
 send_text(StateData, iolist_to_binary(Header)),
220 
:-(
 send_element(StateData, mongoose_xmpp_errors:xml_not_well_formed()),
221 
:-(
 send_text(StateData, ?STREAM_TRAILER),
222 
:-(
 {stop, normal, StateData};
223 wait_for_stream(closed, StateData) ->
224 
:-(
 {stop, normal, StateData};
225 wait_for_stream(replaced, StateData) ->
226 
:-(
 {stop, normal, StateData}.
227
228
229 -spec wait_for_handshake(ejabberd:xml_stream_item(), state()) -> fsm_return().
230 wait_for_handshake({xmlstreamelement, El}, StateData) ->
231 
:-(
 #xmlel{name = Name, children = Els} = El,
232 
:-(
 case {Name, xml:get_cdata(Els)} of
233 {<<"handshake">>, Digest} ->
234 
:-(
 case mongoose_bin:encode_crypto([StateData#state.streamid,
235 StateData#state.password]) of
236 Digest ->
237 
:-(
 try_register_routes(StateData);
238 _ ->
239 
:-(
 send_text(StateData, ?INVALID_HANDSHAKE_ERR),
240 
:-(
 {stop, normal, StateData}
241 end;
242 _ ->
243 
:-(
 {next_state, wait_for_handshake, StateData}
244 end;
245 wait_for_handshake({xmlstreamend, _Name}, StateData) ->
246 
:-(
 {stop, normal, StateData};
247 wait_for_handshake({xmlstreamerror, _}, StateData) ->
248 
:-(
 send_element(StateData, mongoose_xmpp_errors:xml_not_well_formed()),
249 
:-(
 send_text(StateData, ?STREAM_TRAILER),
250 
:-(
 {stop, normal, StateData};
251 wait_for_handshake(replaced, StateData) ->
252 %% We don't expect to receive replaced before handshake
253 
:-(
 do_disconnect_on_conflict(StateData);
254 wait_for_handshake(closed, StateData) ->
255 
:-(
 {stop, normal, StateData}.
256
257 -spec stream_established(ejabberd:xml_stream_item(), state()) -> fsm_return().
258 stream_established({xmlstreamelement, El}, StateData) ->
259 
:-(
 NewEl = jlib:remove_attr(<<"xmlns">>, El),
260 
:-(
 #xmlel{name = Name, attrs = Attrs} = NewEl,
261 
:-(
 From = xml:get_attr_s(<<"from">>, Attrs),
262 
:-(
 FromJID = case StateData#state.check_from of
263 %% If the admin does not want to check the from field
264 %% when accept packets from any address.
265 %% In this case, the component can send packet of
266 %% behalf of the server users.
267 
:-(
 false -> jid:from_binary(From);
268 %% The default is the standard behaviour in XEP-0114
269 _ ->
270 
:-(
 FromJID1 = jid:from_binary(From),
271 
:-(
 case FromJID1 of
272 #jid{lserver = Server} ->
273 
:-(
 case Server =:= StateData#state.host of
274 
:-(
 true -> FromJID1;
275 
:-(
 false -> error
276 end;
277 
:-(
 _ -> error
278 end
279 end,
280 
:-(
 To = xml:get_attr_s(<<"to">>, Attrs),
281 
:-(
 ToJID = case To of
282 
:-(
 <<>> -> error;
283 
:-(
 _ -> jid:from_binary(To)
284 end,
285 
:-(
 if ((Name == <<"iq">>) or
286 (Name == <<"message">>) or
287 (Name == <<"presence">>)) and
288 (ToJID /= error) and (FromJID /= error) ->
289 
:-(
 ejabberd_router:route(FromJID, ToJID, NewEl);
290 true ->
291 
:-(
 ?LOG_INFO(#{what => comp_bad_request,
292 text => <<"Not valid Name or error in FromJID or ToJID">>,
293 
:-(
 stanza_name => Name, from_jid => From, to_jid => To}),
294 
:-(
 Err = jlib:make_error_reply(NewEl, mongoose_xmpp_errors:bad_request()),
295 
:-(
 send_element(StateData, Err),
296 
:-(
 error
297 end,
298 
:-(
 {next_state, stream_established, StateData};
299 stream_established({xmlstreamend, _Name}, StateData) ->
300 % TODO ??
301 
:-(
 {stop, normal, StateData};
302 stream_established({xmlstreamerror, _}, StateData) ->
303 
:-(
 send_element(StateData, mongoose_xmpp_errors:xml_not_well_formed()),
304 
:-(
 send_text(StateData, ?STREAM_TRAILER),
305 
:-(
 {stop, normal, StateData};
306 stream_established(replaced, StateData) ->
307 
:-(
 do_disconnect_on_conflict(StateData);
308 stream_established(closed, StateData) ->
309 % TODO ??
310 
:-(
 {stop, normal, StateData}.
311
312
313 %%----------------------------------------------------------------------
314 %% Func: StateName/3
315 %% Returns: {next_state, NextStateName, NextStateData} |
316 %% {next_state, NextStateName, NextStateData, Timeout} |
317 %% {reply, Reply, NextStateName, NextStateData} |
318 %% {reply, Reply, NextStateName, NextStateData, Timeout} |
319 %% {stop, Reason, NewStateData} |
320 %% {stop, Reason, Reply, NewStateData}
321 %%----------------------------------------------------------------------
322 %state_name(Event, From, StateData) ->
323 % Reply = ok,
324 % {reply, Reply, state_name, StateData}.
325
326 %%----------------------------------------------------------------------
327 %% Func: handle_event/3
328 %% Returns: {next_state, NextStateName, NextStateData} |
329 %% {next_state, NextStateName, NextStateData, Timeout} |
330 %% {stop, Reason, NewStateData}
331 %%----------------------------------------------------------------------
332 handle_event(_Event, StateName, StateData) ->
333 
:-(
 {next_state, StateName, StateData}.
334
335 %%----------------------------------------------------------------------
336 %% Func: handle_sync_event/4
337 %% Returns: {next_state, NextStateName, NextStateData} |
338 %% {next_state, NextStateName, NextStateData, Timeout} |
339 %% {reply, Reply, NextStateName, NextStateData} |
340 %% {reply, Reply, NextStateName, NextStateData, Timeout} |
341 %% {stop, Reason, NewStateData} |
342 %% {stop, Reason, Reply, NewStateData}
343 %%----------------------------------------------------------------------
344 handle_sync_event(_Event, _From, StateName, StateData) ->
345 
:-(
 Reply = ok,
346 
:-(
 {reply, Reply, StateName, StateData}.
347
348
349 code_change(_OldVsn, StateName, StateData, _Extra) ->
350 
:-(
 {ok, StateName, StateData}.
351
352 %%----------------------------------------------------------------------
353 %% Func: handle_info/3
354 %% Returns: {next_state, NextStateName, NextStateData} |
355 %% {next_state, NextStateName, NextStateData, Timeout} |
356 %% {stop, Reason, NewStateData}
357 %%----------------------------------------------------------------------
358 handle_info({send_element, El}, StateName, StateData) ->
359 % is it ever called?
360 
:-(
 ?LOG_ERROR(#{what => comp_deprecated_send_element,
361 
:-(
 component => component_host(StateData), exml_packet => El}),
362 
:-(
 send_element(StateData, El),
363 
:-(
 {next_state, StateName, StateData};
364 handle_info({route, Acc}, StateName, StateData) ->
365 
:-(
 {From, To, Packet} = mongoose_acc:packet(Acc),
366
367 
:-(
 ?LOG_DEBUG(#{what => comp_route,
368 text => <<"Route packet to an external component">>,
369 
:-(
 component => component_host(StateData), acc => Acc}),
370 
:-(
 case acl:match_rule(global, StateData#state.access, From) of
371 allow ->
372 
:-(
 mongoose_hooks:packet_to_component(Acc, From, To),
373 
:-(
 Attrs2 = jlib:replace_from_to_attrs(jid:to_binary(From),
374 jid:to_binary(To),
375 Packet#xmlel.attrs),
376 
:-(
 send_element(StateData, Packet#xmlel{ attrs = Attrs2 });
377 deny ->
378 
:-(
 ejabberd_router:route_error_reply(To, From, Acc, mongoose_xmpp_errors:not_allowed())
379 end,
380 
:-(
 {next_state, StateName, StateData};
381 handle_info({'DOWN', Monitor, _Type, _Object, _Info}, _StateName, StateData)
382 when Monitor == StateData#state.socket_monitor ->
383 
:-(
 {stop, normal, StateData};
384 handle_info(Info, StateName, StateData) ->
385 
:-(
 ?UNEXPECTED_INFO(Info),
386 
:-(
 {next_state, StateName, StateData}.
387
388
389 %%----------------------------------------------------------------------
390 %% Func: terminate/3
391 %% Purpose: Shutdown the fsm
392 %% Returns: any
393 %%----------------------------------------------------------------------
394 terminate(Reason, StateName, StateData) ->
395 
:-(
 ?LOG_INFO(#{what => comp_stopped,
396 
:-(
 component => component_host(StateData), reason => Reason}),
397 
:-(
 case StateName of
398 stream_established ->
399 
:-(
 unregister_routes(StateData);
400 _ ->
401 
:-(
 ok
402 end,
403 
:-(
 mongoose_transport:close(StateData#state.socket),
404 
:-(
 ok.
405
406 %%----------------------------------------------------------------------
407 %% Func: print_state/1
408 %% Purpose: Prepare the state to be printed on error log
409 %% Returns: State to print
410 %%----------------------------------------------------------------------
411 print_state(State) ->
412 
:-(
 State.
413
414 %%%----------------------------------------------------------------------
415 %%% Internal functions
416 %%%----------------------------------------------------------------------
417
418 -spec send_text(state(), binary()) -> ok.
419 send_text(StateData, Text) ->
420 
:-(
 ?LOG_DEBUG(#{what => comp_send_text,
421 component => component_host(StateData),
422 
:-(
 send_text => Text}),
423 
:-(
 mongoose_transport:send_text(StateData#state.socket, Text).
424
425 -spec send_element(state(), exml:element()) -> ok.
426 send_element(StateData, El) ->
427 
:-(
 mongoose_transport:send_element(StateData#state.socket, El).
428
429
430 -spec new_id() -> string().
431 new_id() ->
432 
:-(
 binary_to_list(mongoose_bin:gen_from_crypto()).
433
434 -spec component_host(state()) -> binary() | string().
435 
:-(
 component_host(#state{ host = undefined }) -> "undefined";
436 
:-(
 component_host(#state{ host = Host }) -> Host.
437
438 -spec fsm_limit_opts(options()) -> [{max_queue, integer()}].
439 fsm_limit_opts(#{max_fsm_queue := N}) ->
440 
:-(
 [{max_queue, N}];
441 fsm_limit_opts(#{}) ->
442 
:-(
 case mongoose_config:lookup_opt(max_fsm_queue) of
443 {ok, N} ->
444 
:-(
 [{max_queue, N}];
445 {error, not_found} ->
446 
:-(
 []
447 end.
448
449 try_register_routes(StateData) ->
450 
:-(
 try_register_routes(StateData, 3).
451
452 try_register_routes(StateData, Retries) ->
453 
:-(
 case register_routes(StateData) of
454 {ok, Components} ->
455 
:-(
 send_element(StateData, #xmlel{name = <<"handshake">>}),
456 
:-(
 {next_state, stream_established, StateData#state{components = Components}};
457 {error, Reason} ->
458 
:-(
 RoutesInfo = lookup_routes(StateData),
459 
:-(
 ConflictBehaviour = StateData#state.conflict_behaviour,
460 
:-(
 ?LOG_ERROR(#{what => comp_registration_conflict,
461 text => <<"Another connection from a component with the same name">>,
462 component => component_host(StateData),
463 reason => Reason, retries => Retries, routes_info => RoutesInfo,
464 
:-(
 conflict_behaviour => ConflictBehaviour}),
465 
:-(
 handle_registration_conflict(ConflictBehaviour, RoutesInfo, StateData, Retries)
466 end.
467
468 routes_info_to_pids(RoutesInfo) ->
469 
:-(
 {_Hosts, ExtComponentsPerHost} = lists:unzip(RoutesInfo),
470 %% Flatten the list of lists
471 
:-(
 ExtComponents = lists:append(ExtComponentsPerHost),
472 %% Ignore handlers from other modules
473 
:-(
 [maps:get(pid, mongoose_packet_handler:extra(H))
474 
:-(
 || #external_component{handler = H} <- ExtComponents,
475 
:-(
 mongoose_packet_handler:module(H) =:= ?MODULE].
476
477 handle_registration_conflict(kick_old, RoutesInfo, StateData, Retries) when Retries > 0 ->
478 %% see lookup_routes
479 
:-(
 Pids = lists:usort(routes_info_to_pids(RoutesInfo)),
480 
:-(
 Results = lists:map(fun stop_process/1, Pids),
481 
:-(
 AllOk = lists:all(fun(Result) -> Result =:= ok end, Results),
482 
:-(
 case AllOk of
483 true ->
484 %% Do recursive call
485 
:-(
 try_register_routes(StateData, Retries - 1);
486 false ->
487 
:-(
 ?LOG_ERROR(#{what => comp_registration_kick_failed,
488 text => <<"Failed to stop old component connection. Disconnecting next.">>,
489 component => component_host(StateData),
490 
:-(
 component_pids => Pids, results => Results}),
491 
:-(
 do_disconnect_on_conflict(StateData)
492 end;
493 handle_registration_conflict(_Behaviour, _RoutesInfo, StateData, _Retries) ->
494 
:-(
 do_disconnect_on_conflict(StateData).
495
496 do_disconnect_on_conflict(StateData) ->
497 
:-(
 send_element(StateData, mongoose_xmpp_errors:stream_conflict()),
498 
:-(
 {stop, normal, StateData}.
499
500 lookup_routes(StateData) ->
501 
:-(
 Routes = get_routes(StateData),
502 %% Lookup for all pids for the route (both local and global)
503 
:-(
 [{Route, mongoose_component:lookup_component(Route)} || Route <- Routes].
504
505 -spec register_routes(state()) -> any().
506 register_routes(StateData = #state{hidden_components = AreHidden}) ->
507 
:-(
 Routes = get_routes(StateData),
508 
:-(
 Handler = mongoose_packet_handler:new(?MODULE, #{pid => self()}),
509 
:-(
 mongoose_component:register_components(Routes, node(), Handler, AreHidden).
510
511 -spec unregister_routes(state()) -> any().
512 unregister_routes(#state{components = Components}) ->
513 
:-(
 mongoose_component:unregister_components(Components).
514
515 get_routes(#state{host=Subdomain, is_subdomain=true}) ->
516 
:-(
 Hosts = mongoose_config:get_opt(hosts),
517 
:-(
 component_routes(Subdomain, Hosts);
518 get_routes(#state{host=Host}) ->
519 
:-(
 [Host].
520
521 -spec component_routes(binary(), [binary()]) -> [binary()].
522 component_routes(Subdomain, Hosts) ->
523 
:-(
 [<<Subdomain/binary, ".", Host/binary>> || Host <- Hosts].
524
525 stop_process(Pid) ->
526 
:-(
 p1_fsm:send_event(Pid, replaced),
527 
:-(
 MonRef = erlang:monitor(process, Pid),
528 
:-(
 receive
529 {'DOWN', MonRef, process, Pid, _Reason} ->
530 
:-(
 ok
531 after 5000 ->
532 
:-(
 erlang:demonitor(MonRef, [flush]),
533 
:-(
 {error, timeout}
534 end.
Line Hits Source