anchor.diff:  start_link(AppId, Transp) -> 
       gen_server:start_link(?MODULE, [AppId, Transp], []).
   
  +
  +-record(conn, {
  +    dest :: {inet:ip_address(), inet:port_number()},
  +    timeout_ref :: reference(),
  +    refresh_ref :: reference(),
  +    time :: pos_integer(),
  +    stun :: {inet:ip_address(), inet:port_number()}
  +}).
  +
  +-record(stun, {
  +    dest :: {inet:ip_address(), inet:port_number()},
  +    id :: binary(),
  +    packet :: binary(),
  +    retrans_ref :: reference(),
  +    next_retrans :: integer(),
  +    from :: {srv, from()} | {conn, {inet:ip_address(), inet:port_number()}}
  +}).
   
   -record(state, {
       app_id :: nksip:app_id(),
       transport :: nksip_transport:transport(),
       socket :: port(),
       tcp_pid :: pid(),
  -    stuns :: [{Id::binary(), Time::nksip_lib:timestamp(), term()}],
  -    conns :: [{Ref::reference(), Ip::inet:ip_address(), Port::inet:port_number()}]
  +    stuns :: [#stun{}],
  +    conns :: [#conn{}],
  +    timer_t1 :: pos_integer()
   }).
   
   
  
positive.code:                 transport = Transp1, 
                  socket = Socket,
                  tcp_pid = undefined,
                  stuns = []
              },
              {ok, State};
          {error, Error} ->
  
negative.code: handle_call({send, Ip, Port, Packet}, _From, #state{socket=Socket}=State) ->
      {reply, gen_udp:send(Socket, Ip, Port, Packet), State};
  
  handle_call({send_stun, Ip, Port}, From, State) ->
      case do_send_stun(Ip, Port, {srv, From}, State) of
          {ok, State1} -> {noreply, State1};
          {error, State1} -> {reply, error, State1}
      end;
  
  handle_call(get_port, _From, #state{transport=#transport{listen_port=Port}}=State) ->
      {reply, {ok, Port}, State};
  
  handle_call({connect, Ip, Port}, _From, State) ->
      {reply, ok, do_connect_create(Ip, Port, State)};
  
  handle_call(Msg, _Form, State) -> 
      lager:warning("Module ~p received unexpected call: ~p", [?MODULE, Msg]),
  