{deps, [{lager, ".*", {git, "https://github.com/erlang-lager/lager",
{tag, {if_version_above, "17", "3.4.2", "3.2.1"}}}},
- {p1_utils, ".*", {git, "https://github.com/processone/p1_utils", "b49f804"}},
+ {p1_utils, ".*", {git, "https://github.com/processone/p1_utils", "6ff85e8"}},
{cache_tab, ".*", {git, "https://github.com/processone/cache_tab", {tag, "1.0.14"}}},
{fast_tls, ".*", {git, "https://github.com/processone/fast_tls", {tag, "1.0.23"}}},
{stringprep, ".*", {git, "https://github.com/processone/stringprep", {tag, "1.0.12"}}},
{ok, #state{server = Host}}.
mech_step(#state{}, _ClientIn) ->
- User = iolist_to_binary([randoms:get_string(),
+ User = iolist_to_binary([p1_rand:get_string(),
integer_to_binary(p1_time_compat:unique_integer([positive]))]),
{ok, [{username, User},
{authzid, User},
mech_new(Host, GetPassword, _CheckPassword,
CheckPasswordDigest) ->
{ok,
- #state{step = 1, nonce = randoms:get_string(),
+ #state{step = 1, nonce = p1_rand:get_string(),
host = Host, hostfqdn = get_local_fqdn(),
get_password = GetPassword,
check_password = CheckPasswordDigest}}.
Pass#scram.iterationcount};
true ->
TempSalt =
- randoms:bytes(?SALT_LENGTH),
+ p1_rand:bytes(?SALT_LENGTH),
SaltedPassword =
scram:salted_password(Pass,
TempSalt,
str:substr(ClientIn,
str:str(ClientIn, <<"n=">>)),
ServerNonce =
- base64:encode(randoms:bytes(?NONCE_LENGTH)),
+ base64:encode(p1_rand:bytes(?NONCE_LENGTH)),
ServerFirstMessage =
iolist_to_binary(
["r=",
end.
sleep(N) ->
- timer:sleep(randoms:uniform(N)).
+ timer:sleep(p1_rand:uniform(N)).
get_module_file(App, Mod) ->
BaseName = atom_to_list(Mod),
password_to_scram(#scram{} = Password, _IterationCount) ->
Password;
password_to_scram(Password, IterationCount) ->
- Salt = randoms:bytes(?SALT_LENGTH),
+ Salt = p1_rand:bytes(?SALT_LENGTH),
SaltedPassword = scram:salted_password(Password, Salt, IterationCount),
StoredKey = scram:stored_key(scram:client_key(SaltedPassword)),
ServerKey = scram:server_key(SaltedPassword),
end,
{Status, Reason, ?HEADER(CType), <<"">>}.
-make_sid() -> str:sha(randoms:get_string()).
+make_sid() -> str:sha(p1_rand:get_string()).
-compile({no_auto_import, [{min, 2}]}).
erlang:start_timer(Timeout, self(), shaper_timeout).
make_random_jid(Host) ->
- User = randoms:get_string(),
- jid:make(User, Host, randoms:get_string()).
+ User = p1_rand:get_string(),
+ jid:make(User, Host, p1_rand:get_string()).
make_socket(Pid, IP) -> {http_bind, Pid, IP}.
-spec new_uniq_id() -> binary().
new_uniq_id() ->
iolist_to_binary(
- [randoms:get_string(),
+ [p1_rand:get_string(),
integer_to_binary(p1_time_compat:unique_integer([positive]))]).
-spec get_conn_type(state()) -> c2s | c2s_tls | c2s_compressed | websocket |
create_captcha(SID, From, To, Lang, Limiter, Args) ->
case create_image(Limiter) of
{ok, Type, Key, Image} ->
- Id = <<(randoms:get_string())/binary>>,
+ Id = <<(p1_rand:get_string())/binary>>,
JID = jid:encode(From),
CID = <<"sha1+", (str:sha(Image))/binary, "@bob.xmpp.org">>,
Data = #bob_data{cid = CID, 'max-age' = 0, type = Type,
create_captcha_x(SID, To, Lang, Limiter, #xdata{fields = Fs} = X) ->
case create_image(Limiter) of
{ok, Type, Key, Image} ->
- Id = <<(randoms:get_string())/binary>>,
+ Id = <<(p1_rand:get_string())/binary>>,
CID = <<"sha1+", (str:sha(Image))/binary, "@bob.xmpp.org">>,
Data = #bob_data{cid = CID, 'max-age' = 0, type = Type, data = Image},
HelpTxt = translate:translate(Lang,
create_image() -> create_image(undefined).
create_image(Limiter) ->
- Key = str:substr(randoms:get_string(), 1, 6),
+ Key = str:substr(p1_rand:get_string(), 1, 6),
create_image(Limiter, Key).
create_image(Limiter, Key) ->
UnixTime = p1_time_compat:system_time(seconds),
SharedKey = case erlang:get_cookie() of
nocookie ->
- str:sha(randoms:get_string());
+ str:sha(p1_rand:get_string());
Cookie ->
str:sha(misc:atom_to_binary(Cookie))
end,
UnixTime = p1_time_compat:system_time(seconds),
SharedKey = case erlang:get_cookie() of
nocookie ->
- str:sha(randoms:get_string());
+ str:sha(p1_rand:get_string());
Cookie ->
str:sha(misc:atom_to_binary(Cookie))
end,
-spec route(iq(), atom() | pid(), term(), non_neg_integer()) -> ok.
route(#iq{type = T} = IQ, Proc, Ctx, Timeout) when T == set; T == get ->
Expire = current_time() + Timeout,
- Rnd = randoms:get_string(),
+ Rnd = p1_rand:get_string(),
ID = encode_id(Expire, Rnd),
ets:insert(?MODULE, {{Expire, Rnd}, Proc, Ctx}),
gen_server:cast(?MODULE, {restart_timer, Expire}),
active = Active} = PrivacyQuery,
State = #state{user = U, server = S}) ->
JID = jid:make(U, S),
- IQ = #iq{type = set, id = randoms:get_string(),
+ IQ = #iq{type = set, id = p1_rand:get_string(),
from = JID, to = JID, sub_els = [PrivacyQuery]},
case mod_privacy:process_iq(IQ) of
#iq{type = error} = ResIQ ->
-spec process_private(private(), state()) -> {ok, state()} | {error, _}.
process_private(Private, State = #state{user = U, server = S}) ->
JID = jid:make(U, S),
- IQ = #iq{type = set, id = randoms:get_string(),
+ IQ = #iq{type = set, id = p1_rand:get_string(),
from = JID, to = JID, sub_els = [Private]},
case mod_private:process_sm_iq(IQ) of
#iq{type = result} ->
-spec process_vcard(xmlel(), state()) -> {ok, state()} | {error, _}.
process_vcard(El, State = #state{user = U, server = S}) ->
JID = jid:make(U, S),
- IQ = #iq{type = set, id = randoms:get_string(),
+ IQ = #iq{type = set, id = p1_rand:get_string(),
from = JID, to = JID, sub_els = [El]},
case mod_vcard:process_sm_iq(IQ) of
#iq{type = result} ->
erlang:error(Why)
end
catch _:Reason ->
- Timeout = randoms:uniform(
+ Timeout = p1_rand:uniform(
min(10, ejabberd_redis_sup:get_pool_size())),
?ERROR_MSG("Redis connection #~p at ~s:~p has failed: ~p; "
"reconnecting in ~p seconds",
-spec get_rnd_id() -> pos_integer().
get_rnd_id() ->
- randoms:round_robin(ejabberd_redis_sup:get_pool_size() - 1) + 2.
+ p1_rand:round_robin(ejabberd_redis_sup:get_pool_size() - 1) + 2.
-spec get_result([{error, atom() | binary()} | {ok, iodata()}]) ->
{ok, [redis_reply()]} | {error, binary()}.
[ejabberd_riak:get_proc(I) || I <- lists:seq(1, get_pool_size())].
get_random_pid() ->
- I = randoms:round_robin(get_pool_size()) + 1,
+ I = p1_rand:round_robin(get_pool_size()) + 1,
ejabberd_riak:get_proc(I).
transform_options(Opts) ->
-spec get_delay() -> non_neg_integer().
get_delay() ->
MaxDelay = ejabberd_config:get_option(s2s_max_retry_delay, 300),
- randoms:uniform(MaxDelay).
+ p1_rand:uniform(MaxDelay).
-spec set_idle_timeout(state()) -> state().
set_idle_timeout(#{on_route := send, server := LServer} = State) ->
dict:is_key(Server, HostOpts).
random_password() ->
- str:sha(randoms:bytes(20)).
+ str:sha(p1_rand:bytes(20)).
transform_listen_option({hosts, Hosts, O}, Opts) ->
case lists:keyfind(hosts, 1, Opts) of
case get_pids(Host) of
[] -> none;
Pids ->
- I = randoms:round_robin(length(Pids)) + 1,
+ I = p1_rand:round_robin(length(Pids)) + 1,
lists:nth(I, Pids)
end.
StartTime = p1_time_compat:monotonic_time(milli_seconds),
Pool = pool_name(Server),
PoolSize = pool_size(Server),
- I = randoms:round_robin(PoolSize),
+ I = p1_rand:round_robin(PoolSize),
Cmd = str:join(Args, <<":">>),
do_call(Cmd, I, I + PoolSize, Pool, PoolSize,
StartTime + Timeout, StartTime).
{{Year, Month, Day}, {Hour, Minute, Second}} = calendar:universal_time(),
Date = str:format("~4..0B~2..0B~2..0BT~2..0B:~2..0B:~2..0B",
[Year, Month, Day, Hour, Minute, Second]),
- RandomString = randoms:get_string(),
+ RandomString = p1_rand:get_string(),
<<"BANNED_ACCOUNT--", Date/binary, "--", RandomString/binary, "--", Reason/binary>>.
set_password_auth(User, Server, Password) ->
build_packet(Type, Subject, Body) ->
#message{type = misc:binary_to_atom(Type),
body = xmpp:mk_text(Body),
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
subject = xmpp:mk_text(Subject)}.
send_stanza(FromString, ToString, Stanza) ->
ok;
{ok, VCard} ->
VCard1 = VCard#vcard_temp{photo = VCardPhoto},
- IQ = #iq{from = JID, to = JID, id = randoms:get_string(),
+ IQ = #iq{from = JID, to = JID, id = p1_rand:get_string(),
type = set, sub_els = [VCard1], meta = Meta},
LServer = JID#jid.lserver,
ejabberd_hooks:run_fold(vcard_iq_set, LServer, IQ, []),
fun(R) ->
To = jid:replace_resource(From, R),
IQ = #iq{type = set, from = BFrom, to = To,
- id = <<"push", (randoms:get_string())/binary>>,
+ id = <<"push", (p1_rand:get_string())/binary>>,
sub_els = [Event]},
ejabberd_router:route(IQ)
end, ejabberd_sm:get_user_resources(LUser, LServer)).
do_client_version(disabled, _From, _To) -> ok;
do_client_version(enabled, From, To) ->
- Random_resource = randoms:get_string(),
+ Random_resource = p1_rand:get_string(),
From2 = From#jid{resource = Random_resource,
lresource = Random_resource},
- ID = randoms:get_string(),
+ ID = p1_rand:get_string(),
Packet = #iq{from = From2, to = To, type = get,
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = [#version{}]},
ejabberd_router:route(Packet),
receive
case ejabberd_hooks:run_fold(http_upload_slot_request, ServerHost, allow,
[JID, UserDir, Size, Lang]) of
allow ->
- RandStr = randoms:get_alphanum_string(SecretLength),
+ RandStr = p1_rand:get_alphanum_string(SecretLength),
FileStr = make_file_string(File),
?INFO_MSG("Got HTTP upload slot for ~s (file: ~s, size: ~B)",
[jid:encode(JID), File, Size]),
true ->
Dir = filename:dirname(Path),
Ext = atom_to_binary(T, latin1),
- FileName = <<(randoms:get_string())/binary, $., Ext/binary>>,
+ FileName = <<(p1_rand:get_string())/binary, $., Ext/binary>>,
OutPath = filename:join(Dir, FileName),
{W1, H1} = if W > H -> {300, round(H*300/W)};
H > W -> {round(W*300/H), 300};
process_muc_unique(#iq{from = From, type = get,
sub_els = [#muc_unique{}]} = IQ) ->
Name = str:sha(term_to_binary([From, p1_time_compat:timestamp(),
- randoms:get_string()])),
+ p1_rand:get_string()])),
xmpp:make_iq_result(IQ, #muc_unique{name = Name}).
-spec process_mucsub(iq()) -> iq().
{reply, {ok, JIDs}, StateName, StateData};
handle_sync_event({muc_subscribe, From, Nick, Nodes}, _From,
StateName, StateData) ->
- IQ = #iq{type = set, id = randoms:get_string(),
+ IQ = #iq{type = set, id = p1_rand:get_string(),
from = From, sub_els = [#muc_subscribe{nick = Nick,
events = Nodes}]},
Config = StateData#state.config,
{reply, {error, get_error_text(Err)}, StateName, StateData}
end;
handle_sync_event({muc_unsubscribe, From}, _From, StateName, StateData) ->
- IQ = #iq{type = set, id = randoms:get_string(),
+ IQ = #iq{type = set, id = p1_rand:get_string(),
from = From, sub_els = [#muc_unsubscribe{}]},
case process_iq_mucsub(From, IQ, StateData) of
{result, _, NewState} ->
Els1
end,
ejabberd_router:route(#presence{from = State#state.jid, to = JID,
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = Els2}).
-spec send_initial_presence(jid(), state(), state()) -> ok.
Item = #muc_item{jid = JID,
affiliation = Affiliation,
role = none},
- Message = #message{id = randoms:get_string(),
+ Message = #message{id = p1_rand:get_string(),
sub_els = [#muc_user{items = [Item]}]},
Users = get_users_and_subscribers(StateData),
Recipients = case (StateData#state.config)#config.anonymous of
send_self_presence(JID, StateData#state{config = New})
end, ?DICT:to_list(StateData#state.users)),
Message = #message{type = groupchat,
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = [#muc_user{status_codes = Codes}]},
send_wrapped_multiple(StateData#state.jid,
get_users_and_subscribers(StateData),
items = #ps_items{
node = ?NS_MUCSUB_NODES_SUBSCRIBERS,
items = [#ps_item{
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = [Payload]}]}}]},
ejabberd_router:route(xmpp:set_from_to(Packet, From, JID));
false ->
true ->
ejabberd_router:route(
#presence{from = State#state.jid, to = To,
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
type = unavailable});
false ->
ok
items = #ps_items{
node = Node,
items = [#ps_item{
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = [El]}]}}]}.
%% -spec send_multiple(jid(), binary(), [#user{}], stanza()) -> ok.
false ->
case ST of
{wait_for_info, _ID} ->
- Random = randoms:get_string(),
+ Random = p1_rand:get_string(),
ID = <<RServer/binary, $/, Random/binary>>,
send_query_items(FromS, LServiceS, ID),
add_response(RServer, Response, {wait_for_items, ID});
[] ->
add_response(RServer, not_supported, cached);
_ ->
- Random = randoms:get_string(),
+ Random = p1_rand:get_string(),
ID2 = <<RServer/binary, $/, Random/binary>>,
[send_query_info(Item, LServiceS, ID2) || Item <- List],
add_response(RServer, Response,
end.
query_info(RServer, LServiceS, Response) ->
- Random = randoms:get_string(),
+ Random = p1_rand:get_string(),
ID = <<RServer/binary, $/, Random/binary>>,
send_query_info(RServer, LServiceS, ID),
add_response(RServer, Response, {wait_for_info, ID}).
fun(R) ->
To = jid:replace_resource(From, R),
IQ = #iq{type = set, from = BareFrom, to = To,
- id = <<"push", (randoms:get_string())/binary>>,
+ id = <<"push", (p1_rand:get_string())/binary>>,
sub_els = [#privacy_query{
lists = [#privacy_list{name = Name}]}]},
ejabberd_router:route(IQ)
create_node(Host, ServerHost, <<>>, Owner, Type, Access, Configuration) ->
case lists:member(<<"instant-nodes">>, plugin_features(Host, Type)) of
true ->
- Node = randoms:get_string(),
+ Node = p1_rand:get_string(),
case create_node(Host, ServerHost, Node, Owner, Type, Access, Configuration) of
{result, _} ->
{result, #pubsub{create = Node}};
IQ = #iq{type = set,
from = From,
to = jid:make(PushLJID),
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = [PubSub]},
ejabberd_router:route_iq(IQ, HandleResponse).
route_presence_change(To, OldItem, NewItem),
IQ = #iq{type = set, to = To,
from = jid:remove_resource(To),
- id = <<"push", (randoms:get_string())/binary>>,
+ id = <<"push", (p1_rand:get_string())/binary>>,
sub_els = [#roster_query{ver = Ver,
items = [encode_item(NewItem)]}]},
ejabberd_router:route(IQ).
#iq{type = set,
from = UJID,
to = UJID,
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = [#roster_query{
items = [RosterItem]}]}),
throw(submitted);
log_packet(Packet, Host) ->
Loggers = gen_mod:get_module_opt(Host, ?MODULE, loggers),
ForwardedMsg = #message{from = jid:make(Host),
- id = randoms:get_string(),
+ id = p1_rand:get_string(),
sub_els = [#forwarded{
sub_els = [Packet]}]},
lists:foreach(
set_item(User, Server, Resource, Item) ->
ResIQ = #iq{from = jid:make(User, Server, Resource),
to = jid:make(Server),
- type = set, id = <<"push", (randoms:get_string())/binary>>,
+ type = set, id = <<"push", (p1_rand:get_string())/binary>>,
sub_els = [#roster_query{
items = [mod_roster:encode_item(Item)]}]},
ejabberd_router:route(ResIQ).
+++ /dev/null
-%%%----------------------------------------------------------------------
-%%% File : randoms.erl
-%%% Author : Alexey Shchepin <alexey@process-one.net>
-%%% Purpose : Random generation number wrapper
-%%% Created : 13 Dec 2002 by Alexey Shchepin <alexey@process-one.net>
-%%%
-%%%
-%%% ejabberd, Copyright (C) 2002-2018 ProcessOne
-%%%
-%%% This program is free software; you can redistribute it and/or
-%%% modify it under the terms of the GNU General Public License as
-%%% published by the Free Software Foundation; either version 2 of the
-%%% License, or (at your option) any later version.
-%%%
-%%% This program is distributed in the hope that it will be useful,
-%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
-%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-%%% General Public License for more details.
-%%%
-%%% You should have received a copy of the GNU General Public License along
-%%% with this program; if not, write to the Free Software Foundation, Inc.,
-%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-%%%
-%%%----------------------------------------------------------------------
-
--module(randoms).
-
--author('alexey@process-one.net').
-
--export([get_string/0, uniform/0, uniform/1, uniform/2, bytes/1,
- round_robin/1, get_alphanum_string/1]).
-
--define(THRESHOLD, 16#10000000000000000).
-
--ifdef(RAND_UNIFORM).
-get_string() ->
- R = rand:uniform(?THRESHOLD),
- integer_to_binary(R).
-
-uniform() ->
- rand:uniform().
-
-uniform(N) ->
- rand:uniform(N).
-
-uniform(N, M) ->
- rand:uniform(M-N+1) + N-1.
--else.
-get_string() ->
- R = crypto:rand_uniform(0, ?THRESHOLD),
- integer_to_binary(R).
-
-uniform() ->
- crypto:rand_uniform(0, ?THRESHOLD)/?THRESHOLD.
-
-uniform(N) ->
- crypto:rand_uniform(1, N+1).
-
-uniform(N, M) ->
- crypto:rand_uniform(N, M+1).
--endif.
-
--ifdef(STRONG_RAND_BYTES).
-bytes(N) ->
- crypto:strong_rand_bytes(N).
--else.
-bytes(N) ->
- crypto:rand_bytes(N).
--endif.
-
--spec round_robin(pos_integer()) -> non_neg_integer().
-round_robin(N) ->
- p1_time_compat:unique_integer([monotonic, positive]) rem N.
-
--spec get_alphanum_string(non_neg_integer()) -> binary().
-get_alphanum_string(Length) ->
- list_to_binary(get_alphanum_string([], Length)).
-
--spec get_alphanum_string(string(), non_neg_integer()) -> string().
-get_alphanum_string(S, 0) -> S;
-get_alphanum_string(S, N) ->
- get_alphanum_string([make_rand_char() | S], N - 1).
-
--spec make_rand_char() -> char().
-make_rand_char() ->
- map_int_to_char(uniform(0, 61)).
-
--spec map_int_to_char(0..61) -> char().
-map_int_to_char(N) when N =< 9 -> N + 48; % Digit.
-map_int_to_char(N) when N =< 35 -> N + 55; % Upper-case character.
-map_int_to_char(N) when N =< 61 -> N + 61. % Lower-case character.
-spec new_id() -> binary().
new_id() ->
- randoms:get_string().
+ p1_rand:get_string().
-spec is_disconnected(state()) -> boolean().
is_disconnected(#{stream_state := StreamState}) ->
-spec new_id() -> binary().
new_id() ->
- randoms:get_string().
+ p1_rand:get_string().
-spec is_disconnected(state()) -> boolean().
is_disconnected(#{stream_state := StreamState}) ->
fun({{Priority, Weight, Port, Host}, TLS}) ->
N = case Weight of
0 -> 0;
- _ -> (Weight + 1) * randoms:uniform()
+ _ -> (Weight + 1) * p1_rand:uniform()
end,
[{Priority * 65536 - N, Host, Port, TLS}];
(_) ->
projects / ejabberd / commitdiff