{fast_tls, ".*", {git, "https://github.com/processone/fast_tls", {tag, "1.0.10"}}},
{stringprep, ".*", {git, "https://github.com/processone/stringprep", {tag, "1.0.7"}}},
{fast_xml, ".*", {git, "https://github.com/processone/fast_xml", {tag, "1.1.21"}}},
- {xmpp, ".*", {git, "https://github.com/processone/xmpp", {tag, "1.1.8"}}},
+ {xmpp, ".*", {git, "https://github.com/processone/xmpp", "f5cbd6dc0f3ec786b33a7e708979ed27dfbbb0ec"}},
{stun, ".*", {git, "https://github.com/processone/stun", {tag, "1.0.9"}}},
{esip, ".*", {git, "https://github.com/processone/esip", {tag, "1.0.10"}}},
{fast_yaml, ".*", {git, "https://github.com/processone/fast_yaml", {tag, "1.0.8"}}},
Reason) ->
Status = format_reason(State, Reason),
?INFO_MSG("(~s) Closing c2s session for ~s: ~s",
- [SockMod:pp(Socket), jid:to_string(JID), Status]),
+ [SockMod:pp(Socket), jid:encode(JID), Status]),
State1 = case maps:is_key(pres_last, State) of
true ->
Pres = #presence{type = unavailable,
State3 = ejabberd_hooks:run_fold(
c2s_session_opened, LServer, State2, []),
?INFO_MSG("(~s) Opened c2s session for ~s",
- [SockMod:pp(Socket), jid:to_string(JID)]),
+ [SockMod:pp(Socket), jid:encode(JID)]),
{ok, State3};
deny ->
ejabberd_hooks:run(forbidden_session_hook, LServer, [JID]),
?INFO_MSG("(~s) Forbidden c2s session for ~s",
- [SockMod:pp(Socket), jid:to_string(JID)]),
+ [SockMod:pp(Socket), jid:encode(JID)]),
Txt = <<"Denied by ACL">>,
{error, xmpp:err_not_allowed(Txt, Lang), State}
end
case create_image(Limiter) of
{ok, Type, Key, Image} ->
Id = <<(randoms:get_string())/binary>>,
- JID = jid:to_string(From),
+ JID = jid:encode(From),
CID = <<"sha1+", (p1_sha:sha(Image))/binary, "@bob.xmpp.org">>,
Data = #bob_data{cid = CID, 'max-age' = 0, type = Type,
data = Image},
Fs = [mk_field(hidden, <<"FORM_TYPE">>, ?NS_CAPTCHA),
- mk_field(hidden, <<"from">>, jid:to_string(To)),
+ mk_field(hidden, <<"from">>, jid:encode(To)),
mk_field(hidden, <<"challenge">>, Id),
mk_field(hidden, <<"sid">>, SID),
mk_ocr_field(Lang, CID, Type)],
label = translate:translate(
Lang, <<"CAPTCHA web page">>),
values = [Imageurl]},
- mk_field(hidden, <<"from">>, jid:to_string(To)),
+ mk_field(hidden, <<"from">>, jid:encode(To)),
mk_field(hidden, <<"challenge">>, Id),
mk_field(hidden, <<"sid">>, SID),
mk_ocr_field(Lang, CID, Type)],
oauth_issue_token(Jid, TTLSeconds, ScopesString) ->
Scopes = [list_to_binary(Scope) || Scope <- string:tokens(ScopesString, ";")],
- case jid:from_string(list_to_binary(Jid)) of
+ try jid:decode(list_to_binary(Jid)) of
#jid{luser =Username, lserver = Server} ->
case oauth2:authorize_password({Username, Server}, Scopes, admin_generated) of
{ok, {_Ctx,Authorization}} ->
{ok, {_AppCtx2, Response}} = oauth2:issue_token(Authorization, [{expiry_time, TTLSeconds}]),
- {ok, AccessToken} = oauth2_response:access_token(Response),
- {ok, VerifiedScope} = oauth2_response:scope(Response),
+ {ok, AccessToken} = oauth2_response:access_token(Response),
+ {ok, VerifiedScope} = oauth2_response:scope(Response),
{AccessToken, VerifiedScope, integer_to_list(TTLSeconds) ++ " seconds"};
- {error, Error} ->
- {error, Error}
- end;
- error ->
+ {error, Error} ->
+ {error, Error}
+ end
+ catch _:{bad_jid, _} ->
{error, "Invalid JID: " ++ Jid}
end.
Tokens = mnesia:dirty_match_object(#oauth_token{_ = '_'}),
{MegaSecs, Secs, _MiniSecs} = os:timestamp(),
TS = 1000000 * MegaSecs + Secs,
- [{Token, jid:to_string(jid:make(U,S)), Scope, integer_to_list(Expires - TS) ++ " seconds"} ||
+ [{Token, jid:encode(jid:make(U,S)), Scope, integer_to_list(Expires - TS) ++ " seconds"} ||
#oauth_token{token=Token, scope=Scope, us= {U,S},expire=Expires} <- Tokens].
RedirectURI = proplists:get_value(<<"redirect_uri">>, Q, <<"">>),
SScope = proplists:get_value(<<"scope">>, Q, <<"">>),
StringJID = proplists:get_value(<<"username">>, Q, <<"">>),
- #jid{user = Username, server = Server} = jid:from_string(StringJID),
+ #jid{user = Username, server = Server} = jid:decode(StringJID),
Password = proplists:get_value(<<"password">>, Q, <<"">>),
State = proplists:get_value(<<"state">>, Q, <<"">>),
Scope = str:tokens(SScope, <<" ">>),
<<"password">> ->
SScope = proplists:get_value(<<"scope">>, Q, <<"">>),
StringJID = proplists:get_value(<<"username">>, Q, <<"">>),
- #jid{user = Username, server = Server} = jid:from_string(StringJID),
+ #jid{user = Username, server = Server} = jid:decode(StringJID),
Password = proplists:get_value(<<"password">>, Q, <<"">>),
Scope = str:tokens(SScope, <<" ">>),
TTL = proplists:get_value(<<"ttl">>, Q, <<"">>),
Path = path(<<"store">>),
%% Retry 2 times, with a backoff of 500millisec
{User, Server} = R#oauth_token.us,
- SJID = jid:to_string({User, Server, <<"">>}),
+ SJID = jid:encode({User, Server, <<"">>}),
case rest:with_retry(
post,
[?MYNAME, Path, [],
2, 500) of
{ok, 200, {Data}} ->
SJID = proplists:get_value(<<"user">>, Data, <<>>),
- JID = jid:from_string(SJID),
+ JID = jid:decode(SJID),
US = {JID#jid.luser, JID#jid.lserver},
Scope = proplists:get_value(<<"scope">>, Data, []),
Expire = proplists:get_value(<<"expire">>, Data, 0),
store(R) ->
Token = R#oauth_token.token,
{User, Server} = R#oauth_token.us,
- SJID = jid:to_string({User, Server, <<"">>}),
+ SJID = jid:encode({User, Server, <<"">>}),
Scope = str:join(R#oauth_token.scope, <<" ">>),
Expire = R#oauth_token.expire,
?SQL_UPSERT(
?SQL("select @(jid)s, @(scope)s, @(expire)d"
" from oauth_token where token=%(Token)s")) of
{selected, [{SJID, Scope, Expire}]} ->
- JID = jid:from_string(SJID),
+ JID = jid:decode(SJID),
US = {JID#jid.luser, JID#jid.lserver},
#oauth_token{token = Token,
us = US,
attrs = Attrs,
children = Els}}, State) ->
JIDS = fxml:get_attr_s(<<"jid">>, Attrs),
- case jid:from_string(JIDS) of
+ try jid:decode(JIDS) of
#jid{lserver = S} ->
case ejabberd_router:is_my_host(S) of
true ->
process_users(Els, State#state{server = S});
false ->
stop("Unknown host: ~s", [S])
- end;
- error ->
+ end
+ catch _:{bad_jid, _} ->
stop("Invalid 'jid': ~s", [JIDS])
end;
process_el({xmlstreamstart, <<"user">>, Attrs}, State = #state{server = S})
catch _:{xmpp_codec, Why} ->
?ERROR_MSG("failed to decode xml element ~p when "
"routing from ~s to ~s: ~s",
- [El, jid:to_string(From), jid:to_string(To),
+ [El, jid:encode(From), jid:encode(To),
xmpp:format_error(Why)])
end;
route(#jid{} = From, #jid{} = To, Packet) ->
do_route(Domain, Destinations, Packet) ->
?DEBUG("route multicast:~n~s~nDomain: ~s~nDestinations: ~s~n",
[xmpp:pp(Packet), Domain,
- str:join([jid:to_string(To) || To <- Destinations], <<", ">>)]),
+ str:join([jid:encode(To) || To <- Destinations], <<", ">>)]),
%% Try to find an appropriate multicast service
case mnesia:dirty_read(route_multicast, Domain) of
do_route(jid:replace_resource(To, R), Term)
end, get_user_resources(To#jid.user, To#jid.server));
do_route(To, Term) ->
- ?DEBUG("broadcasting ~p to ~s", [Term, jid:to_string(To)]),
+ ?DEBUG("broadcasting ~p to ~s", [Term, jid:encode(To)]),
{U, S, R} = jid:tolower(To),
Mod = get_sm_backend(S),
case online(Mod:get_sessions(U, S, R)) of
watchdog_admins,
fun(JIDs) ->
[jid:tolower(
- jid:from_string(
+ jid:decode(
iolist_to_binary(S))) || S <- JIDs]
end, []).
opt_type(watchdog_admins) ->
fun (JIDs) ->
- [jid:tolower(jid:from_string(iolist_to_binary(S)))
+ [jid:tolower(jid:decode(iolist_to_binary(S)))
|| S <- JIDs]
end;
opt_type(watchdog_large_heap) ->
case Auth of
{SJID, Pass} ->
{HostOfRule, AccessRule} = get_acl_rule(RPath, Method),
- case jid:from_string(SJID) of
- error -> {unauthorized, <<"badformed-jid">>};
- #jid{user = <<"">>, server = User} ->
- get_auth_account(HostOfRule, AccessRule, User, HostHTTP,
- Pass);
- #jid{user = User, server = Server} ->
- get_auth_account(HostOfRule, AccessRule, User, Server,
- Pass)
- end;
+ try jid:decode(SJID) of
+ #jid{user = <<"">>, server = User} ->
+ get_auth_account(HostOfRule, AccessRule, User, HostHTTP,
+ Pass);
+ #jid{user = User, server = Server} ->
+ get_auth_account(HostOfRule, AccessRule, User, Server,
+ Pass)
+ catch _:{bad_jid, _} ->
+ {unauthorized, <<"badformed-jid">>}
+ end;
undefined -> {unauthorized, <<"no-auth-provided">>}
end.
{server_regexp, Val};
string_to_spec(<<"node_regexp">>, Val) ->
#jid{luser = U, lserver = S, resource = <<"">>} =
- jid:from_string(Val),
+ jid:decode(Val),
{node_regexp, U, S};
string_to_spec(<<"user_glob">>, Val) ->
string_to_spec2(user_glob, Val);
{server_glob, Val};
string_to_spec(<<"node_glob">>, Val) ->
#jid{luser = U, lserver = S, resource = <<"">>} =
- jid:from_string(Val),
+ jid:decode(Val),
{node_glob, U, S};
string_to_spec(<<"all">>, _) -> all;
string_to_spec(<<"raw">>, Val) ->
string_to_spec2(ACLName, Val) ->
#jid{luser = U, lserver = S, resource = <<"">>} =
- jid:from_string(Val),
+ jid:decode(Val),
case U of
<<"">> -> {ACLName, S};
_ -> {ACLName, {U, S}}
lists:keysearch(<<"newusername">>, 1, Query),
{value, {_, Password}} =
lists:keysearch(<<"newuserpassword">>, 1, Query),
- case jid:from_string(<<Username/binary, "@",
+ try jid:decode(<<Username/binary, "@",
Host/binary>>)
of
- error -> error;
#jid{user = User, server = Server} ->
case ejabberd_auth:try_register(User, Server, Password)
of
{error, _Reason} -> error;
_ -> ok
end
+ catch _:{bad_jid, _} ->
+ error
end;
false -> nothing
end.
end.
us_to_list({User, Server}) ->
- jid:to_string({User, Server, <<"">>}).
+ jid:encode({User, Server, <<"">>}).
su_to_list({Server, User}) ->
- jid:to_string({User, Server, <<"">>}).
+ jid:encode({User, Server, <<"">>}).
%%%==================================
%%%% get_stats
replace_from_to(From, To,
#xmlel{name = Name, attrs = Attrs, children = Els}) ->
NewAttrs =
- replace_from_to_attrs(jid:to_string(From),
- jid:to_string(To), Attrs),
+ replace_from_to_attrs(jid:encode(From),
+ jid:encode(To), Attrs),
#xmlel{name = Name, attrs = NewAttrs, children = Els}.
-spec replace_from_attrs(binary(), [attr()]) -> [attr()].
replace_from(From,
#xmlel{name = Name, attrs = Attrs, children = Els}) ->
- NewAttrs = replace_from_attrs(jid:to_string(From),
+ NewAttrs = replace_from_attrs(jid:encode(From),
Attrs),
#xmlel{name = Name, attrs = NewAttrs, children = Els}.
-spec string_to_jid(binary()) -> jid() | error.
string_to_jid(S) ->
- jid:from_string(S).
+ try jid:decode(S)
+ catch _:_ -> error end.
-spec jid_to_string(jid() | ljid()) -> binary().
jid_to_string(J) ->
- jid:to_string(J).
+ jid:encode(J).
-spec is_nodename(binary()) -> boolean().
-> xmlel() | error.
create_delay_tag(TimeStamp, FromJID, Desc) when is_tuple(FromJID) ->
- From = jid:to_string(FromJID),
+ From = jid:encode(FromJID),
Stamp = now_to_utc_string(TimeStamp, 3),
Children = case Desc of
<<"">> -> [];
OnlinePids = [Pid || Pid <- Pids, Pid=/=none],
case OnlinePids of
[] ->
- {jid:to_string({U, S, <<>>}), <<"unavailable">>, <<"">>};
+ {jid:encode({U, S, <<>>}), <<"unavailable">>, <<"">>};
[SessionPid|_] ->
{_User, Resource, Show, Status} = get_presence(SessionPid),
- FullJID = jid:to_string({U, S, Resource}),
+ FullJID = jid:encode({U, S, Resource}),
{FullJID, Show, Status}
end.
make_roster_xmlrpc(Roster) ->
lists:foldl(
fun(Item, Res) ->
- JIDS = jid:to_string(Item#roster.jid),
+ JIDS = jid:encode(Item#roster.jid),
Nick = Item#roster.name,
Subs = atom_to_list(Item#roster.subscription),
Ask = atom_to_list(Item#roster.ask),
srg_get_members(Group, Host) ->
Members = mod_shared_roster:get_group_explicit_users(Host,Group),
- [jid:to_string(jid:make(MUser, MServer))
+ [jid:encode(jid:make(MUser, MServer))
|| {MUser, MServer} <- Members].
srg_user_add(User, Host, Group, GroupHost) ->
%% @doc Send a message to a Jabber account.
%% @spec (Type::binary(), From::binary(), To::binary(), Subject::binary(), Body::binary()) -> ok
send_message(Type, From, To, Subject, Body) ->
- FromJID = jid:from_string(From),
- ToJID = jid:from_string(To),
+ FromJID = jid:decode(From),
+ ToJID = jid:decode(To),
Packet = build_packet(Type, Subject, Body),
ejabberd_router:route(xmpp:set_from_to(Packet, FromJID, ToJID)).
send_stanza(FromString, ToString, Stanza) ->
try
#xmlel{} = El = fxml_stream:parse_element(Stanza),
- #jid{} = From = jid:from_string(FromString),
- #jid{} = To = jid:from_string(ToString),
+ From = jid:decode(FromString),
+ To = jid:decode(ToString),
Pkt = xmpp:decode(El, ?NS_CLIENT, [ignore_els]),
ejabberd_router:route(xmpp:set_from_to(Pkt, From, To))
catch _:{xmpp_codec, Why} ->
_:{badmatch, {error, Why}} ->
io:format("invalid xml: ~p~n", [Why]),
{error, Why};
- _:{badmatch, error} ->
+ _:{bad_jid, S} ->
+ io:format("malformed JID: ~s~n", [S]),
{error, "JID malformed"}
end.
decide_rip_jid({UName, UServer}, Match_list) ->
lists:any(
fun(Match_string) ->
- MJID = jid:from_string(list_to_binary(Match_string)),
+ MJID = jid:decode(list_to_binary(Match_string)),
MName = MJID#jid.luser,
MServer = MJID#jid.lserver,
Is_server = is_glob_match(UServer, MServer),
filter_presence({#presence{to = To, type = Type} = Pres,
#{csi_state := inactive} = C2SState})
when Type == available; Type == unavailable ->
- ?DEBUG("Got availability presence stanza for ~s", [jid:to_string(To)]),
+ ?DEBUG("Got availability presence stanza for ~s", [jid:encode(To)]),
enqueue_stanza(presence, Pres, C2SState);
filter_presence(Acc) ->
Acc.
Acc;
_ ->
?DEBUG("Got standalone chat state notification for ~s",
- [jid:to_string(To)]),
+ [jid:encode(To)]),
enqueue_stanza(chatstate, Msg, C2SState)
end;
false ->
undefined ->
Acc;
Node ->
- ?DEBUG("Got PEP notification for ~s", [jid:to_string(To)]),
+ ?DEBUG("Got PEP notification for ~s", [jid:encode(To)]),
enqueue_stanza({pep, Node}, Msg, C2SState)
end;
filter_pep(Acc) ->
#{csi_resend := true} ->
Acc;
_ ->
- ?DEBUG("Won't add stanza for ~s to CSI queue", [jid:to_string(JID)]),
+ ?DEBUG("Won't add stanza for ~s to CSI queue", [jid:encode(JID)]),
From = xmpp:get_from(Stanza),
C2SState1 = dequeue_sender(From, C2SState),
{Stanza, C2SState1}
dequeue_sender(#jid{luser = U, lserver = S},
#{csi_queue := Q, jid := JID} = C2SState) ->
?DEBUG("Flushing packets of ~s@~s from CSI queue of ~s",
- [U, S, jid:to_string(JID)]),
+ [U, S, jid:encode(JID)]),
case queue_take({U, S}, Q) of
{Stanzas, Q1} ->
C2SState1 = flush_stanzas(C2SState, Stanzas),
-spec flush_queue(c2s_state()) -> c2s_state().
flush_queue(#{csi_queue := Q, jid := JID} = C2SState) ->
- ?DEBUG("Flushing CSI queue of ~s", [jid:to_string(JID)]),
+ ?DEBUG("Flushing CSI queue of ~s", [jid:encode(JID)]),
C2SState1 = flush_stanzas(C2SState, queue_to_list(Q)),
C2SState1#{csi_queue => queue_new()}.
allow ->
PermLev = get_permission_level(From),
case get_local_items({PermLev, LServer}, LNode,
- jid:to_string(To), Lang)
+ jid:encode(To), Lang)
of
{result, Res} -> {result, Res};
{error, Error} -> {error, Error}
allow ->
PermLev = get_permission_level(From),
case get_local_items({PermLev, LServer}, [],
- jid:to_string(To), Lang)
+ jid:encode(To), Lang)
of
{result, Res} -> {result, Items ++ Res};
{error, _Error} -> {result, Items}
AccountString = get_value(<<"accountjid">>, XData),
Password = get_value(<<"password">>, XData),
Password = get_value(<<"password-verify">>, XData),
- AccountJID = jid:from_string(AccountString),
+ AccountJID = jid:decode(AccountString),
User = AccountJID#jid.luser,
Server = AccountJID#jid.lserver,
true = lists:member(Server, ?MYHOSTS),
XData),
[_ | _] = AccountStringList,
ASL2 = lists:map(fun (AccountString) ->
- JID = jid:from_string(AccountString),
+ JID = jid:decode(AccountString),
User = JID#jid.luser,
Server = JID#jid.lserver,
true = Server == Host orelse
set_form(From, Host, ?NS_ADMINL(<<"end-user-session">>),
Lang, XData) ->
AccountString = get_value(<<"accountjid">>, XData),
- JID = jid:from_string(AccountString),
+ JID = jid:decode(AccountString),
LUser = JID#jid.luser,
LServer = JID#jid.lserver,
true = LServer == Host orelse
set_form(From, Host,
?NS_ADMINL(<<"get-user-password">>), Lang, XData) ->
AccountString = get_value(<<"accountjid">>, XData),
- JID = jid:from_string(AccountString),
+ JID = jid:decode(AccountString),
User = JID#jid.luser,
Server = JID#jid.lserver,
true = Server == Host orelse
?NS_ADMINL(<<"change-user-password">>), _Lang, XData) ->
AccountString = get_value(<<"accountjid">>, XData),
Password = get_value(<<"password">>, XData),
- JID = jid:from_string(AccountString),
+ JID = jid:decode(AccountString),
User = JID#jid.luser,
Server = JID#jid.lserver,
true = Server == Host orelse
set_form(From, Host,
?NS_ADMINL(<<"get-user-lastlogin">>), Lang, XData) ->
AccountString = get_value(<<"accountjid">>, XData),
- JID = jid:from_string(AccountString),
+ JID = jid:decode(AccountString),
User = JID#jid.luser,
Server = JID#jid.lserver,
true = Server == Host orelse
set_form(From, Host, ?NS_ADMINL(<<"user-stats">>), Lang,
XData) ->
AccountString = get_value(<<"accountjid">>, XData),
- JID = jid:from_string(AccountString),
+ JID = jid:decode(AccountString),
User = JID#jid.luser,
Server = JID#jid.lserver,
true = Server == Host orelse
#iq{to = To, from = From2,
id = ID, type = result, sub_els = [#version{} = V]}} ->
?INFO_MSG("Version of the client ~s:~n~s",
- [jid:to_string(To), xmpp:pp(V)])
+ [jid:encode(To), xmpp:pp(V)])
after 5000 -> % Timeout in miliseconds: 5 seconds
[]
end.
extract_auth(#request{auth = HTTPAuth, ip = {IP, _}}) ->
Info = case HTTPAuth of
{SJID, Pass} ->
- case jid:from_string(SJID) of
+ try jid:decode(SJID) of
#jid{luser = User, lserver = Server} ->
case ejabberd_auth:check_password(User, <<"">>, Server, Pass) of
true ->
#{usr => {User, Server, <<"">>}, caller_server => Server};
false ->
{error, invalid_auth}
- end;
- _ ->
- {error, invalid_auth}
+ end
+ catch _:{bad_jid, _} ->
+ {error, invalid_auth}
end;
{oauth, Token, _} ->
case ejabberd_oauth:check_token(Token) of
end;
deny ->
?DEBUG("Denying HTTP upload slot request from ~s",
- [jid:to_string(From)]),
+ [jid:encode(From)]),
Txt = <<"Denied by ACL">>,
xmpp:make_error(IQ, xmpp:err_forbidden(Txt, Lang))
end;
Size > MaxSize ->
Text = {<<"File larger than ~w bytes">>, [MaxSize]},
?INFO_MSG("Rejecting file ~s from ~s (too large: ~B bytes)",
- [File, jid:to_string(JID), Size]),
+ [File, jid:encode(JID), Size]),
{error, xmpp:err_not_acceptable(Text, Lang)};
create_slot(#state{service_url = undefined,
jid_in_url = JIDinURL,
RandStr = make_rand_string(SecretLength),
FileStr = make_file_string(File),
?INFO_MSG("Got HTTP upload slot for ~s (file: ~s)",
- [jid:to_string(JID), File]),
+ [jid:encode(JID), File]),
{ok, [UserStr, RandStr, FileStr]};
deny ->
{error, xmpp:err_service_unavailable()};
HttpOptions = [{timeout, ?SERVICE_REQUEST_TIMEOUT}],
SizeStr = integer_to_binary(Size),
GetRequest = binary_to_list(ServiceURL) ++
- "?jid=" ++ ?URL_ENC(jid:to_string({U, S, <<"">>})) ++
+ "?jid=" ++ ?URL_ENC(jid:encode({U, S, <<"">>})) ++
"&name=" ++ ?URL_ENC(File) ++
"&size=" ++ ?URL_ENC(SizeStr) ++
"&content_type=" ++ ?URL_ENC(ContentType),
[<<"http", _/binary>> = PutURL,
<<"http", _/binary>> = GetURL] ->
?INFO_MSG("Got HTTP upload slot for ~s (file: ~s)",
- [jid:to_string(JID), File]),
+ [jid:encode(JID), File]),
{ok, PutURL, GetURL};
Lines ->
?ERROR_MSG("Can't parse data received for ~s from <~s>: ~p",
- [jid:to_string(JID), ServiceURL, Lines]),
+ [jid:encode(JID), ServiceURL, Lines]),
Txt = <<"Failed to parse HTTP response">>,
{error, xmpp:err_service_unavailable(Txt, Lang)}
end;
{ok, {402, _Body}} ->
?INFO_MSG("Got status code 402 for ~s from <~s>",
- [jid:to_string(JID), ServiceURL]),
+ [jid:encode(JID), ServiceURL]),
{error, xmpp:err_resource_constraint()};
{ok, {403, _Body}} ->
?INFO_MSG("Got status code 403 for ~s from <~s>",
- [jid:to_string(JID), ServiceURL]),
+ [jid:encode(JID), ServiceURL]),
{error, xmpp:err_not_allowed()};
{ok, {413, _Body}} ->
?INFO_MSG("Got status code 413 for ~s from <~s>",
- [jid:to_string(JID), ServiceURL]),
+ [jid:encode(JID), ServiceURL]),
{error, xmpp:err_not_acceptable()};
{ok, {Code, _Body}} ->
?ERROR_MSG("Got unexpected status code for ~s from <~s>: ~B",
- [jid:to_string(JID), ServiceURL, Code]),
+ [jid:encode(JID), ServiceURL, Code]),
{error, xmpp:err_service_unavailable()};
{error, Reason} ->
?ERROR_MSG("Error requesting upload slot for ~s from <~s>: ~p",
- [jid:to_string(JID), ServiceURL, Reason]),
+ [jid:encode(JID), ServiceURL, Reason]),
{error, xmpp:err_service_unavailable()}
end.
NewSize = case {HardQuota, SoftQuota} of
{0, 0} ->
?DEBUG("No quota specified for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
undefined;
{0, _} ->
?WARNING_MSG("No hard quota specified for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
enforce_quota(Path, Size, OldSize, SoftQuota, SoftQuota);
{_, 0} ->
?WARNING_MSG("No soft quota specified for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
enforce_quota(Path, Size, OldSize, HardQuota, HardQuota);
_ when SoftQuota > HardQuota ->
?WARNING_MSG("Bad quota for ~s (soft: ~p, hard: ~p)",
- [jid:to_string(JID),
+ [jid:encode(JID),
SoftQuota, HardQuota]),
enforce_quota(Path, Size, OldSize, SoftQuota, SoftQuota);
_ ->
?DEBUG("Enforcing quota for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
enforce_quota(Path, Size, OldSize, SoftQuota, HardQuota)
end,
NewDiskUsage = if is_integer(NewSize) ->
To#jid.server),
Reason = translate:translate(Lang, <<"Join the IRC channel here.">>),
BodyTxt = {<<"Join the IRC channel in this Jabber ID: ~s">>,
- [jid:to_string(RoomJID)]},
+ [jid:encode(RoomJID)]},
Invite = #message{
from = RoomJID, to = From,
body = xmpp:mk_text(BodyTxt, Lang),
?ERROR_MSG("failed to convert "
"parameter ~p for user ~s",
[Param,
- jid:to_string(JID)]);
+ jid:encode(JID)]);
true ->
?ERROR_MSG("failed to convert "
"parameter ~p",
send_text(StateData,
io_lib:format("NOTICE ~s :\001USERINFO xmpp:~s\001\r\n",
[FromUser,
- jid:to_string(StateData#state.user)])).
+ jid:encode(StateData#state.user)])).
process_topic(StateData, Chan, From, String) ->
[FromUser | _] = str:tokens(From, <<"!">>),
ejabberd_router:route_error(IQ, Error)
catch E:R ->
?ERROR_MSG("failed to process admin query from ~s: ~p",
- [jid:to_string(From), {E, {R, erlang:get_stacktrace()}}]),
+ [jid:encode(From), {E, {R, erlang:get_stacktrace()}}]),
ejabberd_router:route_error(
IQ, xmpp:err_internal_server_error())
end.
ok.
get_data(LServer, Host, From) ->
- SJID = jid:to_string(jid:tolower(jid:remove_resource(From))),
+ SJID = jid:encode(jid:tolower(jid:remove_resource(From))),
case catch ejabberd_sql:sql_query(
LServer,
?SQL("select @(data)s from irc_custom"
end.
set_data(LServer, Host, From, Data) ->
- SJID = jid:to_string(jid:tolower(jid:remove_resource(From))),
+ SJID = jid:encode(jid:tolower(jid:remove_resource(From))),
SData = jlib:term_to_expr(Data),
F = fun () ->
?SQL_UPSERT_T(
data = Data}) ->
case str:suffix(Host, IRCHost) of
true ->
- SJID = jid:to_string(jid:make(U, S)),
+ SJID = jid:encode(jid:make(U, S)),
SData = jlib:term_to_expr(Data),
[?SQL("delete from irc_custom"
" where jid=%(SJID)s and host=%(IRCHost)s;"),
import(_LServer) ->
[{<<"select jid, host, data from irc_custom;">>,
fun([SJID, IRCHost, SData]) ->
- #jid{luser = U, lserver = S} = jid:from_string(SJID),
+ #jid{luser = U, lserver = S} = jid:decode(SJID),
Data = ejabberd_sql:decode_term(SData),
#irc_custom{us_host = {{U, S}, IRCHost},
data = Data}
catch _:{xmpp_codec, Why} ->
?ERROR_MSG("Failed to decode raw element ~p from message "
"archive of user ~s: ~s",
- [El, jid:to_string(JidArchive), xmpp:format_error(Why)]),
+ [El, jid:encode(JidArchive), xmpp:format_error(Why)]),
{error, invalid_xml}
end.
?SQL("delete from archive_prefs where username=%(LUser)s")).
remove_room(LServer, LName, LHost) ->
- LUser = jid:to_string({LName, LHost, <<>>}),
+ LUser = jid:encode({LName, LHost, <<>>}),
remove_user(LUser, LServer).
delete_old_messages(ServerHost, TimeStamp, Type) ->
ID = integer_to_binary(TSinteger),
SUser = case Type of
chat -> LUser;
- groupchat -> jid:to_string({LUser, LHost, <<>>})
+ groupchat -> jid:encode({LUser, LHost, <<>>})
end,
- BarePeer = jid:to_string(
+ BarePeer = jid:encode(
jid:tolower(
jid:remove_resource(Peer))),
- LPeer = jid:to_string(
+ LPeer = jid:encode(
jid:tolower(Peer)),
XML = fxml:element_to_binary(Pkt),
Body = fxml:get_subtag_cdata(Pkt, <<"body">>),
MAMQuery, RSM, MsgType) ->
User = case MsgType of
chat -> LUser;
- {groupchat, _Role, _MUCState} -> jid:to_string(JidArchive)
+ {groupchat, _Role, _MUCState} -> jid:encode(JidArchive)
end,
{Query, CountQuery} = make_sql_query(User, LServer, MAMQuery, RSM),
% TODO from XEP-0313 v0.2: "To conserve resources, a server MAY place a
WithClause = case catch jid:tolower(With) of
{_, _, <<>>} ->
[<<" and bare_peer='">>,
- Escape(jid:to_string(With)),
+ Escape(jid:encode(With)),
<<"'">>];
{_, _, _} ->
[<<" and peer='">>,
- Escape(jid:to_string(With)),
+ Escape(jid:encode(With)),
<<"'">>];
_ ->
[]
#xmlel{} = El ->
try binary_to_integer(TS) of
TSInt ->
- case jid:from_string(Peer) of
- #jid{} = PeerJID ->
+ try jid:decode(Peer) of
+ PeerJID ->
Now = usec_to_now(TSInt),
PeerLJID = jid:tolower(PeerJID),
T = case Kind of
type = T,
nick = Nick,
peer = PeerLJID},
- MsgType, JidRequestor, JidArchive);
- error ->
+ MsgType, JidRequestor, JidArchive)
+ catch _:{bad_jid, _} ->
?ERROR_MSG("Malformed 'peer' field with value "
"'~s' detected for user ~s in table "
"'archive': invalid JID",
- [Peer, jid:to_string(JidArchive)]),
+ [Peer, jid:encode(JidArchive)]),
{error, invalid_jid}
end
catch _:_ ->
?ERROR_MSG("Malformed 'timestamp' field with value '~s' "
"detected for user ~s in table 'archive': "
"not an integer",
- [TS, jid:to_string(JidArchive)]),
+ [TS, jid:encode(JidArchive)]),
{error, invalid_timestamp}
end;
{error, {_, Reason}} ->
?ERROR_MSG("Malformed 'xml' field with value '~s' detected "
"for user ~s in table 'archive': ~s",
- [XML, jid:to_string(JidArchive), Reason]),
+ [XML, jid:encode(JidArchive), Reason]),
{error, invalid_xml}
end.
LFrom = jid:tolower(BareFrom),
LTo = jid:tolower(jid:remove_resource(To)),
Participant = #mix_participant{jid = BareFrom},
- ItemID = p1_sha:sha(jid:to_string(LFrom)),
+ ItemID = p1_sha:sha(jid:encode(LFrom)),
mod_pubsub:publish_item(
LTo, To#jid.lserver, ?NS_MIX_NODES_PARTICIPANTS,
From, ItemID, [xmpp:encode(Participant)]).
delete_participant(From, To) ->
LFrom = jid:tolower(jid:remove_resource(From)),
- ItemID = p1_sha:sha(jid:to_string(LFrom)),
+ ItemID = p1_sha:sha(jid:encode(LFrom)),
delete_presence(From, To),
delete_item(From, To, ?NS_MIX_NODES_PARTICIPANTS, ItemID).
S = get_room_state(Pid),
lists:map(
fun({_LJID, Info}) ->
- {jid:to_string(Info#user.jid),
+ {jid:encode(Info#user.jid),
Info#user.nick,
atom_to_list(Info#user.role)}
end,
UsersStrings = binary:split(UsersString, <<":">>, [global]),
OccupantsTuples = get_room_occupants(RoomJid#jid.luser,
RoomJid#jid.lserver),
- OccupantsJids = [jid:from_string(JidString)
+ OccupantsJids = [jid:decode(JidString)
|| {JidString, _Nick, _} <- OccupantsTuples],
lists:filtermap(
fun(UserString) ->
- UserJid = jid:from_string(UserString),
+ UserJid = jid:decode(UserString),
Val = lists:all(fun(OccupantJid) ->
UserJid#jid.luser /= OccupantJid#jid.luser
orelse UserJid#jid.lserver /= OccupantJid#jid.lserver
case mod_muc:find_online_room(Name, Service) of
{ok, Pid} ->
%% Get the PID for the online room so we can get the state of the room
- {ok, StateData} = gen_fsm:sync_send_all_state_event(Pid, {process_item_change, {jid:from_string(JID), affiliation, Affiliation, <<"">>}, <<"">>}),
+ {ok, StateData} = gen_fsm:sync_send_all_state_event(Pid, {process_item_change, {jid:decode(JID), affiliation, Affiliation, <<"">>}, <<"">>}),
mod_muc:store_room(StateData#state.server_host, StateData#state.host, StateData#state.room, make_opts(StateData)),
ok;
error ->
throw({error, "Nickname must be set"});
subscribe_room(User, Nick, Room, Nodes) ->
NodeList = re:split(Nodes, "\\h*,\\h*"),
- case jid:from_string(Room) of
+ try jid:decode(Room) of
#jid{luser = Name, lserver = Host} when Name /= <<"">> ->
- case jid:from_string(User) of
- error ->
- throw({error, "Malformed user JID"});
+ try jid:decode(User) of
#jid{lresource = <<"">>} ->
throw({error, "User's JID should have a resource"});
UserJID ->
_ ->
throw({error, "The room does not exist"})
end
+ catch _:{bad_jid, _} ->
+ throw({error, "Malformed user JID"})
end;
_ ->
throw({error, "Malformed room JID"})
+ catch _:{bad_jid, _} ->
+ throw({error, "Malformed room JID"})
end.
unsubscribe_room(User, Room) ->
- case jid:from_string(Room) of
+ try jid:decode(Room) of
#jid{luser = Name, lserver = Host} when Name /= <<"">> ->
- case jid:from_string(User) of
- error ->
- throw({error, "Malformed user JID"});
+ try jid:decode(User) of
UserJID ->
case get_room_pid(Name, Host) of
Pid when is_pid(Pid) ->
_ ->
throw({error, "The room does not exist"})
end
+ catch _:{bad_jid, _} ->
+ throw({error, "Malformed user JID"})
end;
_ ->
throw({error, "Malformed room JID"})
+ catch _:{bad_jid, _} ->
+ throw({error, "Malformed room JID"})
end.
get_subscribers(Name, Host) ->
case get_room_pid(Name, Host) of
Pid when is_pid(Pid) ->
{ok, JIDList} = gen_fsm:sync_send_all_state_event(Pid, get_subscribers),
- [jid:to_string(jid:remove_resource(J)) || J <- JIDList];
+ [jid:encode(jid:remove_resource(J)) || J <- JIDList];
_ ->
throw({error, "The room does not exist"})
end.
{Fd, Fn, Fnrel}.
get_room_name(RoomJID) ->
- JID = jid:from_string(RoomJID), JID#jid.user.
+ JID = jid:decode(RoomJID), JID#jid.user.
%% calculate day before
get_timestamp_daydiff(TimeStamp, Daydiff) ->
{value, {_, SA}} -> SA;
false -> <<"">>
end,
- #room{jid = jid:to_string(RoomJID), title = Title,
+ #room{jid = jid:encode(RoomJID), title = Title,
subject = Subject, subject_author = SubjectAuthor,
config = Opts}.
<<RoleS/binary, ": ", UsersString/binary>>.
get_room_occupants(RoomJIDString) ->
- RoomJID = jid:from_string(RoomJIDString),
+ RoomJID = jid:decode(RoomJIDString),
RoomName = RoomJID#jid.luser,
MucService = RoomJID#jid.lserver,
StateData = get_room_state(RoomName, MucService),
opts = Opts});
import(_LServer, <<"muc_registered">>,
[J, RoomHost, Nick, _TimeStamp]) ->
- #jid{user = U, server = S} = jid:from_string(J),
+ #jid{user = U, server = S} = jid:decode(J),
mnesia:dirty_write(
#muc_registered{us_host = {{U, S}, RoomHost},
nick = Nick}).
muc_room_schema());
import(_LServer, <<"muc_registered">>,
[J, RoomHost, Nick, _TimeStamp]) ->
- #jid{user = U, server = S} = jid:from_string(J),
+ #jid{user = U, server = S} = jid:decode(J),
R = #muc_registered{us_host = {{U, S}, RoomHost}, nick = Nick},
ejabberd_riak:put(R, muc_registered_schema(),
[{'2i', [{<<"nick_host">>, {Nick, RoomHost}}]}]).
State1 = set_opts(DefRoomOpts, State),
store_room(State1),
?INFO_MSG("Created MUC room ~s@~s by ~s",
- [Room, Host, jid:to_string(Creator)]),
+ [Room, Host, jid:encode(Creator)]),
add_to_log(room_existence, created, State1),
add_to_log(room_existence, started, State1),
{ok, normal_state, State1};
destroy_room(#muc_destroy{xmlns = ?NS_MUC_OWNER, reason = Reason},
StateData),
?INFO_MSG("Destroyed MUC room ~s with reason: ~p",
- [jid:to_string(StateData#state.jid), Reason]),
+ [jid:encode(StateData#state.jid), Reason]),
add_to_log(room_existence, destroyed, StateData),
{stop, shutdown, StateData};
handle_event(destroy, StateName, StateData) ->
?INFO_MSG("Destroyed MUC room ~s",
- [jid:to_string(StateData#state.jid)]),
+ [jid:encode(StateData#state.jid)]),
handle_event({destroy, undefined}, StateName, StateData);
handle_event({set_affiliations, Affiliations},
StateName, StateData) ->
true ->
?INFO_MSG("Destroyed MUC room ~s because it's temporary "
"and empty",
- [jid:to_string(StateData1#state.jid)]),
+ [jid:encode(StateData1#state.jid)]),
add_to_log(room_existence, destroyed, StateData1),
{stop, normal, StateData1};
_ -> {next_state, normal_state, StateData1}
true ->
Reason = str:format("This participant is considered a ghost "
"and is expulsed: ~s",
- [jid:to_string(From)]),
+ [jid:encode(From)]),
{expulse_sender, Reason};
false -> continue_delivery
end,
{result, Res} ->
?INFO_MSG("Processing MUC admin query from ~s in "
"room ~s:~n ~p",
- [jid:to_string(UJID),
- jid:to_string(StateData#state.jid), Res]),
+ [jid:encode(UJID),
+ jid:encode(StateData#state.jid), Res]),
case lists:foldl(process_item_change(UJID),
StateData, lists:flatten(Res)) of
{error, _} = Err ->
end
catch E:R ->
?ERROR_MSG("failed to set item ~p from ~s: ~p",
- [Item, jid:to_string(UJID),
+ [Item, jid:encode(UJID),
{E, {R, erlang:get_stacktrace()}}]),
{error, xmpp:err_internal_server_error()}
end.
{error, xmpp:err_forbidden(ErrText, Lang)};
Destroy /= undefined, Config == undefined, Items == [] ->
?INFO_MSG("Destroyed MUC room ~s by the owner ~s",
- [jid:to_string(StateData#state.jid), jid:to_string(From)]),
+ [jid:encode(StateData#state.jid), jid:encode(From)]),
add_to_log(room_existence, destroyed, StateData),
destroy_room(Destroy, StateData);
Config /= undefined, Destroy == undefined, Items == [] ->
MaxUsersRoom = get_max_users(StateData),
Title = str:format(
translate:translate(Lang, <<"Configuration of room ~s">>),
- [jid:to_string(StateData#state.jid)]),
+ [jid:encode(StateData#state.jid)]),
Fs = [{roomname, Config#config.title},
{roomdesc, Config#config.description}] ++
case acl:match_rule(StateData#state.server_host, AccessPersistent, From) of
translate:translate(
Lang,
<<"~s invites you to the room ~s">>),
- [jid:to_string(From),
- jid:to_string({StateData#state.room, StateData#state.host, <<"">>})]),
+ [jid:encode(From),
+ jid:encode({StateData#state.room, StateData#state.host, <<"">>})]),
case (StateData#state.config)#config.password_protected of
true ->
<<", ",
ejabberd_sql:sql_transaction(LServer, F).
can_use_nick(LServer, Host, JID, Nick) ->
- SJID = jid:to_string(jid:tolower(jid:remove_resource(JID))),
+ SJID = jid:encode(jid:tolower(jid:remove_resource(JID))),
case catch ejabberd_sql:sql_query(
LServer,
?SQL("select @(jid)s from muc_registered "
end.
get_nick(LServer, Host, From) ->
- SJID = jid:to_string(jid:tolower(jid:remove_resource(From))),
+ SJID = jid:encode(jid:tolower(jid:remove_resource(From))),
case catch ejabberd_sql:sql_query(
LServer,
?SQL("select @(nick)s from muc_registered where"
end.
set_nick(LServer, Host, From, Nick) ->
- JID = jid:to_string(jid:tolower(jid:remove_resource(From))),
+ JID = jid:encode(jid:tolower(jid:remove_resource(From))),
F = fun () ->
case Nick of
<<"">> ->
nick = Nick}) ->
case str:suffix(Host, RoomHost) of
true ->
- SJID = jid:to_string(jid:make(U, S)),
+ SJID = jid:encode(jid:make(U, S)),
[?SQL("delete from muc_registered where"
" jid=%(SJID)s and host=%(RoomHost)s;"),
?SQL("insert into muc_registered(jid, host, "
ejabberd_router:route_error(Packet, Error);
reply ->
To = xmpp:get_to(IQ),
- LServiceS = jid:to_string(To),
+ LServiceS = jid:encode(To),
case Packet#iq.type of
result ->
process_iqreply_result(LServiceS, IQ);
Delivereds = [],
Dests2 = lists:map(
fun(D) ->
- #dest{jid_string = jid:to_string(D),
+ #dest{jid_string = jid:encode(D),
jid_jid = D, type = bcc,
full_xml = #address{type = bcc, jid = D}}
end, Destinations),
fun(#address{jid = undefined} = Addr) ->
#dest{jid_string = none, full_xml = Addr};
(#address{jid = JID, type = Type} = Addr) ->
- #dest{jid_string = jid:to_string(JID), jid_jid = JID,
+ #dest{jid_string = jid:encode(JID), jid_jid = JID,
type = Type, full_xml = Addr}
end, Addrs).
make_reply(forbidden, Lang, ErrText) ->
xmpp:err_forbidden(ErrText, Lang).
-stj(String) -> jid:from_string(String).
+stj(String) -> jid:decode(String).
-jts(String) -> jid:to_string(String).
+jts(String) -> jid:encode(String).
depends(_Host, _Opts) ->
[].
Node = integer_to_binary(Seq),
#disco_item{jid = BareJID,
node = Node,
- name = jid:to_string(From)}
+ name = jid:encode(From)}
end, Hdrs)};
get_sm_items(Acc, _From, _To, _Node, _Lang) ->
Acc.
{route, Pkt2}
catch _:{xmpp_codec, Why} ->
?ERROR_MSG("failed to decode packet ~p of user ~s: ~s",
- [R#offline_msg.packet, jid:to_string(To),
+ [R#offline_msg.packet, jid:encode(To),
xmpp:format_error(Why)]),
error
end.
catch _:{xmpp_codec, Why} ->
?ERROR_MSG("failed to decode packet ~p "
"of user ~s: ~s",
- [El, jid:to_string(To),
+ [El, jid:encode(To),
xmpp:format_error(Why)]),
[]
end
fun({Seq, From, To, TS, El}) ->
ID = integer_to_binary(Seq),
FPacket = ejabberd_web_admin:pretty_print_xml(El),
- SFrom = jid:to_string(From),
- STo = jid:to_string(To),
+ SFrom = jid:encode(From),
+ STo = jid:encode(To),
Time = case TS of
undefined ->
Stamp = fxml:get_path_s(El, [{elem, <<"delay">>},
end.
us_to_list({User, Server}) ->
- jid:to_string({User, Server, <<"">>}).
+ jid:encode({User, Server, <<"">>}).
get_queue_length(LUser, LServer) ->
count_offline_messages(LUser, LServer).
el_to_offline_msg(El) ->
To_s = fxml:get_tag_attr_s(<<"to">>, El),
From_s = fxml:get_tag_attr_s(<<"from">>, El),
- To = jid:from_string(To_s),
- From = jid:from_string(From_s),
- if To == error ->
+ try
+ To = jid:decode(To_s),
+ From = jid:decode(From_s),
+ {ok, #offline_msg{us = {To#jid.luser, To#jid.lserver},
+ from = From,
+ to = To,
+ packet = El}}
+ catch _:{bad_jid, To_s} ->
?ERROR_MSG("failed to get 'to' JID from offline XML ~p", [El]),
{error, bad_jid_to};
- From == error ->
+ _:{bad_jid, From_s} ->
?ERROR_MSG("failed to get 'from' JID from offline XML ~p", [El]),
- {error, bad_jid_from};
- true ->
- {ok, #offline_msg{us = {To#jid.luser, To#jid.lserver},
- from = From,
- to = To,
- packet = El}}
+ {error, bad_jid_from}
end.
in ->
?WARNING_MSG("User ~s is being flooded, ignoring received "
"presence subscriptions",
- [jid:to_string(JID)]);
+ [jid:encode(JID)]);
out ->
IP = ejabberd_sm:get_user_ip(JID#jid.luser,
JID#jid.lserver,
JID#jid.lresource),
?WARNING_MSG("Flooder detected: ~s, on IP: ~s ignoring "
"sent presence subscriptions~n",
- [jid:to_string(JID),
+ [jid:encode(JID),
jlib:ip_to_list(IP)])
end,
{stop, deny};
-spec encode_value(listitem_type(), listitem_value()) -> binary().
encode_value(Type, Val) ->
case Type of
- jid -> jid:to_string(Val);
+ jid -> jid:encode(Val);
group -> Val;
subscription ->
case Val of
listitem_value().
decode_value(Type, Value) ->
case Type of
- jid -> jid:tolower(jid:from_string(Value));
+ jid -> jid:tolower(jid:decode(Value));
subscription ->
case Value of
<<"from">> -> from;
{Type, Value} = case SType of
<<"n">> -> {none, none};
<<"j">> ->
- case jid:from_string(SValue) of
- #jid{} = JID ->
- {jid, jid:tolower(JID)}
- end;
+ JID = jid:decode(SValue),
+ {jid, jid:tolower(JID)};
<<"g">> -> {group, SValue};
<<"s">> ->
case SValue of
match_presence_out = MatchPresenceOut}) ->
{SType, SValue} = case Type of
none -> {<<"n">>, <<"">>};
- jid -> {<<"j">>, jid:to_string(Value)};
+ jid -> {<<"j">>, jid:encode(Value)};
group -> {<<"g">>, Value};
subscription ->
case Value of
case acl:match_rule(ServerHost, ACL, InitiatorJID) of
allow ->
Node = ejabberd_cluster:get_node_by_id(To#jid.lresource),
- Target = jid:to_string(jid:tolower(TargetJID)),
- Initiator = jid:to_string(jid:tolower(InitiatorJID)),
+ Target = jid:encode(jid:tolower(TargetJID)),
+ Initiator = jid:encode(jid:tolower(InitiatorJID)),
SHA1 = p1_sha:sha(<<SID/binary, Initiator/binary, Target/binary>>),
Mod = gen_mod:ram_db_mod(global, mod_proxy65),
MaxConnections = max_connections(ServerHost),
{S1, S2} when is_port(S1), is_port(S2) ->
P1 ! {activate, P2, S2, J1, J2},
P2 ! {activate, P1, S1, J1, J2},
- JID1 = jid:to_string(J1),
- JID2 = jid:to_string(J2),
+ JID1 = jid:encode(J1),
+ JID2 = jid:encode(J2),
?INFO_MSG("(~w:~w) Activated bytestream for ~s "
"-> ~s",
[P1, P2, JID1, JID2]),
binary()) -> adhoc_command() | {error, stanza_error()}.
send_pending_auth_events(Host, Node, Owner, Lang) ->
?DEBUG("Sending pending auth events for ~s on ~s:~s",
- [jid:to_string(Owner), Host, Node]),
+ [jid:encode(Owner), Host, Node]),
Action =
fun(#pubsub_node{id = Nidx, type = Type}) ->
case lists:member(<<"get-pending">>, plugin_features(Host, Type)) of
EventItem0;
publisher ->
EventItem0#ps_item{
- publisher = jid:to_string(From)};
+ publisher = jid:encode(From)};
none ->
EventItem0
end,
case ejabberd_auth:set_password(User, Server, Password) of
ok ->
?INFO_MSG("~s has changed password from ~s",
- [jid:to_string({User, Server, <<"">>}),
+ [jid:encode({User, Server, <<"">>}),
ejabberd_config:may_hide_data(
jlib:ip_to_list(maps:get(ip, M, {0,0,0,0})))]),
xmpp:make_iq_result(IQ);
case gen_mod:get_module_opt(
Host, Mod, registration_watchers,
fun(Ss) ->
- [#jid{} = jid:from_string(iolist_to_binary(S))
- || S <- Ss]
+ [jid:decode(iolist_to_binary(S)) || S <- Ss]
end, []) of
[] -> ok;
JIDs when is_list(JIDs) ->
(str:format("[~s] The account ~s was registered from "
"IP address ~s on node ~w using ~p.",
[get_time_string(),
- jid:to_string(UJID),
+ jid:encode(UJID),
ip_to_string(Source), node(),
Mod])),
lists:foreach(
fun (N) when is_number(N), N >= 0 -> N end;
mod_opt_type(registration_watchers) ->
fun (Ss) ->
- [#jid{} = jid:from_string(iolist_to_binary(S))
- || S <- Ss]
+ [jid:decode(iolist_to_binary(S)) || S <- Ss]
end;
mod_opt_type(welcome_message) ->
fun (Opts) ->
end)
catch E:R ->
?ERROR_MSG("failed to process roster get for ~s: ~p",
- [jid:to_string(To), {E, {R, erlang:get_stacktrace()}}]),
+ [jid:encode(To), {E, {R, erlang:get_stacktrace()}}]),
Txt = <<"Roster module has failed">>,
xmpp:make_error(IQ, xmpp:err_internal_server_error(Txt, Lang))
end.
case JIDURI of
<<>> ->
?XAC(<<"td">>, [{<<"class">>, <<"valign">>}],
- (jid:to_string(RosterJID)));
+ (jid:encode(RosterJID)));
URI when is_binary(URI) ->
?XAE(<<"td">>, [{<<"class">>, <<"valign">>}],
- [?AC(JIDURI, (jid:to_string(RosterJID)))])
+ [?AC(JIDURI, (jid:encode(RosterJID)))])
end.
user_roster_parse_query(User, Server, Items, Query) ->
{value, _} ->
case lists:keysearch(<<"newjid">>, 1, Query) of
{value, {_, SJID}} ->
- case jid:from_string(SJID) of
- JID when is_record(JID, jid) ->
- user_roster_subscribe_jid(User, Server, JID), ok;
- error -> error
+ try jid:decode(SJID) of
+ JID ->
+ user_roster_subscribe_jid(User, Server, JID), ok
+ catch _:{bad_jid, _} ->
+ error
end;
false -> error
end;
nothing.
us_to_list({User, Server}) ->
- jid:to_string({User, Server, <<"">>}).
+ jid:encode({User, Server, <<"">>}).
webadmin_user(Acc, _User, _Server, Lang) ->
Acc ++
ok.
import(LServer, {sql, _}, _DBType, <<"rostergroups">>, [LUser, SJID, Group]) ->
- LJID = jid:tolower(jid:from_string(SJID)),
+ LJID = jid:tolower(jid:decode(SJID)),
ets:insert(rostergroups_tmp, {{LUser, LServer, LJID}, Group}),
ok;
import(LServer, {sql, _}, DBType, <<"rosterusers">>, Row) ->
%% Bad JID in database:
error -> [];
R ->
- SJID = jid:to_string(R#roster.jid),
+ SJID = jid:encode(R#roster.jid),
Groups = case dict:find(SJID, GroupsDict) of
{ok, Gs} -> Gs;
error -> []
get_roster_by_jid(LUser, LServer, LJID) ->
{selected, Res} =
- sql_queries:get_roster_by_jid(LServer, LUser, jid:to_string(LJID)),
+ sql_queries:get_roster_by_jid(LServer, LUser, jid:encode(LJID)),
case Res of
[] ->
#roster{usj = {LUser, LServer, LJID},
ejabberd_sql:sql_transaction(LServer, F).
get_roster_by_jid_with_groups(LUser, LServer, LJID) ->
- SJID = jid:to_string(LJID),
+ SJID = jid:encode(LJID),
case sql_queries:get_roster_by_jid(LServer, LUser, SJID) of
{selected, [I]} ->
case raw_to_record(LServer, I) of
{atomic, ok}.
update_roster(LUser, LServer, LJID, Item) ->
- SJID = jid:to_string(LJID),
+ SJID = jid:encode(LJID),
ItemVals = record_to_row(Item),
ItemGroups = Item#roster.groups,
sql_queries:update_roster(LServer, LUser, SJID, ItemVals,
ItemGroups).
del_roster(LUser, LServer, LJID) ->
- SJID = jid:to_string(LJID),
+ SJID = jid:encode(LJID),
sql_queries:del_roster(LServer, LUser, SJID).
read_subscription_and_groups(LUser, LServer, LJID) ->
- SJID = jid:to_string(LJID),
+ SJID = jid:encode(LJID),
case catch sql_queries:get_subscription(LServer, LUser, SJID) of
{selected, [{SSubscription}]} ->
Subscription = case SSubscription of
raw_to_record(LServer,
{User, SJID, Nick, SSubscription, SAsk, SAskMessage,
_SServer, _SSubscribe, _SType}) ->
- case jid:from_string(SJID) of
- error ->
- ?ERROR_MSG("~s", [format_row_error(User, LServer, {jid, SJID})]),
- error;
+ try jid:decode(SJID) of
JID ->
LJID = jid:tolower(JID),
Subscription = case SSubscription of
us = {User, LServer}, jid = LJID, name = Nick,
subscription = Subscription, ask = Ask,
askmessage = SAskMessage}
+ catch _:{bad_jid, _} ->
+ ?ERROR_MSG("~s", [format_row_error(User, LServer, {jid, SJID})]),
+ error
end.
record_to_row(
#roster{us = {LUser, _LServer},
jid = JID, name = Name, subscription = Subscription,
ask = Ask, askmessage = AskMessage}) ->
- SJID = jid:to_string(jid:tolower(JID)),
+ SJID = jid:encode(jid:tolower(JID)),
SSubscription = case Subscription of
both -> <<"B">>;
to -> <<"T">>;
<<"@all@">> -> USs;
<<"@online@">> -> USs;
_ ->
- case jid:from_string(SJID)
- of
- JID
- when is_record(JID,
- jid) ->
+ try jid:decode(SJID) of
+ JID ->
[{JID#jid.luser,
JID#jid.lserver}
- | USs];
- error -> error
+ | USs]
+ catch _:{bad_jid, _} ->
+ error
end
end
end,
end.
us_to_list({User, Server}) ->
- jid:to_string({User, Server, <<"">>}).
+ jid:encode({User, Server, <<"">>}).
split_grouphost(Host, Group) ->
case str:tokens(Group, <<"@">>) of
opts = ejabberd_sql:decode_term(SOpts)},
mnesia:dirty_write(G);
import(LServer, <<"sr_user">>, [SJID, Group, _TimeStamp]) ->
- #jid{luser = U, lserver = S} = jid:from_string(SJID),
+ #jid{luser = U, lserver = S} = jid:decode(SJID),
User = #sr_user{us = {U, S}, group_host = {Group, LServer}},
mnesia:dirty_write(User).
opts = ejabberd_sql:decode_term(SOpts)},
ejabberd_riak:put(G, sr_group_schema(), [{'2i', [{<<"host">>, LServer}]}]);
import(LServer, <<"sr_user">>, [SJID, Group|_]) ->
- #jid{luser = U, lserver = S} = jid:from_string(SJID),
+ #jid{luser = U, lserver = S} = jid:decode(SJID),
User = #sr_user{us = {U, S}, group_host = {Group, LServer}},
ejabberd_riak:put(User, sr_user_schema(),
[{i, {{U, S}, {Group, LServer}}},
{selected, Rs} ->
lists:map(
fun({JID}) ->
- {U, S, _} = jid:tolower(jid:from_string(JID)),
+ {U, S, _} = jid:tolower(jid:decode(JID)),
{U, S}
end, Rs);
_ ->
%%% Internal functions
%%%===================================================================
make_jid_s(U, S) ->
- jid:to_string(jid:tolower(jid:make(U, S))).
+ jid:encode(jid:tolower(jid:make(U, S))).
make_jid_s({U, S}) -> make_jid_s(U, S).
c2s_handle_info(#{mgmt_ack_timer := TRef, jid := JID, mod := Mod} = State,
{timeout, TRef, ack_timeout}) ->
?DEBUG("Timed out waiting for stream management acknowledgement of ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
State1 = State#{stop_reason => {socket, timeout}},
State2 = Mod:close(State1, _SendTrailer = false),
{stop, transition_to_pending(State2)};
c2s_handle_info(#{mgmt_state := pending, jid := JID, mod := Mod} = State,
{timeout, _, pending_timeout}) ->
?DEBUG("Timed out waiting for resumption of stream for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
Mod:stop(State#{mgmt_state => timeout});
c2s_handle_info(#{jid := JID} = State, {_Ref, {resume, OldState}}) ->
%% This happens if the resume_session/1 request timed out; the new session
%% now receives the late response.
?DEBUG("Received old session state for ~s after failed resumption",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
route_unacked_stanzas(OldState#{mgmt_resend => false}),
State;
c2s_handle_info(State, _) ->
c2s_terminated(#{mgmt_state := resumed, jid := JID} = State, _Reason) ->
?INFO_MSG("Closing former stream of resumed session for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
bounce_message_queue(),
{stop, State};
c2s_terminated(#{mgmt_state := MgmtState, mgmt_stanzas_in := In, sid := SID,
end,
Res = if Timeout > 0 ->
?INFO_MSG("Stream management with resumption enabled for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
#sm_enabled{xmlns = Xmlns,
id = make_resume_id(State),
resume = true,
max = Timeout};
true ->
?INFO_MSG("Stream management without resumption enabled for ~s",
- [jid:to_string(JID)]),
+ [jid:encode(JID)]),
#sm_enabled{xmlns = Xmlns}
end,
State1 = State#{mgmt_state => active,
%% csi_flush_queue(State4),
State5 = ejabberd_hooks:run_fold(c2s_session_resumed, LServer, State4, []),
?INFO_MSG("(~s) Resumed session for ~s",
- [SockMod:pp(Socket), jid:to_string(JID)]),
+ [SockMod:pp(Socket), jid:encode(JID)]),
{ok, State5};
{error, El, Msg} ->
?INFO_MSG("Cannot resume session for ~s@~s: ~s",
transition_to_pending(#{mgmt_state := active, jid := JID,
lserver := LServer, mgmt_timeout := Timeout} = State) ->
State1 = cancel_ack_timer(State),
- ?INFO_MSG("Waiting for resumption of stream for ~s", [jid:to_string(JID)]),
+ ?INFO_MSG("Waiting for resumption of stream for ~s", [jid:encode(JID)]),
erlang:start_timer(timer:seconds(Timeout), self(), pending_timeout),
State2 = State1#{mgmt_state => pending},
ejabberd_hooks:run_fold(c2s_session_pending, LServer, State2, []);
check_h_attribute(#{mgmt_stanzas_out := NumStanzasOut, jid := JID} = State, H)
when H > NumStanzasOut ->
?DEBUG("~s acknowledged ~B stanzas, but only ~B were sent",
- [jid:to_string(JID), H, NumStanzasOut]),
+ [jid:encode(JID), H, NumStanzasOut]),
mgmt_queue_drop(State#{mgmt_stanzas_out => H}, NumStanzasOut);
check_h_attribute(#{mgmt_stanzas_out := NumStanzasOut, jid := JID} = State, H) ->
?DEBUG("~s acknowledged ~B of ~B stanzas",
- [jid:to_string(JID), H, NumStanzasOut]),
+ [jid:encode(JID), H, NumStanzasOut]),
mgmt_queue_drop(State, H).
-spec update_num_stanzas_in(state(), xmpp_element()) -> state().
MgmtState == pending orelse
MgmtState == timeout) andalso QueueLen > 0 ->
?DEBUG("Resending ~B unacknowledged stanza(s) to ~s",
- [QueueLen, jid:to_string(JID)]),
+ [QueueLen, jid:encode(JID)]),
queue_foldl(
fun({_, Time, Pkt}, AccState) ->
NewPkt = add_resent_delay_info(AccState, Pkt, Time),
end
end,
?DEBUG("Re-routing ~B unacknowledged stanza(s) to ~s",
- [QueueLen, jid:to_string(JID)]),
+ [QueueLen, jid:encode(JID)]),
queue_foreach(
fun({_, _Time, #presence{from = From}}) ->
- ?DEBUG("Dropping presence stanza from ~s", [jid:to_string(From)]);
+ ?DEBUG("Dropping presence stanza from ~s", [jid:encode(From)]);
({_, _Time, #iq{} = El}) ->
Txt = <<"User session terminated">>,
ejabberd_router:route_error(
%% back to the original sender." Resending such a stanza could
%% easily lead to unexpected results as well.
?DEBUG("Dropping forwarded message stanza from ~s",
- [jid:to_string(From)]);
+ [jid:encode(From)]);
({_, Time, #message{} = Msg}) ->
case ejabberd_hooks:run_fold(message_is_archived,
LServer, false,
[State, Msg]) of
true ->
?DEBUG("Dropping archived message stanza from ~s",
- [jid:to_string(xmpp:get_from(Msg))]);
+ [jid:encode(xmpp:get_from(Msg))]);
false when ResendOnTimeout ->
NewEl = add_resent_delay_info(State, Msg, Time),
ejabberd_router:route(NewEl);
-spec mk_search_form(jid(), binary(), binary()) -> search().
mk_search_form(JID, ServerHost, Lang) ->
Title = <<(translate:translate(Lang, <<"Search users in ">>))/binary,
- (jid:to_string(JID))/binary>>,
+ (jid:encode(JID))/binary>>,
Mod = gen_mod:db_mod(ServerHost, ?MODULE),
SearchFields = Mod:search_fields(ServerHost),
Fs = [mk_tfield(Label, Var, Lang) || {Label, Var} <- SearchFields],
#xdata{type = result,
title = <<(translate:translate(Lang,
<<"Search Results for ">>))/binary,
- (jid:to_string(JID))/binary>>,
+ (jid:encode(JID))/binary>>,
reported = Reported,
items = lists:map(fun (Item) -> item_to_field(Item) end,
search(ServerHost, XFields))}.
-spec decode_jid(SJID :: binary()) -> ljid().
decode_jid(SJID) ->
- jid:tolower(jid:from_string(SJID)).
+ jid:tolower(jid:decode(SJID)).
-spec decode_affiliation(Arg :: binary()) -> atom().
decode_affiliation(<<"o">>) -> owner;
-spec encode_jid(JID :: ljid()) -> binary().
encode_jid(JID) ->
- jid:to_string(JID).
+ jid:encode(JID).
-spec encode_jid_like(JID :: ljid()) -> binary().
encode_jid_like(JID) ->
- ejabberd_sql:escape_like_arg_circumflex(jid:to_string(JID)).
+ ejabberd_sql:escape_like_arg_circumflex(jid:encode(JID)).
-spec encode_host(Host :: host()) -> binary().
encode_host({_U, _S, _R} = LJID) -> encode_jid(LJID);
options = Module:options()}.
nodeidx({U,S,R}, Node) ->
- JID = jid:to_string(jid:make(U,S,R)),
+ JID = jid:encode(jid:make(U,S,R)),
<<JID/binary, ":", Node/binary>>;
nodeidx(Host, Node) ->
<<Host/binary, ":", Node/binary>>.
nodeid(Nidx) ->
[Head, Node] = binary:split(Nidx, <<":">>),
- case jid:from_string(Head) of
+ case jid:decode(Head) of
{jid,<<>>,Host,<<>>,_,_,_} -> {Host, Node};
{jid,U,S,R,_,_,_} -> {{U,S,R}, Node}
end.
ok
end;
convert_data(_Host, "config", _User, [Data]) ->
- RoomJID = jid:from_string(proplists:get_value(<<"jid">>, Data, <<"">>)),
+ RoomJID = jid:decode(proplists:get_value(<<"jid">>, Data, <<"">>)),
Config = proplists:get_value(<<"_data">>, Data, []),
RoomCfg = convert_room_config(Data),
case proplists:get_bool(<<"persistent">>, Config) of
convert_pending_item(LUser, LServer, LuaList) ->
lists:flatmap(
fun({S, true}) ->
- case jid:from_string(S) of
- #jid{} = J ->
+ try jid:decode(S) of
+ J ->
LJID = jid:tolower(J),
[#roster{usj = {LUser, LServer, LJID},
us = {LUser, LServer},
jid = LJID,
- ask = in}];
- error ->
+ ask = in}]
+ catch _:{bad_jid, _} ->
[]
end;
(_) ->
end, LuaList).
convert_roster_item(LUser, LServer, JIDstring, LuaList) ->
- case jid:from_string(JIDstring) of
- #jid{} = JID ->
+ try jid:decode(JIDstring) of
+ JID ->
LJID = jid:tolower(JID),
InitR = #roster{usj = {LUser, LServer, LJID},
us = {LUser, LServer},
({<<"name">>, Name}, R) ->
R#roster{name = Name}
end, InitR, LuaList),
- [Roster];
- error ->
+ [Roster]
+ catch _:{bad_jid, _} ->
[]
end.
convert_room_affiliations(Data) ->
lists:flatmap(
fun({J, Aff}) ->
- case jid:from_string(J) of
+ try jid:decode(J) of
#jid{luser = U, lserver = S} ->
- [{{U, S, <<>>}, jlib:binary_to_atom(Aff)}];
- error ->
+ [{{U, S, <<>>}, jlib:binary_to_atom(Aff)}]
+ catch _:{bad_jid, _} ->
[]
end
end, proplists:get_value(<<"_affiliations">>, Data, [])).
[{password_protected, true},
{password, Password}]
end,
- Subj = case jid:from_string(
+ Subj = try jid:decode(
proplists:get_value(
<<"subject_from">>, Config, <<"">>)) of
#jid{lresource = Nick} when Nick /= <<"">> ->
[{subject, proplists:get_value(<<"subject">>, Config, <<"">>)},
- {subject_author, Nick}];
- _ ->
+ {subject_author, Nick}]
+ catch _:{bad_jid, _} ->
[]
end,
Anonymous = case proplists:get_value(<<"whois">>, Config, <<"moderators">>) of
{Type, Value} = try case T of
none -> {T, none};
group -> {T, V};
- jid -> {T, jid:tolower(jid:from_string(V))};
+ jid -> {T, jid:tolower(jid:decode(V))};
subscription -> {T, jlib:binary_to_atom(V)}
end
catch _:_ ->
match_presence_out = MatchPresOut}.
el_to_offline_msg(LUser, LServer, #xmlel{attrs = Attrs} = El) ->
- try xmpp_util:decode_timestamp(
- fxml:get_attr_s(<<"stamp">>, Attrs)) of
- {_, _, _} = TS ->
- Attrs1 = lists:filter(
- fun(<<"stamp">>) -> false;
- (<<"stamp_legacy">>) -> false;
- (_) -> true
- end, Attrs),
- Packet = El#xmlel{attrs = Attrs1},
- case {jid:from_string(fxml:get_attr_s(<<"from">>, Attrs)),
- jid:from_string(fxml:get_attr_s(<<"to">>, Attrs))} of
- {#jid{} = From, #jid{} = To} ->
- [#offline_msg{
- us = {LUser, LServer},
- timestamp = TS,
- expire = never,
- from = From,
- to = To,
- packet = Packet}];
- _ ->
- []
- end
+ try
+ TS = xmpp_util:decode_timestamp(
+ fxml:get_attr_s(<<"stamp">>, Attrs)),
+ Attrs1 = lists:filter(
+ fun(<<"stamp">>) -> false;
+ (<<"stamp_legacy">>) -> false;
+ (_) -> true
+ end, Attrs),
+ Packet = El#xmlel{attrs = Attrs1},
+ From = jid:decode(fxml:get_attr_s(<<"from">>, Attrs)),
+ To = jid:decode(fxml:get_attr_s(<<"to">>, Attrs)),
+ [#offline_msg{
+ us = {LUser, LServer},
+ timestamp = TS,
+ expire = never,
+ from = From,
+ to = To,
+ packet = Packet}]
catch _:{bad_timestamp, _} ->
+ [];
+ _:{bad_jid, _} ->
[]
end.
case lists:member(<<"EXTERNAL">>, Mechs) of
true ->
State1 = State#{stream_state => wait_for_sasl_response},
- Authzid = jid:to_string(jid:make(User, Server)),
+ Authzid = jid:encode(jid:make(User, Server)),
send_pkt(State1, #sasl_auth{mechanism = Mech, text = Authzid});
false ->
process_sasl_failure(
true -> error
end,
if D /= error ->
- case jid:from_string(D) of
+ try jid:decode(D) of
#jid{luser = <<"">>, lserver = LD,
lresource = <<"">>} ->
[LD];
_ -> []
+ catch _:{bad_jid, _} ->
+ []
end;
true -> []
end;
value = XmppAddr}}) ->
case 'XmppAddr':decode('XmppAddr', XmppAddr) of
{ok, D} when is_binary(D) ->
- case jid:from_string(D) of
+ try jid:decode(D) of
#jid{luser = <<"">>,
lserver = LD,
lresource = <<"">>} ->
[PCLD]
end;
_ -> []
+ catch _:{bad_jid, _} ->
+ []
end;
_ -> []
end;
({dNSName, D}) when is_list(D) ->
- case jid:from_string(list_to_binary(D)) of
+ try jid:decode(list_to_binary(D)) of
#jid{luser = <<"">>,
lserver = LD,
lresource = <<"">>} ->
[LD];
_ -> []
+ catch _:{bad_jid, _} ->
+ []
end;
(_) -> []
end, SANs);
projects / ejabberd / commitdiff