Merge branch 'anders/diameter/packet_callback/OTP-10441' into maint

* anders/diameter/packet_callback/OTP-10441:
  Use packet callbacks in traffic suite
  Improve other diameter_app doc
  Document eval_packet
  Add eval_packet for examining outgoing messages after encode

3 files changed, 284 insertions, 168 deletions

diff --git a/lib/diameter/doc/src/diameter_app.xml b/lib/diameter/doc/src/diameter_app.xml
index 4a4b212787..9d8a6568eb 100644
--- a/lib/diameter/doc/src/diameter_app.xml
+++ b/lib/diameter/doc/src/diameter_app.xml
@@ -112,7 +112,8 @@ and, for the call-specific callbacks, any extra arguments passed to
 <item>
 <p>
 A record containing the identities of
-the local Diameter node and the remote Diameter peer having an established transport
+the local Diameter node and the remote Diameter peer having an
+established transport
 connection, as well as the capabilities as
 determined by capabilities exchange.
 Each field of the record is a 2-tuple consisting of
@@ -168,13 +169,14 @@ Fields should not be set in return values except as documented.</p>
 <tag><c>peer_ref() = term()</c></tag>
 <item>
 <p>
-A term identifying a transport connection with a Diameter peer.
-Should be treated opaquely.</p>
+A term identifying a transport connection with a Diameter peer.</p>
 </item>
 
 <marker id="peer"/>
 
-<tag><c>peer() = {<seealso marker="#peer_ref">peer_ref()</seealso>, <seealso marker="#capabilities">capabilities()</seealso>}</c></tag>
+<tag><c>peer() =
+          {<seealso marker="#peer_ref">peer_ref()</seealso>,
+           <seealso marker="#capabilities">capabilities()</seealso>}</c></tag>
 <item>
 <p>
 A tuple representing a Diameter peer connection.</p>
@@ -219,10 +221,29 @@ process.</p>
 </type>
 <desc>
 <p>
-Invoked when a transport connection has been established
-and a successful capabilities exchange has indicated that the peer
-supports the Diameter application of the application on which
-the callback module in question has been configured.</p>
+Invoked to signal the availability of a peer connection.
+In particular, capabilities exchange with the peer has indicated
+support for the application in question, the RFC 3539 watchdog state
+machine for the connection has reached state <c>OKAY</c> and Diameter
+messages can be both sent and received.</p>
+
+<note>
+<p>
+A watchdog state machine can reach state <c>OKAY</c> from state
+<c>SUSPECT</c> without a new capabilities exchange taking place.
+A new transport connection (and capabilities exchange) results in a
+new peer_ref().</p>
+</note>
+
+<note>
+<p>
+There is no requirement that a callback return before incoming
+requests are received: <seealso
+marker="#handle_request">handle_request/3</seealso> callbacks must be
+handled independently of <seealso
+marker="#peer_up">peer_up/3</seealso> and <seealso
+marker="#peer_down">peer_down/3</seealso>.</p>
+</note>
 
 <marker id="peer_down"/>
 </desc>
@@ -238,36 +259,42 @@ the callback module in question has been configured.</p>
 </type>
 <desc>
 <p>
-Invoked when a transport connection has been lost following a previous
-call to <seealso marker="#peer_up">peer_up/3</seealso>.</p>
+Invoked to signal that a peer connection is no longer available
+following a previous call to <seealso
+marker="#peer_up">peer_up/3</seealso>.
+In particular, that the RFC 3539 watchdog state machine for the
+connection has left state <c>OKAY</c> and the peer will no longer be a
+candidate in <seealso marker="#pick_peer">pick_peer()</seealso>
+callbacks.</p>
 
 <marker id="pick_peer"/>
 </desc>
 </func>
 
 <func>
-<name>Mod:pick_peer(Candidates, Reserved, SvcName, State)
-      -> {ok, Peer} | {Peer, NewState} | false</name>
+<name>Mod:pick_peer(Candidates, _Reserved, SvcName, State)
+      -> Selection | false</name>
 <fsummary>Select a target peer for an outgoing request.</fsummary>
 <type>
 <v>Candidates = [<seealso marker="#peer">peer()</seealso>]</v>
-<v>Peer = <seealso marker="#peer">peer()</seealso> | false</v>
 <v>SvcName = <seealso marker="diameter#service_name">diameter:service_name()</seealso></v>
 <v>State = NewState = <seealso marker="#state">state()</seealso></v>
+<v>Selection = {ok, Peer} | {Peer, NewState}</v>
+<v>Peer = <seealso marker="#peer">peer()</seealso> | false</v>
 </type>
 <desc>
 <p>
 Invoked as a consequence of a call to <seealso
 marker="diameter#call">diameter:call/4</seealso> to select a destination
