anchor.diff:  
   %% throttle/1
   
  -throttle(#transport{throttle_cb = false} = S) ->
  -    recv(<<>>, S);
  -
  -throttle(#transport{throttle_cb = F} = S) ->
  -    throttle(diameter_lib:eval(F), S).
  +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
   
  -%% Don't ask for more packets as long as there are previously received
  -%% messages to extract.
  -throttle(ok, S) ->
  -    recv(<<>>, S#transport{throttled = false});
  +%% 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});
   
  -%% Ask again after the specified number of milliseconds.
  +%% Callback says to ask again in the specified number of milliseconds.
   throttle({timeout, Tmo}, #transport{} = S) ->
       erlang:send_after(Tmo, self(), throttle),
  -    S#transport{throttled = true};
  +    S;
   
   throttle({timeout = T, Tmo, F}, S) ->
       throttle({T, Tmo}, S#transport{throttle_cb = F});
  
positive.code:                         socket = Sock,
                          ssl = SslOpts,
                          timeout = Tmo,
                          throttle_cb = Throttle});
  %% Put the reference in the process dictionary since we now use it
  %% advertise the ssl socket after TLS upgrade.
  
  
negative.code: 
  %% Receive packets until a full message is received, then check
  %% whether to keep receiving.
  recv(Bin, #transport{frag = Head, throttled = false} = S) ->
      case rcv(Head, Bin) of
          {Msg, 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
  
  