anchor.diff:  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) ->
  
positive.code: %% the accumulated values for the ref and associated peer pids.
  
  info_transport(S) ->
      PeerD = peer_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,
  
negative.code:               [],
                PeerD).
  
  %% Only a config entry for a listening transport: use it.
  transport([[{type, listen}, _] = L]) ->
      L ++ [{accept, []}];
  
  %% Only one config or peer entry for a connecting transport: use it.
  transport([[{type, connect} | _] = L]) ->
      L;
  
  %% Peer entries: discard config. Note that the peer entries have
  %% length at least 3.
  transport([[_,_] | L]) ->
      transport(L);
  
  %% Possibly many peer entries for a listening transport. Note that all
  %% have the same options by construction, which is not terribly space
  %% efficient. (TODO: all entries for the same Ref should share options.)
  transport([[{type, accept}, {options, Opts} | _] | _] = Ls) ->
      [{type, listen},
       {options, Opts},
       {accept, [lists:nthtail(2,L) || L <- Ls]}].
  
  peer_dict(#state{peerT = PeerT, connT = ConnT}, Dict0) ->
      ets:foldl(fun(T,A) -> peer_acc(ConnT, A, T) end, Dict0, PeerT).
  
  peer_acc(ConnT, Acc, #peer{pid = Pid,
                             type = Type,
  