-peer for an outgoing request, the return value indicating the selected
-peer.</p>
+peer for an outgoing request.
+The return value indicates the selected peer.</p>
 
 <p>
-The candidate peers list will only include those
-which are selected by any <c>filter</c> option specified in the call to
-<seealso marker="diameter#call">diameter:call/4</seealso>, and only
-those which have indicated support for the Diameter application in
-question.
+The candidate list contains only those peers that have advertised
+support for the Diameter application in question during capabilities
+exchange, that have not be excluded by a <c>filter</c> option in
+the call to <seealso marker="diameter#call">diameter:call/4</seealso>
+and whose watchdog state machine is in the <c>OKAY</c> state.
 The order of the elements is unspecified except that any
 peers whose Origin-Host and Origin-Realm matches that of the
 outgoing request (in the sense of a <c>{filter, {all, [host, realm]}}</c>
@@ -275,36 +302,40 @@ option to <seealso marker="diameter#call">diameter:call/4</seealso>)
 will be placed at the head of the list.</p>
 
 <p>
-The return values <c>false</c> and <c>{false, State}</c> are
-equivalent when callback state is mutable, as are
-<c>{ok, Peer}</c> and <c>{Peer, State}</c>.
-Returning a peer as <c>false</c> causes <c>{error, no_connection}</c>
-to be returned from <seealso marker="diameter#call">diameter:call/4</seealso>.
-Returning a <seealso marker="#peer">peer()</seealso> from an initial
-pick_peer/4 callback will result in a
-<seealso marker="#prepare_request">prepare_request/3</seealso> callback
-followed by either <seealso
-marker="#handle_answer">handle_answer/4</seealso>
+A callback that returns a peer() will be followed by a
+<seealso marker="#prepare_request">prepare_request/3</seealso>
+callback and, if the latter indicates that the request should be sent,
+by either <seealso marker="#handle_answer">handle_answer/4</seealso>
 or <seealso marker="#handle_error">handle_error/4</seealso> depending
 on whether or not an answer message is received from the peer.
-If transport with the peer is lost before this then a new <seealso
-marker="#pick_peer">pick_peer/4</seealso> callback takes place to
-select an alternate peer.</p>
-
-<p>
-Note that there is no guarantee that a <seealso
+If the transport becomes unavailable after <seealso
+marker="prepare_request">prepare_request/3</seealso> then a new <seealso
+marker="#pick_peer">pick_peer/4</seealso> callback may take place to
+failover to an alternate peer, after which <seealso
+marker="#prepare_retransmit">prepare_retransmit/3</seealso> takes the
+place of <seealso
+marker="prepare_request">prepare_request/3</seealso> in resending the
+request.
+There is no guarantee that a <seealso
 marker="#pick_peer">pick_peer/4</seealso> callback to select
-an alternate peer will be followed by any additional callbacks, only
-that the initial <seealso
-marker="#pick_peer">pick_peer/4</seealso> will be, since a
+an alternate peer will be followed by any additional callbacks since a
 retransmission to an alternate peer is abandoned if an answer is
 received from a previously selected peer.</p>
 
+<p>
+Returning <c>false</c> or <c>{false, NewState}</c> causes <c>{error,
+no_connection}</c> to be returned from <seealso
+marker="diameter#call">diameter:call/4</seealso>.</p>
+
+<p>
+The return values <c>false</c> and <c>{false, State}</c> (that is,
+<c>NewState = State</c>) are equivalent, as are <c>{ok, Peer}</c> and
+<c>{Peer, State}</c>.</p>
+
 <note>
 <p>
-<c>{Peer, NewState}</c> and its equivalents can only be returned if
-the Diameter application in question was
-configured with the <seealso
+The return value <c>{Peer, NewState}</c> is only allowed if
+the Diameter application in question was configured with the <seealso
 marker="diameter#application_opt">diameter:application_opt()</seealso>
 <c>{call_mutates_state, true}</c>.
 Otherwise, the <c>State</c> argument is always
@@ -325,33 +356,45 @@ or <seealso marker="#peer_down">peer_down/3</seealso> callback.</p>
 <v>Packet = <seealso marker="#packet">packet()</seealso></v>
 <v>SvcName = <seealso marker="diameter#service_name">diameter:service_name()</seealso></v>
 <v>Peer = <seealso marker="#peer">peer()</seealso></v>
