Merge branch 'anders/diameter/hardening/OTP-11721' into maint

* anders/diameter/hardening/OTP-11721:
  Simplify example server
  Make example server answer unsupported requests with 3001
  Make example code quiet
  Don't count messages on arbitrary keys
  Replace traffic-related log reports with no-op function calls

6 files changed, 253 insertions, 158 deletions

diff --git a/lib/diameter/src/base/diameter_codec.erl b/lib/diameter/src/base/diameter_codec.erl
index 9db3552286..84139d7f5e 100644
--- a/lib/diameter/src/base/diameter_codec.erl
+++ b/lib/diameter/src/base/diameter_codec.erl
@@ -70,18 +70,15 @@ encode(Mod, #diameter_packet{} = Pkt) ->
     try
         e(Mod, Pkt)
     catch
-        exit: {_, _, #diameter_header{}} = T ->
+        exit: {Reason, Stack, #diameter_header{} = H} = T ->
             %% Exit with a header in the reason to let the caller
             %% count encode errors.
-            X = {?MODULE, encode, T},
-            diameter_lib:error_report(X, {?MODULE, encode, [Mod, Pkt]}),
-            exit(X);
+            ?LOG(encode_error, {Reason, Stack, H}),
+            exit({?MODULE, encode, T});
         error: Reason ->
-            %% Be verbose since a crash report may be truncated and
-            %% encode errors are self-inflicted.
-            X = {?MODULE, encode, {Reason, ?STACK}},
-            diameter_lib:error_report(X, {?MODULE, encode, [Mod, Pkt]}),
-            exit(X)
+            T = {Reason, diameter_lib:get_stacktrace()},
+            ?LOG(encode_error, T),
+            exit({?MODULE, encode, T})
     end;
 
 encode(Mod, Msg) ->
@@ -115,7 +112,7 @@ e(_, #diameter_packet{msg = [#diameter_header{} = Hdr | As]} = Pkt) ->
                                         Avps/binary>>}
     catch
         error: Reason ->
-            exit({Reason, ?STACK, Hdr})
+            exit({Reason, diameter_lib:get_stacktrace(), Hdr})
     end;
 
 e(Mod, #diameter_packet{header = Hdr0, msg = Msg} = Pkt) ->
@@ -147,7 +144,7 @@ e(Mod, #diameter_packet{header = Hdr0, msg = Msg} = Pkt) ->
                                         Avps/binary>>}
     catch
         error: Reason ->
-            exit({Reason, ?STACK, Hdr})
+            exit({Reason, diameter_lib:get_stacktrace(), Hdr})
     end.
 
 %% make_flags/2
@@ -278,23 +275,23 @@ decode(Id, Mod, Bin)
     decode(Id, Mod, #diameter_packet{header = decode_header(Bin), bin = Bin}).
 
 decode_avps(MsgName, Mod, Pkt, {E, Avps}) ->
-    ?LOG(invalid, Pkt#diameter_packet.bin),
+    ?LOG(invalid_avp_length, Pkt#diameter_packet.header),
     #diameter_packet{errors = Failed}
         = P
         = decode_avps(MsgName, Mod, Pkt, Avps),
     P#diameter_packet{errors = [E | Failed]};
 
-decode_avps('', Mod, Pkt, Avps) ->  %% unknown message ...
-    ?LOG(unknown, {Mod, Pkt#diameter_packet.header}),
+decode_avps('', _, Pkt, Avps) ->  %% unknown message ...
+    ?LOG(unknown_message, Pkt#diameter_packet.header),
     Pkt#diameter_packet{avps = lists:reverse(Avps),
                         errors = [3001]};   %% DIAMETER_COMMAND_UNSUPPORTED
 %% msg = undefined identifies this case.
 
 decode_avps(MsgName, Mod, Pkt, Avps) ->  %% ... or not
-    {Rec, As, Failed} = Mod:decode_avps(MsgName, Avps),
-    ?LOGC([] /= Failed, failed, {Mod, Failed}),
+    {Rec, As, Errors} = Mod:decode_avps(MsgName, Avps),
+    ?LOGC([] /= Errors, decode_errors, Pkt#diameter_packet.header),
     Pkt#diameter_packet{msg = Rec,
-                        errors = Failed,
+                        errors = Errors,
                         avps = As}.
 
 %%% ---------------------------------------------------------------------------
diff --git a/lib/diameter/src/base/diameter_lib.erl b/lib/diameter/src/base/diameter_lib.erl
index 44d81e2778..5b3a2063f8 100644
--- a/lib/diameter/src/base/diameter_lib.erl
+++ b/lib/diameter/src/base/diameter_lib.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2010-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2010-2014. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -25,6 +25,8 @@
          now_diff/1,
          time/1,
          eval/1,
+         eval_name/1,
+         get_stacktrace/0,
          ipaddr/1,
          spawn_opts/2,
          wait/1,
@@ -32,6 +34,22 @@
          log/4]).
 
 %% ---------------------------------------------------------------------------
+%% # get_stacktrace/0
+%% ---------------------------------------------------------------------------
+
+%% Return a stacktrace with a leading, potentially large, argument
+%% list replaced by an arity. Trace on stacktrace/0 to see the
+%% original.
+
+get_stacktrace() ->
+    stacktrace(erlang:get_stacktrace()).
+
+stacktrace([{M,F,A,L} | T]) when is_list(A) ->
+    [{M, F, length(A), L} | T];
+stacktrace(L) ->
+    L.
+
+%% ---------------------------------------------------------------------------
 %% # info_report/2
 %% ---------------------------------------------------------------------------
 
@@ -60,9 +78,17 @@ warning_report(Reason, T) ->
     report(fun error_logger:warning_report/1, Reason, T).
 
 report(Fun, Reason, T) ->
-    Fun([{why, Reason}, {who, self()}, {what, T}]),
+    Fun(io_lib:format("diameter: ~" ++ fmt(Reason) ++ "~n    ~p~n",
+                      [Reason, T])),
     false.
 
+fmt(T) ->
+    if is_list(T) ->
+            "s";
+       true ->
+            "p"
+    end.
+
 %% ---------------------------------------------------------------------------
 %% # now_diff/1
 %% ---------------------------------------------------------------------------
@@ -129,8 +155,8 @@ eval({M,F,A}) ->
 eval([{M,F,A} | X]) ->
     apply(M, F, X ++ A);
 
-eval([[F|A] | X]) ->
-    eval([F | X ++ A]);
+eval([[F|X] | A]) ->
+    eval([F | A ++ X]);
 
 eval([F|A]) ->
     apply(F,A);
@@ -142,6 +168,28 @@ eval(F) ->
     F().
 
 %% ---------------------------------------------------------------------------
+%% eval_name/1
+%% ---------------------------------------------------------------------------
+
+eval_name({M,F,A}) ->
+    {M, F, length(A)};
+
+eval_name([{M,F,A} | X]) ->
+    {M, F, length(A) + length(X)};
+
+eval_name([[F|A] | X]) ->
+    eval_name([F | X ++ A]);
+
+eval_name([F|_]) ->
+    F;
+
+eval_name({F}) ->
+    eval_name(F);
+
+eval_name(F) ->
+    F.
+
+%% ---------------------------------------------------------------------------
 %% # ipaddr/1
 %%
 %% Parse an IP address.
diff --git a/lib/diameter/src/base/diameter_peer_fsm.erl b/lib/diameter/src/base/diameter_peer_fsm.erl
index 32e1b91966..31e570ae20 100644
--- a/lib/diameter/src/base/diameter_peer_fsm.erl
+++ b/lib/diameter/src/base/diameter_peer_fsm.erl
@@ -283,7 +283,7 @@ handle_info(T, #state{} = State) ->
         ok ->
             {noreply, State};
         #state{state = X} = S ->
-            ?LOGC(X =/= State#state.state, transition, X),
+            ?LOGC(X /= State#state.state, transition, X),
             {noreply, S};
         {stop, Reason} ->
             ?LOG(stop, Reason),
@@ -293,15 +293,11 @@ handle_info(T, #state{} = State) ->
             {stop, {shutdown, T}, State}
     catch
         exit: {diameter_codec, encode, T} = Reason ->
-            incr_error(send, T),
+            incr_error(send, T, State#state.dictionary),
             ?LOG(stop, Reason),
-            %% diameter_codec:encode/2 emits an error report. Only
-            %% indicate the probable reason here.
-            diameter_lib:info_report(probable_configuration_error,
-                                     insufficient_capabilities),
             {stop, {shutdown, Reason}, State};
         {?MODULE, Tag, Reason}  ->
-            ?LOG(Tag, {Reason, T}),
+            ?LOG(stop, Tag),
             {stop, {shutdown, Reason}, State}
     end.
 %% The form of the throw caught here is historical. It's
@@ -477,12 +473,12 @@ send_CER(#state{state = {'Wait-Conn-Ack', Tmo},
         orelse
         close({already_connected, Remote, LCaps}),
     CER = build_CER(S),
-    ?LOG(send, 'CER'),
     #diameter_packet{header = #diameter_header{end_to_end_id = Eid,
                                                hop_by_hop_id = Hid}}
         = Pkt
         = encode(CER, Dict),
     send(TPid, Pkt),
+    ?LOG(send, 'CER'),
     start_timer(Tmo, S#state{state = {'Wait-CEA', Hid, Eid}}).
 
 %% Register ourselves as connecting to the remote endpoint in
@@ -527,7 +523,6 @@ recv(#diameter_packet{header = #diameter_header{} = Hdr}
      = S) ->
     Name = diameter_codec:msg_name(Dict0, Hdr),
     Pid ! {recv, self(), Name, Pkt},
-    diameter_stats:incr({msg_id(Name, Hdr), recv}), %% count received
     rcv(Name, Pkt, S);
 
 recv(#diameter_packet{header = undefined,
@@ -554,42 +549,30 @@ recv(#diameter_header{length = Len}
 recv(#diameter_header{}
      = H,
      #diameter_packet{bin = Bin},
-     #state{length_errors = E}
-     = S) ->
-    invalid(E,
-            invalid_message_length,
-            recv,
-            [size(Bin), bit_size(Bin) rem 8, H, S]);
+     #state{length_errors = E}) ->
+    T = {size(Bin), bit_size(Bin) rem 8, H},
+    invalid(E, message_length_mismatch, T);
 
-recv(false, Pkt, #state{length_errors = E} = S) ->
-    invalid(E, truncated_header, recv, [Pkt, S]).
+recv(false, #diameter_packet{bin = Bin}, #state{length_errors = E}) ->
+    invalid(E, truncated_header, Bin).
 
 %% Note that counters here only count discarded messages.
-invalid(E, Reason, F, A) ->
+invalid(E, Reason, T) ->
     diameter_stats:incr(Reason),
-    abort(E, Reason, F, A).
-
-abort(exit, Reason, F, A) ->
-    diameter_lib:warning_report(Reason, {?MODULE, F, A}),
-    throw({?MODULE, abort, Reason});
-
-abort(_, _, _, _) ->
+    E == exit andalso close({Reason, T}),
+    ?LOG(Reason, T),
     ok.
 
-msg_id({_,_,_} = T, _) ->
-    T;
-msg_id(_, Hdr) ->
-    {_,_,_} = diameter_codec:msg_id(Hdr).
-
 %% rcv/3
 
 %% Incoming CEA.
-rcv('CEA',
+rcv('CEA' = N,
     #diameter_packet{header = #diameter_header{end_to_end_id = Eid,
                                                hop_by_hop_id = Hid}}
     = Pkt,
     #state{state = {'Wait-CEA', Hid, Eid}}
     = S) ->
+    ?LOG(recv, N),
     handle_CEA(Pkt, S);
 
 %% Incoming CER
@@ -610,29 +593,46 @@ rcv('DPR' = N, Pkt, S) ->
 %% DPA in response to DPR and with the expected identifiers.
 rcv('DPA' = N,
     #diameter_packet{header = #diameter_header{end_to_end_id = Eid,
-                                               hop_by_hop_id = Hid}}
+                                               hop_by_hop_id = Hid}
+                            = H}
     = Pkt,
     #state{dictionary = Dict0,
            transport = TPid,
            dpr = {Hid, Eid}}) ->
-
+    ?LOG(recv, N),
+    incr(recv, H, Dict0),
     incr_rc(recv, diameter_codec:decode(Dict0, Pkt), Dict0),
     diameter_peer:close(TPid),
     {stop, N};
 
 %% Ignore anything else, an unsolicited DPA in particular.
+rcv(N, #diameter_packet{header = H}, _)
+  when N == 'CER';
+       N == 'CEA';
+       N == 'DPR';
+       N == 'DPA' ->
+    ?LOG(ignored, N),
+    %% Note that these aren't counted in the normal recv counter.
+    diameter_stats:incr({diameter_codec:msg_id(H), recv, ignored}),
+    ok;
+
 rcv(_, _, _) ->
     ok.
 
+%% incr/3
+
+incr(Dir, Hdr, Dict0) ->
+    diameter_traffic:incr(Dir, Hdr, self(), Dict0).
+
 %% incr_rc/3
 
 incr_rc(Dir, Pkt, Dict0) ->
     diameter_traffic:incr_rc(Dir, Pkt, self(), Dict0).
 
-%% incr_error/2
+%% incr_error/3
 
-incr_error(Dir, Pkt) ->
-    diameter_traffic:incr_error(Dir, Pkt, self()).
+incr_error(Dir, Pkt, Dict0) ->
+    diameter_traffic:incr_error(Dir, Pkt, self(), Dict0).
 
 %% send/2
 
@@ -640,19 +640,23 @@ incr_error(Dir, Pkt) ->
 %% sending. In particular, the watchdog will send DWR as a binary
 %% while messages coming from clients will be in a #diameter_packet.
 send(Pid, Msg) ->
-    diameter_stats:incr({diameter_codec:msg_id(Msg), send}),
     diameter_peer:send(Pid, Msg).
 
 %% handle_request/3
+%%
+%% Incoming CER or DPR.
 
-handle_request(Type, #diameter_packet{} = Pkt, #state{dictionary = D} = S) ->
-    ?LOG(recv, Type),
-    send_answer(Type, diameter_codec:decode(D, Pkt), S).
+handle_request(Name,
+               #diameter_packet{header = H} = Pkt,
+               #state{dictionary = Dict0} = S) ->
+    ?LOG(recv, Name),
+    incr(recv, H, Dict0),
+    send_answer(Name, diameter_codec:decode(Dict0, Pkt), S).
 
 %% send_answer/3
 
 send_answer(Type, ReqPkt, #state{transport = TPid, dictionary = Dict} = S) ->
-    incr_error(recv, ReqPkt),
+    incr_error(recv, ReqPkt, Dict),
 
     #diameter_packet{header = H,
                      transport_data = TD}
@@ -672,10 +676,15 @@ send_answer(Type, ReqPkt, #state{transport = TPid, dictionary = Dict} = S) ->
 
     AnsPkt = diameter_codec:encode(Dict, Pkt),
 
+    incr(send, AnsPkt, Dict),
     incr_rc(send, AnsPkt, Dict),
     send(TPid, AnsPkt),
+    ?LOG(send, ans(Type)),
     eval(PostF, S).
 
+ans('CER') -> 'CEA';
+ans('DPR') -> 'DPA'.
+
 eval([F|A], S) ->
     apply(F, A ++ [S]);
 eval(T, _) ->
@@ -868,13 +877,12 @@ recv_CER(CER, #state{service = Svc, dictionary = Dict}) ->
 
 %% handle_CEA/2
 
-handle_CEA(#diameter_packet{bin = Bin}
+handle_CEA(#diameter_packet{header = H}
            = Pkt,
            #state{dictionary = Dict0,
                   service = #diameter_service{capabilities = LCaps}}
-           = S)
-  when is_binary(Bin) ->
-    ?LOG(recv, 'CEA'),
+           = S) ->
+    incr(recv, H, Dict0),
 
     #diameter_packet{}
         = DPkt
@@ -895,9 +903,7 @@ handle_CEA(#diameter_packet{bin = Bin}
     %% connection with the peer.
 
     try
-        is_integer(RC)
-            orelse ?THROW(no_result_code),
-        ?IS_SUCCESS(RC)
+        is_integer(RC) andalso ?IS_SUCCESS(RC)
             orelse ?THROW(RC),
         [] == SApps
             andalso ?THROW(no_common_application),
@@ -917,7 +923,7 @@ handle_CEA(#diameter_packet{bin = Bin}
 %% capabilities exchange could send DIAMETER_LIMITED_SUCCESS = 2002,
 %% even if this isn't required by RFC 3588.
 
-result_code({{'Result-Code', N}, _}) ->
+result_code({'Result-Code', N}) ->
     N;
 result_code(_) ->
     undefined.
@@ -1013,19 +1019,13 @@ capz(#diameter_caps{} = L, #diameter_caps{} = R) ->
                                                    tl(tuple_to_list(R)))]).
 
 %% close/1
+%%
+%% A good function to trace on in case of problems with capabilities
+%% exchange.
 
 close(Reason) ->
-    report(Reason),
     throw({?MODULE, close, Reason}).
 
-%% Could possibly log more here.
-report({M, _, _, _, _} = T)
-  when M == 'CER';
-       M == 'CEA' ->
-    diameter_lib:error_report(failure, T);
-report(_) ->
-    ok.
-
 %% dpr/2
 %%
 %% The RFC isn't clear on whether DPR should be send in a non-Open
@@ -1059,7 +1059,7 @@ dpr(_Reason, _S) ->
 %% process and contact it. (eg. diameter:service_info/2)
 
 dpr([CB|Rest], [Reason | _] = Args, S) ->
-    try diameter_lib:eval([CB | Args]) of
+    case diameter_lib:eval([CB | Args]) of
         {dpr, Opts} when is_list(Opts) ->
             send_dpr(Reason, Opts, S);
         dpr ->
@@ -1069,14 +1069,7 @@ dpr([CB|Rest], [Reason | _] = Args, S) ->
         ignore ->
             dpr(Rest, Args, S);
         T ->
-            No = {disconnect_cb, T},
-            diameter_lib:error_report(invalid, No),
-            {stop, No}
-    catch
-        E:R ->
-            No = {disconnect_cb, E, R, ?STACK},
-            diameter_lib:error_report(failure, No),
-            {stop, No}
+            ?ERROR({disconnect_cb, CB, Args, T})
     end;
 
 dpr([], [Reason | _], S) ->
diff --git a/lib/diameter/src/base/diameter_service.erl b/lib/diameter/src/base/diameter_service.erl
index 0dc3eb7123..b7cd311e02 100644
--- a/lib/diameter/src/base/diameter_service.erl
+++ b/lib/diameter/src/base/diameter_service.erl
@@ -731,14 +731,27 @@ remotes(F) ->
         L when is_list(L) ->
             L;
         T ->
-            diameter_lib:error_report({invalid_return, T}, F),
+            ?LOG(invalid_return, {F,T}),
+            error_report(invalid_return, share_peers, F),
             []
     catch
         E:R ->
-            diameter_lib:error_report({failure, {E, R, ?STACK}}, F),
+            ?LOG(failure, {E, R, F, diameter_lib:get_stacktrace()}),
+            error_report(failure, share_peers, F),
             []
     end.
 
+%% error_report/3
+
+error_report(T, What, F) ->
+    Reason = io_lib:format("~s from ~p callback", [reason(T), What]),
+    diameter_lib:error_report(Reason, diameter_lib:eval_name(F)).
+
+reason(invalid_return) ->
+    "invalid return";
+reason(failure) ->
+    "failure".
+
 %% ---------------------------------------------------------------------------
 %% # start/3
 %% ---------------------------------------------------------------------------
@@ -1038,8 +1051,11 @@ peer_cb(App, F, A) ->
             true
     catch
         E:R ->
-            diameter_lib:error_report({failure, {E, R, ?STACK}},
-                                      {App, F, A}),
+            %% Don't include arguments since a #diameter_caps{} strings
+            %% from the peer, which could be anything (especially, large).
+            [Mod|X] = App#diameter_app.module,
+            ?LOG(failure, {E, R, Mod, F, diameter_lib:get_stacktrace()}),
+            error_report(failure, F, {Mod, F, A ++ X}),
             false
     end.
 
@@ -1262,13 +1278,14 @@ cm([#diameter_app{alias = Alias} = App], Req, From, Svc) ->
             mod_state(Alias, ModS),
             {T, RC};
         T ->
-            diameter_lib:error_report({invalid, T},
-                                      {App, handle_call, Args}),
+            ModX = App#diameter_app.module,
+            ?LOG(invalid_return, {ModX, handle_call, Args, T}),
             invalid
     catch
         E: Reason ->
-            diameter_lib:error_report({failure, {E, Reason, ?STACK}},
-                                      {App, handle_call, Args}),
+            ModX = App#diameter_app.module,
+            Stack = diameter_lib:get_stacktrace(),
+            ?LOG(failure, {E, Reason, ModX, handle_call, Stack}),
             failure
     end;
 
@@ -1426,13 +1443,16 @@ pick_peer(Local,
             T;                     %% Accept returned state in the immutable
         {false = No, S} ->         %% case as long it isn't changed.
             No;
-        T ->
-            diameter_lib:error_report({invalid, T, App},
-                                      {App, pick_peer, Args})
+        T when M ->
+            ModX = App#diameter_app.module,
+            ?LOG(invalid_return, {ModX, pick_peer, T}),
+            false
     catch
-        E: Reason ->
-            diameter_lib:error_report({failure, {E, Reason, ?STACK}},
-                                      {App, pick_peer, Args})
+        E: Reason when M ->
+            ModX = App#diameter_app.module,
+            Stack = diameter_lib:get_stacktrace(),
+            ?LOG(failure, {E, Reason, ModX, pick_peer, Stack}),
+            false
     end.
 
 %% peers/4
diff --git a/lib/diameter/src/base/diameter_traffic.erl b/lib/diameter/src/base/diameter_traffic.erl
index f2ac745053..5fac61f416 100644
--- a/lib/diameter/src/base/diameter_traffic.erl
+++ b/lib/diameter/src/base/diameter_traffic.erl
@@ -32,7 +32,8 @@
 -export([receive_message/4]).
 
 %% towards diameter_peer_fsm and diameter_watchdog
--export([incr_error/3,
+-export([incr/4,
+         incr_error/4,
          incr_rc/4]).
 
 %% towards diameter_service
@@ -48,6 +49,8 @@
 -include_lib("diameter/include/diameter.hrl").
 -include("diameter_internal.hrl").
 
+-define(LOGX(Reason, T), begin ?LOG(Reason, T), x({Reason, T}) end).
+
 -define(RELAY, ?DIAMETER_DICT_RELAY).
 -define(BASE,  ?DIAMETER_DICT_COMMON).  %% Note: the RFC 3588 dictionary
 
@@ -113,38 +116,52 @@ peer_down(TPid) ->
     failover(TPid).
 
 %% ---------------------------------------------------------------------------
-%% incr_error/3
+%% incr/4
 %% ---------------------------------------------------------------------------
 
-%% A decoded message with errors.
-incr_error(Dir, #diameter_packet{header = H, errors = [_|_]}, TPid) ->
-    incr_error(Dir, H, TPid);
+incr(Dir, #diameter_packet{header = H}, TPid, Dict) ->
+    incr(Dir, H, TPid, Dict);
 
-%% An encoded message with errors and an identifiable header ...
-incr_error(Dir, {_, _, #diameter_header{} = H}, TPid) ->
-    incr_error(Dir, H, TPid);
+incr(Dir, #diameter_header{} = H, TPid, Dict) ->
+    incr(TPid, {msg_id(H, Dict), Dir}).
 
-%% ... or not.
-incr_error(Dir, {_,_}, TPid) ->
-    incr(TPid, {unknown, Dir, error});
+%% ---------------------------------------------------------------------------
+%% incr_error/4
+%% ---------------------------------------------------------------------------
 
-incr_error(Dir, #diameter_header{} = H, TPid) ->
-    incr_error(Dir, diameter_codec:msg_id(H), TPid);
+%% Decoded message without errors.
+incr_error(recv, #diameter_packet{errors = []}, _, _) ->
+    ok;
 
-incr_error(Dir, {_,_,_} = Id, TPid) ->
-    incr(TPid, {Id, Dir, error});
+incr_error(recv = D, #diameter_packet{header = H}, TPid, Dict) ->
+    incr_error(D, H, TPid, Dict);
 
-incr_error(_, _, _) ->
-    false.
+%% Encoded message with errors and an identifiable header ...
+incr_error(send = D, {_, _, #diameter_header{} = H}, TPid, Dict) ->
+    incr_error(D, H, TPid, Dict);
+
+%% ... or not.
+incr_error(send = D, {_,_}, TPid, _) ->
+    incr_error(D, unknown, TPid);
 
+incr_error(Dir, #diameter_header{} = H, TPid, Dict) ->
+    incr_error(Dir, msg_id(H, Dict), TPid);
+
+incr_error(Dir, Id, TPid, _) ->
+    incr_error(Dir, Id, TPid).
+
+incr_error(Dir, Id, TPid) ->
+    incr(TPid, {Id, Dir, error}).
+    
 %% ---------------------------------------------------------------------------
 %% incr_rc/4
 %% ---------------------------------------------------------------------------
 
--spec incr_rc(send|recv, #diameter_packet{}, TPid, Dict0)
+-spec incr_rc(send|recv, Pkt, TPid, Dict0)
    -> {Counter, non_neg_integer()}
     | Reason
- when TPid :: pid(),
+ when Pkt :: #diameter_packet{},
+      TPid :: pid(),
       Dict0 :: module(),
       Counter :: {'Result-Code', integer()}
                | {'Experimental-Result', integer(), integer()},
@@ -154,9 +171,8 @@ incr_rc(Dir, Pkt, TPid, Dict0) ->
     try
         incr_rc(Dir, Pkt, Dict0, TPid, Dict0)
     catch
-        exit: {invalid_error_bit = E, _} ->
-            E;
-        exit: no_result_code = E ->
+        exit: {E,_} when E == no_result_code;
+                         E == invalid_error_bit ->
             E
     end.
 
@@ -234,7 +250,7 @@ spawn_request(TPid, Pkt, Dict0, Opts, RecvData) ->
         spawn_opt(fun() -> recv_request(TPid, Pkt, Dict0, RecvData) end, Opts)
     catch
         error: system_limit = E ->  %% discard
-            ?LOG({error, E}, now())
+            ?LOG(error, E)
     end.
 
 %% ---------------------------------------------------------------------------
@@ -263,8 +279,9 @@ recv_R({#diameter_app{id = Id, dictionary = Dict} = App, Caps},
        Pkt0,
        Dict0,
        RecvData) ->
+    incr(recv, Pkt0, TPid, Dict),
     Pkt = errors(Id, diameter_codec:decode(Id, Dict, Pkt0)),
-    incr_error(recv, Pkt, TPid),
+    incr_error(recv, Pkt, TPid, Dict),
     {Caps, Pkt, App, recv_R(App, TPid, Dict0, Caps, RecvData, Pkt)};
 %% Note that the decode is different depending on whether or not Id is
 %% ?APP_ID_RELAY.
@@ -336,23 +353,25 @@ rc(N) ->
 %%      This error is returned when a request is received with an invalid
 %%      message length.
 
-errors(_, #diameter_packet{header = #diameter_header{length = Len},
+errors(_, #diameter_packet{header = #diameter_header{length = Len} = H,
                            bin = Bin,
                            errors = Es}
           = Pkt)
   when Len < 20;
        0 /= Len rem 4;
        8*Len /= bit_size(Bin) ->
+    ?LOG(invalid_message_length, {H, bit_size(Bin)}),
     Pkt#diameter_packet{errors = [5015 | Es]};
 
 %%   DIAMETER_UNSUPPORTED_VERSION       5011
 %%      This error is returned when a request was received, whose version
 %%      number is unsupported.
 
-errors(_, #diameter_packet{header = #diameter_header{version = V},
+errors(_, #diameter_packet{header = #diameter_header{version = V} = H,
                            errors = Es}
           = Pkt)
   when V /= ?DIAMETER_VERSION ->
+    ?LOG(unsupported_version, H),
     Pkt#diameter_packet{errors = [5011 | Es]};
 
 %%   DIAMETER_COMMAND_UNSUPPORTED       3001
@@ -360,12 +379,13 @@ errors(_, #diameter_packet{header = #diameter_header{version = V},
 %%      recognize or support.  This MUST be used when a Diameter node
 %%      receives an experimental command that it does not understand.
 
-errors(Id, #diameter_packet{header = #diameter_header{is_proxiable = P},
+errors(Id, #diameter_packet{header = #diameter_header{is_proxiable = P} = H,
                             msg = M,
                             errors = Es}
            = Pkt)
   when ?APP_ID_RELAY /= Id, undefined == M;  %% don't know the command
        ?APP_ID_RELAY == Id, not P ->         %% command isn't proxiable
+    ?LOG(command_unsupported, H),
     Pkt#diameter_packet{errors = [3001 | Es]};
 
 %%   DIAMETER_INVALID_HDR_BITS          3008
@@ -374,9 +394,11 @@ errors(Id, #diameter_packet{header = #diameter_header{is_proxiable = P},
 %%      inconsistent with the command code's definition.
 
 errors(_, #diameter_packet{header = #diameter_header{is_request = true,
-                                                     is_error = true},
+                                                     is_error = true}
+                                  = H,
                             errors = Es}
           = Pkt) ->
+    ?LOG(invalid_hdr_bits, H),
     Pkt#diameter_packet{errors = [3008 | Es]};
 
 %% Green.
@@ -532,7 +554,6 @@ answer_message(RC,
                               origin_realm = {OR,_}},
                Dict0,
                Pkt) ->
-    ?LOG({error, RC}, Pkt),
     {Dict0, answer_message(OH, OR, RC, Dict0, Pkt)}.
 
 %% resend/7
@@ -651,6 +672,7 @@ reply(Msg, Dict, TPid, Dict0, Fs, ReqPkt) ->
                  TPid,
                  reset(make_answer_packet(Msg, ReqPkt), Dict, Dict0),
                  Fs),
+    incr(send, Pkt, TPid, Dict),
     incr_rc(send, Pkt, Dict, TPid, Dict0),  %% count outgoing
     send(TPid, Pkt).
 
@@ -1035,21 +1057,29 @@ incr_rc(Dir, Pkt, Dict, TPid, Dict0) ->
                      errors = Es}
         = Pkt,
 
-    Id = diameter_codec:msg_id(Hdr),
+    Id = msg_id(Hdr, Dict),
 
     %% Count incoming decode errors.
-    recv /= Dir orelse [] == Es orelse incr_error(Dir, Id, TPid),
+    recv /= Dir orelse [] == Es orelse incr_error(Dir, Id, TPid, Dict),
 
     %% Exit on a missing result code.
     T = rc_counter(Dict, Msg),
-    T == false andalso x(no_result_code, answer, [Dir, Pkt]),
+    T == false andalso ?LOGX(no_result_code, {Dict, Dir, Hdr}),
     {Ctr, RC} = T,
 
     %% Or on an inappropriate value.
     is_result(RC, E, Dict0)
-        orelse x({invalid_error_bit, RC}, answer, [Dir, Pkt]),
+        orelse ?LOGX(invalid_error_bit, {Dict, Dir, Hdr, RC}),
 
-    incr(TPid, {Id, Dir, Ctr}).
+    incr(TPid, {Id, Dir, Ctr}),
+    Ctr.
+
+%% Only count on known keeps so as not to be vulnerable to attack:
+%% there are 2^32 (application ids) * 2^24 (command codes) * 2 (R-bits)
+%% = 2^57 Ids for an attacker to choose from.
+msg_id(Hdr, Dict) ->
+    {_ApplId, Code, R} = Id = diameter_codec:msg_id(Hdr),
+    choose('' == Dict:msg_name(Code, 0 == R), unknown, Id).
 
 %% No E-bit: can't be 3xxx.
 is_result(RC, false, _Dict0) ->
@@ -1067,8 +1097,8 @@ is_result(RC, true, _) ->
 
 %% incr/2
 
-incr(TPid, {_, _, T} = Counter) ->
-    {T, diameter_stats:incr(Counter, TPid, 1)}.
+incr(TPid, Counter) ->
+    diameter_stats:incr(Counter, TPid, 1).
 
 %% rc_counter/2
 
@@ -1112,13 +1142,6 @@ int(N)
 int(_) ->
     undefined.
 
--spec x(any(), atom(), list()) -> no_return().
-
-%% Warn and exit request process on errors in an incoming answer.
-x(Reason, F, A) ->
-    diameter_lib:warning_report(Reason, {?MODULE, F, A}),
-    x(Reason).
-
 x(T) ->
     exit(T).
 
@@ -1425,12 +1448,14 @@ handle_answer(SvcName,
 %% want to examine the answer?
 
 handle_A(Pkt, SvcName, Dict, Dict0, App, #request{transport = TPid} = Req) ->
+    incr(recv, Pkt, TPid, Dict),
+
     try
         incr_rc(recv, Pkt, Dict, TPid, Dict0) %% count incoming
     of
         _ -> answer(Pkt, SvcName, App, Req)
     catch
-        exit: no_result_code ->
+        exit: {no_result_code, _} ->
             %% RFC 6733 requires one of Result-Code or
             %% Experimental-Result, but the decode will have detected
             %% a missing AVP. If both are optional in the dictionary
@@ -1462,11 +1487,16 @@ a(#diameter_packet{errors = Es}
        callback == AE ->
     cb(ModX, handle_answer, [Pkt, msg(P), SvcName, {TPid, Caps}]);
 
-a(Pkt, SvcName, _, report, Req) ->
-    x(errors, handle_answer, [SvcName, Req, Pkt]);
+a(Pkt, SvcName, _, AE, _) ->
+    a(Pkt#diameter_packet.header, SvcName, AE).
+
+a(Hdr, SvcName, report) ->
+    MFA = {?MODULE, handle_answer, [SvcName, Hdr]},
+    diameter_lib:warning_report(errors, MFA),
+    a(Hdr, SvcName, discard);
 
-a(Pkt, SvcName, _, discard, Req) ->
-    x({errors, handle_answer, [SvcName, Req, Pkt]}).
+a(Hdr, SvcName, discard) ->
+    x({answer_errors, {SvcName, Hdr}}).
 
 %% Note that we don't check that the application id in the answer's
 %% header is what we expect. (TODO: Does the rfc says anything about
@@ -1544,7 +1574,7 @@ encode(Dict, TPid, #diameter_packet{bin = undefined} = Pkt) ->
         diameter_codec:encode(Dict, Pkt)
     catch
         exit: {diameter_codec, encode, T} = Reason ->
-            incr_error(send, T, TPid),
+            incr_error(send, T, TPid, Dict),
             exit(Reason)
     end;
 
@@ -1652,7 +1682,7 @@ resend_request(Pkt0,
                        packet = Pkt0,
                        caps = Caps},
 
-    ?LOG(retransmission, Req),
+    ?LOG(retransmission, Pkt#diameter_packet.header),
     TRef = send_request(TPid, Pkt, Req, SvcName, Tmo),
     {TRef, Req}.
 
diff --git a/lib/diameter/src/base/diameter_watchdog.erl b/lib/diameter/src/base/diameter_watchdog.erl
index e89b1394ee..eff5096745 100644
--- a/lib/diameter/src/base/diameter_watchdog.erl
+++ b/lib/diameter/src/base/diameter_watchdog.erl
@@ -219,7 +219,6 @@ dict0(_, _, Acc) ->
     Acc.
 
 config_error(T) ->
-    diameter_lib:error_report(configuration_error, T),
     exit({shutdown, {configuration_error, T}}).
 
 %% handle_call/3
@@ -268,7 +267,7 @@ event(Msg,
     TPid = tpid(F,T),
     E = {[TPid | data(Msg, TPid, From, To)], From, To},
     send(Pid, {watchdog, self(), E}),
-    ?LOG(transition, {self(), E}).
+    ?LOG(transition, {From, To}).
 
 data(Msg, TPid, reopen, okay) ->
     {recv, TPid, 'DWA', _Pkt} = Msg,  %% assert
@@ -477,8 +476,7 @@ encode(dwr = M, Dict0, Mask) ->
                            hop_by_hop_id = Seq},
     Pkt = #diameter_packet{header = Hdr,
                            msg = Msg},
-    #diameter_packet{bin = Bin} = diameter_codec:encode(Dict0, Pkt),
-    Bin;
+    diameter_codec:encode(Dict0, Pkt);
 
 encode(dwa, Dict0, #diameter_packet{header = H, transport_data = TD}
                    = ReqPkt) ->
@@ -547,10 +545,14 @@ send_watchdog(#watchdog{pending = false,
                         dictionary = Dict0,
                         sequence = Mask}
               = S) ->
-    send(TPid, {send, encode(dwr, Dict0, Mask)}),
+    #diameter_packet{bin = Bin} = EPkt = encode(dwr, Dict0, Mask),
+    diameter_traffic:incr(send, EPkt, TPid, Dict0),
+    send(TPid, {send, Bin}),
     ?LOG(send, 'DWR'),
     S#watchdog{pending = true}.
 
+%% Dont' count encode errors since we don't expect any on DWR/DWA.
+
 %% recv/3
 
 recv(Name, Pkt, S) ->
@@ -567,9 +569,12 @@ recv(Name, Pkt, S) ->
 
 rcv('DWR', Pkt, #watchdog{transport = TPid,
                           dictionary = Dict0}) ->
+    ?LOG(recv, 'DWR'),
     DPkt = diameter_codec:decode(Dict0, Pkt),
-    diameter_traffic:incr_error(recv, DPkt, TPid),
+    diameter_traffic:incr(recv, DPkt, TPid, Dict0),
+    diameter_traffic:incr_error(recv, DPkt, TPid, Dict0),
     EPkt = encode(dwa, Dict0, Pkt),
+    diameter_traffic:incr(send, EPkt, TPid, Dict0),
     diameter_traffic:incr_rc(send, EPkt, TPid, Dict0),
 
     send(TPid, {send, EPkt}),
@@ -577,6 +582,8 @@ rcv('DWR', Pkt, #watchdog{transport = TPid,
 
 rcv('DWA', Pkt, #watchdog{transport = TPid,
                           dictionary = Dict0}) ->
+    ?LOG(recv, 'DWA'),
+    diameter_traffic:incr(recv, Pkt, TPid, Dict0),
     diameter_traffic:incr_rc(recv,
                              diameter_codec:decode(Dict0, Pkt),
                              TPid,