anchor.diff:  
   %% Receive packets until a full message is received, then check
   %% whether to keep receiving.
  -recv(Bin, #transport{parent = Pid, frag = Head, throttled = false} = S) ->
  +recv(Bin, #transport{frag = Head, throttled = false} = S) ->
       case rcv(Head, Bin) of
           {Msg, B} ->
  -            diameter_peer:recv(Pid, Msg),
  -            throttle(S#transport{frag = B});
  +            throttle(S#transport{frag = B, throttled = Msg});
           Frag ->
               setopts(S),
               start_fragment_timer(S#transport{frag = Frag,
                                                flush = false})
       end.
  +
  +%% recv/1
  +
  +recv(S) ->
  +    recv(<<>>, S).
   
   %% rcv/2
   
  
positive.code:     false = T,  %% assert
      recv(Bin, S);
  
  %% Check whether or not to read more after a throttle_cb timeout.
  transition(throttle, #transport{throttled = B} = S) ->
      true = B,  %% assert
      throttle(S);
  
  %% Capabilties exchange has decided on whether or not to run over TLS.
  
negative.code: 
  %% throttle/1
  
  throttle(#transport{throttled = false} = S) ->
      recv(S);
  
  throttle(#transport{throttle_cb = F, throttled = B} = S) ->
      throttle(cb(F, B), S).
  
  %% cb/2
  
  cb(false, _) ->
      ok;
  
  cb(F, B) ->
      diameter_lib:eval([F, true /= B andalso B]).
  
  %% throttle/2
  
  %% Callback says to receive another message.
  throttle(ok, #transport{throttled = true} = S) ->
      recv(S#transport{throttled = false});
  
  %% Callback says to accept a received message.
  throttle(ok, #transport{parent = Pid, throttled = Msg} = S) ->
      diameter_peer:recv(Pid, Msg),
      throttle(S#transport{throttled = true});
  
  throttle({ok = T, F}, S) ->
      throttle(T, S#transport{throttle_cb = F});
  
  %% Callback says to ask again in the specified number of milliseconds.
  throttle({timeout, Tmo}, #transport{} = S) ->
      erlang:send_after(Tmo, self(), throttle),
      S;
  
  throttle({timeout = T, Tmo, F}, S) ->
      throttle({T, Tmo}, S#transport{throttle_cb = F});
  