anchor.diff:  	    undefined ->
   		State0
   	end,
  -    {reply, ok, StateName, next_packet(State)};
  -
  -handle_sync_event(stop, _, _StateName, #state{connection_state = Connection0,
  -					     role = Role,
  -					     opts = Opts} = State0) ->
  -    {disconnect, Reason, {{replies, Replies}, Connection}} =
  -	ssh_connection:handle_msg(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
  -						      description = "User closed down connection",
  -						      language = "en"}, Connection0, Role),
  -    State = send_replies(Replies, State0),
  -    SSHOpts = proplists:get_value(ssh_opts, Opts),
  -    disconnect_fun(Reason, SSHOpts),
  -    {stop, normal, ok, State#state{connection_state = Connection}}.
  +    {reply, ok, StateName, next_packet(State)}.
   
   %%--------------------------------------------------------------------
   -spec handle_info({atom(), port(), binary()} | {atom(), port()} |
  
positive.code: 	    end,
      {reply, Reply, StateName, next_packet(State)};
  
  handle_sync_event(get_print_info, _From, StateName, State) ->
      Reply =
  	try
  	    {inet:sockname(State#state.socket),
  	     inet:peername(State#state.socket)
  	    }
  	of
  	    {{ok,Local}, {ok,Remote}} -> {{Local,Remote},io_lib:format("statename=~p",[StateName])};
  	    _ -> {{"-",0},"-"}
  	catch
  	    _:_ -> {{"?",0},"?"}
  	end,
      {reply, Reply, StateName, State};
  
  handle_sync_event({connection_info, Options}, _From, StateName, State) ->
      Info = ssh_info(Options, State, []),
      {reply, Info, StateName, State};
  
  handle_sync_event({channel_info, ChannelId, Options}, _From, StateName,
  		  #state{connection_state = #connection{channel_cache = Cache}} = State) ->
      case ssh_channel:cache_lookup(Cache, ChannelId) of
         #channel{} = Channel ->
  	    Info = ssh_channel_info(Options, Channel, []),
  	    {reply, Info, StateName, State};
  	undefined ->
  	    {reply, [], StateName, State}
      end;
  
  handle_sync_event({info, ChannelPid}, _From, StateName,
  	    #state{connection_state =
  		       #connection{channel_cache = Cache}} = State) ->
      Result = ssh_channel:cache_foldl(
  	       fun(Channel, Acc) when ChannelPid == all;
  				      Channel#channel.user == ChannelPid ->
  		       [Channel | Acc];
  		  (_, Acc) ->
  		       Acc
  	       end, [], Cache),
      {reply, {ok, Result}, StateName, State};
  
  handle_sync_event({close, ChannelId}, _, StateName,
  		  #state{connection_state =
  			     #connection{channel_cache = Cache}} = State0) ->
  
negative.code: 			     renegotiate = true})};
  
  handle_event(renegotiate, StateName, State) ->
      %% Already in key-exchange so safe to ignore
      {next_state, StateName, State};
  
  %% Rekey due to sent data limit reached?
  