undo 2

src/c2s/mongoose_c2s.erl

@@ -371,7 +371,7 @@ handle_starttls(StateData = #c2s_data{socket = TcpSocket,
 handle_auth_start(StateData, El, SaslState, Retries) ->
     case {mongoose_c2s_socket:is_ssl(StateData#c2s_data.socket), StateData#c2s_data.listener_opts} of
         {false, #{tls := #{mode := starttls_required}}} ->
-        Error = mongoose_xmpp_errors:policy_violation(
+            Error = mongoose_xmpp_errors:policy_violation(
                       StateData#c2s_data.lang, <<"Use of STARTTLS required">>),
             c2s_stream_error(StateData, Error);
         _ ->
@@ -547,8 +547,8 @@ maybe_retry_state(StateData = #c2s_data{listener_opts = LOpts}, C2SState) ->
 
 -spec handle_cast(c2s_data(), c2s_state(), term()) -> fsm_res().
 handle_cast(StateData, _C2SState, {exit, Reason}) when is_binary(Reason) ->
-    Error = mongoose_xmpp_errors:stream_conflict(StateData#c2s_data.lang, Reason),
-    send_element_from_server_jid(StateData, Error),
+    StreamConflict = mongoose_xmpp_errors:stream_conflict(StateData#c2s_data.lang, Reason),
+    send_element_from_server_jid(StateData, StreamConflict),
     send_trailer(StateData),
     {stop, {shutdown, Reason}};
 handle_cast(StateData, _C2SState, {exit, system_shutdown}) ->

src/ejabberd_socket.erl

@@ -303,19 +303,3 @@ peername(#socket_state{sockmod = SockMod, socket = Socket}) ->
 -spec get_socket(socket_state()) -> term().
 get_socket(#socket_state{socket = Socket}) ->
     Socket.
-
-
-% format_socket(#socket_state{sockmod = Mod, socket = Socket,
-%                             receiver = Receiver, connection_details = Info}) ->
-%     Info2 = format_details(Info),
-%     Info2#{socket_module => Mod,
-%            socket => format_term(Socket),
-%            receiver => format_term(Receiver)};
-% format_socket(_) ->
-%     #{}.
-
-% format_term(X) -> iolist_to_binary(io_lib:format("~0p", [X])).
-
-% format_details(Info = #{dest_address := DestAddr, src_address := SrcAddr}) ->
-%     Info#{dest_address => inet:ntoa(DestAddr),
-%           src_address => inet:ntoa(SrcAddr)}.

src/mod_bosh_socket.erl

@@ -435,7 +435,7 @@ handle_info(Info, SName, State) ->
 terminate(Reason, StateName, #state{sid = Sid, handlers = Handlers} = S) ->
     [Pid ! {close, Sid} || {_, _, Pid} <- lists:sort(Handlers)],
     mod_bosh_backend:delete_session(Sid),
-    catch ejabberd_c2s:stop(S#state.c2s_pid),
+    catch mongoose_c2s:stop(S#state.c2s_pid, normal),
     ?LOG_DEBUG(ls(#{what => bosh_socket_closing_session, reason => Reason,
                     state_name => StateName, handlers => Handlers,
                     pending => S#state.pending}, S)).

src/system_metrics/mongoose_system_metrics_collector.erl

@@ -132,7 +132,7 @@ filter_unknown_api(ApiList) ->
 get_transport_mechanisms() ->
     HTTP = [Mod || Mod <- get_http_handler_modules(),
                    Mod =:= mod_bosh orelse Mod =:= mod_websockets],
-    TCP = lists:usort([tcp || #{proto := tcp} <- get_listeners(ejabberd_c2s)]),
+    TCP = lists:usort([tcp || #{proto := tcp} <- get_listeners(mongoose_c2s_listener)]),
     [#{report_name => transport_mechanism,
        key => Transport,
        value => enabled} || Transport <- HTTP ++ TCP].
@@ -149,7 +149,7 @@ get_http_handler_modules(#{handlers := Handlers}) ->
     [Module || #{module := Module} <- Handlers].
 
 get_tls_options() ->
-    TLSOptions = lists:flatmap(fun extract_tls_options/1, get_listeners(ejabberd_c2s)),
+    TLSOptions = lists:flatmap(fun extract_tls_options/1, get_listeners(mongoose_c2s_listener)),
     [#{report_name => tls_option, key => TLSMode, value => TLSModule} ||
         {TLSMode, TLSModule} <- lists:usort(TLSOptions)].
 

test/acc_SUITE.erl

@@ -30,6 +30,7 @@ groups() ->
        store_retrieve_and_delete_many,
        init_from_element,
        produce_iq_meta_automatically,
+       strip,
        strip_with_params,
        parse_with_cdata
       ]
@@ -129,6 +130,38 @@ parse_with_cdata(_C) ->
     {XMLNS, _} = mongoose_iq:xmlns(Acc),
     ?assertEqual(<<"jabber:iq:roster">>, XMLNS).
 
+strip(_C) ->
+    El = iq_stanza(),
+    FromJID = jid:make(<<"jajid">>, <<"localhost">>, <<>>),
+    ToJID = jid:make(<<"tyjid">>, <<"localhost">>, <<>>),
+    Server = maps:get(lserver, ?ACC_PARAMS),
+    HostType = maps:get(host_type, ?ACC_PARAMS),
+    Acc = mongoose_acc:new(?ACC_PARAMS#{element => El,
+                                        from_jid => FromJID,
+                                        to_jid => ToJID}),
+    {XMLNS1, Acc1} = mongoose_iq:xmlns(Acc),
+    ?assertEqual(<<"urn:ietf:params:xml:ns:xmpp-session">>, XMLNS1),
+    ?assertEqual(<<"set">>, mongoose_acc:stanza_type(Acc1)),
+    ?assertEqual(undefined, mongoose_acc:get(ns, ppp, undefined, Acc1)),
+    Acc2 = mongoose_acc:set_permanent(ns, ppp, 997, Acc1),
+    Acc3 = mongoose_acc:set(ns2, [{a, 1}, {b, 2}], Acc2),
+    ?assertMatch([_, _], mongoose_acc:get(ns2, Acc3)),
+    ?assertEqual(Server, mongoose_acc:lserver(Acc3)),
+    ?assertEqual(HostType, mongoose_acc:host_type(Acc3)),
+    ?assertEqual({FromJID, ToJID, El}, mongoose_acc:packet(Acc3)),
+    Ref = mongoose_acc:ref(Acc3),
+    %% strip stanza and check that only non-permanent fields are missing
+    NAcc1 = mongoose_acc:strip(Acc3),
+    {XMLNS3, NAcc2} = mongoose_iq:xmlns(NAcc1),
+    ?assertEqual(<<"urn:ietf:params:xml:ns:xmpp-session">>, XMLNS3),
+    ?assertEqual(<<"set">>, mongoose_acc:stanza_type(NAcc2)),
+    ?assertEqual(Server, mongoose_acc:lserver(NAcc2)),
+    ?assertEqual(HostType, mongoose_acc:host_type(NAcc2)),
+    ?assertEqual({FromJID, ToJID, El}, mongoose_acc:packet(NAcc2)),
+    ?assertEqual(Ref, mongoose_acc:ref(NAcc2)),
+    ?assertEqual(997, mongoose_acc:get(ns, ppp, NAcc2)),
+    ?assertEqual([], mongoose_acc:get(ns2, NAcc2)).
+
 strip_with_params(_Config) ->
     FromJID = jid:make(<<"jajid">>, <<"localhost">>, <<>>),
     ToJID = jid:make(<<"tyjid">>, <<"localhost">>, <<>>),