anchor.diff:      %% Since accept/connect might block indefinitely, spawn a process
       %% that kills us with the parent until call returns, and then
       %% sends outgoing messages.
  -    {ok, MPid} = diameter_tcp_sup:start_child(#monitor{parent = Pid}),
       {[SO|TO], Rest} = proplists:split(Opts, [ssl_options,
  -                                             fragment_timer,
  -                                             throttle_cb]),
  +                                             fragment_timer]),
       SslOpts = ssl_opts(SO),
       OwnOpts = lists:append(TO),
       Tmo = proplists:get_value(fragment_timer,
                                 OwnOpts,
                                 ?DEFAULT_FRAGMENT_TIMEOUT),
       ?IS_TIMEOUT(Tmo) orelse ?ERROR({fragment_timer, Tmo}),
  -    Throttle = proplists:get_value(throttle_cb, OwnOpts, false),
  +    {ok, MPid} = diameter_tcp_sup:start_child(#monitor{parent = Pid}),
       Sock = init(T, Ref, Mod, Pid, SslOpts, Rest, Addrs, SPid),
       M = if SslOpts -> ssl; true -> Mod end,
       monitor(process, MPid),
       MPid ! {start, self(), Sock, M}, %% prepare monitor for sending
       putr(?REF_KEY, Ref),
  -    throttle(#transport{parent = Pid,
  -                        module = M,
  -                        socket = Sock,
  -                        ssl = SslOpts,
  -                        timeout = Tmo,
  -                        throttle_cb = Throttle,
  -                        throttled = false /= Throttle, 
  -                        monitor = MPid});
  +    setopts(#transport{parent = Pid,
  +                       module = M,
  +                       socket = Sock,
  +                       ssl = SslOpts,
  +                       timeout = Tmo,
  +                       monitor = MPid});
   %% Put the reference in the process dictionary since we now use it
   %% advertise the ssl socket after TLS upgrade.
   
  
positive.code: %% also eventually lead to watchdog failover.
  
  %% No fragment to flush or not receiving messages.
  flush(#transport{frag = Frag, throttled = B} = S)
    when Frag == <<>>;
         B /= false ->
      S;
  
  %% Messages have been received since last timer expiry.
  
negative.code: %% using Nagle.
  
  %% Receive packets until a full message is received,
  recv(Bin, #transport{parent = Pid, frag = Head} = S) ->
      case rcv(Head, Bin) of
          {Msg, B} ->         %% have a complete message ...
              diameter_peer:recv(Pid, Msg),
              recv(<<>>, S#transport{frag = B});
          Frag ->             %% read more on the socket
              start_fragment_timer(setopts(S#transport{frag = Frag,
                                                       flush = false}))
      end.
  
  %% rcv/2
  
  