lists:foreach(
fun(Host) ->
ACLs = ejabberd_config:get_option(
- {acl, Host}, fun(V) -> V end, []),
+ {acl, Host}, []),
AccessRules = ejabberd_config:get_option(
- {access, Host}, fun(V) -> V end, []),
+ {access, Host}, []),
AccessRulesNew = ejabberd_config:get_option(
- {access_rules, Host}, fun(V) -> V end, []),
+ {access_rules, Host}, []),
ShaperRules = ejabberd_config:get_option(
- {shaper_rules, Host}, fun(V) -> V end, []),
+ {shaper_rules, Host}, []),
lists:foreach(
fun({ACLName, SpecList}) ->
lists:foreach(
(deny) -> true;
(_) -> false
end),
- throw({replace_with, Rules}).
+ Rules.
shaper_rules_validator(Name) when is_atom(Name) ->
(V2) when is_integer(V2) -> true;
(_) -> false
end),
- throw({replace_with, Rules}).
+ Rules.
access_shaper_rules_validator([{Type, Acls} = Rule | Rest], RuleTypeCheck) ->
case RuleTypeCheck(Type) of
check_password :: check_password_fun(),
auth_module :: atom(),
host = <<"">> :: binary(),
- hostfqdn = <<"">> :: binary() | [binary()]}).
+ hostfqdn = [] :: [binary()]}).
start(_Opts) ->
Fqdn = get_local_fqdn(),
false
end.
-is_host_fqdn(Host, Fqdn) when is_binary(Fqdn) ->
- Host == Fqdn;
is_host_fqdn(_Host, []) ->
false;
is_host_fqdn(Host, [Fqdn | _FqdnTail]) when Host == Fqdn ->
is_host_fqdn(Host, FqdnTail).
get_local_fqdn() ->
- case catch get_local_fqdn2() of
- Str when is_binary(Str) -> Str;
- List when is_list(List) -> List;
- _ ->
- <<"unknown-fqdn, please configure fqdn "
- "option in ejabberd.yml!">>
- end.
-
-get_local_fqdn2() ->
- case ejabberd_config:get_option(
- fqdn, fun(X) -> X end) of
- ConfiguredFqdn when is_binary(ConfiguredFqdn) ->
- ConfiguredFqdn;
- [A | _] = ConfiguredFqdns when is_binary(A) ->
- ConfiguredFqdns;
- undefined ->
- {ok, Hostname} = inet:gethostname(),
- {ok, {hostent, Fqdn, _, _, _, _}} =
- inet:gethostbyname(Hostname),
- list_to_binary(Fqdn)
+ case ejabberd_config:get_option(fqdn) of
+ undefined ->
+ {ok, Hostname} = inet:gethostname(),
+ {ok, {hostent, Fqdn, _, _, _, _}} = inet:gethostbyname(Hostname),
+ [list_to_binary(Fqdn)];
+ Fqdn ->
+ Fqdn
end.
hex(S) ->
":", (hex((erlang:md5(A2))))/binary>>,
hex((erlang:md5(T))).
-opt_type(fqdn) -> fun iolist_to_binary/1;
+opt_type(fqdn) ->
+ fun(FQDN) when is_binary(FQDN) ->
+ [FQDN];
+ (FQDNs) when is_list(FQDNs) ->
+ [iolist_to_binary(FQDN) || FQDN <- FQDNs]
+ end;
opt_type(_) -> [fqdn].
[{acl,{acl,admin}},
{oauth,[<<"ejabberd:admin">>],[{acl,{acl,admin}}]}],
{all, [start, stop]}}}],
- ApiPerms = ejabberd_config:get_option(api_permissions, fun(A) -> A end,
- DefaultOptions),
+ ApiPerms = ejabberd_config:get_option(api_permissions, DefaultOptions),
AllCommands = ejabberd_commands:get_commands_definition(),
Frags = lists:foldl(
fun({_Name, Generator}, Acc) ->
%%%===================================================================
parse_api_permissions(Data) when is_list(Data) ->
- throw({replace_with, [parse_api_permission(Name, Args) || {Name, Args} <- Data]}).
+ [parse_api_permission(Name, Args) || {Name, Args} <- Data].
parse_api_permission(Name, Args0) ->
Args = lists:flatten(Args0),
throw:{invalid_syntax, Msg} ->
report_error(<<"Invalid access rule: '~s' used inside 'who' section for api_permission '~s'">>,
[Msg, Name]);
- throw:{replace_with, NVal} ->
- {access, NVal};
error:_ ->
report_error(<<"Invalid access rule '~p' used inside 'who' section for api_permission '~s'">>,
[Val, Name])
%%%
connect_nodes() ->
- Nodes = ejabberd_config:get_option(
- cluster_nodes,
- fun(Ns) ->
- true = lists:all(fun is_atom/1, Ns),
- Ns
- end, []),
+ Nodes = ejabberd_config:get_option(cluster_nodes, []),
lists:foreach(fun(Node) ->
net_kernel:connect_node(Node)
end, Nodes).
end.
set_settings_from_config() ->
- Ticktime = ejabberd_config:get_option(
- net_ticktime,
- opt_type(net_ticktime),
- 60),
+ Ticktime = ejabberd_config:get_option(net_ticktime, 60),
net_kernel:set_net_ticktime(Ticktime).
file_queue_init() ->
end.
password_format(LServer) ->
- ejabberd_config:get_option({auth_password_format, LServer},
- opt_type(auth_password_format),
- plain).
+ ejabberd_config:get_option({auth_password_format, LServer}, plain).
%%%----------------------------------------------------------------------
%%% Internal functions
auth_modules(Server) ->
LServer = jid:nameprep(Server),
Default = ejabberd_config:default_db(LServer, ?MODULE),
- Methods = ejabberd_config:get_option(
- {auth_method, LServer}, opt_type(auth_method), [Default]),
+ Methods = ejabberd_config:get_option({auth_method, LServer}, [Default]),
[misc:binary_to_atom(<<"ejabberd_auth_",
(misc:atom_to_binary(M))/binary>>)
|| M <- Methods].
-module(ejabberd_auth_anonymous).
-behaviour(ejabberd_config).
+-behaviour(ejabberd_auth).
-author('mickael.remond@process-one.net').
-export([start/1,
+ stop/1,
allow_anonymous/1,
is_sasl_anonymous_enabled/1,
is_login_anonymous_enabled/1,
?MODULE, unregister_connection, 100),
ok.
+stop(Host) ->
+ ejabberd_hooks:delete(sm_register_connection_hook, Host,
+ ?MODULE, register_connection, 100),
+ ejabberd_hooks:delete(sm_remove_connection_hook, Host,
+ ?MODULE, unregister_connection, 100).
+
%% Return true if anonymous is allowed for host or false otherwise
allow_anonymous(Host) ->
lists:member(?MODULE, ejabberd_auth:auth_modules(Host)).
%% Return the anonymous protocol to use: sasl_anon|login_anon|both
%% defaults to login_anon
anonymous_protocol(Host) ->
- ejabberd_config:get_option(
- {anonymous_protocol, Host},
- fun(sasl_anon) -> sasl_anon;
- (login_anon) -> login_anon;
- (both) -> both
- end,
- sasl_anon).
+ ejabberd_config:get_option({anonymous_protocol, Host}, sasl_anon).
%% Return true if multiple connections have been allowed in the config file
%% defaults to false
allow_multiple_connections(Host) ->
- ejabberd_config:get_option(
- {allow_multiple_connections, Host},
- fun(V) when is_boolean(V) -> V end,
- false).
+ ejabberd_config:get_option({allow_multiple_connections, Host}, false).
anonymous_user_exist(User, Server) ->
lists:any(
%%% API
%%%----------------------------------------------------------------------
start(Host) ->
- Cmd = ejabberd_config:get_option(
- {extauth_program, Host},
- fun(V) ->
- binary_to_list(iolist_to_binary(V))
- end,
- "extauth"),
+ Cmd = ejabberd_config:get_option({extauth_program, Host}, "extauth"),
extauth:start(Host, Cmd),
check_cache_last_options(Host),
ejabberd_auth_mnesia:start(Host).
%% @spec (Host::string()) -> false | {true, CacheTime::integer()}
get_cache_option(Host) ->
- case ejabberd_config:get_option(
- {extauth_cache, Host},
- fun(false) -> undefined;
- (I) when is_integer(I), I >= 0 -> I
- end) of
- undefined -> false;
+ case ejabberd_config:get_option({extauth_cache, Host}, false) of
+ false -> false;
CacheTime -> {true, CacheTime}
end.
end.
is_configured(Host, Module) ->
- Os = ejabberd_config:get_option({modules, Host},
- fun(M) when is_list(M) -> M end),
+ Os = ejabberd_config:get_option({modules, Host}, []),
lists:keymember(Module, 1, Os).
opt_type(extauth_cache) ->
- fun (false) -> undefined;
+ fun (false) -> false;
(I) when is_integer(I), I >= 0 -> I
end;
opt_type(extauth_program) ->
%% Internal functions
%%====================================================================
get_pam_service(Host) ->
- ejabberd_config:get_option(
- {pam_service, Host},
- fun iolist_to_binary/1,
- <<"ejabberd">>).
+ ejabberd_config:get_option({pam_service, Host}, <<"ejabberd">>).
get_pam_userinfotype(Host) ->
- ejabberd_config:get_option(
- {pam_userinfotype, Host},
- fun(username) -> username;
- (jid) -> jid
- end,
- username).
+ ejabberd_config:get_option({pam_userinfotype, Host}, username).
opt_type(pam_service) -> fun iolist_to_binary/1;
opt_type(pam_userinfotype) ->
tls_options(#{lserver := LServer, tls_options := DefaultOpts}) ->
TLSOpts1 = case ejabberd_config:get_option(
{c2s_certfile, LServer},
- fun iolist_to_binary/1,
ejabberd_config:get_option(
- {domain_certfile, LServer},
- fun iolist_to_binary/1)) of
+ {domain_certfile, LServer})) of
undefined -> DefaultOpts;
CertFile -> lists:keystore(certfile, 1, DefaultOpts,
{certfile, CertFile})
end,
TLSOpts2 = case ejabberd_config:get_option(
- {c2s_ciphers, LServer},
- fun iolist_to_binary/1) of
+ {c2s_ciphers, LServer}) of
undefined -> TLSOpts1;
Ciphers -> lists:keystore(ciphers, 1, TLSOpts1,
{ciphers, Ciphers})
end,
TLSOpts3 = case ejabberd_config:get_option(
- {c2s_protocol_options, LServer},
- fun (Options) -> str:join(Options, <<$|>>) end) of
+ {c2s_protocol_options, LServer}) of
undefined -> TLSOpts2;
ProtoOpts -> lists:keystore(protocol_options, 1, TLSOpts2,
{protocol_options, ProtoOpts})
end,
TLSOpts4 = case ejabberd_config:get_option(
- {c2s_dhfile, LServer},
- fun iolist_to_binary/1) of
+ {c2s_dhfile, LServer}) of
undefined -> TLSOpts3;
DHFile -> lists:keystore(dhfile, 1, TLSOpts3,
{dhfile, DHFile})
end,
TLSOpts5 = case ejabberd_config:get_option(
- {c2s_cafile, LServer},
- fun iolist_to_binary/1) of
+ {c2s_cafile, LServer}) of
undefined -> TLSOpts4;
CAFile -> lists:keystore(cafile, 1, TLSOpts4,
{cafile, CAFile})
end,
- case ejabberd_config:get_option(
- {c2s_tls_compression, LServer},
- fun(B) when is_boolean(B) -> B end) of
+ case ejabberd_config:get_option({c2s_tls_compression, LServer}) of
undefined -> TLSOpts5;
false -> [compression_none | TLSOpts5];
true -> lists:delete(compression_none, TLSOpts5)
ejabberd_hooks:run_fold(c2s_post_auth_features, LServer, [], [LServer]).
sasl_mechanisms(Mechs, #{lserver := LServer}) ->
- Mechs1 = ejabberd_config:get_option(
- {disable_sasl_mechanisms, LServer},
- fun(V) when is_list(V) ->
- lists:map(fun(M) -> str:to_upper(M) end, V);
- (V) ->
- [str:to_upper(V)]
- end, []),
+ Mechs1 = ejabberd_config:get_option({disable_sasl_mechanisms, LServer}, []),
Mechs2 = case ejabberd_auth_anonymous:is_sasl_anonymous_enabled(LServer) of
true -> Mechs1;
false -> [<<"ANONYMOUS">>|Mechs1]
OptionRaw = case ejabberd_sm:is_existing_resource(U, S, R) of
true ->
ejabberd_config:get_option(
- {resource_conflict, S},
- fun(setresource) -> setresource;
- (closeold) -> closeold;
- (closenew) -> closenew;
- (acceptnew) -> acceptnew
- end);
+ {resource_conflict, S}, acceptnew);
false ->
acceptnew
end,
Option = case OptionRaw of
setresource -> setresource;
- closeold ->
- acceptnew; %% ejabberd_sm will close old session
+ closeold -> acceptnew; %% ejabberd_sm will close old session
closenew -> closenew;
- acceptnew -> acceptnew;
- _ -> acceptnew %% default ejabberd behavior
+ acceptnew -> acceptnew
end,
case Option of
acceptnew -> {accept_resource, R};
%% Get first c2s configuration limitations to apply it to other c2s
%% connectors.
get_c2s_limits() ->
- C2SFirstListen = ejabberd_config:get_option(
- listen, fun ejabberd_listener:validate_cfg/1, []),
+ C2SFirstListen = ejabberd_config:get_option(listen, []),
case lists:keysearch(ejabberd_c2s, 2, C2SFirstListen) of
false -> [];
{value, {_Port, ejabberd_c2s, Opts}} ->
end.
get_prog_name() ->
- case ejabberd_config:get_option(
- captcha_cmd,
- fun(FileName) ->
- F = iolist_to_binary(FileName),
- if F /= <<"">> -> F end
- end) of
+ case ejabberd_config:get_option(captcha_cmd) of
undefined ->
?DEBUG("The option captcha_cmd is not configured, "
"but some module wants to use the CAPTCHA "
end.
get_url(Str) ->
- CaptchaHost = ejabberd_config:get_option(
- captcha_host,
- fun iolist_to_binary/1,
- <<"">>),
+ CaptchaHost = ejabberd_config:get_option(captcha_host, <<"">>),
case str:tokens(CaptchaHost, <<":">>) of
[Host] ->
<<"http://", Host/binary, "/captcha/", Str/binary>>;
get_captcha_transfer_protocol(PortListeners).
get_port_listeners(PortNumber) ->
- AllListeners = ejabberd_config:get_option(
- listen, fun ejabberd_listener:validate_cfg/1, []),
+ AllListeners = ejabberd_config:get_option(listen, []),
lists:filter(fun (Listener) when is_list(Listener) ->
case proplists:get_value(port, Listener) of
PortNumber -> true;
is_limited(undefined) -> false;
is_limited(Limiter) ->
- case ejabberd_config:get_option(
- captcha_limit,
- fun(I) when is_integer(I), I > 0 -> I end) of
+ case ejabberd_config:get_option(captcha_limit) of
undefined -> false;
Int ->
case catch gen_server:call(?MODULE,
-author('badlop@process-one.net').
-behaviour(gen_server).
+-behaviour(ejabberd_config).
-define(DEFAULT_VERSION, 1000000).
get_exposed_commands() ->
get_exposed_commands(?DEFAULT_VERSION).
get_exposed_commands(Version) ->
- Opts0 = ejabberd_config:get_option(
- commands,
- fun(V) when is_list(V) -> V end,
- []),
+ Opts0 = ejabberd_config:get_option(commands, []),
Opts = lists:map(fun(V) when is_tuple(V) -> [V]; (V) -> V end, Opts0),
CommandsList = list_commands_policy(Version),
OpenCmds = [N || {N, _, _, open} <- CommandsList],
_ ->
{Extra, global}
end,
- AdminAccess = ejabberd_config:get_option(
- commands_admin_access,
- fun(V) -> V end,
- none),
+ AdminAccess = ejabberd_config:get_option(commands_admin_access, none),
case acl:access_matches(AdminAccess, ACLInfo, Server) of
allow ->
case catch check_auth(get_command_definition(Name), Auth) of
permission_addon() ->
[{<<"'commands' option compatibility shim">>,
{[],
- [{access, ejabberd_config:get_option(commands_admin_access,
- fun(V) -> V end,
- none)}],
+ [{access, ejabberd_config:get_option(commands_admin_access, none)}],
{get_exposed_commands(), []}}}].
opt_type(commands_admin_access) -> fun acl:access_rules_validator/1;
-author('alexey@process-one.net').
-export([start/0, load_file/1, reload_file/0, read_file/1,
- get_option/2, get_option/3, add_option/2, has_option/1,
+ get_option/1, get_option/2, add_option/2, has_option/1,
get_vh_by_auth_method/1, is_file_readable/1,
get_version/0, get_myhosts/0, get_mylang/0, get_lang/1,
get_ejabberd_config_path/0, is_using_elixir_config/0,
%% The following functions are deprecated.
-export([add_global_option/2, add_local_option/2,
get_global_option/2, get_local_option/2,
- get_global_option/3, get_local_option/3]).
+ get_global_option/3, get_local_option/3,
+ get_option/3]).
-deprecated([{add_global_option, 2}, {add_local_option, 2},
{get_global_option, 2}, {get_local_option, 2},
- {get_global_option, 3}, {get_local_option, 3}]).
+ {get_global_option, 3}, {get_local_option, 3},
+ {get_option, 3}]).
-include("ejabberd.hrl").
-include("logger.hrl").
set_log_level().
set_log_level() ->
- Level = get_option(
- loglevel,
- fun(P) when P>=0, P=<5 -> P end,
- 4),
+ Level = get_option(loglevel, 4),
ejabberd_logger:set(Level).
add_global_option(Opt, Val) ->
-spec get_global_option(any(), check_fun()) -> any().
-get_global_option(Opt, F) ->
- get_option(Opt, F, undefined).
+get_global_option(Opt, _) ->
+ get_option(Opt, undefined).
-spec get_global_option(any(), check_fun(), any()) -> any().
-get_global_option(Opt, F, Default) ->
- get_option(Opt, F, Default).
+get_global_option(Opt, _, Default) ->
+ get_option(Opt, Default).
-spec get_local_option(any(), check_fun()) -> any().
-get_local_option(Opt, F) ->
- get_option(Opt, F, undefined).
+get_local_option(Opt, _) ->
+ get_option(Opt, undefined).
-spec get_local_option(any(), check_fun(), any()) -> any().
-get_local_option(Opt, F, Default) ->
- get_option(Opt, F, Default).
+get_local_option(Opt, _, Default) ->
+ get_option(Opt, Default).
--spec get_option(any(), check_fun()) -> any().
-
-get_option(Opt, F) ->
- get_option(Opt, F, undefined).
+-spec get_option(any()) -> any().
+get_option(Opt) ->
+ get_option(Opt, undefined).
-spec get_option(any(), check_fun(), any()) -> any().
-
-get_option(Opt, F, Default) when is_atom(Opt) ->
- get_option({Opt, global}, F, Default);
-get_option(Opt, F, Default) ->
+get_option(Opt, _, Default) ->
+ get_option(Opt, Default).
+
+-spec get_option(any(), check_fun() | any()) -> any().
+get_option(Opt, F) when is_function(F) ->
+ get_option(Opt, undefined);
+get_option(Opt, Default) when is_atom(Opt) ->
+ get_option({Opt, global}, Default);
+get_option(Opt, Default) ->
{Key, Host} = case Opt of
{O, global} when is_atom(O) -> Opt;
{O, H} when is_atom(O), is_binary(H) -> Opt;
case ejabberd_options:is_known(Key) of
true ->
case ejabberd_options:Key(Host) of
- {ok, Val} -> prepare_opt_val(Opt, Val, F, Default);
+ {ok, Val} -> Val;
undefined -> Default
end;
false ->
-spec has_option(atom() | {atom(), global | binary()}) -> any().
has_option(Opt) ->
- get_option(Opt, fun(_) -> true end, false).
+ get_option(Opt) /= undefined.
init_module_db_table(Modules) ->
%% Dirty hack for mod_pubsub
-spec default_db(default_db | default_ram_db, binary() | global, module()) -> atom().
default_db(Opt, Host, Module) ->
- case get_option({Opt, Host}, fun(T) when is_atom(T) -> T end) of
+ case get_option({Opt, Host}) of
undefined ->
mnesia;
DBType ->
{ok, [Mod|_]} ->
VFun = Mod:opt_type(Opt),
try VFun(Val) of
- _ ->
- true
- catch {replace_with, NewVal} ->
- {true, In#local_config{value = NewVal}};
- {invalid_syntax, Error} ->
+ NewVal ->
+ {true, In#local_config{value = NewVal}}
+ catch {invalid_syntax, Error} ->
?ERROR_MSG("ignoring option '~s' with "
"invalid value: ~p: ~s",
[Opt, Val, Error]),
get_vh_by_auth_method(AuthMethod, Hosts, []).
get_vh_by_auth_method(Method, [Host|Hosts], Result) ->
- Methods = get_option({auth_method, Host}, fun(Ms) -> Ms end, []),
+ Methods = get_option({auth_method, Host}, []),
case lists:member(Method, Methods) of
true when Host == global ->
get_myhosts();
-spec get_myhosts() -> [binary()].
get_myhosts() ->
- get_option(hosts, fun(V) -> V end).
+ get_option(hosts).
-spec get_mylang() -> binary().
-spec get_lang(global | binary()) -> binary().
get_lang(Host) ->
- get_option(
- {language, Host},
- fun iolist_to_binary/1,
- <<"en">>).
+ get_option({language, Host}, <<"en">>).
replace_module(mod_announce_odbc) -> {mod_announce, sql};
replace_module(mod_blocking_odbc) -> {mod_blocking, sql};
opt_type(hide_sensitive_log_data) ->
fun (H) when is_boolean(H) -> H end;
opt_type(hosts) ->
- fun(L) when is_list(L) ->
- lists:map(
- fun(H) ->
- iolist_to_binary(H)
- end, L)
+ fun(L) ->
+ [iolist_to_binary(H) || H <- L]
end;
opt_type(language) ->
fun iolist_to_binary/1;
opt_type(shared_key) ->
fun iolist_to_binary/1;
opt_type(node_start) ->
- fun(I) when is_integer(I), I>0 -> I end;
+ fun(I) when is_integer(I), I>=0 -> I end;
opt_type(_) ->
[hide_sensitive_log_data, hosts, language, max_fsm_queue,
default_db, default_ram_db, queue_type, queue_dir, loglevel,
-spec may_hide_data(any()) -> any().
may_hide_data(Data) ->
- case get_option(
- hide_sensitive_log_data,
- fun(false) -> false;
- (true) -> true
- end,
- false) of
+ case get_option(hide_sensitive_log_data, false) of
false ->
Data;
true ->
{_, I} when is_integer(I), I>0 ->
[{max_queue, I}];
false ->
- case get_option(
- max_fsm_queue,
- fun(I) when is_integer(I), I>0 -> I end) of
+ case get_option(max_fsm_queue) of
undefined -> [];
N -> [{max_queue, N}]
end
-spec queue_dir() -> binary() | undefined.
queue_dir() ->
- get_option(queue_dir, opt_type(queue_dir)).
+ get_option(queue_dir).
-spec default_queue_type(binary()) -> ram | file.
default_queue_type(Host) ->
- get_option({queue_type, Host}, opt_type(queue_type), ram).
+ get_option({queue_type, Host}, ram).
-spec use_cache(binary() | global) -> boolean().
use_cache(Host) ->
- get_option({use_cache, Host}, opt_type(use_cache), true).
+ get_option({use_cache, Host}, true).
-spec cache_size(binary() | global) -> pos_integer() | infinity.
cache_size(Host) ->
- get_option({cache_size, Host}, opt_type(cache_size), 1000).
+ get_option({cache_size, Host}, 1000).
-spec cache_missed(binary() | global) -> boolean().
cache_missed(Host) ->
- get_option({cache_missed, Host}, opt_type(cache_missed), true).
+ get_option({cache_missed, Host}, true).
-spec cache_life_time(binary() | global) -> pos_integer() | infinity.
%% NOTE: the integer value returned is in *seconds*
cache_life_time(Host) ->
- get_option({cache_life_time, Host}, opt_type(cache_life_time), 3600).
+ get_option({cache_life_time, Host}, 3600).
end.
get_accesscommands() ->
- ejabberd_config:get_option(ejabberdctl_access_commands,
- fun(V) when is_list(V) -> V end, []).
+ ejabberd_config:get_option(ejabberdctl_access_commands, []).
%%-----------------------------
%% Command calling
analyze_ip_xff({IPLast, Port}, XFF, Host) ->
[ClientIP | ProxiesIPs] = str:tokens(XFF, <<", ">>) ++
[misc:ip_to_list(IPLast)],
- TrustedProxies = ejabberd_config:get_option(
- {trusted_proxies, Host},
- fun(all) -> all;
- (TPs) ->
- [iolist_to_binary(TP) || TP <- TPs]
- end, []),
+ TrustedProxies = ejabberd_config:get_option({trusted_proxies, Host}, []),
IPClient = case is_ipchain_trusted(ProxiesIPs,
TrustedProxies)
of
Opts = ejabberd_c2s_config:get_c2s_limits() ++ SOpts,
PingInterval = ejabberd_config:get_option(
{websocket_ping_interval, ?MYNAME},
- fun(I) when is_integer(I), I>=0 -> I end,
?PING_INTERVAL) * 1000,
WSTimeout = ejabberd_config:get_option(
{websocket_timeout, ?MYNAME},
- fun(I) when is_integer(I), I>0 -> I end,
?WEBSOCKET_TIMEOUT) * 1000,
Socket = {http_ws, self(), IP},
?DEBUG("Client connected through websocket ~p",
{ok, {{one_for_one, 10, 1}, listeners_childspec()}}.
listeners_childspec() ->
- case ejabberd_config:get_option(listen, fun validate_cfg/1) of
- undefined ->
- [];
- Ls ->
- Specs = lists:map(
- fun({Port, Module, Opts}) ->
- maybe_start_sip(Module),
- ets:insert(?MODULE, {Port, Module, Opts}),
- {Port,
- {?MODULE, start, [Port, Module, Opts]},
- transient,
- brutal_kill,
- worker,
- [?MODULE]}
- end, Ls),
- report_duplicated_portips(Ls),
- Specs
- end.
+ Ls = ejabberd_config:get_option(listen, []),
+ Specs = lists:map(
+ fun({Port, Module, Opts}) ->
+ maybe_start_sip(Module),
+ ets:insert(?MODULE, {Port, Module, Opts}),
+ {Port,
+ {?MODULE, start, [Port, Module, Opts]},
+ transient,
+ brutal_kill,
+ worker,
+ [?MODULE]}
+ end, Ls),
+ report_duplicated_portips(Ls),
+ Specs.
start_listeners() ->
lists:foreach(
supervisor:start_child(?MODULE, ChildSpec).
stop_listeners() ->
- Ports = ejabberd_config:get_option(listen, fun validate_cfg/1),
+ Ports = ejabberd_config:get_option(listen, []),
lists:foreach(
fun({PortIpNetp, Module, _Opts}) ->
delete_listener(PortIpNetp, Module)
ok.
config_reloaded() ->
- New = case ejabberd_config:get_option(listen, fun validate_cfg/1) of
- undefined -> [];
- Ls -> Ls
- end,
+ New = ejabberd_config:get_option(listen, []),
Old = ets:tab2list(?MODULE),
lists:foreach(
fun({PortIP, Module, _Opts}) ->
-module(ejabberd_oauth).
-behaviour(gen_server).
+-behaviour(ejabberd_config).
-compile(export_all).
Access =
ejabberd_config:get_option(
{oauth_access, JID#jid.lserver},
- fun(A) -> A end,
none),
case acl:match_rule(JID#jid.lserver, Access, JID) of
allow ->
true -> DBMod:use_cache();
false ->
ejabberd_config:get_option(
- oauth_use_cache, opt_type(oauth_use_cache),
+ oauth_use_cache,
ejabberd_config:use_cache(global))
end.
cache_opts() ->
MaxSize = ejabberd_config:get_option(
oauth_cache_size,
- opt_type(oauth_cache_size),
ejabberd_config:cache_size(global)),
CacheMissed = ejabberd_config:get_option(
oauth_cache_missed,
- opt_type(oauth_cache_missed),
ejabberd_config:cache_missed(global)),
LifeTime = case ejabberd_config:get_option(
oauth_cache_life_time,
- opt_type(oauth_cache_life_time),
ejabberd_config:cache_life_time(global)) of
infinity -> infinity;
I -> timer:seconds(I)
[{max_size, MaxSize}, {life_time, LifeTime}, {cache_missed, CacheMissed}].
expire() ->
- ejabberd_config:get_option(
- oauth_expire,
- fun(I) when is_integer(I) -> I end,
- ?EXPIRE).
+ ejabberd_config:get_option(oauth_expire, ?EXPIRE).
-define(DIV(Class, Els),
?XAE(<<"div">>, [{<<"class">>, Class}], Els)).
get_db_backend() ->
DBType = ejabberd_config:get_option(
- oauth_db_type,
- fun(T) -> ejabberd_config:v_db(?MODULE, T) end,
- mnesia),
+ oauth_db_type,
+ ejabberd_config:default_db(?MODULE)),
list_to_atom("ejabberd_oauth_" ++ atom_to_list(DBType)).
-module(ejabberd_oauth_rest).
+-behaviour(ejabberd_config).
+
-export([init/0,
store/1,
lookup/1,
ok.
path(Path) ->
- Base = ejabberd_config:get_option(ext_api_path_oauth,
- fun(X) -> iolist_to_binary(X) end,
- <<"/oauth">>),
+ Base = ejabberd_config:get_option(ext_api_path_oauth, <<"/oauth">>),
<<Base/binary, "/", Path/binary>>.
%% Returns {true, App} if we have configured sql for the given host
needs_sql(Host) ->
LHost = jid:nameprep(Host),
- case ejabberd_config:get_option({sql_type, LHost},
- fun(mysql) -> mysql;
- (pgsql) -> pgsql;
- (sqlite) -> sqlite;
- (mssql) -> mssql;
- (odbc) -> odbc
- end, undefined) of
+ case ejabberd_config:get_option({sql_type, LHost}, undefined) of
mysql -> {true, p1_mysql};
pgsql -> {true, p1_pgsql};
sqlite -> {true, sqlite3};
end.
hibernate_timeout() ->
- ejabberd_config:get_option(receiver_hibernate,
- opt_type(receiver_hibernate),
- timer:seconds(90)).
+ ejabberd_config:get_option(receiver_hibernate, timer:seconds(90)).
opt_type(receiver_hibernate) ->
fun(I) when is_integer(I), I>0 -> I;
%%%===================================================================
-spec connect(state()) -> {ok, pid()} | {error, any()}.
connect(#state{num = Num}) ->
- Server = ejabberd_config:get_option(redis_server,
- fun iolist_to_list/1,
- "localhost"),
- Port = ejabberd_config:get_option(redis_port,
- fun(P) when is_integer(P),
- P>0, P<65536 ->
- P
- end, 6379),
- DB = ejabberd_config:get_option(redis_db,
- fun(I) when is_integer(I), I >= 0 ->
- I
- end, 0),
- Pass = ejabberd_config:get_option(redis_password,
- fun iolist_to_list/1,
- ""),
+ Server = ejabberd_config:get_option(redis_server, "localhost"),
+ Port = ejabberd_config:get_option(redis_port, 6379),
+ DB = ejabberd_config:get_option(redis_db, 0),
+ Pass = ejabberd_config:get_option(redis_password, ""),
ConnTimeout = timer:seconds(
ejabberd_config:get_option(
- redis_connect_timeout,
- fun(I) when is_integer(I), I>0 -> I end,
- 1)),
+ redis_connect_timeout, 1)),
try case do_connect(Num, Server, Port, Pass, DB, ConnTimeout) of
{ok, Client} ->
?DEBUG("Connection #~p established to Redis at ~s:~p",
_ -> queued
end.
--spec iolist_to_list(iodata()) -> string().
-iolist_to_list(IOList) ->
- binary_to_list(iolist_to_binary(IOList)).
-
-spec max_fsm_queue() -> pos_integer().
max_fsm_queue() ->
proplists:get_value(max_queue, fsm_limit_opts(), ?DEFAULT_MAX_QUEUE).
ejabberd_config:fsm_limit_opts([]).
get_queue_type() ->
- case ejabberd_config:get_option(
- redis_queue_type,
- ejabberd_redis_sup:opt_type(redis_queue_type)) of
- undefined ->
- ejabberd_config:default_queue_type(global);
- Type ->
- Type
- end.
+ ejabberd_config:get_option(
+ redis_queue_type,
+ ejabberd_config:default_queue_type(global)).
-spec flush_queue(p1_queue:queue()) -> p1_queue:queue().
flush_queue(Q) ->
PoolSize = ejabberd_config:has_option({redis_pool_size, Host}),
ConnTimeoutConfigured = ejabberd_config:has_option(
{redis_connect_timeout, Host}),
- Modules = ejabberd_config:get_option(
- {modules, Host},
- fun(L) when is_list(L) -> L end, []),
- SMConfigured = ejabberd_config:get_option(
- {sm_db_type, Host},
- fun(V) -> V end) == redis,
- RouterConfigured = ejabberd_config:get_option(
- {router_db_type, Host},
- fun(V) -> V end) == redis,
+ Modules = ejabberd_config:get_option({modules, Host}, []),
+ SMConfigured = ejabberd_config:get_option({sm_db_type, Host}) == redis,
+ RouterConfigured = ejabberd_config:get_option({router_db_type, Host}) == redis,
ModuleWithRedisDBConfigured =
lists:any(
fun({Module, Opts}) ->
end, lists:seq(1, get_pool_size())).
get_pool_size() ->
- ejabberd_config:get_option(
- redis_pool_size,
- fun(N) when is_integer(N), N >= 1 -> N end,
- ?DEFAULT_POOL_SIZE) + 1.
+ ejabberd_config:get_option(redis_pool_size, ?DEFAULT_POOL_SIZE) + 1.
iolist_to_list(IOList) ->
binary_to_list(iolist_to_binary(IOList)).
AuthConfigured = lists:member(
ejabberd_auth_riak,
ejabberd_auth:auth_modules(Host)),
- SMConfigured = ejabberd_config:get_option(
- {sm_db_type, Host},
- ejabberd_sm:opt_type(sm_db_type)) == riak,
- RouterConfigured = ejabberd_config:get_option(
- {router_db_type, Host},
- ejabberd_router:opt_type(router_db_type)) == riak,
- Modules = ejabberd_config:get_option(
- {modules, Host},
- fun(L) when is_list(L) -> L end, []),
+ SMConfigured = ejabberd_config:get_option({sm_db_type, Host}) == riak,
+ RouterConfigured = ejabberd_config:get_option({router_db_type, Host}) == riak,
+ Modules = ejabberd_config:get_option({modules, Host}, []),
ModuleWithRiakDBConfigured = lists:any(
fun({Module, Opts}) ->
gen_mod:db_type(Host, Opts, Module) == riak
end, lists:seq(1, PoolSize)).
get_start_interval() ->
- ejabberd_config:get_option(
- riak_start_interval,
- fun(N) when is_integer(N), N >= 1 -> N end,
- ?DEFAULT_RIAK_START_INTERVAL).
+ ejabberd_config:get_option(riak_start_interval, ?DEFAULT_RIAK_START_INTERVAL).
get_pool_size() ->
- ejabberd_config:get_option(
- riak_pool_size,
- fun(N) when is_integer(N), N >= 1 -> N end,
- ?DEFAULT_POOL_SIZE).
+ ejabberd_config:get_option(riak_pool_size, ?DEFAULT_POOL_SIZE).
get_riak_server() ->
- ejabberd_config:get_option(
- riak_server,
- fun(S) ->
- binary_to_list(iolist_to_binary(S))
- end, ?DEFAULT_RIAK_HOST).
+ ejabberd_config:get_option(riak_server, ?DEFAULT_RIAK_HOST).
get_riak_cacertfile() ->
- ejabberd_config:get_option(
- riak_cacertfile,
- fun(S) ->
- binary_to_list(iolist_to_binary(S))
- end, nil).
+ ejabberd_config:get_option(riak_cacertfile, nil).
get_riak_username() ->
- ejabberd_config:get_option(
- riak_username,
- fun(S) ->
- binary_to_list(iolist_to_binary(S))
- end, nil).
+ ejabberd_config:get_option(riak_username, nil).
get_riak_password() ->
- ejabberd_config:get_option(
- riak_password,
- fun(S) ->
- binary_to_list(iolist_to_binary(S))
- end, nil).
+ ejabberd_config:get_option(riak_password, nil).
get_riak_port() ->
- ejabberd_config:get_option(
- riak_port,
- fun(P) when is_integer(P), P > 0, P < 65536 -> P end,
- ?DEFAULT_RIAK_PORT).
+ ejabberd_config:get_option(riak_port, ?DEFAULT_RIAK_PORT).
get_pids() ->
[ejabberd_riak:get_proc(I) || I <- lists:seq(1, get_pool_size())].
opt_type(riak_pool_size) ->
fun (N) when is_integer(N), N >= 1 -> N end;
-opt_type(riak_port) -> fun (_) -> true end;
-opt_type(riak_server) -> fun (_) -> true end;
+opt_type(riak_port) ->
+ fun(P) when is_integer(P), P > 0, P < 65536 -> P end;
+opt_type(riak_server) ->
+ fun(S) -> binary_to_list(iolist_to_binary(S)) end;
opt_type(riak_start_interval) ->
fun (N) when is_integer(N), N >= 1 -> N end;
-opt_type(riak_cacertfile) -> fun iolist_to_binary/1;
-opt_type(riak_username) -> fun iolist_to_binary/1;
-opt_type(riak_password) -> fun iolist_to_binary/1;
+opt_type(riak_cacertfile) ->
+ fun(S) -> binary_to_list(iolist_to_binary(S)) end;
+opt_type(riak_username) ->
+ fun(S) -> binary_to_list(iolist_to_binary(S)) end;
+opt_type(riak_password) ->
+ fun(S) -> binary_to_list(iolist_to_binary(S)) end;
opt_type(_) ->
[riak_pool_size, riak_port, riak_server,
riak_start_interval, riak_cacertfile, riak_username, riak_password].
-spec get_component_number(binary()) -> pos_integer() | undefined.
get_component_number(LDomain) ->
- ejabberd_config:get_option(
- {domain_balancing_component_number, LDomain},
- fun(N) when is_integer(N), N > 1 -> N end,
- undefined).
+ ejabberd_config:get_option({domain_balancing_component_number, LDomain}).
-spec get_domain_balancing(jid(), jid(), binary()) -> any().
get_domain_balancing(From, To, LDomain) ->
- case ejabberd_config:get_option(
- {domain_balancing, LDomain}, fun(D) when is_atom(D) -> D end) of
+ case ejabberd_config:get_option({domain_balancing, LDomain}) of
undefined -> p1_time_compat:system_time();
random -> p1_time_compat:system_time();
source -> jid:tolower(From);
-spec get_backend() -> module().
get_backend() ->
- DBType = case ejabberd_config:get_option(
- router_db_type,
- fun(T) -> ejabberd_config:v_db(?MODULE, T) end) of
- undefined ->
- ejabberd_config:default_ram_db(?MODULE);
- T ->
- T
- end,
+ DBType = ejabberd_config:get_option(
+ router_db_type,
+ ejabberd_config:default_ram_db(?MODULE)),
list_to_atom("ejabberd_router_" ++ atom_to_list(DBType)).
-spec cache_nodes(module()) -> [node()].
true -> Mod:use_cache();
false ->
ejabberd_config:get_option(
- router_use_cache, opt_type(router_use_cache),
+ router_use_cache,
ejabberd_config:use_cache(global))
end.
cache_opts() ->
MaxSize = ejabberd_config:get_option(
router_cache_size,
- opt_type(router_cache_size),
ejabberd_config:cache_size(global)),
CacheMissed = ejabberd_config:get_option(
router_cache_missed,
- opt_type(router_cache_missed),
ejabberd_config:cache_missed(global)),
LifeTime = case ejabberd_config:get_option(
router_cache_life_time,
- opt_type(router_cache_life_time),
ejabberd_config:cache_life_time(global)) of
infinity -> infinity;
I -> timer:seconds(I)
tls_options(LServer, DefaultOpts) ->
TLSOpts1 = case ejabberd_config:get_option(
{s2s_certfile, LServer},
- fun iolist_to_binary/1,
ejabberd_config:get_option(
- {domain_certfile, LServer},
- fun iolist_to_binary/1)) of
+ {domain_certfile, LServer})) of
undefined -> DefaultOpts;
CertFile -> lists:keystore(certfile, 1, DefaultOpts,
{certfile, CertFile})
end,
TLSOpts2 = case ejabberd_config:get_option(
- {s2s_ciphers, LServer},
- fun iolist_to_binary/1) of
+ {s2s_ciphers, LServer}) of
undefined -> TLSOpts1;
Ciphers -> lists:keystore(ciphers, 1, TLSOpts1,
{ciphers, Ciphers})
end,
TLSOpts3 = case ejabberd_config:get_option(
- {s2s_protocol_options, LServer},
- fun (Options) -> str:join(Options, <<$|>>) end) of
+ {s2s_protocol_options, LServer}) of
undefined -> TLSOpts2;
ProtoOpts -> lists:keystore(protocol_options, 1, TLSOpts2,
{protocol_options, ProtoOpts})
end,
TLSOpts4 = case ejabberd_config:get_option(
- {s2s_dhfile, LServer},
- fun iolist_to_binary/1) of
+ {s2s_dhfile, LServer}) of
undefined -> TLSOpts3;
DHFile -> lists:keystore(dhfile, 1, TLSOpts3,
{dhfile, DHFile})
end,
TLSOpts5 = case ejabberd_config:get_option(
- {s2s_cafile, LServer},
- fun iolist_to_binary/1) of
+ {s2s_cafile, LServer}) of
undefined -> TLSOpts4;
CAFile -> lists:keystore(cafile, 1, TLSOpts4,
{cafile, CAFile})
end,
- case ejabberd_config:get_option(
- {s2s_tls_compression, LServer},
- fun(B) when is_boolean(B) -> B end) of
+ case ejabberd_config:get_option({s2s_tls_compression, LServer}) of
undefined -> TLSOpts5;
false -> [compression_none | TLSOpts5];
true -> lists:delete(compression_none, TLSOpts5)
-spec zlib_enabled(binary()) -> boolean().
zlib_enabled(LServer) ->
- ejabberd_config:get_option(
- {s2s_zlib, LServer},
- fun(B) when is_boolean(B) -> B end,
- false).
+ ejabberd_config:get_option({s2s_zlib, LServer}, false).
-spec use_starttls(binary()) -> boolean() | optional | required | required_trusted.
use_starttls(LServer) ->
- ejabberd_config:get_option(
- {s2s_use_starttls, LServer},
- fun(true) -> true;
- (false) -> false;
- (optional) -> optional;
- (required) -> required;
- (required_trusted) -> required_trusted
- end, false).
+ ejabberd_config:get_option({s2s_use_starttls, LServer}, false).
-spec get_idle_timeout(binary()) -> non_neg_integer() | infinity.
get_idle_timeout(LServer) ->
- ejabberd_config:get_option(
- {s2s_timeout, LServer},
- fun(I) when is_integer(I), I >= 0 -> timer:seconds(I);
- (infinity) -> infinity
- end, timer:minutes(10)).
+ ejabberd_config:get_option({s2s_timeout, LServer}, timer:minutes(10)).
-spec queue_type(binary()) -> ram | file.
queue_type(LServer) ->
- case ejabberd_config:get_option(
- {s2s_queue_type, LServer}, opt_type(s2s_queue_type)) of
- undefined -> ejabberd_config:default_queue_type(LServer);
- Type -> Type
- end.
+ ejabberd_config:get_option(
+ {s2s_queue_type, LServer},
+ ejabberd_config:default_queue_type(LServer)).
%%====================================================================
%% gen_server callbacks
-spec is_service(jid(), jid()) -> boolean().
is_service(From, To) ->
LFromDomain = From#jid.lserver,
- case ejabberd_config:get_option(
- {route_subdomains, LFromDomain},
- fun(s2s) -> s2s; (local) -> local end, local) of
+ case ejabberd_config:get_option({route_subdomains, LFromDomain}, local) of
s2s -> % bypass RFC 3920 10.3
false;
local ->
not is_temporarly_blocked(S2SHost).
allow_host1(MyHost, S2SHost) ->
- Rule = ejabberd_config:get_option(
- {s2s_access, MyHost},
- fun acl:access_rules_validator/1,
- all),
+ Rule = ejabberd_config:get_option({s2s_access, MyHost}, all),
JID = jid:make(S2SHost),
case acl:match_rule(MyHost, Rule, JID) of
deny -> false;
opt_type(s2s_zlib) ->
fun(B) when is_boolean(B) -> B end;
opt_type(s2s_timeout) ->
- fun(I) when is_integer(I), I>=0 -> I;
- (infinity) -> infinity
+ fun(I) when is_integer(I), I >= 0 -> timer:seconds(I);
+ (infinity) -> infinity;
+ (unlimited) -> infinity
end;
opt_type(s2s_queue_type) ->
fun(ram) -> ram; (file) -> file end;
connect_timeout(#{server := LServer}) ->
ejabberd_config:get_option(
{outgoing_s2s_timeout, LServer},
- fun(TimeOut) when is_integer(TimeOut), TimeOut > 0 ->
- timer:seconds(TimeOut);
- (infinity) ->
- infinity
- end, timer:seconds(10)).
+ timer:seconds(10)).
default_port(#{server := LServer}) ->
- ejabberd_config:get_option(
- {outgoing_s2s_port, LServer},
- fun(I) when is_integer(I), I > 0, I =< 65536 -> I end,
- 5269).
+ ejabberd_config:get_option({outgoing_s2s_port, LServer}, 5269).
address_families(#{server := LServer}) ->
ejabberd_config:get_option(
{outgoing_s2s_families, LServer},
- fun(Families) ->
- lists:map(
- fun(ipv4) -> inet;
- (ipv6) -> inet6
- end, Families)
- end, [inet, inet6]).
+ [inet, inet6]).
dns_retries(#{server := LServer}) ->
- ejabberd_config:get_option(
- {s2s_dns_retries, LServer},
- fun(I) when is_integer(I), I>=0 -> I end,
- 2).
+ ejabberd_config:get_option({s2s_dns_retries, LServer}, 2).
dns_timeout(#{server := LServer}) ->
- ejabberd_config:get_option(
- {s2s_dns_timeout, LServer},
- fun(I) when is_integer(I), I>=0 ->
- timer:seconds(I);
- (infinity) ->
- infinity
- end, timer:seconds(10)).
+ ejabberd_config:get_option({s2s_dns_timeout, LServer}, timer:seconds(10)).
handle_auth_success(Mech, #{sockmod := SockMod,
socket := Socket, ip := IP,
-spec get_delay() -> non_neg_integer().
get_delay() ->
- MaxDelay = ejabberd_config:get_option(
- s2s_max_retry_delay,
- fun(I) when is_integer(I), I > 0 -> I end,
- 300),
+ MaxDelay = ejabberd_config:get_option(s2s_max_retry_delay, 300),
crypto:rand_uniform(1, MaxDelay).
-spec set_idle_timeout(state()) -> state().
ok.
opt_type(outgoing_s2s_families) ->
- fun (Families) ->
- true = lists:all(fun (ipv4) -> true;
- (ipv6) -> true
- end,
- Families),
- Families
+ fun(Families) ->
+ lists:map(
+ fun(ipv4) -> inet;
+ (ipv6) -> inet6
+ end, Families)
end;
opt_type(outgoing_s2s_port) ->
fun (I) when is_integer(I), I > 0, I =< 65536 -> I end;
opt_type(outgoing_s2s_timeout) ->
- fun (TimeOut) when is_integer(TimeOut), TimeOut > 0 ->
- TimeOut;
- (infinity) -> infinity
+ fun(TimeOut) when is_integer(TimeOut), TimeOut > 0 ->
+ timer:seconds(TimeOut);
+ (unlimited) ->
+ infinity;
+ (infinity) ->
+ infinity
end;
opt_type(s2s_dns_retries) ->
fun (I) when is_integer(I), I >= 0 -> I end;
opt_type(s2s_dns_timeout) ->
- fun (TimeOut) when is_integer(TimeOut), TimeOut > 0 ->
- TimeOut;
- (infinity) -> infinity
+ fun(I) when is_integer(I), I>=0 -> timer:seconds(I);
+ (infinity) -> infinity;
+ (unlimited) -> infinity
end;
opt_type(s2s_max_retry_delay) ->
fun (I) when is_integer(I), I > 0 -> I end;
-spec get_sm_backend(binary()) -> module().
get_sm_backend(Host) ->
- DBType = case ejabberd_config:get_option(
+ DBType = ejabberd_config:get_option(
{sm_db_type, Host},
- fun(T) -> ejabberd_config:v_db(?MODULE, T) end) of
- undefined ->
- ejabberd_config:default_ram_db(Host, ?MODULE);
- T ->
- T
- end,
+ ejabberd_config:default_ram_db(Host, ?MODULE)),
list_to_atom("ejabberd_sm_" ++ atom_to_list(DBType)).
-spec get_sm_backends() -> [module()].
cache_opts() ->
MaxSize = ejabberd_config:get_option(
sm_cache_size,
- opt_type(sm_cache_size),
ejabberd_config:cache_size(global)),
CacheMissed = ejabberd_config:get_option(
sm_cache_missed,
- opt_type(sm_cache_missed),
ejabberd_config:cache_missed(global)),
LifeTime = case ejabberd_config:get_option(
sm_cache_life_time,
- opt_type(sm_cache_life_time),
ejabberd_config:cache_life_time(global)) of
infinity -> infinity;
I -> timer:seconds(I)
false ->
ejabberd_config:get_option(
{sm_use_cache, LServer},
- ejabberd_sm:opt_type(sm_use_cache),
ejabberd_config:use_cache(LServer))
end.
-spec sqlite_file(binary()) -> string().
sqlite_file(Host) ->
- case ejabberd_config:get_option({sql_database, Host},
- fun iolist_to_binary/1) of
+ case ejabberd_config:get_option({sql_database, Host}) of
undefined ->
{ok, Cwd} = file:get_cwd(),
filename:join([Cwd, "sqlite", atom_to_list(node()),
%%% Callback functions from gen_fsm
%%%----------------------------------------------------------------------
init([Host, StartInterval]) ->
- case ejabberd_config:get_option(
- {sql_keepalive_interval, Host},
- fun(I) when is_integer(I), I>0 -> I end) of
+ case ejabberd_config:get_option({sql_keepalive_interval, Host}) of
undefined ->
ok;
KeepaliveInterval ->
[DBType | _] = db_opts(Host),
(?GEN_FSM):send_event(self(), connect),
ejabberd_sql_sup:add_pid(Host, self()),
- QueueType = case ejabberd_config:get_option(
- {sql_queue_type, Host}, opt_type(sql_queue_type)) of
+ QueueType = case ejabberd_config:get_option({sql_queue_type, Host}) of
undefined ->
ejabberd_config:default_queue_type(Host);
Type ->
end.
db_opts(Host) ->
- Type = ejabberd_config:get_option({sql_type, Host},
- fun(mysql) -> mysql;
- (pgsql) -> pgsql;
- (sqlite) -> sqlite;
- (mssql) -> mssql;
- (odbc) -> odbc
- end, odbc),
- Server = ejabberd_config:get_option({sql_server, Host},
- fun iolist_to_binary/1,
- <<"localhost">>),
- Transport = case ejabberd_config:get_option(
- {sql_ssl, Host},
- fun(B) when is_boolean(B) -> B end,
- false) of
+ Type = ejabberd_config:get_option({sql_type, Host}, odbc),
+ Server = ejabberd_config:get_option({sql_server, Host}, <<"localhost">>),
+ Transport = case ejabberd_config:get_option({sql_ssl, Host}, false) of
false -> tcp;
true -> ssl
end,
_ ->
Port = ejabberd_config:get_option(
{sql_port, Host},
- fun(P) when is_integer(P), P > 0, P < 65536 -> P end,
case Type of
mssql -> ?MSSQL_PORT;
mysql -> ?MYSQL_PORT;
pgsql -> ?PGSQL_PORT
end),
DB = ejabberd_config:get_option({sql_database, Host},
- fun iolist_to_binary/1,
<<"ejabberd">>),
User = ejabberd_config:get_option({sql_username, Host},
- fun iolist_to_binary/1,
<<"ejabberd">>),
Pass = ejabberd_config:get_option({sql_password, Host},
- fun iolist_to_binary/1,
<<"">>),
SSLOpts = get_ssl_opts(Transport, Host),
case Type of
?WARNING_MSG("SSL connection is not supported for ~s", [Type]).
get_ssl_opts(ssl, Host) ->
- Opts1 = case ejabberd_config:get_option({sql_ssl_certfile, Host},
- fun iolist_to_binary/1) of
+ Opts1 = case ejabberd_config:get_option({sql_ssl_certfile, Host}) of
undefined -> [];
CertFile -> [{certfile, CertFile}]
end,
- Opts2 = case ejabberd_config:get_option({sql_ssl_cafile, Host},
- fun iolist_to_binary/1) of
+ Opts2 = case ejabberd_config:get_option({sql_ssl_cafile, Host}) of
undefined -> Opts1;
CAFile -> [{cacertfile, CAFile}|Opts1]
end,
- case ejabberd_config:get_option({sql_ssl_verify, Host},
- fun(B) when is_boolean(B) -> B end,
- false) of
+ case ejabberd_config:get_option({sql_ssl_verify, Host}, false) of
true ->
case lists:keymember(cacertfile, 1, Opts2) of
true ->
[].
init_mssql(Host) ->
- Server = ejabberd_config:get_option({sql_server, Host},
- fun iolist_to_binary/1,
- <<"localhost">>),
- Port = ejabberd_config:get_option(
- {sql_port, Host},
- fun(P) when is_integer(P), P > 0, P < 65536 -> P end,
- ?MSSQL_PORT),
- DB = ejabberd_config:get_option({sql_database, Host},
- fun iolist_to_binary/1,
- <<"ejabberd">>),
+ Server = ejabberd_config:get_option({sql_server, Host}, <<"localhost">>),
+ Port = ejabberd_config:get_option({sql_port, Host}, ?MSSQL_PORT),
+ DB = ejabberd_config:get_option({sql_database, Host}, <<"ejabberd">>),
FreeTDS = io_lib:fwrite("[~s]~n"
"\thost = ~s~n"
"\tport = ~p~n"
init([Host]) ->
StartInterval = ejabberd_config:get_option(
{sql_start_interval, Host},
- fun(I) when is_integer(I), I>0 -> I end,
?DEFAULT_SQL_START_INTERVAL),
- Type = ejabberd_config:get_option({sql_type, Host},
- fun(mysql) -> mysql;
- (pgsql) -> pgsql;
- (sqlite) -> sqlite;
- (mssql) -> mssql;
- (odbc) -> odbc
- end, odbc),
+ Type = ejabberd_config:get_option({sql_type, Host}, odbc),
PoolSize = get_pool_size(Type, Host),
case Type of
sqlite ->
get_pool_size(SQLType, Host) ->
PoolSize = ejabberd_config:get_option(
{sql_pool_size, Host},
- fun(I) when is_integer(I), I>0 -> I end,
case SQLType of
sqlite -> 1;
_ -> ?DEFAULT_POOL_SIZE
%% Description: Starts the server
%%--------------------------------------------------------------------
start_link() ->
- LH = ejabberd_config:get_option(
- watchdog_large_heap,
- fun(I) when is_integer(I), I > 0 -> I end,
- 1000000),
+ LH = ejabberd_config:get_option(watchdog_large_heap, 1000000),
Opts = [{large_heap, LH}],
gen_server:start_link({local, ?MODULE}, ?MODULE, Opts,
[]).
sub_els = ExtraEls}).
get_admin_jids() ->
- ejabberd_config:get_option(
- watchdog_admins,
- fun(JIDs) ->
- [jid:tolower(
- jid:decode(
- iolist_to_binary(S))) || S <- JIDs]
- end, []).
+ ejabberd_config:get_option(watchdog_admins, []).
detailed_info(Pid) ->
case process_info(Pid, dictionary) of
end;
_ -> nothing
end,
- Rules = case ejabberd_config:get_option(
- {access, Name, Host}, fun(V) -> V end)
- of
- undefined -> [];
- Rs1 -> Rs1
- end,
+ Rules = ejabberd_config:get_option({access, Name, Host}, []),
make_xhtml([?XC(<<"h1">>,
(str:format(
?T(<<"~s access rule configuration">>),
{Module, proplists:get_value(summary, Attrs, "")}.
is_contrib_allowed() ->
- ejabberd_config:get_option(allow_contrib_modules,
- fun(false) -> false;
- (no) -> false;
- (_) -> true
- end, true).
+ ejabberd_config:get_option(allow_contrib_modules, true).
%% -- build functions
randoms:uniform(MaxNum) - 1.
get_instances(Server) ->
- ejabberd_config:get_option(
- {extauth_instances, Server},
- fun(V) when is_integer(V), V > 0 ->
- V
- end, 1).
+ ejabberd_config:get_option({extauth_instances, Server}, 1).
loop(Port, Timeout, ProcessName, ExtPrg) ->
receive
end, ?MYHOSTS).
get_modules_options(Host) ->
- ejabberd_config:get_option(
- {modules, Host},
- fun(Mods) ->
- lists:map(
- fun({M, A}) when is_atom(M), is_list(A) ->
- {M, A}
- end, Mods)
- end, []).
+ ejabberd_config:get_option({modules, Host}, []).
sort_modules(Host, ModOpts) ->
G = digraph:new([acyclic]),
-spec reload_modules(binary()) -> ok.
reload_modules(Host) ->
- NewMods = ejabberd_config:get_option(
- {modules, Host}, opt_type(modules), []),
+ NewMods = ejabberd_config:get_option({modules, Host}, []),
OldMods = ets:select(
ejabberd_modules,
ets:fun2ms(
get_opt({Opt, Host}, Opts, F, Default) ->
case lists:keysearch(Opt, 1, Opts) of
false ->
- ejabberd_config:get_option({Opt, Host}, F, Default);
+ ejabberd_config:get_option({Opt, Host}, Default);
{value, {_, Val}} ->
ejabberd_config:prepare_opt_val(Opt, Val, F, Default)
end;
%% @doc Get the uptime of the ejabberd node, expressed in seconds.
%% When ejabberd is starting, ejabberd_config:start/0 stores the datetime.
get_node_uptime() ->
- case ejabberd_config:get_option(
- node_start,
- fun(S) when is_integer(S), S >= 0 -> S end) of
+ case ejabberd_config:get_option(node_start) of
undefined ->
trunc(element(1, erlang:statistics(wall_clock)) / 1000);
Now ->
With = proplists:get_value(with, MAMQuery),
WithText = proplists:get_value(withtext, MAMQuery),
{Max, Direction, ID} = get_max_direction_id(RSM),
- ODBCType = ejabberd_config:get_option(
- {sql_type, LServer},
- ejabberd_sql:opt_type(sql_type)),
+ ODBCType = ejabberd_config:get_option({sql_type, LServer}),
Escape =
case ODBCType of
mssql -> fun ejabberd_sql:standard_escape/1;
check_timeout(undefined) -> true;
check_timeout(Source) ->
- Timeout = ejabberd_config:get_option(
- registration_timeout,
- fun(TO) when is_integer(TO), TO > 0 ->
- TO;
- (infinity) ->
- infinity;
- (unlimited) ->
- infinity
- end, 600),
+ Timeout = ejabberd_config:get_option(registration_timeout, 600),
if is_integer(Timeout) ->
Priority = -p1_time_compat:system_time(seconds),
CleanPriority = Priority + Timeout,
remove_timeout(undefined) -> true;
remove_timeout(Source) ->
- Timeout = ejabberd_config:get_option(
- registration_timeout,
- fun(TO) when is_integer(TO), TO > 0 ->
- TO;
- (infinity) ->
- infinity;
- (unlimited) ->
- infinity
- end, 600),
+ Timeout = ejabberd_config:get_option(registration_timeout, 600),
if is_integer(Timeout) ->
F = fun () ->
Treap = case mnesia:read(mod_register_ip, treap, write)
%%%===================================================================
-spec make_key(binary(), binary(), binary()) -> binary().
make_key(From, To, StreamID) ->
- Secret = ejabberd_config:get_option(shared_key, fun(V) -> V end),
+ Secret = ejabberd_config:get_option(shared_key),
str:to_hexlist(
crypto:hmac(sha256, str:to_hexlist(crypto:hash(sha256, Secret)),
[To, " ", From, " ", StreamID])).
lists:foreach(fun esip:cancel/1, State#state.tr_ids).
add_certfile(LServer, Opts) ->
- case ejabberd_config:get_option({domain_certfile, LServer},
- fun iolist_to_binary/1) of
+ case ejabberd_config:get_option({domain_certfile, LServer}) of
CertFile when is_binary(CertFile), CertFile /= <<"">> ->
[{certfile, CertFile}|Opts];
_ ->
LTServer = safe_nameprep(TServer),
FromTag = esip:get_param(<<"tag">>, FParams),
CallID = esip:get_hdr('call-id', Hdrs),
- SharedKey = ejabberd_config:get_option(shared_key, fun(V) -> V end),
+ SharedKey = ejabberd_config:get_option(shared_key),
str:sha([SharedKey, LFUser, LFServer, LTUser, LTServer,
FromTag, CallID, TS]).
start(Host) ->
p1_http:start(),
- Pool_size =
- ejabberd_config:get_option({ext_api_http_pool_size, Host},
- fun(X) when is_integer(X), X > 0->
- X
- end,
- 100),
+ Pool_size = ejabberd_config:get_option({ext_api_http_pool_size, Host}, 100),
p1_http:set_pool_size(Pool_size).
stop(_Host) ->
<<"http", _Url/binary>> -> Tail;
_ ->
Base = ejabberd_config:get_option({ext_api_url, Server},
- fun(X) ->
- iolist_to_binary(X)
- end,
<<"http://localhost/api">>),
<<Base/binary, "/", Tail/binary>>
end.
-spec load_from_config() -> ok | {error, any()}.
load_from_config() ->
- Shapers = ejabberd_config:get_option(
- shaper, fun(V) -> V end, []),
+ Shapers = ejabberd_config:get_option(shaper, []),
case mnesia:transaction(
fun() ->
lists:foreach(
fun(pgsql, _) ->
case
ejabberd_config:get_option(
- {pgsql_users_number_estimate, LServer},
- fun(V) when is_boolean(V) -> V end,
- false) of
+ {pgsql_users_number_estimate, LServer}, false) of
true ->
ejabberd_sql:sql_query_t(
?SQL("select @(reltuples :: bigint)d from pg_class"
projects / ejabberd / commitdiff