-<v>Action = {send, <seealso marker="#packet">packet()</seealso> | <seealso marker="#message">message()</seealso>} | {discard, Reason} | discard</v>
+<v>Action = Send | Discard | {eval_packet, Action, PostF}</v>
+<v>Send = {send, <seealso marker="#packet">packet()</seealso>
+                 | <seealso marker="#message">message()</seealso>}</v>
+<v>Discard = {discard, Reason} | discard</v>
+<v>PostF =
+    <seealso marker="diameter#evaluable">diameter:evaluable()</seealso>}</v>
 </type>
 <desc>
 <p>
 Invoked to return a request for encoding and transport.
-Allows the sender to access the selected peer's capabilities
-in order to set (for example) <c>Destination-Host</c> and/or
-<c>Destination-Realm</c> in the outgoing request, although the
-callback need not be limited to this usage.
+Allows the sender to use the selected peer's capabilities
+to modify the outgoing request.
 Many implementations may simply want to return <c>{send, Packet}</c></p>
 
 <p>
-A returned <seealso marker="#packet">packet()</seealso> should set the request to be encoded in its
+A returned <seealso marker="#packet">packet()</seealso> should set the
+request to be encoded in its
 <c>msg</c> field and can set the <c>transport_data</c> field in order
-to pass information to the transport module.
+to pass information to the transport process.
 Extra arguments passed to <seealso
 marker="diameter#call">diameter:call/4</seealso> can be used to
-communicate transport data to the callback.
-A returned <seealso marker="#packet">packet()</seealso> can also set the <c>header</c> field to a
-<c>#diameter_header{}</c> record in order to specify values that should
-be preserved in the outgoing request, although this should typically
-not be necessary and allows the callback to set header values
-inappropriately.
+communicate transport (or any other) data to the callback.</p>
+
+<p>
+A returned <seealso marker="#packet">packet()</seealso> can set
+the <c>header</c> field to a
+<c>#diameter_header{}</c> in order to specify values that should
+be preserved in the outgoing request, values otherwise being those in
+the header record contained in <c>Packet</c>.
 A returned <c>length</c>, <c>cmd_code</c> or <c>application_id</c> is
 ignored.</p>
 
 <p>
+A returned <c>PostF</c> will be evaluated on any encoded
+<c>#diameter_packet{}</c> prior to transmission, the <c>bin</c> field
+containing the encoded binary.
+The return value is ignored.</p>
+
+<p>
 Returning <c>{discard, Reason}</c> causes the request to be aborted
 and the <seealso
 marker="diameter#call">diameter:call/4</seealso> for which the
@@ -364,13 +407,18 @@ discarded}</c>.</p>
 </func>
 
 <func>
-<name>Mod:prepare_retransmit(Packet, SvcName, Peer) -> Result</name>
+<name>Mod:prepare_retransmit(Packet, SvcName, Peer) -> Action</name>
 <fsummary>Return a request for encoding and retransmission.</fsummary>
 <type>
 <v>Packet  = <seealso marker="#packet">packet()</seealso></v>
 <v>SvcName = <seealso marker="diameter#service_name">diameter:service_name()</seealso></v>
-<v>Peer    = <seealso marker="#peer">peer()</seealso></v>
-<v>Result  = {send, <seealso marker="#packet">packet()</seealso> | <seealso marker="#message">message()</seealso>} | {discard, Reason} | discard</v>
+<v>Peer = <seealso marker="#peer">peer()</seealso></v>
+<v>Action = Send | Discard | {eval_packet, Action, PostF}</v>
+<v>Send = {send, <seealso marker="#packet">packet()</seealso>
+                | <seealso marker="#message">message()</seealso>}</v>
+<v>Discard = {discard, Reason} | discard</v>
+<v>PostF =
+    <seealso marker="diameter#evaluable">diameter:evaluable()</seealso>}</v>
 </type>
 <desc>
 <p>
@@ -378,8 +426,9 @@ Invoked to return a request for encoding and retransmission.
 Has the same role as <seealso
 marker="#prepare_request">prepare_request/3</seealso> in the case that
 a peer connection is lost an an alternate peer selected but the
-argument <seealso marker="#packet">packet()</seealso> is as returned by the initial
-<c>prepare_request/3</c>.</p>
+argument <seealso marker="#packet">packet()</seealso> is as returned
+by the initial <seealso
+marker="#prepare_request">prepare_request/3</seealso>.</p>
 
 <p>
 Returning <c>{discard, Reason}</c> causes the request to be aborted
@@ -406,40 +455,41 @@ discarded}</c>.</p>
 <desc>
 <p>
 Invoked when an answer message is received from a peer.
