anchor.diff:  
       send_req(cb(ModX, prepare_request, [Pkt, SvcName, {TPid, Caps}]),
                Pkt,
  -             T,
  +             Transport,
                Opts,
                Caller,
                SvcName,
                []).
   
  -send_req({send, P}, Pkt, T, Opts, Caller, SvcName, Fs) ->
  -    send_req(make_request_packet(P, Pkt), T, Opts, Caller, SvcName, Fs);
  +send_req({send, Msg}, Pkt, Transport, Opts, Caller, SvcName, Fs) ->
  +    send_req(make_request_packet(Msg, Pkt),
  +             Transport,
  +             Opts,
  +             Caller,
  +             SvcName,
  +             Fs);
   
   send_req({discard, Reason} , _, _, _, _, _, _) ->
       {error, Reason};
  
positive.code: encode(_, #diameter_packet{} = Pkt) ->
      Pkt.
  
  %% send_request/4
  
  send_request(TPid, #diameter_packet{bin = Bin} = Pkt, Req, Timeout)
    when node() == node(TPid) ->
      %% Store the outgoing request before sending to avoid a race with
      %% reply reception.
      TRef = store_request(TPid, Bin, Req, Timeout),
      send(TPid, Pkt),
      TRef;
  
  %% Send using a remote transport: spawn a process on the remote node
  %% to relay the answer.
  send_request(TPid, #diameter_packet{} = Pkt, Req, Timeout) ->
      TRef = erlang:start_timer(Timeout, self(), timeout),
      T = {TPid, Pkt, Req, Timeout, TRef},
      spawn(node(TPid), ?MODULE, send, [T]),
      TRef.
  
  %% send/1
  
  send({TPid, Pkt, #request{handler = Pid} = Req, Timeout, TRef}) ->
      Ref = send_request(TPid, Pkt, Req#request{handler = self()}, Timeout),
      Pid ! reref(receive T -> T end, Ref, TRef).
  
  reref({T, Ref, R}, Ref, TRef) ->
  
negative.code:     exit(T).
  
  %% ---------------------------------------------------------------------------
  %% # failover/1-2
  %% ---------------------------------------------------------------------------
  
  %% Failover as a consequence of request_peer_down/1: inform the
  %% request process.
  failover({_, Req, TRef}) ->
      #request{handler = Pid,
               packet = #diameter_packet{msg = M}}
          = Req,
      M /= undefined andalso (Pid ! {failover, TRef}).
  %% Failover is not performed when msg = binary() since sending
  %% pre-encoded binaries is only partially supported. (Mostly for
  %% test.)
  
  %% Failover as a consequence of store_request/4.
  failover(TRef, Seqs)
    when is_reference(TRef) ->
      case lookup_request(Seqs, TRef) of
          #request{} = Req ->
              failover({Seqs, Req, TRef});
          false ->
              ok
      end.
  
  %% ---------------------------------------------------------------------------
  %% # report_status/5
  