anchor.diff:  %% the accumulated values for the ref and associated peer pids.
   
   info_transport(S) ->
  -    PeerD = peer_dict(S),
  +    PeerD = peer_dict(S, config_dict(S)),
       RefsD = dict:map(fun(_, Ls) -> [P || L <- Ls, {peer, {P,_}} <- L] end,
                        PeerD),
       Refs = lists:append(dict:fold(fun(R, Ps, A) -> [[R|Ps] | A] end,
  
positive.code:               [],
                PeerD).
  
  transport([[{type, connect} | _] = L]) ->
      L;
  
  transport([[{type, accept}, {options, Opts} | _] | _] = Ls) ->
      [{type, listen},
       {options, Opts},
       {accept, [lists:nthtail(2,L) || L <- Ls]}].
  %% Note that all peer records for a listening transport (ie. same Ref)
  %% have the same options. (TODO)
  
  peer_dict(#state{peerT = PeerT, connT = ConnT}) ->
      ets:foldl(fun(T,A) -> peer_acc(ConnT, A, T) end, dict:new(), PeerT).
  
  peer_acc(ConnT, Acc, #peer{pid = Pid,
                             type = Type,
  
negative.code: info_conn(_, _, _) ->
      [].
  
  %% The point of extracting the config here is so that 'transport' info
  %% has one entry for each transport ref, the peer table only
  %% containing entries that have a living watchdog.
  
  config_dict(#state{service_name = SvcName}) ->
      lists:foldl(fun config_acc/2,
                  dict:new(),
                  diameter_config:lookup(SvcName)).
  
  config_acc({Ref, T, Opts}, Dict)
    when T == listen;
         T == connect ->
      dict:store(Ref, [[{type, T}, {options, Opts}]], Dict);
  config_acc(_, Dict) ->
      Dict.
  
  wd_state({_,S}) ->
      S;
  wd_state(?STATE_UP) ->
  