-The return value is returned from the call to <seealso
-marker="diameter#call">diameter:call/4</seealso> for which the
-callback takes place unless the <c>detach</c> option was
-specified.</p>
+The return value is returned from <seealso
+marker="diameter#call">diameter:call/4</seealso> unless the
+<c>detach</c> option was specified.</p>
 
 <p>
-The decoded answer record is in the <c>msg</c> field of the argument
-<seealso marker="#packet">packet()</seealso>,
-the undecoded binary in the <c>packet</c> field.
+The decoded answer record and undecoded binary are in the <c>msg</c>
+and <c>bin</c> fields of the argument
+<seealso marker="#packet">packet()</seealso> respectively.
 <c>Request</c> is the outgoing request message as was returned from
 <seealso marker="#prepare_request">prepare_request/3</seealso> or
-<seealso marker="#prepare_retransmit">prepare_retransmit/3</seealso>
-before the request was passed to the transport.</p>
+<seealso
+    marker="#prepare_retransmit">prepare_retransmit/3</seealso>.</p>
 
 <p>
 For any given call to <seealso
 marker="diameter#call">diameter:call/4</seealso> there is at most one
-call to the handle_answer callback of the application in question: any
+<seealso marker="#handle_answer">handle_answer/4</seealso> callback: any
 duplicate answer (due to retransmission or otherwise) is discarded.
-Similarly, only one of <c>handle_answer/4</c> or <c>handle_error/4</c> is
-called for any given request.</p>
+Similarly, only one of <seealso
+marker="#handle_answer">handle_answer/4</seealso> or
+<seealso marker="#handle_error">handle_error/4</seealso> is 
+called.</p>
 
 <p>
 By default, an incoming answer message that cannot be successfully
-decoded causes the request process in question to fail, causing the
-relevant call to <seealso
-marker="diameter#call">diameter:call/4</seealso>
-to return <c>{error, failure} (unless the <c>detach</c> option was
-specified)</c>.
-In particular, there is no <c>handle_error/4</c> callback in this
+decoded causes the request process to fail, causing
+<seealso marker="diameter#call">diameter:call/4</seealso>
+to return <c>{error, failure}</c> unless the <c>detach</c> option was
+specified.
+In particular, there is no <seealso
+marker="#handle_error">handle_error/4</seealso> callback in this
 case.
-Application configuration may change this behaviour as described for
-<seealso
-marker="diameter#start_service">diameter:start_service/2</seealso>.</p>
+The <seealso
+marker="diameter#application_opt">diameter:application_opt()</seealso>
+<c>answer_errors</c> can be set to change this behaviour.</p>
 
 <marker id="handle_error"/>
 </desc>
@@ -457,21 +507,20 @@ marker="diameter#start_service">diameter:start_service/2</seealso>.</p>
 </type>
 <desc>
 <p>
-Invoked when an error occurs before an answer message is received from
-a peer in response to an outgoing request.
-The return value is returned from the call to <seealso
-marker="diameter#call">diameter:call/4</seealso> for which the
-callback takes place (unless the <c>detach</c> option was
-specified).</p>
+Invoked when an error occurs before an answer message is received
+in response to an outgoing request.
+The return value is returned from <seealso
+marker="diameter#call">diameter:call/4</seealso> unless the
+<c>detach</c> option was specified.</p>
 
 <p>
 Reason <c>timeout</c> indicates that an answer message has not been
-received within the required time.
+received within the time specified with the corresponding <seealso
+marker="diameter#call_opt">diameter:call_opt()</seealso>.
 Reason <c>failover</c> indicates
 that the transport connection to the peer to which the request has
-been sent has been lost but that not alternate node was available,
-possibly because a <seealso marker="#pick_peer">pick_peer/4</seealso>
-callback returned false.</p>
+been sent has become unavailable and that not alternate peer was
+not selected.</p>
 
 <marker id="handle_request"/>
 </desc>
@@ -484,7 +533,10 @@ callback returned false.</p>
 <v>Packet  = <seealso marker="#packet">packet()</seealso></v>
 <v>SvcName = term()</v>
 <v>Peer    = <seealso marker="#peer">peer()</seealso></v>
-<v>Action  = Reply | {relay, [Opt]} | discard | {eval, Action, PostF}</v>
+<v>Action  = Reply
+           | {relay, [Opt]}
+           | discard
+           | {eval|eval_packet, Action, PostF}</v>
 <v>Reply   = {reply, <seealso marker="#message">message()</seealso>}
            | {protocol_error, 3000..3999}</v>
 <v>Opt     = <seealso marker="diameter#call_opt">diameter:call_opt()</seealso></v>
