anchor.diff:  
   -record(state, { conn_id = none,
   		 response = [],
  -		 scrape_stack,
  -	         announce_stack }).
  +	         announce_stack = [] }).
   
   %%====================================================================
   -spec start_link({ip(), port()}) -> {ok, pid()}.
   start_link(Tracker) ->
       gen_fsm:start_link(?MODULE, [Tracker], []).
   
  +
  +announce(Pid, Proplist) ->
  +    announce(Pid, Proplist, timer:seconds(60)).
  +
  +%% TODO: consider changing this to the gproc call rather than Pid
  +announce(Pid, Proplist, Timeout) ->
  +    %% TODO: Consider hauling the TRef with us as well so we can cancel the timer
  +    TRef = erlang:send_after(Timeout, self(), announce_timeout),
  +    gen_fsm:send_event(Pid, {announce, self(), Proplist, TRef}),
  +    {ok, TRef}.
  +
  +%%====================================================================
  +%% Retrieve a message from the socket.
   msg(Pid, M) ->
       gen_fsm:send_event(Pid, {msg, M}).
   
  -announce(Pid, Proplist) ->
  -    announce(Pid, Proplist, timer:seconds(600)).
  -
  -%% TODO: consider changing this to the gproc call rather than Pid
  -announce(Pid, Proplist, Timeout) ->
  -    R = make_ref(),
  -    %% TODO: Consider hauling the TRef with us as well so we can cancel the timer
  -    _TRef = erlang:send_after(Timeout, self(), {announce_timeout, R}),
  -    gen_fsm:send_event(Pid, {announce, self(), Proplist, R}),
  -    {ok, R}.
  -
  -%%====================================================================
   init([Tracker]) ->
       gproc:add_local_name({udp_tracker, Tracker}),
  -    {ok, idle, #state{ conn_id = none,
  -		       scrape_stack = [],
  -		       announce_stack = [] }, timer:seconds(3600)}.
  +    {ok, idle, #state{}, timer:seconds(3600)}.
   
   idle({msg, {_TID, {conn_response, _ConnID}}}, S) ->
  -    {next_state, idle, S};
  +    {next_state, idle, S, timer:seconds(3600)};
   idle({msg, {TID, {announce_response, Peers, Status}}}, #state { response = R} = S) ->
       announce_reply(Peers, Status, proplists:lookup(TID, R)),
       PL = proplists:delete(TID, R),
  -    {next_state, idle, S#state { response = PL }};
  +    {next_state, idle, S#state { response = PL }, timer:seconds(3600)};
   %% The idle state is when we have no outstanding requests running with the server
   idle({announce, Requestor, PL, R}, #state { announce_stack = Q } = S) ->
       Tid = request_connid(0),
  -    {next_state, request_conn, S#state { scrape_stack = [{announce, Requestor, PL, R} | Q],
  +    {next_state, request_conn, S#state { announce_stack = [{announce, Requestor, PL, R} | Q],
   				         conn_id = {req, Tid} }};
  -idle(_Event, S) ->
  -    {next_state, idle, S}.
  +idle(Event, S) ->
  +    ?INFO([unknown_msg, idle, Event, ?MODULE]),
  +    {next_state, idle, S, timer:seconds(3600)}.
   
   %% The request_conn state is when we have requested a connection ID from the server
   request_conn({msg, {TID, {conn_response, ConnID}}}, S) ->
  
positive.code:     {stop, {state_inconsistent, {connid_expired, SN, S}}, idle};
  handle_info({announce_timeout, N, Tid}, has_conn,
  	    #state { response = R, conn_id = ConnId} = S) ->
      case proplists:lookup(Tid, R) of
  	none ->
  	    %% Stray
  
negative.code:     erlang:send_after(timer:seconds(60), self(), connid_expired),
      ARes = announce_requests(ConnID, S#state.announce_stack),
      {next_state, has_conn, #state { conn_id = ConnID,
  				    announce_stack = [],
  				    response = S#state.response ++ ARes }};
  request_conn({msg, {TID, {announce_response, Peers, Status}}}, #state { response = R} = S) ->
      announce_reply(Peers, Status, proplists:lookup(TID, R)),
      PL = proplists:delete(TID, R),
      {next_state, request_conn, S#state { response = PL }};
  request_conn({announce, Requestor, PL, R}, #state { announce_stack = Q } = S) ->
      {next_state, request_conn, S#state { announce_stack = [{announce, Requestor, PL, R} | Q]}};
  request_conn(Event, S) ->
      ?INFO([unknown_msg, request_conn, Event, ?MODULE]),
      {next_state, request_conn, S}.
  
  %% The has_conn is when we currently have a live conn ID from the server
  has_conn({announce, _, _, _} = M, #state { response = Resp } = S) ->
      Ares = announce_requests(S#state.conn_id, [M]),
      {next_state, has_conn, S#state { response = Ares ++ Resp }};
  has_conn({msg, {TID, {announce_response, Peers, Status}}}, #state { response = R} = S) ->
      announce_reply(Peers, Status, proplists:lookup(TID, R)),
      PL = proplists:delete(TID, R),
      {next_state, has_conn, S#state { response = PL }};
  has_conn(Event, S) ->
      ?INFO([unknown_msg, has_conn, Event, ?MODULE]),
      {next_state, has_conn, S}.
  
  idle(_Event, _F, S) ->
      {reply, ok, idle, S}.
  