anchor.diff:  	     timeout_cb = Callback,
   	     parameters = Parameters, 
   	     signature = Signature,
  -	     certificate = Certificate,
  -	     timeout_counter = 0
  +	     certificate = Certificate
   	    },
   
       %% Find or create the service
  
positive.code:     ?info("    schedule:timeout(): service:          ~p", [ SvcName]),
      ?info("    schedule:timeout(): trans_id:         ~p", [ TransID]),
  
      %% Atomically increment our counter to ensure that we are the
      %% first and only processing accessing the entry.
      [ Svc] = ets:lookup(SvcTid, SvcName),
      case ets:update_counter(Svc#service.messages_tid, 
  			    TransID, 
  			    { #message.timeout_counter, 1 }) of 
  	%% If it is one, we were the first one who got an update through.
  	1 ->
  	    %% Delete from ets.
  	    [ Msg ] = ets:lookup(Svc#service.messages_tid, TransID),
  	    do_timeout_callback(Svc, Msg),
  	    ets:delete(Svc#service.messages_tid, TransID);
  
  	%% send_messages() processed the message before we had a
  	%% chance to get it.
  	_ ->
  	    ?info("    schedule:timeout(~p/~p): Already processed. Ignored", 
  		  [ SvcName, TransID])
      end,
      {noreply, St};
  
  
negative.code: 	    { ok, St};
  
  	Key ->
  	    ?debug("schedule:try_send(): Sending: ~p", [Key]),
  	    %% Extract first message and try to send it
  	    [ Msg ] = ets:lookup(Tid, Key),
  	    case send_message(NetworkAddress, 
  			      SvcName, 
  			      Msg#message.timeout,
  			      Msg#message.parameters,
  			      Msg#message.signature,
  			      Msg#message.certificate) of
  		ok -> 
  		    %% Send successful - delete entry.
  		    ets:delete(Tid, Key),
  
  		    %% Delete timeout ref
  		    erlang:cancel_timer(Msg#message.timeout_tref),
  
  		    %% Send the rest.
  		    try_sending_messages(Service, St);
  
  		Err ->
  		    %% Failed to send message, leave in queue and err out.
  		    { {send_failed, Err}, St}
  	    end
      end.
  
  
  