@@ -603,14 +655,25 @@ causes the request to be answered with 3002 (DIAMETER_UNABLE_TO_DELIVER).</p>
 <tag><c>discard</c></tag>
 <item>
 <p>
-Discard the request.</p>
+Discard the request.
+No answer message is sent to the peer.</p>
 </item>
 
 <tag><c>{eval, Action, PostF}</c></tag>
 <item>
 <p>
 Handle the request as if <c>Action</c> has been returned and then
-evaluate <c>PostF</c> in the request process.</p>
+evaluate <c>PostF</c> in the request process.
+The return value is ignored.</p>
+</item>
+
+<tag><c>{eval_packet, Action, PostF}</c></tag>
+<item>
+<p>
+Like <c>eval</c> but evaluate <c>PostF</c> on any encoded
+<c>#diameter_packet{}</c> prior to transmission, the <c>bin</c> field
+containing the encoded binary.
+The return value is ignored.</p>
 </item>
 
 </taglist>
diff --git a/lib/diameter/src/base/diameter_service.erl b/lib/diameter/src/base/diameter_service.erl
index 725cccda1e..01c50a8e30 100644
--- a/lib/diameter/src/base/diameter_service.erl
+++ b/lib/diameter/src/base/diameter_service.erl
@@ -1301,28 +1301,34 @@ cm([_,_|_], _, _, _) ->
 %% The mod field of the #diameter_app{} here includes any extra
 %% arguments passed to diameter:call/2.
 
-send_request({TPid, Caps, App}, Msg, Opts, Caller, SvcName) ->
+send_request({TPid, Caps, App} = T, Msg, Opts, Caller, SvcName) ->
     #diameter_app{module = ModX}
         = App,
 
     Pkt = make_request_packet(Msg),
 
-    case cb(ModX, prepare_request, [Pkt, SvcName, {TPid, Caps}]) of
-        {send, P} ->
-            send_request(make_request_packet(P, Pkt),
-                         TPid,
-                         Caps,
-                         App,
-                         Opts,
-                         Caller,
-                         SvcName);
-        {discard, Reason} ->
-            {error, Reason};
-        discard ->
-            {error, discarded};
-        T ->
-            ?ERROR({invalid_return, prepare_request, App, T})
-    end.
+    send_req(cb(ModX, prepare_request, [Pkt, SvcName, {TPid, Caps}]),
+             Pkt,
+             T,
+             Opts,
+             Caller,
+             SvcName,
+             []).
+
+send_req({send, P}, Pkt, T, Opts, Caller, SvcName, Fs) ->
+    send_request(make_request_packet(P, Pkt), T, Opts, Caller, SvcName, Fs);
+
+send_req({discard, Reason} , _, _, _, _, _, _) ->
+    {error, Reason};
+
+send_req(discard, _, _, _, _, _, _) ->
+    {error, discarded};
+
+send_req({eval_packet, RC, F}, Pkt, T, Opts, Caller, SvcName, Fs) ->
+    send_req(RC, Pkt, T, Opts, Caller, SvcName, [F|Fs]);
+
+send_req(E, _, {_, _, App}, _, _, _, _) ->
+    ?ERROR({invalid_return, prepare_request, App, E}).
 
 %% make_request_packet/1
 %%
@@ -1400,16 +1406,16 @@ fold_record(undefined, R) ->
 fold_record(Rec, R) ->
     diameter_lib:fold_tuple(2, Rec, R).
 
-%% send_request/7
+%% send_request/6
 
-send_request(Pkt, TPid, Caps, App, Opts, Caller, SvcName) ->
+send_request(Pkt, {TPid, Caps, App}, Opts, Caller, SvcName, Fs) ->
     #diameter_app{alias = Alias,
                   dictionary = Dict,
                   module = ModX,
                   options = [{answer_errors, AE} | _]}
         = App,
 
-    EPkt = encode(Dict, Pkt),
+    EPkt = encode(Dict, Pkt, Fs),
 
     #options{filter = Filter,
              timeout = Timeout}
@@ -1490,6 +1496,13 @@ msg(#diameter_packet{msg = undefined, bin = Bin}) ->
 msg(#diameter_packet{msg = Msg}) ->
     Msg.
 
+%% encode/3
+
+encode(Dict, Pkt, Fs) ->
+    P = encode(Dict, Pkt),
+    eval_packet(P, Fs),
+    P.
+
 %% encode/2
 
 %% Note that prepare_request can return a diameter_packet containing
@@ -1571,38 +1584,47 @@ send(Pid, Pkt) ->
 
 %% retransmit/4
 
-retransmit({TPid, Caps, #diameter_app{alias = Alias} = App},
-           #request{app = Alias,
-                    packet = Pkt}
+retransmit({TPid, Caps, #diameter_app{alias = Alias} = App} = T,
+           #request{app = Alias, packet = Pkt}
            = Req,
            SvcName,
            Timeout) ->
     have_request(Pkt, TPid)      %% Don't failover to a peer we've
         andalso ?THROW(timeout), %% already sent to.
 
-    case cb(App, prepare_retransmit, [Pkt, SvcName, {TPid, Caps}]) of
-        {send, P} ->
-            retransmit(make_request_packet(P, Pkt), TPid, Caps, Req, Timeout);
-        {discard, Reason} ->
-            ?THROW(Reason);
-        discard ->
-            ?THROW(discarded);
-        T ->
-            ?ERROR({invalid_return, prepare_retransmit, App, T})
-    end.
+    resend_req(cb(App, prepare_retransmit, [Pkt, SvcName, {TPid, Caps}]),
+               T,
+               Req,
+               Timeout,
+               []).
 
-%% retransmit/5
+resend_req({send, P}, T, #request{packet = Pkt} = Req, Timeout, Fs) ->
+    retransmit(make_request_packet(P, Pkt), T, Req, Timeout, Fs);
 
-retransmit(Pkt, TPid, Caps, #request{dictionary = Dict} = Req, Timeout) ->
-    EPkt = encode(Dict, Pkt),
+resend_req({discard, Reason}, _, _, _, _) ->
+    ?THROW(Reason);
 
-    NewReq = Req#request{transport = TPid,
-                         packet = Pkt,
-                         caps = Caps},
+resend_req(discard, _, _, _, _) ->
+    ?THROW(discarded);
 
-    ?LOG(retransmission, NewReq),
-    TRef = send_request(TPid, EPkt, NewReq, Timeout),
-    {TRef, NewReq}.
+resend_req({eval_packet, RC, F}, T, Req, Timeout, Fs) ->
+    resend_req(RC, T, Req, Timeout, [F|Fs]);
+    
+resend_req(T, {_, _, App}, _, _, _) ->
+    ?ERROR({invalid_return, prepare_retransmit, App, T}).
+
+%% retransmit/6
+
+retransmit(Pkt, {TPid, Caps, _}, #request{dictionary = D} = Req0, Tmo, Fs) ->
+    EPkt = encode(D, Pkt, Fs),
+
+    Req = Req0#request{transport = TPid,
+                       packet = Pkt,
+                       caps = Caps},
+
+    ?LOG(retransmission, Req),
+    TRef = send_request(TPid, EPkt, Req, Tmo),
+    {TRef, Req}.
 
 %% store_request/4
 
@@ -1805,7 +1827,12 @@ recv_request(T, TC, App, Pkt) ->
 %% (3xxx) errors that lead to an answer-message.
 
 request_cb({SvcName, _OH, _OR} = T, TC, App, Pkt) ->
-    request_cb(cb(App, handle_request, [Pkt, SvcName, TC]), App, T, TC, Pkt).
+    request_cb(cb(App, handle_request, [Pkt, SvcName, TC]),
+               App,
+               T,
+               TC,
+               [],
+               Pkt).
 
 %% examine/1
 %%
@@ -1825,7 +1852,7 @@ examine(#diameter_packet{errors = Es} = Pkt) ->
     Pkt#diameter_packet{errors = [5011 | Es]}.
 %% It's odd/unfortunate that this isn't a protocol error.
 
-%% request_cb/5
+%% request_cb/6
 
 %% A reply may be an answer-message, constructed either here or by
 %% the handle_request callback. The header from the incoming request
@@ -1836,20 +1863,21 @@ request_cb({reply, Ans},
            #diameter_app{dictionary = Dict},
            _,
            {TPid, _},
+           Fs,
            Pkt) ->
-    reply(Ans, Dict, TPid, Pkt);
+    reply(Ans, Dict, TPid, Fs, Pkt);
 
 %% An 3xxx result code, for which the E-bit is set in the header.
-request_cb({protocol_error, RC}, _, T, {TPid, _}, Pkt)
+request_cb({protocol_error, RC}, _, T, {TPid, _}, Fs, Pkt)
   when 3000 =< RC, RC < 4000 ->
-    protocol_error(RC, T, TPid, Pkt);
+    protocol_error(RC, T, TPid, Fs, Pkt);
 
 %% RFC 3588 says we must reply 3001 to anything unrecognized or
 %% unsupported. 'noreply' is undocumented (and inappropriately named)
 %% backwards compatibility for this, protocol_error the documented
 %% alternative.
-request_cb(noreply, _, T, {TPid, _}, Pkt) ->
-    protocol_error(3001, T, TPid, Pkt);
+request_cb(noreply, _, T, {TPid, _}, Fs, Pkt) ->
+    protocol_error(3001, T, TPid, Fs, Pkt);
 
 %% Relay a request to another peer. This is equivalent to doing an
 %% explicit call/4 with the message in question except that (1) a loop
@@ -1871,26 +1899,36 @@ request_cb({A, Opts},
            = App,
            T,
            TC,
+           Fs,
            Pkt)
   when A == relay, Id == ?APP_ID_RELAY;
        A == proxy, Id /= ?APP_ID_RELAY;
        A == resend ->
-    resend(Opts, App, T, TC, Pkt);
+    resend(Opts, App, T, TC, Fs, Pkt);
 
-request_cb(discard, _, _, _, _) ->
+request_cb(discard, _, _, _, _, _) ->
     ok;
 
-request_cb({eval, RC, F}, App, T, TC, Pkt) ->
-    request_cb(RC, App, T, TC, Pkt),
+request_cb({eval_packet, RC, F}, App, T, TC, Fs, Pkt) ->
+    request_cb(RC, App, T, TC, [F|Fs], Pkt);
+
+request_cb({eval, RC, F}, App, T, TC, Fs, Pkt) ->
+    request_cb(RC, App, T, TC, Pkt, Fs),
     diameter_lib:eval(F).
 
-%% protocol_error/4
+%% protocol_error/5
 
-protocol_error(RC, {_, OH, OR}, TPid, #diameter_packet{avps = Avps} = Pkt) ->
+protocol_error(RC, {_, OH, OR}, TPid, Fs, Pkt) ->
+    #diameter_packet{avps = Avps} = Pkt,
     ?LOG({error, RC}, Pkt),
-    reply(answer_message({OH, OR, RC}, Avps), ?BASE, TPid, Pkt).
+    reply(answer_message({OH, OR, RC}, Avps), ?BASE, TPid, Fs, Pkt).
+
+%% protocol_error/4
 
-%% resend/5
+protocol_error(RC, T, TPid, Pkt) ->
+    protocol_error(RC, T, TPid, [], Pkt).
+
+%% resend/6
 %%
 %% Resend a message as a relay or proxy agent.
 
@@ -1898,9 +1936,12 @@ resend(Opts,
        #diameter_app{} = App,
        {_SvcName, OH, _OR} = T,
        {_TPid, _Caps} = TC,
+       Fs,
        #diameter_packet{avps = Avps} = Pkt) ->
     {Code, _Flags, Vid} = ?BASE:avp_header('Route-Record'),
-    resend(is_loop(Code, Vid, OH, Avps), Opts, App, T, TC, Pkt).
+    resend(is_loop(Code, Vid, OH, Avps), Opts, App, T, TC, Fs, Pkt).
+
+%% resend/7
 
 %%   DIAMETER_LOOP_DETECTED             3005
 %%      An agent detected a loop while trying to get the message to the
@@ -1908,8 +1949,8 @@ resend(Opts,
 %%      if one is available, but the peer reporting the error has
 %%      identified a configuration problem.
 
-resend(true, _, _, T, {TPid, _}, Pkt) ->  %% Route-Record loop
-    protocol_error(3005, T, TPid, Pkt);
+resend(true, _, _, T, {TPid, _}, Fs, Pkt) ->  %% Route-Record loop
+    protocol_error(3005, T, TPid, Fs, Pkt);
 
 %% 6.1.8.  Relaying and Proxying Requests
 %%
@@ -1922,6 +1963,7 @@ resend(false,
        App,
        {SvcName, _, _} = T,
        {TPid, #diameter_caps{origin_host = {_, OH}}},
+       Fs,
        #diameter_packet{header = Hdr0,
                         avps = Avps}
        = Pkt) ->
@@ -1929,7 +1971,7 @@ resend(false,
     Seq = diameter_session:sequence(),
     Hdr = Hdr0#diameter_header{hop_by_hop_id = Seq},
     Msg = [Hdr, Route | Avps],
-    resend(call(SvcName, App, Msg, Opts), T, TPid, Pkt).
+    resend(call(SvcName, App, Msg, Opts), T, TPid, Fs, Pkt).
 %% The incoming request is relayed with the addition of a
 %% Route-Record. Note the requirement on the return from call/4 below,
 %% which places a requirement on the value returned by the
@@ -1955,15 +1997,18 @@ resend(#diameter_packet{bin = B}
        = Pkt,
        _,
        TPid,
+       Fs,
        #diameter_packet{header = #diameter_header{hop_by_hop_id = Id},
                         transport_data = TD}) ->
-    send(TPid, Pkt#diameter_packet{bin = diameter_codec:hop_by_hop_id(Id, B),
-                                   transport_data = TD});
+    P = Pkt#diameter_packet{bin = diameter_codec:hop_by_hop_id(Id, B),
+                                   transport_data = TD},
+    eval_packet(P, Fs),
+    send(TPid, P);
 %% TODO: counters
 
 %% Or not: DIAMETER_UNABLE_TO_DELIVER.
-resend(_, T, TPid, Pkt) ->
-    protocol_error(3002, T, TPid, Pkt).
+resend(_, T, TPid, Fs, Pkt) ->
+    protocol_error(3002, T, TPid, Fs, Pkt).
 
 %% is_loop/4
 %%
@@ -1985,33 +2030,38 @@ is_loop(Code, Vid, OH, [_ | Avps])
 is_loop(Code, Vid, OH, Avps) ->
     is_loop(Code, Vid, ?BASE:avp(encode, OH, 'Route-Record'), Avps).
 
-%% reply/4
+%% reply/5
 %%
 %% Send a locally originating reply.
 
 %% Skip the setting of Result-Code and Failed-AVP's below.
-reply([Msg], Dict, TPid, Pkt)
+reply([Msg], Dict, TPid, Fs, Pkt)
   when is_list(Msg);
        is_tuple(Msg) ->
-    reply(Msg, Dict, TPid, Pkt#diameter_packet{errors = []});
+    reply(Msg, Dict, TPid, Fs, Pkt#diameter_packet{errors = []});
 
 %% No errors or a diameter_header/avp list.
-reply(Msg, Dict, TPid, #diameter_packet{errors = Es,
-                                        transport_data = TD}
-                       = ReqPkt)
+reply(Msg, Dict, TPid, Fs, #diameter_packet{errors = Es,
+                                            transport_data = TD}
+                           = ReqPkt)
   when [] == Es;
        is_record(hd(Msg), diameter_header) ->
     Pkt = diameter_codec:encode(Dict, make_answer_packet(Msg, ReqPkt)),
+    eval_packet(Pkt, Fs),
     incr(send, Pkt, Dict, TPid),  %% count result codes in sent answers
     send(TPid, Pkt#diameter_packet{transport_data = TD});
 
 %% Or not: set Result-Code and Failed-AVP AVP's.
-reply(Msg, Dict, TPid, #diameter_packet{errors = [H|_] = Es} = Pkt) ->
+reply(Msg, Dict, TPid, Fs, #diameter_packet{errors = [H|_] = Es} = Pkt) ->
     reply(rc(Msg, rc(H), [A || {_,A} <- Es], Dict),
           Dict,
           TPid,
+          Fs,
           Pkt#diameter_packet{errors = []}).
 
+eval_packet(Pkt, Fs) ->
+    lists:foreach(fun(F) -> diameter_lib:eval([F,Pkt]) end, Fs).
+    
 %% make_answer_packet/2
 
 %% Binaries and header/avp lists are sent as-is.
diff --git a/lib/diameter/test/diameter_traffic_SUITE.erl b/lib/diameter/test/diameter_traffic_SUITE.erl
index 669918f757..dd07679764 100644
--- a/lib/diameter/test/diameter_traffic_SUITE.erl
+++ b/lib/diameter/test/diameter_traffic_SUITE.erl
@@ -624,7 +624,10 @@ prepare_request(Pkt, ?CLIENT, {_Ref, Caps}, Name) ->
     {send, prepare(Pkt, Caps, Name)}.
 
 prepare_request(Pkt, ?CLIENT, {_Ref, Caps}, send_detach, _) ->
-    {send, prepare(Pkt, Caps)}.
+    {eval_packet, {send, prepare(Pkt, Caps)}, [fun log/2, detach]}.
+
+log(#diameter_packet{} = P, T) ->
+    io:format("~p: ~p~n", [T,P]).
 
 prepare(Pkt, Caps, send_unsupported) ->
     Req = prepare(Pkt, Caps),
@@ -738,7 +741,7 @@ handle_request(#diameter_packet{msg = M}, ?SERVER, {_Ref, Caps}) ->
 
 request(#diameter_base_accounting_ACR{'Accounting-Record-Number' = 0},
         _) ->
-    {protocol_error, ?INVALID_AVP_BITS};
+    {eval_packet, {protocol_error, ?INVALID_AVP_BITS}, [fun log/2, invalid]};
 
 request(#diameter_base_accounting_ACR{'Session-Id' = SId,
                                       'Accounting-Record-Type' = RT,