Merge branch 'hans/ssh/gen_statem/OTP-13267'

19 files changed, 1709 insertions, 1642 deletions

diff --git a/lib/ssh/src/ssh.erl b/lib/ssh/src/ssh.erl
index d0121e73ba..2eae897ce2 100644
--- a/lib/ssh/src/ssh.erl
+++ b/lib/ssh/src/ssh.erl
@@ -36,6 +36,11 @@
 	 shell/1, shell/2, shell/3
 	]).
 
+%%% Type exports
+-export_type([connection_ref/0,
+	      channel_id/0
+	     ]).
+
 %%--------------------------------------------------------------------
 -spec start() -> ok | {error, term()}.
 -spec start(permanent | transient | temporary) -> ok | {error, term()}.
@@ -81,7 +86,7 @@ connect(Host, Port, Options, Timeout) ->
 	    ConnectionTimeout = proplists:get_value(connect_timeout, Options, infinity),
 	    try Transport:connect(Host, Port,  [ {active, false} | SocketOptions], ConnectionTimeout) of
 		{ok, Socket} ->
-		    Opts =  [{user_pid, self()}, {host, Host} | fix_idle_time(SshOptions)],
+		    Opts =  [{user_pid,self()}, {host,Host} | SshOptions],
 		    ssh_connection_handler:start_connection(client, Socket, Opts, Timeout);
 		{error, Reason} ->
 		    {error, Reason}
@@ -223,13 +228,6 @@ default_algorithms() ->
 %%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
-fix_idle_time(SshOptions) ->
-    case proplists:get_value(idle_time, SshOptions) of
-	undefined ->
-	    [{idle_time, infinity}|SshOptions];
-	_ ->
-	    SshOptions
-    end.
 start_daemon(Host, Port, Options, Inet) ->
     case handle_options(Options) of
 	{error, _Reason} = Error ->
diff --git a/lib/ssh/src/ssh.hrl b/lib/ssh/src/ssh.hrl
index 73d6e4d2bc..868f3a9181 100644
--- a/lib/ssh/src/ssh.hrl
+++ b/lib/ssh/src/ssh.hrl
@@ -70,8 +70,6 @@
 
 -record(ssh,
 	{
-	  %%state,        %% what it's waiting for
-
 	  role,         %% client | server
 	  peer,         %% string version of peer address 
 
@@ -135,8 +133,8 @@
 	  user,
 	  service,
 	  userauth_quiet_mode,              %  boolean()
-	  userauth_supported_methods,       %  string() eg "keyboard-interactive,password"
 	  userauth_methods,                 %  list( string() )  eg ["keyboard-interactive", "password"]
+	  userauth_supported_methods,       %  string() eg "keyboard-interactive,password"
 	  kb_tries_left = 0,                %  integer(), num tries left for "keyboard-interactive"
 	  userauth_preference,
 	  available_host_keys,
diff --git a/lib/ssh/src/ssh_auth.erl b/lib/ssh/src/ssh_auth.erl
index 4b3c21ce3f..49eec8072f 100644
--- a/lib/ssh/src/ssh_auth.erl
+++ b/lib/ssh/src/ssh_auth.erl
@@ -135,9 +135,9 @@ init_userauth_request_msg(#ssh{opts = Opts} = Ssh) ->
 						  service = "ssh-connection"});
 	{error, no_user} ->
 	    ErrStr = "Could not determine the users name",
-	    throw(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_ILLEGAL_USER_NAME,
-				      description = ErrStr,
-				      language = "en"})
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_ILLEGAL_USER_NAME,
+				  description = ErrStr})
     end.
 
 userauth_request_msg(#ssh{userauth_preference = []} = Ssh) ->    
@@ -355,10 +355,10 @@ handle_userauth_info_response(#ssh_msg_userauth_info_response{num_responses = 1,
 
 handle_userauth_info_response(#ssh_msg_userauth_info_response{},
 			      _Auth) ->
-    throw(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
-			      description = "Server does not support"
-			      "keyboard-interactive",
-			      language = "en"}).
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+			  description = "Server does not support keyboard-interactive"
+			 }).
 
 
 %%--------------------------------------------------------------------
@@ -420,10 +420,10 @@ check_password(User, Password, Opts, Ssh) ->
 		{false,NewState} ->
 		    {false, Ssh#ssh{pwdfun_user_state=NewState}};
 		disconnect ->
-		    throw(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
-					      description = 
-						  "Unable to connect using the available authentication methods",
-					      language = ""})
+		    ssh_connection_handler:disconnect(
+		      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+					  description = "Unable to connect using the available authentication methods"
+					 })
 	    end
     end.
 
diff --git a/lib/ssh/src/ssh_channel.erl b/lib/ssh/src/ssh_channel.erl
index de6908bb38..a8e6ebde16 100644
--- a/lib/ssh/src/ssh_channel.erl
+++ b/lib/ssh/src/ssh_channel.erl
@@ -68,7 +68,7 @@
 %% Internal application API
 -export([cache_create/0, cache_lookup/2, cache_update/2, 
 	 cache_delete/1, cache_delete/2,  cache_foldl/3,
-	 cache_find/2,
+	 cache_info/2,  cache_find/2,
 	 get_print_info/1]).
 
 -record(state, {
@@ -335,6 +335,9 @@ cache_delete(Cache) ->
 cache_foldl(Fun, Acc, Cache) ->
     ets:foldl(Fun, Acc, Cache).
     
+cache_info(num_entries, Cache) ->
+    proplists:get_value(size, ets:info(Cache)).
+
 cache_find(ChannelPid, Cache) ->
    case ets:match_object(Cache, #channel{user = ChannelPid}) of
        [] ->
diff --git a/lib/ssh/src/ssh_connect.hrl b/lib/ssh/src/ssh_connect.hrl
index 397d51de9d..47a166dcfd 100644
--- a/lib/ssh/src/ssh_connect.hrl
+++ b/lib/ssh/src/ssh_connect.hrl
@@ -22,13 +22,15 @@
 
 %%% Description : SSH connection protocol 
 
--type channel_id()           :: integer().
+-type role()               :: client | server .
+-type connection_ref()     :: pid().
+-type channel_id()         :: pos_integer().
 
 -define(DEFAULT_PACKET_SIZE, 65536).
 -define(DEFAULT_WINDOW_SIZE, 10*?DEFAULT_PACKET_SIZE).
 
 -define(DEFAULT_TIMEOUT, 5000).
--define(MAX_PROTO_VERSION, 255).
+-define(MAX_PROTO_VERSION, 255).      % Max length of the hello string
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%
diff --git a/lib/ssh/src/ssh_connection.erl b/lib/ssh/src/ssh_connection.erl
index a34478732c..25d552240a 100644
--- a/lib/ssh/src/ssh_connection.erl
+++ b/lib/ssh/src/ssh_connection.erl
@@ -232,6 +232,8 @@ exit_status(ConnectionHandler, Channel, Status) ->
     ssh_connection_handler:request(ConnectionHandler, Channel,
 				   "exit-status", false, [?uint32(Status)], 0).
 
+%% The client wants the server to make a tcp connection on behalf of
+%% the client
 direct_tcpip(ConnectionHandler, RemoteHost,
 	     RemotePort, OrigIP, OrigPort, Timeout) ->
     direct_tcpip(ConnectionHandler, RemoteHost, RemotePort, OrigIP, OrigPort,
@@ -256,6 +258,10 @@ direct_tcpip(ConnectionHandler, RemoteIP, RemotePort, OrigIP, OrigPort,
 						Timeout)
     end.
 
+%% The client wants the server to listen on BindIP:BindPort for tcp
+%% connections. When there is a tcp connect (SYN) to that pair on the
+%% server, the server sends a #ssh_msg_channel_open{"forwarded-tcpip"}
+%% back to the client for each new tcp connection
 tcpip_forward(ConnectionHandler, BindIP, BindPort) ->
     case encode_ip(BindIP) of
 	false -> 
@@ -300,22 +306,11 @@ l2b([]) ->
 
 channel_data(ChannelId, DataType, Data, Connection, From)
   when is_list(Data)->
-    channel_data(ChannelId, DataType, 
-%%		 list_to_binary(Data), Connection, From);
-		 l2b(Data), Connection, From);
-		 %% try list_to_binary(Data)
-		 %% of
-		 %%     B -> B
-		 %% catch
-		 %%     _:_ -> io:format('BAD BINARY: ~p~n',[Data]),
-		 %% 	    unicode:characters_to_binary(Data)
-		 %% end,
-		 %% Connection, From);
+    channel_data(ChannelId, DataType, l2b(Data), Connection, From);
 
 channel_data(ChannelId, DataType, Data, 
 	     #connection{channel_cache = Cache} = Connection,
 	     From) ->
-    
     case ssh_channel:cache_lookup(Cache, ChannelId) of
 	#channel{remote_id = Id, sent_close = false} = Channel0 ->
 	    {SendList, Channel} =
@@ -331,8 +326,7 @@ channel_data(ChannelId, DataType, Data,
 	    FlowCtrlMsgs = flow_control(Replies, Channel, Cache),
 	    {{replies, Replies ++ FlowCtrlMsgs}, Connection};
 	_ ->
-	    gen_fsm:reply(From, {error, closed}),
-	    {noreply, Connection}
+	    {{replies,[{channel_request_reply,From,{error,closed}}]}, Connection}
     end.
 
 handle_msg(#ssh_msg_channel_open_confirmation{recipient_channel = ChannelId, 
@@ -499,7 +493,8 @@ handle_msg(#ssh_msg_channel_open{channel_type = "session" = Type,
 
 handle_msg(#ssh_msg_channel_open{channel_type = "session",
 				 sender_channel = RemoteId}, 
-	   Connection, client) ->
+	   Connection,
+	   client) ->
     %% Client implementations SHOULD reject any session channel open
     %% requests to make it more difficult for a corrupt server to attack the
     %% client. See See RFC 4254 6.1.
@@ -514,10 +509,10 @@ handle_msg(#ssh_msg_channel_open{channel_type = "forwarded-tcpip" = Type,
 				 initial_window_size = RWindowSz,
 				 maximum_packet_size = RPacketSz,
 				 data = Data}, 
-	   #connection{channel_cache = Cache,
-		       options = SSHopts} = Connection0, server) ->
+	   #connection{channel_cache = Cache, options = SSHopts} = Connection0,
+	   server) ->
     <<?UINT32(ALen), Address:ALen/binary, ?UINT32(Port),
-     ?UINT32(OLen), Orig:OLen/binary, ?UINT32(OrigPort)>> = Data,
+      ?UINT32(OLen), Orig:OLen/binary, ?UINT32(OrigPort)>> = Data,
     
     MinAcceptedPackSz = proplists:get_value(minimal_remote_max_packet_size, SSHopts, 0),
     
@@ -786,11 +781,11 @@ handle_msg(#ssh_msg_global_request{name = _Type,
 
 handle_msg(#ssh_msg_request_failure{},
 	   #connection{requests = [{_, From} | Rest]} = Connection, _) ->
-    {{replies, [{channel_requst_reply, From, {failure, <<>>}}]},
+    {{replies, [{channel_request_reply, From, {failure, <<>>}}]},
      Connection#connection{requests = Rest}};
 handle_msg(#ssh_msg_request_success{data = Data},
 	   #connection{requests = [{_, From} | Rest]} = Connection, _) ->
-    {{replies, [{channel_requst_reply, From, {success, Data}}]},
+    {{replies, [{channel_request_reply, From, {success, Data}}]},
      Connection#connection{requests = Rest}};
 
 handle_msg(#ssh_msg_disconnect{code = Code,
@@ -1059,7 +1054,7 @@ request_reply_or_data(#channel{local_id = ChannelId, user = ChannelPid},
 		      Connection, Reply) -> 
     case lists:keysearch(ChannelId, 1, Requests) of
 	{value, {ChannelId, From}} ->
-	    {{channel_requst_reply, From, Reply}, 
+	    {{channel_request_reply, From, Reply}, 
 	     Connection#connection{requests = 
 				       lists:keydelete(ChannelId, 1, Requests)}};
 	false when (Reply == success) or (Reply == failure) ->
diff --git a/lib/ssh/src/ssh_connection_handler.erl b/lib/ssh/src/ssh_connection_handler.erl
index 2bef6a41cd..e5229eb954 100644
--- a/lib/ssh/src/ssh_connection_handler.erl
+++ b/lib/ssh/src/ssh_connection_handler.erl
@@ -28,94 +28,91 @@
 
 -module(ssh_connection_handler).
 
--behaviour(gen_fsm).
+-behaviour(gen_statem).
 
 -include("ssh.hrl").
 -include("ssh_transport.hrl").
 -include("ssh_auth.hrl").
 -include("ssh_connect.hrl").
--compile(export_all).
--export([start_link/3]).
 
-%% Internal application API
--export([open_channel/6, reply_request/3, request/6, request/7,
-	 global_request/4, send/5, send_eof/2, info/1, info/2,
-	 connection_info/2, channel_info/3,
-	 adjust_window/3, close/2, stop/1, renegotiate/1, renegotiate_data/1,
-	 start_connection/4,
-	 get_print_info/1]).
-
-%% gen_fsm callbacks
--export([hello/2, kexinit/2, key_exchange/2, 
-	 key_exchange_dh_gex_init/2, key_exchange_dh_gex_reply/2,
-	 new_keys/2,
-	 service_request/2, connected/2,
-	 userauth/2,
-	 userauth_keyboard_interactive/2,
-	 userauth_keyboard_interactive_info_response/2,
-	 error/2]).
-
--export([init/1, handle_event/3,
-	 handle_sync_event/4, handle_info/3, terminate/3, format_status/2, code_change/4]).
-
--record(state, {
-	  role,
-	  client,
-	  starter,
-	  auth_user,
-	  connection_state,
-	  latest_channel_id = 0,
-	  idle_timer_ref,
-	  transport_protocol,      % ex: tcp
-	  transport_cb,
-	  transport_close_tag,
-	  ssh_params,              %  #ssh{} - from ssh.hrl
-	  socket,                  %  socket()
-	  decoded_data_buffer,     %  binary()
-	  encoded_data_buffer,     %  binary()
-	  undecoded_packet_length, %  integer()
-	  key_exchange_init_msg,   %  #ssh_msg_kexinit{}
-	  renegotiate = false,     %  boolean() 
-	  last_size_rekey = 0,
-	  event_queue = [],
-	  connection_queue,
-	  address,
-	  port,
-	  opts,
-	  recbuf
-	 }). 
-
--type state_name()           :: hello | kexinit | key_exchange | key_exchange_dh_gex_init |
-				key_exchange_dh_gex_reply | new_keys | service_request | 
-				userauth | userauth_keyboard_interactive |
-				userauth_keyboard_interactive_info_response |
-				connection.
-
--type gen_fsm_state_return() :: {next_state, state_name(), term()} |
-				{next_state, state_name(), term(), timeout()} |
-				{stop, term(), term()}.
-
--type gen_fsm_sync_return() :: {next_state, state_name(), term()} |
-			       {next_state, state_name(), term(), timeout()} |
-			       {reply, term(), state_name(), term()} |
-			       {stop, term(), term(), term()}.
+%%====================================================================
+%%% Exports
+%%====================================================================
+
+%%% Start and stop
+-export([start_link/3,
+	 stop/1
+	]).
+
+%%% Internal application API
+-export([start_connection/4,
+	 open_channel/6,
+	 request/6, request/7,
+	 reply_request/3, 
+	 global_request/4,
+	 send/5,
+	 send_eof/2,
+	 info/1, info/2,
+	 connection_info/2,
+	 channel_info/3,
+	 adjust_window/3, close/2,
+	 disconnect/1, disconnect/2,
+	 get_print_info/1
+	]).
+
+%%% Behaviour callbacks
+-export([handle_event/4, terminate/3, format_status/2, code_change/4]).
+
+%%% Exports not intended to be used :). They are used for spawning and tests
+-export([init_connection_handler/3,	   % proc_lib:spawn needs this
+	 init_ssh_record/3,		   % Export of this internal function
+					   % intended for low-level protocol test suites
+	 renegotiate/1, renegotiate_data/1 % Export intended for test cases
+	]).
 
 %%====================================================================
-%% Internal application API
+%% Start / stop
 %%====================================================================
+%%--------------------------------------------------------------------
+-spec start_link(role(),
+		 inet:socket(),
+		 proplists:proplist()
+		) -> {ok, pid()}.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+start_link(Role, Socket, Options) ->
+    {ok, proc_lib:spawn_link(?MODULE, init_connection_handler, [Role, Socket, Options])}.
+
 
 %%--------------------------------------------------------------------
--spec start_connection(client| server, port(), proplists:proplist(),
-		       timeout()) -> {ok, pid()} | {error, term()}.
+-spec stop(connection_ref()
+	  ) -> ok | {error, term()}.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+stop(ConnectionHandler)->
+    case call(ConnectionHandler, stop) of
+       {error, closed} ->
+	    ok;
+	Other ->
+	    Other
+    end.
+
+%%====================================================================
+%% Internal application API
+%%====================================================================
+
+-define(DefaultTransport,  {tcp, gen_tcp, tcp_closed} ).
+
 %%--------------------------------------------------------------------
+-spec start_connection(role(),
+		       inet:socket(),
+		       proplists:proplist(),
+		       timeout()
+		      ) -> {ok, connection_ref()} | {error, term()}.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 start_connection(client = Role, Socket, Options, Timeout) ->
     try
 	{ok, Pid} = sshc_sup:start_child([Role, Socket, Options]),
-	{_, Callback, _} =
-	    proplists:get_value(transport, Options, {tcp, gen_tcp, tcp_closed}),
-	ok = socket_control(Socket, Pid, Callback),
-	Ref = erlang:monitor(process, Pid),
-	handshake(Pid, Ref, Timeout)
+	ok = socket_control(Socket, Pid, Options),
+	handshake(Pid, erlang:monitor(process,Pid), Timeout)
     catch
 	exit:{noproc, _} ->
 	    {error, ssh_not_started};
@@ -128,8 +125,8 @@ start_connection(server = Role, Socket, Options, Timeout) ->
     try
 	case proplists:get_value(parallel_login, SSH_Opts, false) of
 	    true ->
-		HandshakerPid = 
-		    spawn_link(fun() -> 
+		HandshakerPid =
+		    spawn_link(fun() ->
 				       receive
 					   {do_handshake, Pid} ->
 					       handshake(Pid, erlang:monitor(process,Pid), Timeout)
@@ -148,953 +145,1146 @@ start_connection(server = Role, Socket, Options, Timeout) ->
 	    {error, Error}
     end.
 
-start_the_connection_child(UserPid, Role, Socket, Options) ->
-    Sups = proplists:get_value(supervisors, Options),
-    ConnectionSup = proplists:get_value(connection_sup, Sups),
-    Opts = [{supervisors, Sups}, {user_pid, UserPid} | proplists:get_value(ssh_opts, Options, [])],
-    {ok, Pid} = ssh_connection_sup:start_child(ConnectionSup, [Role, Socket, Opts]),
-    {_, Callback, _} =  proplists:get_value(transport, Options, {tcp, gen_tcp, tcp_closed}),
-    socket_control(Socket, Pid, Callback),
-    Pid.
-
+%%--------------------------------------------------------------------
+%%% Some other module has decided to disconnect.
+-spec disconnect(#ssh_msg_disconnect{}) -> no_return().
+-spec disconnect(#ssh_msg_disconnect{}, iodata()) -> no_return().
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+disconnect(Msg = #ssh_msg_disconnect{}) ->
+    throw({keep_state_and_data, 
+	   [{next_event, internal, {disconnect, Msg, Msg#ssh_msg_disconnect.description}}]}).
 
-start_link(Role, Socket, Options) ->
-    {ok, proc_lib:spawn_link(?MODULE, init, [[Role, Socket, Options]])}.
+disconnect(Msg = #ssh_msg_disconnect{}, ExtraInfo) ->
+    throw({keep_state_and_data,
+	   [{next_event, internal, {disconnect, Msg, {Msg#ssh_msg_disconnect.description,ExtraInfo}}}]}).
 
-init([Role, Socket, SshOpts]) ->
-    process_flag(trap_exit, true),
-    {NumVsn, StrVsn} = ssh_transport:versions(Role, SshOpts),
-    {Protocol, Callback, CloseTag} = 
-	proplists:get_value(transport, SshOpts, {tcp, gen_tcp, tcp_closed}),
-    Cache = ssh_channel:cache_create(),
-    State0 = #state{
-		role = Role,
-		connection_state = #connection{channel_cache = Cache,
-					       channel_id_seed = 0,
-					       port_bindings = [],
-					       requests = [],
-					       options = SshOpts},
-		socket = Socket,
-		decoded_data_buffer = <<>>,
-		encoded_data_buffer = <<>>,
-		transport_protocol = Protocol,
-		transport_cb = Callback,
-		transport_close_tag = CloseTag,
-		opts = SshOpts
-	       },
-
-    State = init_role(State0),
-
-    try init_ssh(Role, NumVsn, StrVsn, SshOpts, Socket) of
-	Ssh ->
-	    gen_fsm:enter_loop(?MODULE, [], hello,
-			       State#state{ssh_params = Ssh})
-    catch
-	_:Error ->
-	    gen_fsm:enter_loop(?MODULE, [], error, {Error, State})
-    end.
 
-%% Temporary fix for the Nessus error.  SYN->   <-SYNACK  ACK->  RST-> ?
-error(_Event, {Error,State=#state{}}) ->
-    case Error of
-	{badmatch,{error,enotconn}} ->
-	    %% {error,enotconn} probably from inet:peername in
-	    %% init_ssh(server,..)/5 called from init/1
-	    {stop, {shutdown,"TCP connenction to server was prematurely closed by the client"}, State};
-	_ ->
-	    {stop, {shutdown,{init,Error}}, State}
-    end;
-error(Event, State) -> 
-    %% State deliberately not checked beeing #state. This is a panic-clause...
-    {stop, {shutdown,{init,{spurious_error,Event}}}, State}.
-
-%%--------------------------------------------------------------------
--spec open_channel(pid(), string(), iodata(), integer(), integer(),
-		   timeout()) -> {open, channel_id()} | {error, term()}.
 %%--------------------------------------------------------------------
-open_channel(ConnectionHandler, ChannelType, ChannelSpecificData,
-					InitialWindowSize,
-	     MaxPacketSize, Timeout) ->
-    sync_send_all_state_event(ConnectionHandler, {open, self(), ChannelType,
-						  InitialWindowSize, MaxPacketSize,
-						  ChannelSpecificData,
-						  Timeout}).
-%%--------------------------------------------------------------------
--spec request(pid(), pid(), channel_id(), string(), boolean(), iodata(),
-		   timeout()) -> success | failure | ok | {error, term()}.
+-spec open_channel(connection_ref(), 
+		   string(),
+		   iodata(),
+		   pos_integer(),
+		   pos_integer(),
+		   timeout()
+		  ) -> {open, channel_id()} | {error, term()}.
+		   
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+open_channel(ConnectionHandler, 
+	     ChannelType, ChannelSpecificData, InitialWindowSize, MaxPacketSize, 
+	     Timeout) ->
+    call(ConnectionHandler,
+	 {open, 
+	  self(), 
+	  ChannelType, InitialWindowSize, MaxPacketSize, ChannelSpecificData,
+	  Timeout}).
+
 %%--------------------------------------------------------------------
+-spec request(connection_ref(),
+	      pid(),
+	      channel_id(),
+	      string(),
+	      boolean(),
+	      iodata(),
+	      timeout()
+	     ) -> success | failure | ok | {error,timeout}.
+
+-spec request(connection_ref(),
+	      channel_id(),
+	      string(),
+	      boolean(),
+	      iodata(),
+	      timeout()
+	     ) -> success | failure | ok | {error,timeout}.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 request(ConnectionHandler, ChannelPid, ChannelId, Type, true, Data, Timeout) ->
-    sync_send_all_state_event(ConnectionHandler, {request, ChannelPid, ChannelId, Type, Data,
-						  Timeout});
+    call(ConnectionHandler, {request, ChannelPid, ChannelId, Type, Data, Timeout});
 request(ConnectionHandler, ChannelPid, ChannelId, Type, false, Data, _) ->
-    send_all_state_event(ConnectionHandler, {request, ChannelPid, ChannelId, Type, Data}).
+    cast(ConnectionHandler, {request, ChannelPid, ChannelId, Type, Data}).
 
-%%--------------------------------------------------------------------
--spec request(pid(), channel_id(), string(), boolean(), iodata(),
-		   timeout()) ->  success | failure | {error, timeout}.
-%%--------------------------------------------------------------------
 request(ConnectionHandler, ChannelId, Type, true, Data, Timeout) ->
-    sync_send_all_state_event(ConnectionHandler, {request, ChannelId, Type, Data, Timeout});
+    call(ConnectionHandler, {request, ChannelId, Type, Data, Timeout});
 request(ConnectionHandler, ChannelId, Type, false, Data, _) ->
-    send_all_state_event(ConnectionHandler, {request, ChannelId, Type, Data}).
+    cast(ConnectionHandler, {request, ChannelId, Type, Data}).
 
 %%--------------------------------------------------------------------
--spec reply_request(pid(), success | failure, channel_id()) -> ok.
-%%--------------------------------------------------------------------
+-spec reply_request(connection_ref(),
+		    success | failure,
+		    channel_id()
+		   ) -> ok.
+			   
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 reply_request(ConnectionHandler, Status, ChannelId) ->
-    send_all_state_event(ConnectionHandler, {reply_request, Status, ChannelId}).
+    cast(ConnectionHandler, {reply_request, Status, ChannelId}).
 
 %%--------------------------------------------------------------------
--spec global_request(pid(), string(), boolean(), iolist()) -> ok | error.
-%%--------------------------------------------------------------------
+-spec global_request(connection_ref(),
+		     string(),
+		     boolean(),
+		     iolist()
+		    ) -> ok | error.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 global_request(ConnectionHandler, Type, true = Reply, Data) ->
-    case sync_send_all_state_event(ConnectionHandler,
-				   {global_request, self(), Type, Reply, Data}) of
+    case call(ConnectionHandler, {global_request, self(), Type, Reply, Data}) of
 	{ssh_cm, ConnectionHandler, {success, _}} ->
 	    ok;
 	{ssh_cm, ConnectionHandler, {failure, _}} ->
 	    error
     end;
 global_request(ConnectionHandler, Type, false = Reply, Data) ->
-    send_all_state_event(ConnectionHandler, {global_request, self(), Type, Reply, Data}).
+    cast(ConnectionHandler, {global_request, self(), Type, Reply, Data}).
 
 %%--------------------------------------------------------------------
--spec send(pid(), channel_id(), integer(), iodata(), timeout()) ->
-		  ok | {error, timeout} | {error, closed}.
-%%--------------------------------------------------------------------
+-spec send(connection_ref(),
+	   channel_id(),
+	   non_neg_integer(),
+	   iodata(),
+	   timeout()
+	  ) -> ok | {error, timeout|closed}.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 send(ConnectionHandler, ChannelId, Type, Data, Timeout) ->
-    sync_send_all_state_event(ConnectionHandler, {data, ChannelId, Type, Data, Timeout}).
+    call(ConnectionHandler, {data, ChannelId, Type, Data, Timeout}).
 
 %%--------------------------------------------------------------------
--spec send_eof(pid(), channel_id()) -> ok | {error, closed}.
-%%--------------------------------------------------------------------
+-spec send_eof(connection_ref(),
+	       channel_id()
+	      ) -> ok | {error,closed}.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 send_eof(ConnectionHandler, ChannelId) ->
-    sync_send_all_state_event(ConnectionHandler, {eof, ChannelId}).
+    call(ConnectionHandler, {eof, ChannelId}).
 
 %%--------------------------------------------------------------------
--spec connection_info(pid(), [atom()]) -> proplists:proplist().
+-spec info(connection_ref()
+	  ) -> {ok, [#channel{}]} .
+
+-spec info(connection_ref(),
+	   pid() | all
+	  ) -> {ok, [#channel{}]} .
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+info(ConnectionHandler) ->
+    info(ConnectionHandler, all).
+
+info(ConnectionHandler, ChannelProcess) ->
+    call(ConnectionHandler, {info, ChannelProcess}).
+
 %%--------------------------------------------------------------------
+-type local_sock_info() :: {inet:ip_address(), non_neg_integer()} | string().
+-type peer_sock_info()  :: {inet:ip_address(), non_neg_integer()} | string().
+-type state_info() :: iolist().
+
+-spec get_print_info(connection_ref()
+		    ) -> {{local_sock_info(), peer_sock_info()},
+			  state_info()
+			 }.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 get_print_info(ConnectionHandler) ->
-    sync_send_all_state_event(ConnectionHandler, get_print_info, 1000).
+    call(ConnectionHandler, get_print_info, 1000).
 
+%%--------------------------------------------------------------------
+-spec connection_info(connection_ref(),
+		      [atom()]
+		     ) -> proplists:proplist().
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 connection_info(ConnectionHandler, Options) ->
-    sync_send_all_state_event(ConnectionHandler, {connection_info, Options}).
+    call(ConnectionHandler, {connection_info, Options}).
 
 %%--------------------------------------------------------------------
--spec channel_info(pid(), channel_id(), [atom()]) -> proplists:proplist().
-%%--------------------------------------------------------------------
+-spec channel_info(connection_ref(),
+		   channel_id(),
+		   [atom()]
+		  ) -> proplists:proplist().
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 channel_info(ConnectionHandler, ChannelId, Options) ->
-    sync_send_all_state_event(ConnectionHandler, {channel_info, ChannelId, Options}).
+    call(ConnectionHandler, {channel_info, ChannelId, Options}).
 
 %%--------------------------------------------------------------------
--spec adjust_window(pid(), channel_id(), integer()) -> ok.
-%%--------------------------------------------------------------------
+-spec adjust_window(connection_ref(),
+		    channel_id(),
+		    integer()
+		   ) -> ok.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 adjust_window(ConnectionHandler, Channel, Bytes) ->
-    send_all_state_event(ConnectionHandler, {adjust_window, Channel, Bytes}).
-%%--------------------------------------------------------------------
--spec renegotiate(pid()) -> ok.
-%%--------------------------------------------------------------------
-renegotiate(ConnectionHandler) ->
-    send_all_state_event(ConnectionHandler, renegotiate).
+    cast(ConnectionHandler, {adjust_window, Channel, Bytes}).
 
 %%--------------------------------------------------------------------
--spec renegotiate_data(pid()) -> ok.
-%%--------------------------------------------------------------------
-renegotiate_data(ConnectionHandler) ->
-    send_all_state_event(ConnectionHandler, data_size).
-
-%%--------------------------------------------------------------------
--spec close(pid(), channel_id()) -> ok.
-%%--------------------------------------------------------------------
+-spec close(connection_ref(),
+	    channel_id()
+	   ) -> ok.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 close(ConnectionHandler, ChannelId) ->
-    case sync_send_all_state_event(ConnectionHandler, {close, ChannelId}) of
+    case call(ConnectionHandler, {close, ChannelId}) of
 	ok ->
 	    ok;
-	{error, closed} -> 
+	{error, closed} ->
 	    ok
-    end.	
-	
-%%--------------------------------------------------------------------
--spec stop(pid()) -> ok | {error, term()}.
-%%--------------------------------------------------------------------
-stop(ConnectionHandler)->
-    case sync_send_all_state_event(ConnectionHandler, stop) of
-       {error, closed} ->
-	    ok;
-	Other ->
-	    Other
     end.
 
-info(ConnectionHandler) ->
-    info(ConnectionHandler, {info, all}).
+%%====================================================================
+%% Test support
+%%====================================================================
+%%--------------------------------------------------------------------
+-spec renegotiate(connection_ref()
+		 ) -> ok.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+renegotiate(ConnectionHandler) ->
+    cast(ConnectionHandler, renegotiate).
 
-info(ConnectionHandler, ChannelProcess) ->
-    sync_send_all_state_event(ConnectionHandler, {info, ChannelProcess}).
+%%--------------------------------------------------------------------
+-spec renegotiate_data(connection_ref()
+		      ) -> ok.
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+renegotiate_data(ConnectionHandler) ->
+    cast(ConnectionHandler, data_size).
 
 
 %%====================================================================
-%% gen_fsm callbacks
+%% Internal process state
 %%====================================================================
+-record(data, {
+	  starter                               :: pid(),
+	  auth_user                             :: string()
+						 | undefined,
+	  connection_state                      :: #connection{},
+	  latest_channel_id         = 0         :: non_neg_integer(),
+	  idle_timer_ref                        :: undefined 
+						 | infinity
+						 | reference(),
+	  idle_timer_value          = infinity  :: infinity
+						 | pos_integer(),
+	  transport_protocol                    :: atom(),	% ex: tcp
+	  transport_cb                          :: atom(),	% ex: gen_tcp
+	  transport_close_tag                   :: atom(),	% ex: tcp_closed
+	  ssh_params                            :: #ssh{}
+						 | undefined,
+	  socket                                :: inet:socket(),
+	  decrypted_data_buffer     = <<>>      :: binary(),
+	  encrypted_data_buffer     = <<>>      :: binary(),
+	  undecrypted_packet_length             :: undefined | non_neg_integer(),
+	  key_exchange_init_msg                 :: #ssh_msg_kexinit{}
+						 | undefined,
+	  last_size_rekey           = 0         :: non_neg_integer(),
+	  event_queue               = []        :: list(),
+	  opts                                  :: proplists:proplist(),
+	  inet_initial_recbuf_size              :: pos_integer()
+						 | undefined
+	 }).
 
+%%====================================================================
+%% Intitialisation
+%%====================================================================
 %%--------------------------------------------------------------------
--spec hello(socket_control | {info_line, list()} | {version_exchange, list()},
-	    #state{}) -> gen_fsm_state_return().
+-spec init_connection_handler(role(),
+			      inet:socket(),
+			      proplists:proplist()
+			     ) -> no_return().
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+init_connection_handler(Role, Socket, Opts) ->
+    process_flag(trap_exit, true),
+    S0 = init_process_state(Role, Socket, Opts),
+    try
+	{Protocol, Callback, CloseTag} =
+	    proplists:get_value(transport, Opts, ?DefaultTransport),
+	S0#data{ssh_params = init_ssh_record(Role, Socket, Opts),
+		 transport_protocol = Protocol,
+		 transport_cb = Callback,
+		 transport_close_tag = CloseTag
+		}
+    of
+	S ->
+	    gen_statem:enter_loop(?MODULE,
+				  [], %%[{debug,[trace,log,statistics,debug]} || Role==server],
+				  handle_event_function,
+				  {hello,Role},
+				  S)
+    catch
+	_:Error ->
+	    gen_statem:enter_loop(?MODULE,
+				  [],
+				  handle_event_function,
+				  {init_error,Error},
+				  S0)
+    end.
+
+
+init_process_state(Role, Socket, Opts) ->
+    D = #data{connection_state =
+		   C = #connection{channel_cache = ssh_channel:cache_create(),
+				   channel_id_seed = 0,
+				   port_bindings = [],
+				   requests = [],
+				   options = Opts},
+	       starter = proplists:get_value(user_pid, Opts),
+	       socket = Socket,
+	       opts = Opts
+	      },
+    case Role of
+	client ->
+	    %% Start the renegotiation timers
+	    timer:apply_after(?REKEY_TIMOUT,      gen_statem, cast, [self(), renegotiate]),
+	    timer:apply_after(?REKEY_DATA_TIMOUT, gen_statem, cast, [self(), data_size]),
+	    cache_init_idle_timer(D);
+	server ->
+	    D#data{connection_state = init_connection(Role, C, Opts)}
+    end.
+
+
+init_connection(server, C = #connection{}, Opts) ->
+    Sups = proplists:get_value(supervisors, Opts),
+    SystemSup = proplists:get_value(system_sup, Sups),
+    SubSystemSup = proplists:get_value(subsystem_sup, Sups),
+    ConnectionSup = proplists:get_value(connection_sup, Sups),
+    Shell = proplists:get_value(shell, Opts),
+    Exec = proplists:get_value(exec, Opts),
+    CliSpec = proplists:get_value(ssh_cli, Opts, {ssh_cli, [Shell]}),
+    C#connection{cli_spec = CliSpec,
+		 exec = Exec,
+		 system_supervisor = SystemSup,
+		 sub_system_supervisor = SubSystemSup,
+		 connection_supervisor = ConnectionSup
+		}.
+
+
+init_ssh_record(Role, Socket, Opts) ->
+    {ok, PeerAddr} = inet:peername(Socket),
+    KeyCb = proplists:get_value(key_cb, Opts, ssh_file),
+    AuthMethods = proplists:get_value(auth_methods, Opts, ?SUPPORTED_AUTH_METHODS),
+    S0 = #ssh{role = Role,
+	      key_cb = KeyCb,
+	      opts = Opts,
+	      userauth_supported_methods = AuthMethods,
+	      available_host_keys = supported_host_keys(Role, KeyCb, Opts),
+	      random_length_padding = proplists:get_value(max_random_length_padding,
+							  Opts,
+							  (#ssh{})#ssh.random_length_padding)
+	   },
+
+    {Vsn, Version} = ssh_transport:versions(Role, Opts),
+    case Role of
+	client ->
+	    PeerName =  proplists:get_value(host, Opts),
+	    S0#ssh{c_vsn = Vsn,
+		   c_version = Version,
+		   io_cb = case proplists:get_value(user_interaction, Opts, true) of
+			       true ->  ssh_io;
+			       false -> ssh_no_io
+			   end,
+		   userauth_quiet_mode = proplists:get_value(quiet_mode, Opts, false),
+		   peer = {PeerName, PeerAddr}
+		  };
+
+	server ->
+	    S0#ssh{s_vsn = Vsn,
+		   s_version = Version,
+		   io_cb = proplists:get_value(io_cb, Opts, ssh_io),
+		   userauth_methods = string:tokens(AuthMethods, ","),
+		   kb_tries_left = 3,
+		   peer = {undefined, PeerAddr}
+		  }
+    end.
+
+
+
+%%====================================================================
+%% gen_statem callbacks
+%%====================================================================
 %%--------------------------------------------------------------------
+-type event_content() ::  any().
+
+-type renegotiate_flag() :: init | renegotiate.
+
+-type state_name() :: 
+	{init_error,any()}
+      | {hello, role()}
+      | {kexinit, role(), renegotiate_flag()}
+      | {key_exchange, role(), renegotiate_flag()}
+      | {key_exchange_dh_gex_init, server, renegotiate_flag()}
+      | {key_exchange_dh_gex_reply, client, renegotiate_flag()}
+      | {new_keys, role()}
+      | {service_request, role()}
+      | {userauth, role()}
+      | {userauth_keyboard_interactive, role()}
+      | {connected, role()}
+	.
+
+-type handle_event_result() :: gen_statem:handle_event_result().
+
+-spec handle_event(gen_statem:event_type(),
+		   event_content(),
+		   state_name(),
+		   #data{}
+		  ) -> handle_event_result().
+		   
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+%%% ######## Error in the initialisation ####
+
+handle_event(_, _Event, {init_error,Error}, _) ->
+    case Error of
+	{badmatch,{error,enotconn}} ->
+	    %% Handles the abnormal sequence:
+	    %%    SYN->
+	    %%            <-SYNACK
+	    %%    ACK->
+	    %%    RST->
+	    {stop, {shutdown,"TCP connenction to server was prematurely closed by the client"}};
+
+	OtherError ->
+	    {stop, {shutdown,{init,OtherError}}}
+    end;
+
+
+%%% ######## {hello, client|server} ####
+%% The very first event that is sent when the we are set as controlling process of Socket
+handle_event(_, socket_control, {hello,_}, D) ->
+    VsnMsg = ssh_transport:hello_version_msg(string_version(D#data.ssh_params)),
+    ok = send_bytes(VsnMsg, D),
+    case inet:getopts(Socket=D#data.socket, [recbuf]) of
+	{ok, [{recbuf,Size}]} ->
+	    %% Set the socket to the hello text line handling mode:
+	    inet:setopts(Socket, [{packet, line},
+				  {active, once},
+				  % Expecting the version string which might
+				  % be max ?MAX_PROTO_VERSION bytes:
+				  {recbuf, ?MAX_PROTO_VERSION},
+				  {nodelay,true}]),
+	    {keep_state, D#data{inet_initial_recbuf_size=Size}};
+
+	Other ->
+	    {stop, {shutdown,{unexpected_getopts_return, Other}}}
+    end;
 
-hello(socket_control, #state{socket = Socket, ssh_params = Ssh} = State) ->
-    VsnMsg = ssh_transport:hello_version_msg(string_version(Ssh)),
-    send_msg(VsnMsg, State),
-    case getopt(recbuf, Socket) of
-	{ok, Size} ->
-	    inet:setopts(Socket, [{packet, line}, {active, once}, {recbuf, ?MAX_PROTO_VERSION}]),
-	    {next_state, hello, State#state{recbuf = Size}};
-	{error, Reason} ->
-	    {stop, {shutdown, Reason}, State}
+handle_event(_, {info_line,_Line}, {hello,Role}, D) ->
+    case Role of
+	client ->
+	    %% The server may send info lines to the client before the version_exchange
+	    inet:setopts(D#data.socket, [{active, once}]),
+	    keep_state_and_data;
+	server ->
+	    %% But the client may NOT send them to the server. Openssh answers with cleartext,
+	    %% and so do we
+	    ok = send_bytes("Protocol mismatch.", D),
+	    {stop, {shutdown,"Protocol mismatch in version exchange. Client sent info lines."}}
     end;
 
-hello({info_line, _Line},#state{role = client, socket = Socket} = State) ->
-    %% The server may send info lines before the version_exchange
-    inet:setopts(Socket, [{active, once}]),
-    {next_state, hello, State};
-
-hello({info_line, _Line},#state{role = server,
-				socket = Socket,
-				transport_cb = Transport } = State) ->
-    %% as openssh
-    Transport:send(Socket, "Protocol mismatch."),
-    {stop, {shutdown,"Protocol mismatch in version exchange."}, State};
-
-hello({version_exchange, Version}, #state{ssh_params = Ssh0,
-					  socket = Socket,
-					  recbuf = Size} = State) ->
+handle_event(_, {version_exchange,Version}, {hello,Role}, D) ->
     {NumVsn, StrVsn} = ssh_transport:handle_hello_version(Version),
-    case handle_version(NumVsn, StrVsn, Ssh0) of
+    case handle_version(NumVsn, StrVsn, D#data.ssh_params) of
 	{ok, Ssh1} ->
-	    inet:setopts(Socket, [{packet,0}, {mode,binary}, {active, once}, {recbuf, Size}]),
+	    %% Since the hello part is finnished correctly, we set the
+	    %% socket to the packet handling mode (including recbuf size):
+	    inet:setopts(D#data.socket, [{packet,0},
+					 {mode,binary},
+					 {active, once},
+					 {recbuf, D#data.inet_initial_recbuf_size}]),
 	    {KeyInitMsg, SshPacket, Ssh} = ssh_transport:key_exchange_init_msg(Ssh1),
-	    send_msg(SshPacket, State),
-	    {next_state, kexinit, next_packet(State#state{ssh_params = Ssh,
-							  key_exchange_init_msg = 
-							  KeyInitMsg})};
+	    ok = send_bytes(SshPacket, D),
+	    {next_state, {kexinit,Role,init}, D#data{ssh_params = Ssh,
+						     key_exchange_init_msg = KeyInitMsg}};
 	not_supported ->
-	    DisconnectMsg =
-		#ssh_msg_disconnect{code = 
-					?SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED,
-				    description = "Protocol version " ++  StrVsn 
-				    ++ " not supported",
-				    language = "en"},
-	    handle_disconnect(DisconnectMsg, State)
-    end.
+	    disconnect(
+	      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED,
+				  description = ["Protocol version ",StrVsn," not supported"]},
+	      {next_state, {hello,Role}, D})
+    end;
 
-%%--------------------------------------------------------------------
--spec kexinit({#ssh_msg_kexinit{}, binary()}, #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
-kexinit({#ssh_msg_kexinit{} = Kex, Payload},
-	#state{ssh_params = #ssh{role = Role} = Ssh0,
-	       key_exchange_init_msg = OwnKex} =
-	    State) ->
-    Ssh1 = ssh_transport:key_init(opposite_role(Role), Ssh0, Payload), 
-    case ssh_transport:handle_kexinit_msg(Kex, OwnKex, Ssh1) of
-	{ok, NextKexMsg, Ssh} when Role == client ->
-	    send_msg(NextKexMsg, State),
-	    {next_state, key_exchange, 
-	     next_packet(State#state{ssh_params = Ssh})};
-	{ok, Ssh} when Role == server ->
-	    {next_state, key_exchange, 
-	     next_packet(State#state{ssh_params = Ssh})}
-    end.
+		  
+%%% ######## {kexinit, client|server, init|renegotiate} ####
 
-%%--------------------------------------------------------------------
--spec key_exchange(#ssh_msg_kexdh_init{} | #ssh_msg_kexdh_reply{} |
-		   #ssh_msg_kex_dh_gex_group{} | #ssh_msg_kex_dh_gex_request{} |
-		   #ssh_msg_kex_dh_gex_request{} | #ssh_msg_kex_dh_gex_reply{}, #state{})
-		  -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
+handle_event(_, {#ssh_msg_kexinit{}=Kex, Payload}, {kexinit,Role,ReNeg},
+	     D = #data{key_exchange_init_msg = OwnKex}) ->
+    Ssh1 = ssh_transport:key_init(peer_role(Role), D#data.ssh_params, Payload),
+    Ssh = case ssh_transport:handle_kexinit_msg(Kex, OwnKex, Ssh1) of
+	      {ok, NextKexMsg, Ssh2} when Role==client ->
+		  ok = send_bytes(NextKexMsg, D),
+		  Ssh2;
+	      {ok, Ssh2} when Role==server ->
+		  Ssh2
+	  end,
+    {next_state, {key_exchange,Role,ReNeg}, D#data{ssh_params=Ssh}};
 
-key_exchange(#ssh_msg_kexdh_init{} = Msg, 
-	     #state{ssh_params = #ssh{role = server} = Ssh0} = State) ->
-    case ssh_transport:handle_kexdh_init(Msg, Ssh0) of
-	{ok, KexdhReply, Ssh1} ->
-	    send_msg(KexdhReply, State),
-	    {ok, NewKeys, Ssh} = ssh_transport:new_keys_message(Ssh1),
-	    send_msg(NewKeys, State),
-	    {next_state, new_keys, next_packet(State#state{ssh_params = Ssh})}
-    end;
 
-key_exchange(#ssh_msg_kexdh_reply{} = Msg, 
-	     #state{ssh_params = #ssh{role = client} = Ssh0} = State) -> 
-    {ok, NewKeys, Ssh} = ssh_transport:handle_kexdh_reply(Msg, Ssh0),
-    send_msg(NewKeys, State),
-    {next_state, new_keys, next_packet(State#state{ssh_params = Ssh})};
-
-key_exchange(#ssh_msg_kex_dh_gex_request{} = Msg, 
-	     #state{ssh_params = #ssh{role = server} = Ssh0} = State) ->
-    {ok, GexGroup, Ssh} = ssh_transport:handle_kex_dh_gex_request(Msg, Ssh0),
-    send_msg(GexGroup, State),
-    {next_state, key_exchange_dh_gex_init, next_packet(State#state{ssh_params = Ssh})};
-
-key_exchange(#ssh_msg_kex_dh_gex_request_old{} = Msg, 
-	     #state{ssh_params = #ssh{role = server} = Ssh0} = State) ->
-    {ok, GexGroup, Ssh} = ssh_transport:handle_kex_dh_gex_request(Msg, Ssh0),
-    send_msg(GexGroup, State),
-    {next_state, key_exchange_dh_gex_init, next_packet(State#state{ssh_params = Ssh})};
-
-key_exchange(#ssh_msg_kex_dh_gex_group{} = Msg, 
-	     #state{ssh_params = #ssh{role = client} = Ssh0} = State) ->
-    {ok, KexGexInit, Ssh} = ssh_transport:handle_kex_dh_gex_group(Msg, Ssh0),
-    send_msg(KexGexInit, State),
-    {next_state, key_exchange_dh_gex_reply, next_packet(State#state{ssh_params = Ssh})};
-
-key_exchange(#ssh_msg_kex_ecdh_init{} = Msg, 
-	     #state{ssh_params = #ssh{role = server} = Ssh0} = State) ->
-    {ok, KexEcdhReply, Ssh1} = ssh_transport:handle_kex_ecdh_init(Msg, Ssh0),
-    send_msg(KexEcdhReply, State),
+%%% ######## {key_exchange, client|server, init|renegotiate} ####
+
+%%%---- diffie-hellman
+handle_event(_, #ssh_msg_kexdh_init{} = Msg, {key_exchange,server,ReNeg}, D) ->
+    {ok, KexdhReply, Ssh1} = ssh_transport:handle_kexdh_init(Msg, D#data.ssh_params),
+    ok = send_bytes(KexdhReply, D),
     {ok, NewKeys, Ssh} = ssh_transport:new_keys_message(Ssh1),
-    send_msg(NewKeys, State),
-    {next_state, new_keys, next_packet(State#state{ssh_params = Ssh})};
+    ok = send_bytes(NewKeys, D),
+    {next_state, {new_keys,server,ReNeg}, D#data{ssh_params=Ssh}};
+
+handle_event(_, #ssh_msg_kexdh_reply{} = Msg, {key_exchange,client,ReNeg}, D) ->
+    {ok, NewKeys, Ssh} = ssh_transport:handle_kexdh_reply(Msg, D#data.ssh_params),
+    ok = send_bytes(NewKeys, D),
+    {next_state, {new_keys,client,ReNeg}, D#data{ssh_params=Ssh}};
+
+%%%---- diffie-hellman group exchange
+handle_event(_, #ssh_msg_kex_dh_gex_request{} = Msg, {key_exchange,server,ReNeg}, D) ->
+    {ok, GexGroup, Ssh} = ssh_transport:handle_kex_dh_gex_request(Msg, D#data.ssh_params),
+    ok = send_bytes(GexGroup, D),
+    {next_state, {key_exchange_dh_gex_init,server,ReNeg}, D#data{ssh_params=Ssh}};
+
+handle_event(_, #ssh_msg_kex_dh_gex_request_old{} = Msg, {key_exchange,server,ReNeg}, D) ->
+    {ok, GexGroup, Ssh} = ssh_transport:handle_kex_dh_gex_request(Msg, D#data.ssh_params),
+    ok = send_bytes(GexGroup, D),
+    {next_state, {key_exchange_dh_gex_init,server,ReNeg}, D#data{ssh_params=Ssh}};
+
+handle_event(_, #ssh_msg_kex_dh_gex_group{} = Msg, {key_exchange,client,ReNeg}, D) ->
+    {ok, KexGexInit, Ssh} = ssh_transport:handle_kex_dh_gex_group(Msg, D#data.ssh_params),
+    ok = send_bytes(KexGexInit, D),
+    {next_state, {key_exchange_dh_gex_reply,client,ReNeg}, D#data{ssh_params=Ssh}};
+
+%%%---- elliptic curve diffie-hellman
+handle_event(_, #ssh_msg_kex_ecdh_init{} = Msg, {key_exchange,server,ReNeg}, D) ->
+    {ok, KexEcdhReply, Ssh1} = ssh_transport:handle_kex_ecdh_init(Msg, D#data.ssh_params),
+    ok = send_bytes(KexEcdhReply, D),
+    {ok, NewKeys, Ssh} = ssh_transport:new_keys_message(Ssh1),
+    ok = send_bytes(NewKeys, D),
+    {next_state, {new_keys,server,ReNeg}, D#data{ssh_params=Ssh}};
 
-key_exchange(#ssh_msg_kex_ecdh_reply{} = Msg, 
-	     #state{ssh_params = #ssh{role = client} = Ssh0} = State) ->
-    {ok, NewKeys, Ssh} = ssh_transport:handle_kex_ecdh_reply(Msg, Ssh0),
-    send_msg(NewKeys, State),
-    {next_state, new_keys, next_packet(State#state{ssh_params = Ssh})}.
+handle_event(_, #ssh_msg_kex_ecdh_reply{} = Msg, {key_exchange,client,ReNeg}, D) ->
+    {ok, NewKeys, Ssh} = ssh_transport:handle_kex_ecdh_reply(Msg, D#data.ssh_params),
+    ok = send_bytes(NewKeys, D),
+    {next_state, {new_keys,client,ReNeg}, D#data{ssh_params=Ssh}};
 
-%%--------------------------------------------------------------------
--spec key_exchange_dh_gex_init(#ssh_msg_kex_dh_gex_init{}, #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
-key_exchange_dh_gex_init(#ssh_msg_kex_dh_gex_init{} = Msg,
-			 #state{ssh_params = #ssh{role = server} = Ssh0} = State) ->
-    {ok, KexGexReply, Ssh1} =  ssh_transport:handle_kex_dh_gex_init(Msg, Ssh0),
-    send_msg(KexGexReply, State),
+
+%%% ######## {key_exchange_dh_gex_init, server, init|renegotiate} ####
+
+handle_event(_, #ssh_msg_kex_dh_gex_init{} = Msg, {key_exchange_dh_gex_init,server,ReNeg}, D) ->
+    {ok, KexGexReply, Ssh1} =  ssh_transport:handle_kex_dh_gex_init(Msg, D#data.ssh_params),
+    ok = send_bytes(KexGexReply, D),
     {ok, NewKeys, Ssh} = ssh_transport:new_keys_message(Ssh1),
-    send_msg(NewKeys, State),
-    {next_state, new_keys, next_packet(State#state{ssh_params = Ssh})}.
+    ok = send_bytes(NewKeys, D),
+    {next_state, {new_keys,server,ReNeg}, D#data{ssh_params=Ssh}};
 
-%%--------------------------------------------------------------------
--spec key_exchange_dh_gex_reply(#ssh_msg_kex_dh_gex_reply{}, #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
-key_exchange_dh_gex_reply(#ssh_msg_kex_dh_gex_reply{} = Msg,
-			  #state{ssh_params = #ssh{role = client} = Ssh0} = State) ->
-    {ok, NewKeys, Ssh1} =  ssh_transport:handle_kex_dh_gex_reply(Msg, Ssh0),
-    send_msg(NewKeys, State),
-    {next_state, new_keys, next_packet(State#state{ssh_params = Ssh1})}.
 
-%%--------------------------------------------------------------------
--spec new_keys(#ssh_msg_newkeys{}, #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
+%%% ######## {key_exchange_dh_gex_reply, client, init|renegotiate} ####
 
-new_keys(#ssh_msg_newkeys{} = Msg, #state{ssh_params = Ssh0} = State0) ->
-    {ok, Ssh} = ssh_transport:handle_new_keys(Msg, Ssh0),
-    after_new_keys(next_packet(State0#state{ssh_params = Ssh})).
+handle_event(_, #ssh_msg_kex_dh_gex_reply{} = Msg, {key_exchange_dh_gex_reply,client,ReNeg}, D) ->
+    {ok, NewKeys, Ssh1} = ssh_transport:handle_kex_dh_gex_reply(Msg, D#data.ssh_params),
+    ok = send_bytes(NewKeys, D),
+    {next_state, {new_keys,client,ReNeg}, D#data{ssh_params=Ssh1}};
 
-%%--------------------------------------------------------------------
--spec service_request(#ssh_msg_service_request{} | #ssh_msg_service_accept{},
-		      #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
-service_request(#ssh_msg_service_request{name = "ssh-userauth"} = Msg, 
-	 #state{ssh_params = #ssh{role = server, 
-				  session_id = SessionId} = Ssh0} = State) ->
-    {ok, {Reply, Ssh}} = ssh_auth:handle_userauth_request(Msg, SessionId, Ssh0),
-    send_msg(Reply, State),
-    {next_state, userauth, next_packet(State#state{ssh_params = Ssh})};
-
-service_request(#ssh_msg_service_accept{name = "ssh-userauth"},  
-		#state{ssh_params = #ssh{role = client,
-					 service = "ssh-userauth"} = Ssh0} = 
-		    State) ->
+
+%%% ######## {new_keys, client|server} ####
+
+%% First key exchange round:
+handle_event(_, #ssh_msg_newkeys{} = Msg, {new_keys,Role,init}, D) ->
+    {ok, Ssh1} = ssh_transport:handle_new_keys(Msg, D#data.ssh_params),
+    Ssh = case Role of
+	      client ->
+		  {MsgReq, Ssh2} = ssh_auth:service_request_msg(Ssh1),
+		  ok = send_bytes(MsgReq, D),
+		  Ssh2;
+	      server ->
+		  Ssh1
+	  end,
+    {next_state, {service_request,Role}, D#data{ssh_params=Ssh}};
+
+%% Subsequent key exchange rounds (renegotiation):
+handle_event(_, #ssh_msg_newkeys{}, {new_keys,Role,renegotiate}, D) ->
+    {next_state, {connected,Role}, D};
+
+%%% ######## {service_request, client|server}
+
+handle_event(_, Msg = #ssh_msg_service_request{name=ServiceName}, StateName = {service_request,server}, D) ->
+    case ServiceName of
+	"ssh-userauth" ->
+	    Ssh0 = #ssh{session_id=SessionId} = D#data.ssh_params,
+	    {ok, {Reply, Ssh}} = ssh_auth:handle_userauth_request(Msg, SessionId, Ssh0),
+	    ok = send_bytes(Reply, D),
+	    {next_state, {userauth,server}, D#data{ssh_params = Ssh}};
+
+	_ ->
+	    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+					   description = "Unknown service"},
+		       StateName, D)
+    end;
+
+handle_event(_, #ssh_msg_service_accept{name = "ssh-userauth"}, {service_request,client},
+	     #data{ssh_params = #ssh{service="ssh-userauth"} = Ssh0} = State) ->
     {Msg, Ssh} = ssh_auth:init_userauth_request_msg(Ssh0),
-    send_msg(Msg, State),
-    {next_state, userauth, next_packet(State#state{auth_user = Ssh#ssh.user, ssh_params = Ssh})}.
+    ok = send_bytes(Msg, State),
+    {next_state, {userauth,client}, State#data{auth_user = Ssh#ssh.user, ssh_params = Ssh}};
 
-%%--------------------------------------------------------------------
--spec userauth(#ssh_msg_userauth_request{} | #ssh_msg_userauth_info_request{} |
-	       #ssh_msg_userauth_info_response{} | #ssh_msg_userauth_success{} |
-	       #ssh_msg_userauth_failure{} | #ssh_msg_userauth_banner{},
-	       #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
-userauth(#ssh_msg_userauth_request{service = "ssh-connection",
-                                  method = "none"} = Msg, 
-        #state{ssh_params = #ssh{session_id = SessionId, role = server, 
-                                 service = "ssh-connection"} = Ssh0
-              } = State) -> 
-    {not_authorized, {_User, _Reason}, {Reply, Ssh}} =
-	ssh_auth:handle_userauth_request(Msg, SessionId, Ssh0),
-    send_msg(Reply, State),
-    {next_state, userauth, next_packet(State#state{ssh_params = Ssh})};
-
-userauth(#ssh_msg_userauth_request{service = "ssh-connection",
-				   method = Method} = Msg, 
-	 #state{ssh_params = #ssh{session_id = SessionId, role = server, 
-				  service = "ssh-connection",
-				  peer = {_, Address}} = Ssh0,
-		opts = Opts, starter = Pid} = State) ->
-    case lists:member(Method, Ssh0#ssh.userauth_methods) of
-	true ->
-	    case ssh_auth:handle_userauth_request(Msg, SessionId, Ssh0) of
-		{authorized, User, {Reply, Ssh}} ->
-		    send_msg(Reply, State),
-		    Pid ! ssh_connected,
-		    connected_fun(User, Address, Method, Opts),
-		    {next_state, connected, 
-		     next_packet(State#state{auth_user = User, ssh_params = Ssh#ssh{authenticated = true}})};
-		{not_authorized, {User, Reason}, {Reply, Ssh}} when Method == "keyboard-interactive" ->
-		    retry_fun(User, Address, Reason, Opts),
-		    send_msg(Reply, State),
-		    {next_state, userauth_keyboard_interactive, next_packet(State#state{ssh_params = Ssh})};
-		{not_authorized, {User, Reason}, {Reply, Ssh}} ->
-		    retry_fun(User, Address, Reason, Opts),
-		    send_msg(Reply, State),
-		    {next_state, userauth, next_packet(State#state{ssh_params = Ssh})} 
+
+%%% ######## {userauth, client|server} ####
+
+%%---- userauth request to server
+handle_event(_, 
+	     Msg = #ssh_msg_userauth_request{service = ServiceName, method = Method},
+	     StateName = {userauth,server},
+	     D = #data{ssh_params=Ssh0}) ->
+
+    case {ServiceName, Ssh0#ssh.service, Method} of
+	{"ssh-connection", "ssh-connection", "none"} ->
+	    %% Probably the very first userauth_request but we deny unauthorized login
+	    {not_authorized, _, {Reply,Ssh}} =
+		ssh_auth:handle_userauth_request(Msg, Ssh0#ssh.session_id, Ssh0),
+	    ok = send_bytes(Reply, D),
+	    {keep_state, D#data{ssh_params = Ssh}};
+	
+	{"ssh-connection", "ssh-connection", Method} ->
+	    %% Userauth request with a method like "password" or so
+	    case lists:member(Method, Ssh0#ssh.userauth_methods) of
+		true ->
+		    %% Yepp! we support this method
+		    case ssh_auth:handle_userauth_request(Msg, Ssh0#ssh.session_id, Ssh0) of
+			{authorized, User, {Reply, Ssh}} ->
+			    ok = send_bytes(Reply, D),
+			    D#data.starter ! ssh_connected,
+			    connected_fun(User, Method, D),
+			    {next_state, {connected,server},
+			     D#data{auth_user = User, 
+				    ssh_params = Ssh#ssh{authenticated = true}}};
+			{not_authorized, {User, Reason}, {Reply, Ssh}} when Method == "keyboard-interactive" ->
+			    retry_fun(User, Reason, D),
+			    ok = send_bytes(Reply, D),
+			    {next_state, {userauth_keyboard_interactive,server}, D#data{ssh_params = Ssh}};
+			{not_authorized, {User, Reason}, {Reply, Ssh}} ->
+			    retry_fun(User, Reason, D),
+			    ok = send_bytes(Reply, D),
+			    {keep_state, D#data{ssh_params = Ssh}}
+		    end;
+		false ->
+		    %% No we do not support this method (=/= none)
+		    %% At least one non-erlang client does like this. Retry as the next event
+		    {keep_state_and_data,
+		     [{next_event, internal, Msg#ssh_msg_userauth_request{method="none"}}]
+		    }
 	    end;
-	false ->
-	    userauth(Msg#ssh_msg_userauth_request{method="none"}, State)
+
+	%% {"ssh-connection", Expected, Method} when Expected =/= ServiceName -> Do what?
+	%% {ServiceName,      Expected, Method} when Expected =/= ServiceName -> Do what?
+
+	{ServiceName, _, _} when ServiceName =/= "ssh-connection" ->
+	    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+					   description = "Unknown service"},
+		       StateName, D)
     end;
 
-userauth(#ssh_msg_userauth_success{}, #state{ssh_params = #ssh{role = client} = Ssh,
-					     starter = Pid} = State) ->
-    Pid ! ssh_connected,
-    {next_state, connected, next_packet(State#state{ssh_params =
-							Ssh#ssh{authenticated = true}})};
-userauth(#ssh_msg_userauth_failure{},  
-	 #state{ssh_params = #ssh{role = client,
-				  userauth_methods = []}} 
-	 = State) ->
-    Msg = #ssh_msg_disconnect{code = 
-			      ?SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
+%%---- userauth success to client
+handle_event(_, #ssh_msg_userauth_success{}, {userauth,client}, D=#data{ssh_params = Ssh}) ->
+    D#data.starter ! ssh_connected,
+    {next_state, {connected,client}, D#data{ssh_params=Ssh#ssh{authenticated = true}}};
+
+
+%%---- userauth failure response to client
+handle_event(_, #ssh_msg_userauth_failure{}, {userauth,client}=StateName,
+	     D = #data{ssh_params = #ssh{userauth_methods = []}}) ->
+    Msg = #ssh_msg_disconnect{code = ?SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
 			      description = "Unable to connect using the available"
-			      " authentication methods",
-			      language = "en"},
-    handle_disconnect(Msg, State); 
-
-%% Server tells us which authentication methods that are allowed
-userauth(#ssh_msg_userauth_failure{authentications = Methodes},  
-	 #state{ssh_params = #ssh{role = client,
-				  userauth_methods = none} = Ssh0} = State) ->
-    AuthMethods = string:tokens(Methodes, ","),
-    Ssh1 = Ssh0#ssh{userauth_methods = AuthMethods},
+			                    " authentication methods"},
+    disconnect(Msg, StateName, D);
+
+handle_event(_, #ssh_msg_userauth_failure{authentications = Methods}, StateName={userauth,client},
+	     D = #data{ssh_params = Ssh0}) ->
+    %% The prefered authentication method failed try next method
+    Ssh1 = case Ssh0#ssh.userauth_methods of
+	       none ->
+		   %% Server tells us which authentication methods that are allowed
+		   Ssh0#ssh{userauth_methods = string:tokens(Methods, ",")};
+	       _ ->
+		   %% We already know...
+		   Ssh0
+	   end,
     case ssh_auth:userauth_request_msg(Ssh1) of
 	{disconnect, DisconnectMsg, {Msg, Ssh}} ->
-	    send_msg(Msg, State),
-	    handle_disconnect(DisconnectMsg, State#state{ssh_params = Ssh});
+	    send_bytes(Msg, D),
+	    disconnect(DisconnectMsg, StateName, D#data{ssh_params = Ssh});
 	{"keyboard-interactive", {Msg, Ssh}} ->
-	    send_msg(Msg, State),
-	    {next_state, userauth_keyboard_interactive, next_packet(State#state{ssh_params = Ssh})};
+	    send_bytes(Msg, D),
+	    {next_state, {userauth_keyboard_interactive,client}, D#data{ssh_params = Ssh}};
 	{_Method, {Msg, Ssh}} ->
-	    send_msg(Msg, State),
-	    {next_state, userauth, next_packet(State#state{ssh_params = Ssh})}
+	    send_bytes(Msg, D),
+	    {keep_state, D#data{ssh_params = Ssh}}
     end;
 
-%% The prefered authentication method failed try next method 
-userauth(#ssh_msg_userauth_failure{},
-	 #state{ssh_params = #ssh{role = client} = Ssh0} = State) ->
-    case ssh_auth:userauth_request_msg(Ssh0) of
-	{disconnect,  DisconnectMsg,{Msg, Ssh}} ->
-	    send_msg(Msg, State),
-	    handle_disconnect(DisconnectMsg, State#state{ssh_params = Ssh}); 
-	{"keyboard-interactive", {Msg, Ssh}} ->
-	    send_msg(Msg, State),
-	    {next_state, userauth_keyboard_interactive, next_packet(State#state{ssh_params = Ssh})};
-	{_Method, {Msg, Ssh}} ->
-	    send_msg(Msg, State),
-	    {next_state, userauth, next_packet(State#state{ssh_params = Ssh})}
-    end;
+%%---- banner to client
+handle_event(_, #ssh_msg_userauth_banner{message = Msg}, {userauth,client}, D) ->
+    case D#data.ssh_params#ssh.userauth_quiet_mode of
+	false -> io:format("~s", [Msg]);
+	true -> ok
+    end,
+    keep_state_and_data;
+
 
-userauth(#ssh_msg_userauth_banner{}, 
-	 #state{ssh_params = #ssh{userauth_quiet_mode = true, 
-				  role = client}} = State) ->
-    {next_state, userauth, next_packet(State)};
-userauth(#ssh_msg_userauth_banner{message = Msg}, 
-	 #state{ssh_params = 
-		#ssh{userauth_quiet_mode = false, role = client}} = State) ->
-    io:format("~s", [Msg]),
-    {next_state, userauth, next_packet(State)}.
-
-
-
-userauth_keyboard_interactive(#ssh_msg_userauth_info_request{} = Msg, 
-			      #state{ssh_params = #ssh{role = client, 
-						       io_cb = IoCb} = Ssh0} = State) ->
-    {ok, {Reply, Ssh}} = ssh_auth:handle_userauth_info_request(Msg, IoCb, Ssh0),
-    send_msg(Reply, State),
-    {next_state, userauth_keyboard_interactive_info_response, next_packet(State#state{ssh_params = Ssh})};
-
-userauth_keyboard_interactive(#ssh_msg_userauth_info_response{} = Msg, 
-			      #state{ssh_params = #ssh{role = server,
-						       peer = {_, Address}} = Ssh0,
-				     opts = Opts, starter = Pid} = State) ->
-    case ssh_auth:handle_userauth_info_response(Msg, Ssh0) of
+%%% ######## {userauth_keyboard_interactive, client|server}
+
+handle_event(_, #ssh_msg_userauth_info_request{} = Msg, {userauth_keyboard_interactive, client},
+	     #data{ssh_params = Ssh0} = D) ->
+    {ok, {Reply, Ssh}} = ssh_auth:handle_userauth_info_request(Msg, Ssh0#ssh.io_cb, Ssh0),
+    send_bytes(Reply, D),
+    {next_state, {userauth_keyboard_interactive_info_response,client}, D#data{ssh_params = Ssh}};
+
+handle_event(_, #ssh_msg_userauth_info_response{} = Msg, {userauth_keyboard_interactive, server}, D) ->
+    case ssh_auth:handle_userauth_info_response(Msg, D#data.ssh_params) of
 	{authorized, User, {Reply, Ssh}} ->
-	    send_msg(Reply, State),
-	    Pid ! ssh_connected,
-	    connected_fun(User, Address, "keyboard-interactive", Opts),
-	    {next_state, connected, 
-	     next_packet(State#state{auth_user = User, ssh_params = Ssh#ssh{authenticated = true}})};
+	    send_bytes(Reply, D),
+	    D#data.starter ! ssh_connected,
+	    connected_fun(User, "keyboard-interactive", D),
+	    {next_state, {connected,server}, D#data{auth_user = User,
+						    ssh_params = Ssh#ssh{authenticated = true}}};
 	{not_authorized, {User, Reason}, {Reply, Ssh}} ->
-	    retry_fun(User, Address, Reason, Opts),
-	    send_msg(Reply, State),
-	    {next_state, userauth, next_packet(State#state{ssh_params = Ssh})} 
+	    retry_fun(User, Reason, D),
+	    send_bytes(Reply, D),
+	    {next_state, {userauth,server}, D#data{ssh_params = Ssh}}
     end;
-userauth_keyboard_interactive(Msg = #ssh_msg_userauth_failure{},
-			      #state{ssh_params = Ssh0 =
-					 #ssh{role = client,
-					      userauth_preference = Prefs0}} 
-			      = State) ->
-    Prefs = [{Method,M,F,A} || {Method,M,F,A} <- Prefs0,
+
+handle_event(_, Msg = #ssh_msg_userauth_failure{}, {userauth_keyboard_interactive, client},
+	     #data{ssh_params = Ssh0} = D0) ->
+    Prefs = [{Method,M,F,A} || {Method,M,F,A} <- Ssh0#ssh.userauth_preference,
 			       Method =/= "keyboard-interactive"],
-    userauth(Msg, State#state{ssh_params = Ssh0#ssh{userauth_preference=Prefs}}).
+    D = D0#data{ssh_params = Ssh0#ssh{userauth_preference=Prefs}},
+    {next_state, {userauth,client}, D, [{next_event, internal, Msg}]};
 
+handle_event(_, Msg=#ssh_msg_userauth_failure{}, {userauth_keyboard_interactive_info_response, client}, D) ->
+    {next_state, {userauth,client}, D, [{next_event, internal, Msg}]};
 
+handle_event(_, Msg=#ssh_msg_userauth_success{}, {userauth_keyboard_interactive_info_response, client}, D) ->
+    {next_state, {userauth,client}, D, [{next_event, internal, Msg}]};
 
-userauth_keyboard_interactive_info_response(Msg=#ssh_msg_userauth_failure{},
-					    #state{ssh_params = #ssh{role = client}} = State) ->
-    userauth(Msg, State);
-userauth_keyboard_interactive_info_response(Msg=#ssh_msg_userauth_success{},
-					    #state{ssh_params = #ssh{role = client}} = State) ->
-    userauth(Msg, State);
-userauth_keyboard_interactive_info_response(Msg=#ssh_msg_userauth_info_request{},
-					    #state{ssh_params = #ssh{role = client}} = State) ->
-    userauth_keyboard_interactive(Msg, State).
+handle_event(_, Msg=#ssh_msg_userauth_info_request{}, {userauth_keyboard_interactive_info_response, client}, D) ->
+    {next_state, {userauth_keyboard_interactive,client}, D, [{next_event, internal, Msg}]};
 
-%%--------------------------------------------------------------------
--spec connected({#ssh_msg_kexinit{}, binary()}, %%| %% #ssh_msg_kexdh_init{},
-		 #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
-connected({#ssh_msg_kexinit{}, _Payload} = Event, #state{ssh_params = Ssh0} = State0) ->
-    {KeyInitMsg, SshPacket, Ssh} = ssh_transport:key_exchange_init_msg(Ssh0),
-    State = State0#state{ssh_params = Ssh,
-			 key_exchange_init_msg = KeyInitMsg,
-			 renegotiate = true},
-    send_msg(SshPacket, State),
-    kexinit(Event, State).
 
-%%--------------------------------------------------------------------
--spec handle_event(#ssh_msg_disconnect{} | #ssh_msg_ignore{} | #ssh_msg_debug{} |
-		   #ssh_msg_unimplemented{} | {adjust_window, integer(), integer()} |
-		   {reply_request, success | failure, integer()} | renegotiate |
-		   data_size | {request, pid(), integer(), integer(), iolist()} |
-		   {request, integer(), integer(), iolist()}, state_name(),
-		   #state{}) -> gen_fsm_state_return().
+%%% ######## {connected, client|server} ####
 
-%%--------------------------------------------------------------------
-handle_event(#ssh_msg_disconnect{description = Desc} = DisconnectMsg, _StateName, #state{} = State) ->
-    handle_disconnect(peer, DisconnectMsg, State),
-    {stop, {shutdown, Desc}, State};
-
-handle_event(#ssh_msg_ignore{}, StateName, State) ->
-    {next_state, StateName, next_packet(State)};
-
-handle_event(#ssh_msg_debug{always_display = Display, message = DbgMsg, language=Lang}, 
-	     StateName, #state{opts = Opts} = State) ->
-    F = proplists:get_value(ssh_msg_debug_fun, Opts, 
-			    fun(_ConnRef, _AlwaysDisplay, _Msg, _Language) -> ok end
-			   ),
-    catch F(self(), Display, DbgMsg, Lang),
-    {next_state, StateName, next_packet(State)};
-
-handle_event(#ssh_msg_unimplemented{}, StateName, State) ->
-    {next_state, StateName, next_packet(State)};
-
-handle_event(renegotiate, connected, #state{ssh_params = Ssh0} 
-	     = State) ->
-    {KeyInitMsg, SshPacket, Ssh} = ssh_transport:key_exchange_init_msg(Ssh0),
-    send_msg(SshPacket, State),
-    timer:apply_after(?REKEY_TIMOUT, gen_fsm, send_all_state_event, [self(), renegotiate]),
-    {next_state, kexinit,
-     next_packet(State#state{ssh_params = Ssh,
-			     key_exchange_init_msg = KeyInitMsg,
-			     renegotiate = true})};
-
-handle_event(renegotiate, StateName, State) ->
+handle_event(_, {#ssh_msg_kexinit{},_} = Event, {connected,Role}, D0) ->
+    {KeyInitMsg, SshPacket, Ssh} = ssh_transport:key_exchange_init_msg(D0#data.ssh_params),
+    D = D0#data{ssh_params = Ssh,
+		key_exchange_init_msg = KeyInitMsg},
+    send_bytes(SshPacket, D),
+    {next_state, {kexinit,Role,renegotiate}, D, [{next_event, internal, Event}]};
+
+handle_event(_, #ssh_msg_disconnect{description=Desc} = Msg, StateName, D0) ->
+    {disconnect, _, {{replies,Replies}, _}} =
+	ssh_connection:handle_msg(Msg, D0#data.connection_state, role(StateName)),
+    {Actions,D} = send_replies(Replies, D0),
+    disconnect_fun(Desc, D),
+    {stop_and_reply, {shutdown,Desc}, Actions, D};
+
+handle_event(_, #ssh_msg_ignore{}, _, _) ->
+    keep_state_and_data;
+
+handle_event(_, #ssh_msg_unimplemented{}, _, _) ->
+    keep_state_and_data;
+
+handle_event(_, #ssh_msg_debug{} = Msg, _, D) ->
+    debug_fun(Msg, D),
+    keep_state_and_data;
+
+handle_event(internal, Msg=#ssh_msg_global_request{},            StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_request_success{},           StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_request_failure{},           StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_open{},              StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_open_confirmation{}, StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_open_failure{},      StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_window_adjust{},     StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_data{},              StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_extended_data{},     StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_eof{},               StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_close{},             StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_request{},           StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_success{},           StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+handle_event(internal, Msg=#ssh_msg_channel_failure{},           StateName, D) ->
+    handle_connection_msg(Msg, StateName, D);
+
+
+handle_event(cast, renegotiate, {connected,Role}, D) ->
+    {KeyInitMsg, SshPacket, Ssh} = ssh_transport:key_exchange_init_msg(D#data.ssh_params),
+    send_bytes(SshPacket, D),
+    timer:apply_after(?REKEY_TIMOUT, gen_statem, cast, [self(), renegotiate]),
+    {next_state, {kexinit,Role,renegotiate}, D#data{ssh_params = Ssh,
+						    key_exchange_init_msg = KeyInitMsg}};
+
+handle_event(cast, renegotiate, _, _) ->
     %% Already in key-exchange so safe to ignore
-    {next_state, StateName, State};
+    timer:apply_after(?REKEY_TIMOUT, gen_statem, cast, [self(), renegotiate]), % FIXME: not here in original
+    keep_state_and_data;
+
 
 %% Rekey due to sent data limit reached?
-handle_event(data_size, connected, #state{ssh_params = Ssh0} = State) ->
-    {ok, [{send_oct,Sent0}]} = inet:getstat(State#state.socket, [send_oct]),
-    Sent = Sent0 - State#state.last_size_rekey,
-    MaxSent = proplists:get_value(rekey_limit, State#state.opts, 1024000000),
-    timer:apply_after(?REKEY_DATA_TIMOUT, gen_fsm, send_all_state_event, [self(), data_size]),
+handle_event(cast, data_size, {connected,Role}, D) ->
+    {ok, [{send_oct,Sent0}]} = inet:getstat(D#data.socket, [send_oct]),
+    Sent = Sent0 - D#data.last_size_rekey,
+    MaxSent = proplists:get_value(rekey_limit, D#data.opts, 1024000000),
+    timer:apply_after(?REKEY_DATA_TIMOUT, gen_statem, cast, [self(), data_size]),
     case Sent >= MaxSent of
 	true ->
-	    {KeyInitMsg, SshPacket, Ssh} = ssh_transport:key_exchange_init_msg(Ssh0),
-	    send_msg(SshPacket, State),
-	    {next_state, kexinit,
-	     next_packet(State#state{ssh_params = Ssh,
-				     key_exchange_init_msg = KeyInitMsg,
-				     renegotiate = true,
-				     last_size_rekey = Sent0})};
+	    {KeyInitMsg, SshPacket, Ssh} =
+		ssh_transport:key_exchange_init_msg(D#data.ssh_params),
+	    send_bytes(SshPacket, D),
+	    {next_state, {kexinit,Role,renegotiate}, D#data{ssh_params = Ssh,
+							    key_exchange_init_msg = KeyInitMsg,
+							    last_size_rekey = Sent0}};
 	_ ->
-	    {next_state, connected, next_packet(State)}
+	    keep_state_and_data
     end;
-handle_event(data_size, StateName, State) ->
+
+handle_event(cast, data_size, _, _) ->
     %% Already in key-exchange so safe to ignore
-    {next_state, StateName, State};
-
-handle_event(Event, StateName, State) when StateName /= connected ->
-    Events = [{event, Event} | State#state.event_queue],
-    {next_state, StateName, State#state{event_queue = Events}};
-
-handle_event({adjust_window, ChannelId, Bytes}, StateName,
-	     #state{connection_state =
-			#connection{channel_cache = Cache}} = State0) ->
-    State =
-	case ssh_channel:cache_lookup(Cache, ChannelId) of
-	    #channel{recv_window_size = WinSize,
-		     recv_window_pending = Pending,
-		     recv_packet_size = PktSize} = Channel
-	      when (WinSize-Bytes) >= 2*PktSize ->
-		%% The peer can send at least two more *full* packet, no hurry.
-		ssh_channel:cache_update(Cache, 
-					 Channel#channel{recv_window_pending = Pending + Bytes}),
-		State0;
-
-	    #channel{recv_window_size = WinSize,
-		     recv_window_pending = Pending,
-		     remote_id = Id} = Channel ->
-		%% Now we have to update the window - we can't receive so many more pkts
-		ssh_channel:cache_update(Cache, 
-					 Channel#channel{recv_window_size =
-							     WinSize + Bytes + Pending,
-							 recv_window_pending = 0}),
-		Msg = ssh_connection:channel_adjust_window_msg(Id, Bytes + Pending),
-		send_replies([{connection_reply, Msg}], State0);
+    timer:apply_after(?REKEY_DATA_TIMOUT, gen_statem, cast, [self(), data_size]),  % FIXME: not here in original
+    keep_state_and_data;
+
+
+
+handle_event(cast, _, StateName, _) when StateName /= {connected,server},
+					 StateName /= {connected,client} ->
+    {keep_state_and_data, [postpone]};
+
+
+handle_event(cast, {adjust_window,ChannelId,Bytes}, {connected,_}, D) ->
+    case ssh_channel:cache_lookup(cache(D), ChannelId) of
+	#channel{recv_window_size = WinSize,
+		 recv_window_pending = Pending,
+		 recv_packet_size = PktSize} = Channel
+	  when (WinSize-Bytes) >= 2*PktSize ->
+	    %% The peer can send at least two more *full* packet, no hurry.
+	    ssh_channel:cache_update(cache(D),
+				     Channel#channel{recv_window_pending = Pending + Bytes}),
+	    keep_state_and_data;
+
+	#channel{recv_window_size = WinSize,
+		 recv_window_pending = Pending,
+		 remote_id = Id} = Channel ->
+	    %% Now we have to update the window - we can't receive so many more pkts
+	    ssh_channel:cache_update(cache(D),
+				     Channel#channel{recv_window_size =
+							 WinSize + Bytes + Pending,
+						     recv_window_pending = 0}),
+	    Msg = ssh_connection:channel_adjust_window_msg(Id, Bytes + Pending),
+	    {keep_state, send_msg(Msg,D)};
 
-	    undefined ->
-		State0
-	end,
-    {next_state, StateName, next_packet(State)};
-
-handle_event({reply_request, success, ChannelId}, StateName,
-		  #state{connection_state =
-			     #connection{channel_cache = Cache}} = State0) ->
-    State = case ssh_channel:cache_lookup(Cache, ChannelId) of
-		#channel{remote_id = RemoteId} ->
-		    Msg = ssh_connection:channel_success_msg(RemoteId),
-		    send_replies([{connection_reply, Msg}], State0);
-		undefined ->
-		    State0
-	    end,
-    {next_state, StateName, State};
-
-handle_event({request, ChannelPid, ChannelId, Type, Data}, StateName, State0) ->
-    {{replies, Replies}, State1} = handle_request(ChannelPid, ChannelId,
-						 Type, Data,
-						 false, none, State0),
-    State = send_replies(Replies, State1),
-    {next_state, StateName, next_packet(State)};
-
-handle_event({request, ChannelId, Type, Data}, StateName, State0) ->
-    {{replies, Replies}, State1} = handle_request(ChannelId, Type, Data,
-						 false, none, State0),
-    State = send_replies(Replies, State1),
-    {next_state, StateName, next_packet(State)};
-
-handle_event({unknown, Data}, StateName, State) ->
+	undefined ->
+	    keep_state_and_data
+    end;
+
+handle_event(cast, {reply_request,success,ChannelId}, {connected,_}, D) ->
+    case ssh_channel:cache_lookup(cache(D), ChannelId) of
+	#channel{remote_id = RemoteId} ->
+	    Msg = ssh_connection:channel_success_msg(RemoteId),
+	    {keep_state, send_msg(Msg,D)};
+
+	undefined ->
+	    keep_state_and_data
+    end;
+
+handle_event(cast, {request,ChannelPid, ChannelId, Type, Data}, {connected,_}, D) ->
+    {keep_state,  handle_request(ChannelPid, ChannelId, Type, Data, false, none, D)};
+
+handle_event(cast, {request,ChannelId,Type,Data}, {connected,_}, D) ->
+    {keep_state,  handle_request(ChannelId, Type, Data, false, none, D)};
+
+handle_event(cast, {unknown,Data}, {connected,_}, D) ->
     Msg = #ssh_msg_unimplemented{sequence = Data},
-    send_msg(Msg, State),
-    {next_state, StateName, next_packet(State)}.
+    {keep_state, send_msg(Msg,D)};
 
-%%--------------------------------------------------------------------
--spec handle_sync_event({request, pid(), channel_id(), integer(), binary(), timeout()} |
-			{request, channel_id(), integer(), binary(), timeout()} |
-			{global_request, pid(), integer(), boolean(), binary()} | {eof, integer()} |
-			{open, pid(), integer(), channel_id(), integer(), binary(), _} |
-			{send_window, channel_id()} | {recv_window, channel_id()} |
-			{connection_info, [client_version | server_version | peer |
-					   sockname]} | {channel_info, channel_id(), [recv_window |
-										      send_window]} |
-			{close, channel_id()} | stop, term(), state_name(), #state{})
-		       -> gen_fsm_sync_return().
-%%--------------------------------------------------------------------
-handle_sync_event(get_print_info, _From, StateName, State) ->
+%%% Previously handle_sync_event began here
+handle_event({call,From}, get_print_info, StateName, D) ->
     Reply =
 	try
-	    {inet:sockname(State#state.socket),
-	     inet:peername(State#state.socket)
+	    {inet:sockname(D#data.socket),
+	     inet:peername(D#data.socket)
 	    }
 	of
-	    {{ok,Local}, {ok,Remote}} -> {{Local,Remote},io_lib:format("statename=~p",[StateName])};
-	    _ -> {{"-",0},"-"}
+	    {{ok,Local}, {ok,Remote}} -> 
+		{{Local,Remote},io_lib:format("statename=~p",[StateName])};
+	    _ ->
+		{{"-",0},"-"}
 	catch
-	    _:_ -> {{"?",0},"?"}
+	    _:_ ->
+		{{"?",0},"?"}
 	end,
-    {reply, Reply, StateName, State};
+    {keep_state_and_data, [{reply,From,Reply}]};
 
-handle_sync_event({connection_info, Options}, _From, StateName, State) ->
-    Info = ssh_info(Options, State, []),
-    {reply, Info, StateName, State};
+handle_event({call,From}, {connection_info, Options}, _, D) ->
+    Info = ssh_info(Options, D, []),
+    {keep_state_and_data, [{reply,From,Info}]};
 
-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 ->
+handle_event({call,From}, {channel_info,ChannelId,Options}, _, D) ->
+    case ssh_channel:cache_lookup(cache(D), ChannelId) of
+	#channel{} = Channel ->
 	    Info = ssh_channel_info(Options, Channel, []),
-	    {reply, Info, StateName, State};
+	    {keep_state_and_data, [{reply,From,Info}]};
 	undefined ->
-	    {reply, [], StateName, State}
+	    {keep_state_and_data, [{reply,From,[]}]}
     end;
 
-handle_sync_event({info, ChannelPid}, _From, StateName,
-	    #state{connection_state =
-		       #connection{channel_cache = Cache}} = State) ->
+
+handle_event({call,From}, {info, all}, _, D) ->
+    Result = ssh_channel:cache_foldl(fun(Channel, Acc) ->
+					     [Channel | Acc]
+				     end,
+				     [], cache(D)),
+    {keep_state_and_data, [{reply, From, {ok,Result}}]};
+    
+handle_event({call,From}, {info, ChannelPid}, _, D) ->
     Result = ssh_channel:cache_foldl(
-	       fun(Channel, Acc) when ChannelPid == all;
-				      Channel#channel.user == ChannelPid ->
+	       fun(Channel, Acc) when Channel#channel.user == ChannelPid ->
 		       [Channel | Acc];
 		  (_, Acc) ->
 		       Acc
-	       end, [], Cache),
-    {reply, {ok, Result}, StateName, State};
+	       end, [], cache(D)),
+    {keep_state_and_data, [{reply, From, {ok,Result}}]};
 
-handle_sync_event(stop, _, _StateName, #state{connection_state = Connection0,
-					     role = Role} = State0) ->
+handle_event({call,From}, stop, StateName, D0) ->
     {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),
-    {stop, normal, ok, State#state{connection_state = Connection}};
-
-
-handle_sync_event(Event, From, StateName, State) when StateName /= connected ->
-    Events = [{sync, Event, From} | State#state.event_queue],
-    {next_state, StateName, State#state{event_queue = Events}};
-
-handle_sync_event({request, ChannelPid, ChannelId, Type, Data, Timeout}, From,  StateName, State0) ->
-    {{replies, Replies}, State1} = handle_request(ChannelPid,
-						 ChannelId, Type, Data,
-						 true, From, State0),
-    %% Note reply to channel will happen later when
-    %% reply is recived from peer on the socket
-    State = send_replies(Replies, State1),
-    start_timeout(ChannelId, From, Timeout),
-    handle_idle_timeout(State),
-    {next_state, StateName, next_packet(State)};
-
-handle_sync_event({request, ChannelId, Type, Data, Timeout}, From,  StateName, State0) ->
-    {{replies, Replies}, State1} = handle_request(ChannelId, Type, Data,
-						 true, From, State0),
-    %% Note reply to channel will happen later when
-    %% reply is recived from peer on the socket
-    State = send_replies(Replies, State1),
-    start_timeout(ChannelId, From, Timeout),
-    handle_idle_timeout(State),
-    {next_state, StateName, next_packet(State)};
-
-handle_sync_event({global_request, Pid, _, _, _} = Request, From, StateName,
-		  #state{connection_state =
-			     #connection{channel_cache = Cache}} = State0) ->
-    State1 = handle_global_request(Request, State0),
-    Channel = ssh_channel:cache_find(Pid, Cache),
-    State = add_request(true, Channel#channel.local_id, From, State1),
-    {next_state, StateName, next_packet(State)};
-
-handle_sync_event({data, ChannelId, Type, Data, Timeout}, From, StateName,
-		  #state{connection_state = #connection{channel_cache = _Cache}
-			 = Connection0} = State0) ->
-
-    case ssh_connection:channel_data(ChannelId, Type, Data, Connection0, From) of
-	{{replies, Replies}, Connection} ->
-	    State = send_replies(Replies,  State0#state{connection_state = Connection}),
-	    start_timeout(ChannelId, From, Timeout),
-	    {next_state, StateName, next_packet(State)};
-	{noreply, Connection} ->
-	    start_timeout(ChannelId, From, Timeout),
-	    {next_state, StateName, next_packet(State0#state{connection_state = Connection})}
-    end;
-
-handle_sync_event({eof, ChannelId}, _From, StateName,
-		  #state{connection_state =
-			     #connection{channel_cache = Cache}} = State0) ->
-    case ssh_channel:cache_lookup(Cache, ChannelId) of
+						      description = "User closed down connection"},
+				  D0#data.connection_state,
+				  role(StateName)),
+    {Repls,D} = send_replies(Replies, D0),
+    {stop_and_reply, normal, [{reply,From,ok}|Repls], D#data{connection_state=Connection}};
+
+handle_event({call,_}, _, StateName, _) when StateName /= {connected,server},
+					     StateName /= {connected,client}  ->
+    {keep_state_and_data, [postpone]};
+
+handle_event({call,From}, {request, ChannelPid, ChannelId, Type, Data, Timeout}, {connected,_}, D0) ->
+    D = handle_request(ChannelPid, ChannelId, Type, Data, true, From, D0),
+    %% Note reply to channel will happen later when reply is recived from peer on the socket
+    start_channel_request_timer(ChannelId, From, Timeout),
+    {keep_state, cache_request_idle_timer_check(D)};
+
+handle_event({call,From}, {request, ChannelId, Type, Data, Timeout}, {connected,_}, D0) ->
+    D = handle_request(ChannelId, Type, Data, true, From, D0),
+    %% Note reply to channel will happen later when reply is recived from peer on the socket
+    start_channel_request_timer(ChannelId, From, Timeout),
+    {keep_state, cache_request_idle_timer_check(D)};
+
+handle_event({call,From}, {global_request, Pid, _, _, _} = Request, {connected,_}, D0) ->
+    D1 = handle_global_request(Request, D0),
+    Channel = ssh_channel:cache_find(Pid, cache(D1)),
+    D = add_request(true, Channel#channel.local_id, From, D1),
+    {keep_state, D};
+
+handle_event({call,From}, {data, ChannelId, Type, Data, Timeout}, {connected,_}, D0) ->
+    {{replies, Replies}, Connection} =
+	ssh_connection:channel_data(ChannelId, Type, Data, D0#data.connection_state, From),
+    {Repls,D} = send_replies(Replies, D0#data{connection_state = Connection}),
+    start_channel_request_timer(ChannelId, From, Timeout), % FIXME: No message exchange so why?
+    {keep_state, D, Repls};
+
+handle_event({call,From}, {eof, ChannelId}, {connected,_}, D0) ->
+    case ssh_channel:cache_lookup(cache(D0), ChannelId) of
 	#channel{remote_id = Id, sent_close = false} ->
-	    State = send_replies([{connection_reply,
-			  ssh_connection:channel_eof_msg(Id)}], State0),
-	    {reply, ok, StateName, next_packet(State)};
+	    D = send_msg(ssh_connection:channel_eof_msg(Id), D0),
+	    {keep_state, D, [{reply,From,ok}]};
 	_ ->
-	    {reply, {error,closed}, StateName, State0}
+	    {keep_state, D0, [{reply,From,{error,closed}}]}
     end;
 
-handle_sync_event({open, ChannelPid, Type, InitialWindowSize, MaxPacketSize, Data, Timeout},
-		  From,  StateName, #state{connection_state =
-					       #connection{channel_cache = Cache}} = State0) ->
+handle_event({call,From},
+	     {open, ChannelPid, Type, InitialWindowSize, MaxPacketSize, Data, Timeout},
+	     {connected,_},
+	     D0) ->
     erlang:monitor(process, ChannelPid),
-    {ChannelId, State1}  = new_channel_id(State0),
-    Msg = ssh_connection:channel_open_msg(Type, ChannelId,
-					  InitialWindowSize,
-					  MaxPacketSize, Data),
-    State2 = send_replies([{connection_reply, Msg}], State1),
-    Channel = #channel{type = Type,
-		       sys = "none",
-		       user = ChannelPid,
-		       local_id = ChannelId,
-		       recv_window_size = InitialWindowSize,
-		       recv_packet_size = MaxPacketSize,
-		       send_buf = queue:new()
-		      },
-    ssh_channel:cache_update(Cache, Channel),
-    State = add_request(true, ChannelId, From, State2),
-    start_timeout(ChannelId, From, Timeout),
-    {next_state, StateName, next_packet(remove_timer_ref(State))};
-
-handle_sync_event({send_window, ChannelId}, _From, StateName,
-		  #state{connection_state =
-			     #connection{channel_cache = Cache}} = State) ->
-    Reply = case ssh_channel:cache_lookup(Cache, ChannelId) of
+    {ChannelId, D1} = new_channel_id(D0),
+    D2 = send_msg(ssh_connection:channel_open_msg(Type, ChannelId,
+						  InitialWindowSize,
+						  MaxPacketSize, Data),
+		  D1),
+    ssh_channel:cache_update(cache(D2), 
+			     #channel{type = Type,
+				      sys = "none",
+				      user = ChannelPid,
+				      local_id = ChannelId,
+				      recv_window_size = InitialWindowSize,
+				      recv_packet_size = MaxPacketSize,
+				      send_buf = queue:new()
+				     }),
+    D = add_request(true, ChannelId, From, D2),
+    start_channel_request_timer(ChannelId, From, Timeout),
+    {keep_state, cache_cancel_idle_timer(D)};
+
+handle_event({call,From}, {send_window, ChannelId}, {connected,_}, D) ->
+    Reply = case ssh_channel:cache_lookup(cache(D), ChannelId) of
 		#channel{send_window_size = WinSize,
 			 send_packet_size = Packsize} ->
 		    {ok, {WinSize, Packsize}};
 		undefined ->
 		    {error, einval}
 	    end,
-    {reply, Reply, StateName, next_packet(State)};
-
-handle_sync_event({recv_window, ChannelId}, _From, StateName,
-		  #state{connection_state = #connection{channel_cache = Cache}}
-	     = State) ->
+    {keep_state_and_data, [{reply,From,Reply}]};
 
-    Reply = case ssh_channel:cache_lookup(Cache, ChannelId) of
+handle_event({call,From}, {recv_window, ChannelId}, {connected,_}, D) ->
+    Reply = case ssh_channel:cache_lookup(cache(D), ChannelId) of
 		#channel{recv_window_size = WinSize,
 			 recv_packet_size = Packsize} ->
 		    {ok, {WinSize, Packsize}};
 		undefined ->
 		    {error, einval}
 	    end,
-    {reply, Reply, StateName, next_packet(State)};
-
-handle_sync_event({close, ChannelId}, _, StateName,
-		  #state{connection_state =
-			     #connection{channel_cache = Cache}} = State0) ->
-    State =
-	case ssh_channel:cache_lookup(Cache, ChannelId) of
-	    #channel{remote_id = Id} = Channel ->
-		State1 = send_replies([{connection_reply,
-				       ssh_connection:channel_close_msg(Id)}], State0),
-		ssh_channel:cache_update(Cache, Channel#channel{sent_close = true}),
-		handle_idle_timeout(State1),
-		State1;
-	    undefined ->
-		State0
-	end,
-    {reply, ok, StateName, next_packet(State)}.
+    {keep_state_and_data, [{reply,From,Reply}]};
 
-%%--------------------------------------------------------------------
--spec handle_info({atom(), port(), binary()} | {atom(), port()} |
-		  term (), state_name(), #state{}) -> gen_fsm_state_return().
-%%--------------------------------------------------------------------
+handle_event({call,From}, {close, ChannelId}, {connected,_}, D0) ->
+    case ssh_channel:cache_lookup(cache(D0), ChannelId) of
+	#channel{remote_id = Id} = Channel ->
+	    D1 = send_msg(ssh_connection:channel_close_msg(Id), D0),
+	    ssh_channel:cache_update(cache(D1), Channel#channel{sent_close = true}),
+	    {keep_state, cache_request_idle_timer_check(D1), [{reply,From,ok}]};
+	undefined ->
+	    {keep_state_and_data, [{reply,From,ok}]}
+    end;
+
+
+%%===== Reception of encrypted bytes, decryption and framing
+handle_event(info, {Proto, Sock, Info}, {hello,_}, #data{socket = Sock,
+							 transport_protocol = Proto}) ->
+    case Info of
+	"SSH-" ++ _ ->  
+	    {keep_state_and_data, [{next_event, internal, {version_exchange,Info}}]};
+	_ ->
+	    {keep_state_and_data, [{next_event, internal, {info_line,Info}}]}
+    end;
 
-handle_info({Protocol, Socket, "SSH-" ++ _ = Version}, hello, 
-	    #state{socket = Socket,
-		   transport_protocol = Protocol} = State ) -> 
-    event({version_exchange, Version}, hello, State);
-
-handle_info({Protocol, Socket, Info}, hello, 
-	    #state{socket = Socket,
-		   transport_protocol = Protocol} = State) -> 
-    event({info_line, Info}, hello, State);
-
-handle_info({Protocol, Socket, Data}, StateName, 
-	    #state{socket = Socket,
-		   transport_protocol = Protocol,
-		   ssh_params = Ssh0,
-		   decoded_data_buffer = DecData0,
-		   encoded_data_buffer = EncData0,
-		   undecoded_packet_length = RemainingSshPacketLen0} = State0) ->
-    Encoded = <<EncData0/binary, Data/binary>>,
-    try ssh_transport:handle_packet_part(DecData0, Encoded, RemainingSshPacketLen0, Ssh0) 
+handle_event(info, {Proto, Sock, NewData}, StateName, D0 = #data{socket = Sock,
+								 transport_protocol = Proto}) ->
+    try ssh_transport:handle_packet_part(
+	  D0#data.decrypted_data_buffer,
+	  <<(D0#data.encrypted_data_buffer)/binary, NewData/binary>>,
+	  D0#data.undecrypted_packet_length,
+	  D0#data.ssh_params)
     of
-	{get_more, DecBytes, EncDataRest, RemainingSshPacketLen, Ssh1} ->
-	    {next_state, StateName,
-	     next_packet(State0#state{encoded_data_buffer = EncDataRest,
-				      decoded_data_buffer = DecBytes,
-				      undecoded_packet_length = RemainingSshPacketLen,
-				      ssh_params = Ssh1})};
-	{decoded, MsgBytes, EncDataRest, Ssh1} ->
-	    generate_event(MsgBytes, StateName,
-			   State0#state{ssh_params = Ssh1,
-					%% Important to be set for
-					%% next_packet
-%%% FIXME: the following three seem to always be set in generate_event!
-					decoded_data_buffer = <<>>,
-					undecoded_packet_length = undefined,
-					encoded_data_buffer = EncDataRest},
-			   EncDataRest);
+	{packet_decrypted, DecryptedBytes, EncryptedDataRest, Ssh1} ->
+	    D = D0#data{ssh_params =
+			    Ssh1#ssh{recv_sequence = ssh_transport:next_seqnum(Ssh1#ssh.recv_sequence)},
+			decrypted_data_buffer = <<>>,
+			undecrypted_packet_length = undefined,
+			encrypted_data_buffer = EncryptedDataRest},
+	    try
+		ssh_message:decode(set_kex_overload_prefix(DecryptedBytes,D))
+	    of
+		Msg = #ssh_msg_kexinit{} ->
+		    {keep_state, D, [{next_event, internal, {Msg,DecryptedBytes}},
+				     {next_event, internal, prepare_next_packet}
+				    ]};
+		Msg ->
+		    {keep_state, D, [{next_event, internal, Msg},
+				     {next_event, internal, prepare_next_packet}
+				    ]}
+	    catch
+		_C:_E  ->
+		    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+						   description = "Encountered unexpected input"},
+			       StateName, D)
+	    end;
+
+	{get_more, DecryptedBytes, EncryptedDataRest, RemainingSshPacketLen, Ssh1} ->
+	    %% Here we know that there are not enough bytes in
+	    %% EncryptedDataRest to use. We must wait for more.
+	    inet:setopts(Sock, [{active, once}]),
+	    {keep_state, D0#data{encrypted_data_buffer = EncryptedDataRest,
+				 decrypted_data_buffer = DecryptedBytes,
+				 undecrypted_packet_length = RemainingSshPacketLen,
+				 ssh_params = Ssh1}};
+
 	{bad_mac, Ssh1} ->
-	    DisconnectMsg = 
-		    #ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-					description = "Bad mac",
-					language = ""},
-	    handle_disconnect(DisconnectMsg, State0#state{ssh_params=Ssh1});
+	    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+					   description = "Bad mac"},
+		       StateName, D0#data{ssh_params=Ssh1});
 
 	{error, {exceeds_max_size,PacketLen}} ->
-	    DisconnectMsg = 
-		#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-				    description = "Bad packet length " 
-				    ++ integer_to_list(PacketLen),
-				    language = ""},
-	    handle_disconnect(DisconnectMsg, State0)
+	    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+					   description = "Bad packet length "
+					   ++ integer_to_list(PacketLen)},
+		       StateName, D0)
     catch
-	_:_ ->
-	    DisconnectMsg = 
-		#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-				    description = "Bad packet",
-				    language = ""},
-	    handle_disconnect(DisconnectMsg, State0)
+	_C:_E ->
+	    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+					   description = "Bad packet"},
+		       StateName, D0)
     end;
-		
-handle_info({CloseTag, _Socket}, _StateName, 
-	    #state{transport_close_tag = CloseTag,
-		   ssh_params = #ssh{role = _Role, opts = _Opts}} = State) ->
-    DisconnectMsg = 
-	#ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
-			    description = "Connection closed",
-			    language = "en"},
-    handle_disconnect(DisconnectMsg, State);
-
-handle_info({timeout, {_, From} = Request}, Statename,
-	    #state{connection_state = #connection{requests = Requests} = Connection} = State) ->
+
+
+%%%==== 
+handle_event(internal, prepare_next_packet, _, D) ->
+    Enough =  erlang:max(8, D#data.ssh_params#ssh.decrypt_block_size),
+    case size(D#data.encrypted_data_buffer) of
+	Sz when Sz >= Enough ->
+	    self() ! {D#data.transport_protocol, D#data.socket, <<>>};
+	_ ->
+	    inet:setopts(D#data.socket, [{active, once}])
+    end,
+    keep_state_and_data;
+
+handle_event(info, {CloseTag,Socket}, StateName,
+	     D = #data{socket = Socket,
+		       transport_close_tag = CloseTag}) ->
+    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
+				   description = "Connection closed"},
+	       StateName, D);
+
+handle_event(info, {timeout, {_, From} = Request}, _,
+	     #data{connection_state = #connection{requests = Requests} = C0} = D) ->
     case lists:member(Request, Requests) of
 	true ->
-	    gen_fsm:reply(From, {error, timeout}),
-	    {next_state, Statename,
-	     State#state{connection_state =
-			     Connection#connection{requests =
-						       lists:delete(Request, Requests)}}};
+	    %% A channel request is not answered in time. Answer {error,timeout}
+	    %% to the caller
+	    C = C0#connection{requests = lists:delete(Request, Requests)},
+	    {keep_state, D#data{connection_state=C}, [{reply,From,{error,timeout}}]};
 	false ->
-	    {next_state, Statename, State}
+	    %% The request is answered - just ignore the timeout
+	    keep_state_and_data
     end;
 
 %%% Handle that ssh channels user process goes down
-handle_info({'DOWN', _Ref, process, ChannelPid, _Reason}, Statename, State0) ->
-    {{replies, Replies}, State1} = handle_channel_down(ChannelPid, State0),
-    State = send_replies(Replies, State1),
-    {next_state, Statename, next_packet(State)};
+handle_event(info, {'DOWN', _Ref, process, ChannelPid, _Reason}, _, D0) ->
+    {{replies, Replies}, D1} = handle_channel_down(ChannelPid, D0),
+    {Repls, D} = send_replies(Replies, D1),
+    {keep_state, D, Repls};
 
 %%% So that terminate will be run when supervisor is shutdown
-handle_info({'EXIT', _Sup, Reason}, _StateName, State) ->
-    {stop, {shutdown, Reason}, State};
+handle_event(info, {'EXIT', _Sup, Reason}, _, _) ->
+    {stop, {shutdown, Reason}};
 
-handle_info({check_cache, _ , _},
-	    StateName, #state{connection_state =
-		       #connection{channel_cache = Cache}} = State) ->
-    {next_state, StateName, check_cache(State, Cache)};
+handle_event(info, check_cache, _, D) ->
+    {keep_state, cache_check_set_idle_timer(D)};
 
-handle_info(UnexpectedMessage, StateName, #state{opts = Opts,
-						 ssh_params = SshParams} = State) ->
-    case unexpected_fun(UnexpectedMessage, Opts, SshParams) of
+handle_event(info, UnexpectedMessage, StateName, D = #data{ssh_params = Ssh}) ->
+    case unexpected_fun(UnexpectedMessage, D) of
 	report ->
 	    Msg = lists:flatten(
 		    io_lib:format(
 		      "Unexpected message '~p' received in state '~p'\n"
 		      "Role: ~p\n"
 		      "Peer: ~p\n"
-		      "Local Address: ~p\n", [UnexpectedMessage, StateName,
-					      SshParams#ssh.role, SshParams#ssh.peer,
-					      proplists:get_value(address, SshParams#ssh.opts)])),
-	    error_logger:info_report(Msg);
+		      "Local Address: ~p\n", [UnexpectedMessage,
+					      StateName,
+					      Ssh#ssh.role, 
+					      Ssh#ssh.peer,
+					      proplists:get_value(address, Ssh#ssh.opts)])),
+	    error_logger:info_report(Msg),
+	    keep_state_and_data;
 
 	skip ->
-	    ok;
+	    keep_state_and_data;
 
 	Other ->
 	    Msg = lists:flatten(
@@ -1103,200 +1293,181 @@ handle_info(UnexpectedMessage, StateName, #state{opts = Opts,
 				  "Message: ~p\n"
 				  "Role: ~p\n"
 				  "Peer: ~p\n"
-				  "Local Address: ~p\n", [Other, UnexpectedMessage, 
-							  SshParams#ssh.role, 
-							  element(2,SshParams#ssh.peer),
-							  proplists:get_value(address, SshParams#ssh.opts)]
+				  "Local Address: ~p\n", [Other,
+							  UnexpectedMessage,
+							  Ssh#ssh.role,
+							  element(2,Ssh#ssh.peer),
+							  proplists:get_value(address, Ssh#ssh.opts)]
 				 )),
+	    error_logger:error_report(Msg),
+	    keep_state_and_data
+    end;
+
+handle_event(internal, {disconnect,Msg,_Reason}, StateName, D) ->
+    disconnect(Msg, StateName, D);
+
+handle_event(Type, Ev, StateName, D) ->
+    Descr =
+	case catch atom_to_list(element(1,Ev)) of
+	    "ssh_msg_" ++_ when Type==internal ->
+		"Message in wrong state";
+	    _ ->
+		"Internal error"
+	end,
+    disconnect(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+				   description = Descr},
+	       StateName, D).
 
-	    error_logger:error_report(Msg)
-    end,
-    {next_state, StateName, State}.
 
 %%--------------------------------------------------------------------
--spec terminate(Reason::term(), state_name(), #state{}) -> _.
-%%--------------------------------------------------------------------
-terminate(normal, _, #state{transport_cb = Transport,
-			    connection_state = Connection,
-			    socket = Socket}) ->
-    terminate_subsystem(Connection),
-    (catch Transport:close(Socket)),
-    ok;
+-spec terminate(any(),
+		state_name(),
+		#data{}
+	       ) -> finalize_termination_result() .
+			
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+terminate(normal, StateName, State) ->
+    finalize_termination(StateName, State);
 
 terminate({shutdown,{init,Reason}}, StateName, State) ->
     error_logger:info_report(io_lib:format("Erlang ssh in connection handler init: ~p~n",[Reason])),
-    terminate(normal, StateName, State);
-
-%% Terminated by supervisor
-terminate(shutdown, StateName, #state{ssh_params = Ssh0} = State) ->
-    DisconnectMsg = 
-	#ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
-			    description = "Application shutdown",
-			    language = "en"},
-    {SshPacket, Ssh} = ssh_transport:ssh_packet(DisconnectMsg, Ssh0),
-    send_msg(SshPacket, State),
-    terminate(normal, StateName, State#state{ssh_params = Ssh});
-
-terminate({shutdown, #ssh_msg_disconnect{} = Msg}, StateName,
-	  #state{ssh_params = Ssh0} = State) ->
-     {SshPacket, Ssh} = ssh_transport:ssh_packet(Msg, Ssh0),
-    send_msg(SshPacket, State),
-     terminate(normal, StateName, State#state{ssh_params = Ssh});
-
-terminate({shutdown, _}, StateName, State) ->
-    terminate(normal, StateName, State);
-
-terminate(Reason, StateName, #state{ssh_params = Ssh0, starter = _Pid,
-				   connection_state = Connection} = State) ->
-    terminate_subsystem(Connection),
+    finalize_termination(StateName, State);
+
+terminate(shutdown, StateName, State0) ->
+    %% Terminated by supervisor
+    State = send_msg(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
+					 description = "Application shutdown"},
+		     State0),
+timer:sleep(400),  %% FIXME!!! gen_tcp:shutdown instead
+    finalize_termination(StateName, State);
+
+%% terminate({shutdown,Msg}, StateName, State0) when is_record(Msg,ssh_msg_disconnect)->
+%%     State = send_msg(Msg, State0),
+%% timer:sleep(400),  %% FIXME!!! gen_tcp:shutdown instead
+%%     finalize_termination(StateName, Msg, State);
+
+terminate({shutdown,_R}, StateName, State) ->
+    finalize_termination(StateName, State);
+
+terminate(Reason, StateName, State0) ->
+    %% Others, e.g  undef, {badmatch,_}
     log_error(Reason),
-    DisconnectMsg = 
-	#ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
-			    description = "Internal error",
-			    language = "en"},
-    {SshPacket, Ssh} = ssh_transport:ssh_packet(DisconnectMsg, Ssh0),
-    send_msg(SshPacket, State),
-    terminate(normal, StateName, State#state{ssh_params = Ssh}).
-
-
-terminate_subsystem(#connection{system_supervisor = SysSup,
-			       sub_system_supervisor = SubSysSup}) when is_pid(SubSysSup) ->
-    ssh_system_sup:stop_subsystem(SysSup, SubSysSup);
-terminate_subsystem(_) ->
-    ok.
-
-format_status(normal, [_, State]) ->
-    [{data, [{"StateData", State}]}]; 
-format_status(terminate, [_, State]) ->
-    SshParams0 = (State#state.ssh_params),
-    SshParams = SshParams0#ssh{c_keyinit = "***",
-			       s_keyinit = "***",
-			       send_mac_key = "***",
-			       send_mac_size =  "***",
-			       recv_mac_key = "***",
-			       recv_mac_size = "***",
-			       encrypt_keys = "***",
-			       encrypt_ctx = "***",
-			       decrypt_keys = "***",
-			       decrypt_ctx = "***",
-			       compress_ctx = "***",
-			       decompress_ctx = "***",
-			       shared_secret =  "***",
-			       exchanged_hash =  "***",
-			       session_id =  "***", 
-			       keyex_key =  "***", 
-			       keyex_info = "***", 
-			       available_host_keys = "***"},
-    [{data, [{"StateData", State#state{decoded_data_buffer = "***",
-				       encoded_data_buffer =  "***",
-				       key_exchange_init_msg = "***",
-				       opts =  "***",
-				       recbuf =  "***",
-				       ssh_params = SshParams
-				      }}]}].
+    State = send_msg(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
+					   description = "Internal error"},
+		     State0),
+    finalize_termination(StateName, State).
 
 %%--------------------------------------------------------------------
--spec code_change(OldVsn::term(), state_name(), Oldstate::term(), Extra::term()) ->
-			 {ok, state_name(), #state{}}.
+
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+format_status(normal, [_, _StateName, D]) ->
+    [{data, [{"State", D}]}];
+format_status(terminate, [_, _StateName, D]) ->
+    DataPropList0 = fmt_stat_rec(record_info(fields, data), D,
+				 [decrypted_data_buffer,
+				  encrypted_data_buffer,
+				  key_exchange_init_msg,
+				  user_passwords,
+				  opts,
+				  inet_initial_recbuf_size]),
+    SshPropList = fmt_stat_rec(record_info(fields, ssh), D#data.ssh_params,
+			       [c_keyinit,
+				s_keyinit,
+				send_mac_key,
+				send_mac_size,
+				recv_mac_key,
+				recv_mac_size,
+				encrypt_keys,
+				encrypt_ctx,
+				decrypt_keys,
+				decrypt_ctx,
+				compress_ctx,
+				decompress_ctx,
+				shared_secret,
+				exchanged_hash,
+				session_id,
+				keyex_key,
+				keyex_info,
+				available_host_keys]),
+    DataPropList = lists:keyreplace(ssh_params, 1, DataPropList0,
+				    {ssh_params,SshPropList}),
+    [{data, [{"State", DataPropList}]}].
+
+
+fmt_stat_rec(FieldNames, Rec, Exclude) ->
+    Values = tl(tuple_to_list(Rec)),
+    [P || {K,_} = P <- lists:zip(FieldNames, Values),
+	  not lists:member(K, Exclude)].
+
 %%--------------------------------------------------------------------
+-spec code_change(term() | {down,term()},
+		  state_name(),
+		  #data{},
+		  term()
+		 ) -> {gen_statem:callback_mode(), state_name(), #data{}}.
+
+%% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
 code_change(_OldVsn, StateName, State, _Extra) ->
-    {ok, StateName, State}.
+    {handle_event_function, StateName, State}.
+
+
+%%====================================================================
+%% Internal functions
+%%====================================================================
 
 %%--------------------------------------------------------------------
-%%% Internal functions
-%%--------------------------------------------------------------------
-init_role(#state{role = client, opts = Opts} = State0) ->
-    Pid = proplists:get_value(user_pid, Opts),
-    TimerRef = get_idle_time(Opts),
-    timer:apply_after(?REKEY_TIMOUT, gen_fsm, send_all_state_event, [self(), renegotiate]),
-    timer:apply_after(?REKEY_DATA_TIMOUT, gen_fsm, send_all_state_event,
-		       [self(), data_size]),
-    State0#state{starter = Pid,
-		 idle_timer_ref = TimerRef};
-init_role(#state{role = server, opts = Opts, connection_state = Connection} = State) ->
-    Sups = proplists:get_value(supervisors, Opts),
-    Pid = proplists:get_value(user_pid, Opts),
-    SystemSup = proplists:get_value(system_sup, Sups),
-    SubSystemSup = proplists:get_value(subsystem_sup, Sups),
+%% Starting
+
+start_the_connection_child(UserPid, Role, Socket, Options) ->
+    Sups = proplists:get_value(supervisors, Options),
     ConnectionSup = proplists:get_value(connection_sup, Sups),
-    Shell = proplists:get_value(shell, Opts),
-    Exec = proplists:get_value(exec, Opts),
-    CliSpec = proplists:get_value(ssh_cli, Opts, {ssh_cli, [Shell]}),
-    State#state{starter = Pid, connection_state = Connection#connection{
-						    cli_spec = CliSpec,
-						    exec = Exec,
-						    system_supervisor = SystemSup,
-						    sub_system_supervisor = SubSystemSup,
-						    connection_supervisor = ConnectionSup
-						   }}.
-
-get_idle_time(SshOptions) ->
-    case proplists:get_value(idle_time, SshOptions) of
-	infinity ->
-	    infinity;
-       _IdleTime -> %% We dont want to set the timeout on first connect
-	    undefined
-    end.
+    Opts = [{supervisors, Sups}, {user_pid, UserPid} | proplists:get_value(ssh_opts, Options, [])],
+    {ok, Pid} = ssh_connection_sup:start_child(ConnectionSup, [Role, Socket, Opts]),
+    ok = socket_control(Socket, Pid, Options),
+    Pid.
 
-init_ssh(client = Role, Vsn, Version, Options, Socket) ->
-    IOCb = case proplists:get_value(user_interaction, Options, true) of
-	       true -> 
-		   ssh_io;
-	       false -> 
-		   ssh_no_io
-	   end,
+%%--------------------------------------------------------------------
+%% Stopping
+-type finalize_termination_result() :: ok .
+
+finalize_termination(_StateName, #data{transport_cb = Transport,
+				       connection_state = Connection,
+				       socket = Socket}) ->
+    case Connection of
+	#connection{system_supervisor = SysSup,
+		    sub_system_supervisor = SubSysSup} when is_pid(SubSysSup) ->
+	    ssh_system_sup:stop_subsystem(SysSup, SubSysSup);
+	_ ->
+	    do_nothing
+    end,
+    (catch Transport:close(Socket)),
+    ok.
 
-    AuthMethods = proplists:get_value(auth_methods, Options, 
-				      ?SUPPORTED_AUTH_METHODS),
-    {ok, PeerAddr} = inet:peername(Socket),
-    
-    PeerName =  proplists:get_value(host, Options),
-    KeyCb =  proplists:get_value(key_cb, Options, ssh_file),
-
-    #ssh{role = Role,
-	 c_vsn = Vsn,
-	 c_version = Version,
-	 key_cb = KeyCb,
-	 io_cb = IOCb,
-	 userauth_quiet_mode = proplists:get_value(quiet_mode, Options, false),
-	 opts = Options,
-	 userauth_supported_methods = AuthMethods,
-	 peer = {PeerName, PeerAddr},
-	 available_host_keys = supported_host_keys(Role, KeyCb, Options),
-	 random_length_padding = proplists:get_value(max_random_length_padding, 
-						     Options, 
-						     (#ssh{})#ssh.random_length_padding)
-	};
-
-init_ssh(server = Role, Vsn, Version, Options, Socket) ->
-    AuthMethods = proplists:get_value(auth_methods, Options, 
-				      ?SUPPORTED_AUTH_METHODS),
-    AuthMethodsAsList = string:tokens(AuthMethods, ","),
-    {ok, PeerAddr} = inet:peername(Socket),
-    KeyCb =  proplists:get_value(key_cb, Options, ssh_file),
-
-    #ssh{role = Role,
-	 s_vsn = Vsn,
-	 s_version = Version,
-	 key_cb = KeyCb,
-	 io_cb = proplists:get_value(io_cb, Options, ssh_io),
-	 opts = Options,
-	 userauth_supported_methods = AuthMethods,
-	 userauth_methods = AuthMethodsAsList,
-	 kb_tries_left = 3,
-	 peer = {undefined, PeerAddr},
-	 available_host_keys = supported_host_keys(Role, KeyCb, Options),
-	 random_length_padding = proplists:get_value(max_random_length_padding, 
-						     Options, 
-						     (#ssh{})#ssh.random_length_padding)
-	 }.
+%%--------------------------------------------------------------------
+%% "Invert" the Role
+peer_role(client) -> server;
+peer_role(server) -> client.
 
+%%--------------------------------------------------------------------
+%% StateName to Role
+role({_,Role}) -> Role;
+role({_,Role,_}) -> Role.
+
+%%--------------------------------------------------------------------
+%% Check the StateName to see if we are in the renegotiation phase
+renegotiation({_,_,ReNeg}) -> ReNeg == renegotiation;
+renegotiation(_) -> false.
+
+%%--------------------------------------------------------------------
 supported_host_keys(client, _, Options) ->
     try
-	case proplists:get_value(public_key, 
+	case proplists:get_value(public_key,
 				 proplists:get_value(preferred_algorithms,Options,[])
 				) of
-	    undefined -> 
+	    undefined ->
 		ssh_transport:default_algorithms(public_key);
 	    L ->
 		L -- (L--ssh_transport:default_algorithms(public_key))
@@ -1311,7 +1482,7 @@ supported_host_keys(client, _, Options) ->
 	    {stop, {shutdown, Reason}}
     end;
 supported_host_keys(server, KeyCb, Options) ->
-    [atom_to_list(A) || A <- proplists:get_value(public_key, 
+    [atom_to_list(A) || A <- proplists:get_value(public_key,
 						 proplists:get_value(preferred_algorithms,Options,[]),
 						 ssh_transport:default_algorithms(public_key)
 						),
@@ -1322,10 +1493,16 @@ supported_host_keys(server, KeyCb, Options) ->
 available_host_key(KeyCb, Alg, Opts) ->
     element(1, catch KeyCb:host_key(Alg, Opts)) == ok.
 
-send_msg(Msg, #state{socket = Socket, transport_cb = Transport}) ->
-    Transport:send(Socket, Msg).
 
-handle_version({2, 0} = NumVsn, StrVsn, Ssh0) -> 
+send_msg(Msg, State=#data{ssh_params=Ssh0}) when is_tuple(Msg) ->
+    {Bytes, Ssh} = ssh_transport:ssh_packet(Msg, Ssh0),
+    send_bytes(Bytes, State),
+    State#data{ssh_params=Ssh}.
+
+send_bytes(Bytes, #data{socket = Socket, transport_cb = Transport}) ->
+    Transport:send(Socket, Bytes).
+
+handle_version({2, 0} = NumVsn, StrVsn, Ssh0) ->
     Ssh = counterpart_versions(NumVsn, StrVsn, Ssh0),
     {ok, Ssh};
 handle_version(_,_,_) ->
@@ -1336,419 +1513,212 @@ string_version(#ssh{role = client, c_version = Vsn}) ->
 string_version(#ssh{role = server, s_version = Vsn}) ->
     Vsn.
 
-send_event(FsmPid, Event) ->
-    gen_fsm:send_event(FsmPid, Event).
 
-send_all_state_event(FsmPid, Event) ->
-    gen_fsm:send_all_state_event(FsmPid, Event).
+cast(FsmPid, Event) ->
+    gen_statem:cast(FsmPid, Event).
 
-sync_send_all_state_event(FsmPid, Event) ->
-    sync_send_all_state_event(FsmPid, Event, infinity).
+call(FsmPid, Event) ->
+    call(FsmPid, Event, infinity).
 
-sync_send_all_state_event(FsmPid, Event, Timeout) ->
-    try gen_fsm:sync_send_all_state_event(FsmPid, Event, Timeout) of
-	{closed, _Channel} ->
+call(FsmPid, Event, Timeout) ->
+    try gen_statem:call(FsmPid, Event, Timeout) of
+	{closed, _R} ->
+	    {error, closed};
+	{killed, _R} ->
 	    {error, closed};
 	Result ->
 	    Result
     catch
-	exit:{noproc, _} ->
+	exit:{noproc, _R} ->
 	    {error, closed};
-	exit:{normal, _} ->
+	exit:{normal, _R} ->
 	    {error, closed};
-	exit:{{shutdown, _},_} ->
+	exit:{{shutdown, _R},_} ->
 	    {error, closed}
     end.
 
-%% simulate send_all_state_event(self(), Event) 
-event(#ssh_msg_disconnect{} = Event, StateName, State) ->
-    handle_event(Event, StateName, State);
-event(#ssh_msg_ignore{} = Event, StateName, State) ->
-    handle_event(Event, StateName, State);
-event(#ssh_msg_debug{} = Event, StateName, State) ->
-    handle_event(Event, StateName, State);
-event(#ssh_msg_unimplemented{} = Event, StateName, State) ->
-    handle_event(Event, StateName, State);
-%% simulate send_event(self(), Event)
-event(Event, StateName, State) ->
-    try
-	?MODULE:StateName(Event, State)
+
+handle_connection_msg(Msg, StateName, State0 =
+			  #data{starter = User,
+				connection_state = Connection0,
+				event_queue = Qev0}) ->
+    Renegotiation = renegotiation(StateName),
+    Role = role(StateName),
+    try ssh_connection:handle_msg(Msg, Connection0, Role) of
+	{{replies, Replies}, Connection} ->
+	    case StateName of
+		{connected,_} ->
+		    {Repls, State} = send_replies(Replies,
+						  State0#data{connection_state=Connection}),
+		    {keep_state, State, Repls};
+		_ ->
+		    {ConnReplies, Replies} =
+			lists:splitwith(fun not_connected_filter/1, Replies),
+		    {Repls, State} = send_replies(Replies,
+						  State0#data{event_queue = Qev0 ++ ConnReplies}),
+		    {keep_state, State, Repls}
+	    end;
+
+	{noreply, Connection} ->
+	    {keep_state, State0#data{connection_state = Connection}};
+
+	{disconnect, Reason0, {{replies, Replies}, Connection}} ->
+	    {Repls,State} = send_replies(Replies, State0#data{connection_state = Connection}),
+	    case {Reason0,Role} of
+		{{_, Reason}, client} when ((StateName =/= {connected,client}) and (not Renegotiation)) ->
+		    User ! {self(), not_connected, Reason};
+		_ ->
+		    ok
+	    end,
+	    {stop, {shutdown,normal}, Repls, State#data{connection_state = Connection}}
+
     catch
-	throw:#ssh_msg_disconnect{} = DisconnectMsg ->
-	    handle_disconnect(DisconnectMsg, State);
-	throw:{ErrorToDisplay, #ssh_msg_disconnect{} = DisconnectMsg}  ->
-	    handle_disconnect(DisconnectMsg, State, ErrorToDisplay);
-	_C:_Error ->
-	    handle_disconnect(#ssh_msg_disconnect{code = error_code(StateName),
-						  description = "Invalid state",
-						  language = "en"}, State)
+	_:Error ->
+	    {disconnect, _Reason, {{replies, Replies}, Connection}} =
+		ssh_connection:handle_msg(
+		  #ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
+				      description = "Internal error"},
+		  Connection0, Role),
+	    {Repls,State} = send_replies(Replies, State0#data{connection_state = Connection}),
+	    {stop, {shutdown,Error}, Repls, State#data{connection_state = Connection}}
     end.
-error_code(key_exchange) ->
-    ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED;
-error_code(new_keys) ->
-    ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED;
-error_code(_) ->
-    ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE.
-
-generate_event(<<?BYTE(Byte), _/binary>> = Msg, StateName,
-	       #state{
-		  role = Role,
-		  starter = User,
-		  renegotiate = Renegotiation,
-		  connection_state = Connection0} = State0, EncData)
-  when  Byte == ?SSH_MSG_GLOBAL_REQUEST;
-	Byte == ?SSH_MSG_REQUEST_SUCCESS;
-	Byte == ?SSH_MSG_REQUEST_FAILURE;
-	Byte == ?SSH_MSG_CHANNEL_OPEN;
-	Byte == ?SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
-	Byte == ?SSH_MSG_CHANNEL_OPEN_FAILURE;
-	Byte == ?SSH_MSG_CHANNEL_WINDOW_ADJUST;
-	Byte == ?SSH_MSG_CHANNEL_DATA;
-	Byte == ?SSH_MSG_CHANNEL_EXTENDED_DATA;
-	Byte == ?SSH_MSG_CHANNEL_EOF;
-	Byte == ?SSH_MSG_CHANNEL_CLOSE;
-	Byte == ?SSH_MSG_CHANNEL_REQUEST;
-	Byte == ?SSH_MSG_CHANNEL_SUCCESS;
-	Byte == ?SSH_MSG_CHANNEL_FAILURE ->
-    try
-	ssh_message:decode(Msg)
-    of
-	ConnectionMsg ->
-	    State1 = generate_event_new_state(State0, EncData),
-	    try ssh_connection:handle_msg(ConnectionMsg, Connection0, Role) of
-		{{replies, Replies0}, Connection} ->
-		    if StateName == connected ->
-			    Replies = Replies0,
-			    State2  = State1;
-		       true ->
-			    {ConnReplies, Replies} =
-				lists:splitwith(fun not_connected_filter/1, Replies0),
-			    Q = State1#state.event_queue ++ ConnReplies,
-			    State2  = State1#state{ event_queue = Q }
-		    end,
-		    State = send_replies(Replies,  State2#state{connection_state = Connection}),
-		    {next_state, StateName, next_packet(State)};
-		{noreply, Connection} ->
-		    {next_state, StateName, next_packet(State1#state{connection_state = Connection})};
-		{disconnect, {_, Reason}, {{replies, Replies}, Connection}} when
-		      Role == client andalso ((StateName =/= connected) and (not Renegotiation)) ->
-		    State = send_replies(Replies,  State1#state{connection_state = Connection}),
-		    User ! {self(), not_connected, Reason},
-		    {stop, {shutdown, normal},
-		     next_packet(State#state{connection_state = Connection})};
-		{disconnect, _Reason, {{replies, Replies}, Connection}} ->
-		    State = send_replies(Replies,  State1#state{connection_state = Connection}),
-		    {stop, {shutdown, normal}, State#state{connection_state = Connection}}
-	    catch
-		_:Error ->
-		    {disconnect, _Reason, {{replies, Replies}, Connection}} =
-			ssh_connection:handle_msg(
-			  #ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
-					      description = "Internal error",
-					      language = "en"}, Connection0, Role),
-		    State = send_replies(Replies,  State1#state{connection_state = Connection}),
-		    {stop, {shutdown, Error}, State#state{connection_state = Connection}}
-	    end
 
-    catch
-	_:_ ->
-	    handle_disconnect(
-	      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-				  description = "Bad packet received",
-				  language = ""}, State0)
-    end;
 
-generate_event(Msg, StateName, State0, EncData) ->
-    try 
-	Event = ssh_message:decode(set_prefix_if_trouble(Msg,State0)),
-	State = generate_event_new_state(State0, EncData),
-	case Event of
-	    #ssh_msg_kexinit{} ->
-		%% We need payload for verification later.
-		event({Event, Msg}, StateName, State);
-	    _ ->
-		event(Event, StateName, State)
-	end
-    catch 
-	_C:_E  ->
-	    DisconnectMsg =
-		#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR, 
-				    description = "Encountered unexpected input",
-				    language = "en"},
-	    handle_disconnect(DisconnectMsg, State0)   
-    end.		
-	    
-
-set_prefix_if_trouble(Msg = <<?BYTE(Op),_/binary>>, #state{ssh_params=SshParams}) 
+set_kex_overload_prefix(Msg = <<?BYTE(Op),_/binary>>, #data{ssh_params=SshParams})
   when Op == 30;
        Op == 31
        ->
     case catch atom_to_list(kex(SshParams)) of
-	"ecdh-sha2-" ++ _ -> 
+	"ecdh-sha2-" ++ _ ->
 	    <<"ecdh",Msg/binary>>;
 	"diffie-hellman-group-exchange-" ++ _ ->
 	    <<"dh_gex",Msg/binary>>;
 	"diffie-hellman-group" ++ _ ->
 	    <<"dh",Msg/binary>>;
-	_ -> 
+	_ ->
 	    Msg
     end;
-set_prefix_if_trouble(Msg, _) ->
+set_kex_overload_prefix(Msg, _) ->
     Msg.
 
 kex(#ssh{algorithms=#alg{kex=Kex}}) -> Kex;
 kex(_) -> undefined.
 
+cache(#data{connection_state=C}) -> C#connection.channel_cache.
+    
 
-handle_request(ChannelPid, ChannelId, Type, Data, WantReply, From,
-	       #state{connection_state =
-		      #connection{channel_cache = Cache}} = State0) ->
-    case ssh_channel:cache_lookup(Cache, ChannelId) of
+%%%----------------------------------------------------------------
+handle_request(ChannelPid, ChannelId, Type, Data, WantReply, From, D) ->
+    case ssh_channel:cache_lookup(cache(D), ChannelId) of
 	#channel{remote_id = Id} = Channel ->
-	    update_sys(Cache, Channel, Type, ChannelPid),
-	    Msg = ssh_connection:channel_request_msg(Id, Type,
-						     WantReply, Data),
-	    Replies = [{connection_reply, Msg}],
-	    State = add_request(WantReply, ChannelId, From, State0),
-	    {{replies, Replies}, State};
+	    update_sys(cache(D), Channel, Type, ChannelPid),
+	    send_msg(ssh_connection:channel_request_msg(Id, Type, WantReply, Data),
+		     add_request(WantReply, ChannelId, From, D));
 	undefined ->
-	    {{replies, []}, State0}
+	    D
     end.
 
-handle_request(ChannelId, Type, Data, WantReply, From,
-	       #state{connection_state =
-		      #connection{channel_cache = Cache}} = State0) ->
-    case ssh_channel:cache_lookup(Cache, ChannelId) of
-	#channel{remote_id = Id}  ->
-	    Msg = ssh_connection:channel_request_msg(Id, Type,
-						     WantReply, Data),
-	    Replies = [{connection_reply, Msg}],
-	    State = add_request(WantReply, ChannelId, From, State0),
-	    {{replies, Replies}, State};
+handle_request(ChannelId, Type, Data, WantReply, From, D) ->
+    case ssh_channel:cache_lookup(cache(D), ChannelId) of
+	#channel{remote_id = Id} ->
+	    send_msg(ssh_connection:channel_request_msg(Id, Type, WantReply, Data),
+		     add_request(WantReply, ChannelId, From, D));
 	undefined ->
-	    {{replies, []}, State0}
+	    D
     end.
 
+%%%----------------------------------------------------------------
 handle_global_request({global_request, ChannelPid,
 		       "tcpip-forward" = Type, WantReply,
-		       <<?UINT32(IPLen),
-			IP:IPLen/binary, ?UINT32(Port)>> = Data},
-		      #state{connection_state =
-				 #connection{channel_cache = Cache}
-			     = Connection0} = State) ->
-    ssh_channel:cache_update(Cache, #channel{user = ChannelPid,
-					     type = "forwarded-tcpip",
-					     sys = none}),
-    Connection = ssh_connection:bind(IP, Port, ChannelPid, Connection0),
+		       <<?UINT32(IPLen),IP:IPLen/binary, ?UINT32(Port)>> = Data
+		      },
+		      D) ->
+    ssh_channel:cache_update(cache(D),
+			     #channel{user = ChannelPid,
+				      type = "forwarded-tcpip",
+				      sys = none}),
+    Connection = ssh_connection:bind(IP, Port, ChannelPid, D#data.connection_state),
     Msg = ssh_connection:global_request_msg(Type, WantReply, Data),
-    send_replies([{connection_reply, Msg}],  State#state{connection_state = Connection});
+    send_msg(Msg, D#data{connection_state = Connection});
 
 handle_global_request({global_request, _Pid, "cancel-tcpip-forward" = Type,
 		       WantReply, <<?UINT32(IPLen),
 				   IP:IPLen/binary, ?UINT32(Port)>> = Data},
-		      #state{connection_state = Connection0} = State) ->
+		      #data{connection_state = Connection0} = State) ->
     Connection = ssh_connection:unbind(IP, Port, Connection0),
     Msg = ssh_connection:global_request_msg(Type, WantReply, Data),
-    send_replies([{connection_reply, Msg}], State#state{connection_state = Connection});
+    send_msg(Msg, State#data{connection_state = Connection});
 
 handle_global_request({global_request, _, "cancel-tcpip-forward" = Type,
 		       WantReply, Data}, State) ->
     Msg = ssh_connection:global_request_msg(Type, WantReply, Data),
-    send_replies([{connection_reply, Msg}], State).
-
-handle_idle_timeout(#state{opts = Opts}) ->
-    case proplists:get_value(idle_time, Opts, infinity) of
-	infinity ->
-	    ok;
-	IdleTime ->
-	    erlang:send_after(IdleTime, self(), {check_cache, [], []})
-    end.
+    send_msg(Msg, State).
 
-handle_channel_down(ChannelPid, #state{connection_state =
-					   #connection{channel_cache = Cache}} =
-			State) ->
+%%%----------------------------------------------------------------
+handle_channel_down(ChannelPid, D) ->
     ssh_channel:cache_foldl(
 	       fun(Channel, Acc) when Channel#channel.user == ChannelPid ->
-		       ssh_channel:cache_delete(Cache,
+		       ssh_channel:cache_delete(cache(D),
 						Channel#channel.local_id),
 		       Acc;
 		  (_,Acc) ->
 		       Acc
-	       end, [], Cache),
-    {{replies, []}, check_cache(State, Cache)}.
+	       end, [], cache(D)),
+    {{replies, []}, cache_check_set_idle_timer(D)}.
+
 
 update_sys(Cache, Channel, Type, ChannelPid) ->
     ssh_channel:cache_update(Cache,
 			     Channel#channel{sys = Type, user = ChannelPid}).
+
 add_request(false, _ChannelId, _From, State) ->
     State;
-add_request(true, ChannelId, From, #state{connection_state =
-					#connection{requests = Requests0} =
-					Connection} = State) ->
+add_request(true, ChannelId, From, #data{connection_state =
+					     #connection{requests = Requests0} =
+					     Connection} = State) ->
     Requests = [{ChannelId, From} | Requests0],
-    State#state{connection_state = Connection#connection{requests = Requests}}.
+    State#data{connection_state = Connection#connection{requests = Requests}}.
 
-new_channel_id(#state{connection_state = #connection{channel_id_seed = Id} =
-		      Connection}
+new_channel_id(#data{connection_state = #connection{channel_id_seed = Id} =
+			 Connection}
 	       = State) ->
-    {Id, State#state{connection_state =
-		     Connection#connection{channel_id_seed = Id + 1}}}.
-
-generate_event_new_state(#state{ssh_params = 
-				#ssh{recv_sequence = SeqNum0} 
-				= Ssh} = State, EncData) ->
-    SeqNum = ssh_transport:next_seqnum(SeqNum0),
-    State#state{ssh_params = Ssh#ssh{recv_sequence = SeqNum},
-		decoded_data_buffer = <<>>,
-		encoded_data_buffer = EncData, 
-		undecoded_packet_length = undefined}.
-
-next_packet(#state{decoded_data_buffer = <<>>,
-		   encoded_data_buffer = Buff,
-		   ssh_params = #ssh{decrypt_block_size = BlockSize},
-		   socket = Socket,
-		   transport_protocol = Protocol} = State) when Buff =/= <<>> ->
-    case  size(Buff) >= erlang:max(8, BlockSize) of
-	true ->
-	    %% Enough data from the next packet has been received to
-	    %% decode the length indicator, fake a socket-recive
-	    %% message so that the data will be processed
-	    self() ! {Protocol, Socket, <<>>};
-	false ->
-	    inet:setopts(Socket, [{active, once}])
-    end,
-    State;
-
-next_packet(#state{socket = Socket} = State) ->
-    inet:setopts(Socket, [{active, once}]),
-    State.
-
-after_new_keys(#state{renegotiate = true} = State) ->
-    State1 = State#state{renegotiate = false, event_queue = []},
-    lists:foldr(fun after_new_keys_events/2, {next_state, connected, State1}, State#state.event_queue);
-after_new_keys(#state{renegotiate = false, 
-		      ssh_params = #ssh{role = client} = Ssh0} = State) ->
-    {Msg, Ssh} = ssh_auth:service_request_msg(Ssh0),
-    send_msg(Msg, State),
-    {next_state, service_request, State#state{ssh_params = Ssh}};
-after_new_keys(#state{renegotiate = false,  
-		      ssh_params = #ssh{role = server}} = State) ->
-    {next_state, service_request, State}.
-
-after_new_keys_events({sync, _Event, From}, {stop, _Reason, _StateData}=Terminator) ->
-    gen_fsm:reply(From, {error, closed}),
-    Terminator;
-after_new_keys_events(_, {stop, _Reason, _StateData}=Terminator) ->
-    Terminator;
-after_new_keys_events({sync, Event, From}, {next_state, StateName, StateData}) ->
-    case handle_sync_event(Event, From, StateName, StateData) of
-	{reply, Reply, NextStateName, NewStateData} ->
-	    gen_fsm:reply(From, Reply),
-	    {next_state, NextStateName, NewStateData};
-	{next_state, NextStateName, NewStateData}->
-	    {next_state, NextStateName, NewStateData};
-	{stop, Reason, Reply, NewStateData} ->
-	    gen_fsm:reply(From, Reply),
-	    {stop, Reason, NewStateData}
-    end;
-after_new_keys_events({event, Event}, {next_state, StateName, StateData}) ->
-    case handle_event(Event, StateName, StateData) of
-	{next_state, NextStateName, NewStateData}->
-	    {next_state, NextStateName, NewStateData};
-	{stop, Reason, NewStateData} ->
-	    {stop, Reason, NewStateData}
-    end;
-after_new_keys_events({connection_reply, _Data} = Reply, {StateName, State}) ->
-    NewState = send_replies([Reply], State),
-    {next_state, StateName, NewState}.
-
-
-handle_disconnect(DisconnectMsg, State) ->
-    handle_disconnect(own, DisconnectMsg, State).
-
-handle_disconnect(#ssh_msg_disconnect{} = DisconnectMsg, State, Error) ->
-    handle_disconnect(own, DisconnectMsg, State, Error);
-handle_disconnect(Type,  #ssh_msg_disconnect{description = Desc} = Msg, #state{connection_state = Connection0,									role = Role} = State0) ->
-    {disconnect, _, {{replies, Replies}, Connection}} = ssh_connection:handle_msg(Msg, Connection0, Role),
-    State = send_replies(disconnect_replies(Type, Msg, Replies), State0),
-    disconnect_fun(Desc, State#state.opts),
-    {stop, {shutdown, Desc}, State#state{connection_state = Connection}}.
-
-handle_disconnect(Type, #ssh_msg_disconnect{description = Desc} = Msg, #state{connection_state = Connection0,
-									      role = Role} = State0, ErrorMsg) ->
-    {disconnect, _, {{replies, Replies}, Connection}} = ssh_connection:handle_msg(Msg, Connection0, Role),
-    State = send_replies(disconnect_replies(Type, Msg, Replies), State0),
-    disconnect_fun(Desc, State#state.opts),
-    {stop, {shutdown, {Desc, ErrorMsg}}, State#state{connection_state = Connection}}.
-
-disconnect_replies(own, Msg, Replies) ->
-    [{connection_reply, Msg} | Replies];
-disconnect_replies(peer, _, Replies) ->
-    Replies.
-
+    {Id, State#data{connection_state =
+			Connection#connection{channel_id_seed = Id + 1}}}.
+
+%%%----------------------------------------------------------------
+%% %%% This server/client has decided to disconnect via the state machine:
+disconnect(Msg=#ssh_msg_disconnect{description=Description}, _StateName, State0) ->
+    State = send_msg(Msg, State0),
+    disconnect_fun(Description, State),
+timer:sleep(400),
+    {stop, {shutdown,Description}, State}.
+
+%%%----------------------------------------------------------------
 counterpart_versions(NumVsn, StrVsn, #ssh{role = server} = Ssh) ->
     Ssh#ssh{c_vsn = NumVsn , c_version = StrVsn};
 counterpart_versions(NumVsn, StrVsn, #ssh{role = client} = Ssh) ->
     Ssh#ssh{s_vsn = NumVsn , s_version = StrVsn}.
 
-opposite_role(client) ->
-    server;
-opposite_role(server) ->
-    client.
-connected_fun(User, PeerAddr, Method, Opts) ->
-    case proplists:get_value(connectfun, Opts) of
-	undefined ->
-	    ok;
-	Fun ->
-	    catch Fun(User, PeerAddr, Method)
-    end.
-
-retry_fun(_, _, undefined, _) ->
-    ok;
-
-retry_fun(User, PeerAddr, {error, Reason}, Opts) ->
-    case proplists:get_value(failfun, Opts) of
-	undefined ->
-	    ok;
-	Fun ->
-	    do_retry_fun(Fun, User, PeerAddr, Reason)
-    end;
-
-retry_fun(User, PeerAddr, Reason, Opts) ->
-    case proplists:get_value(infofun, Opts) of
-	undefined ->
-	    ok;
-	Fun  ->
-	    do_retry_fun(Fun, User, PeerAddr, Reason)
-    end.
-
-do_retry_fun(Fun, User, PeerAddr, Reason) ->
-    case erlang:fun_info(Fun, arity) of
-	{arity, 2} -> %% Backwards compatible
-	    catch Fun(User, Reason);
-	{arity, 3} ->
-	    catch Fun(User, PeerAddr, Reason)
-    end.
-
 ssh_info([], _State, Acc) ->
     Acc;
-ssh_info([client_version | Rest], #state{ssh_params = #ssh{c_vsn = IntVsn,
+ssh_info([client_version | Rest], #data{ssh_params = #ssh{c_vsn = IntVsn,
 							   c_version = StringVsn}} = State, Acc) ->
     ssh_info(Rest, State, [{client_version, {IntVsn, StringVsn}} | Acc]);
 
-ssh_info([server_version | Rest], #state{ssh_params =#ssh{s_vsn = IntVsn,
+ssh_info([server_version | Rest], #data{ssh_params =#ssh{s_vsn = IntVsn,
 							  s_version = StringVsn}} = State, Acc) ->
     ssh_info(Rest, State, [{server_version, {IntVsn, StringVsn}} | Acc]);
-ssh_info([peer | Rest],  #state{ssh_params = #ssh{peer = Peer}} = State, Acc) ->
+ssh_info([peer | Rest], #data{ssh_params = #ssh{peer = Peer}} = State, Acc) ->
     ssh_info(Rest, State, [{peer, Peer} | Acc]);
-ssh_info([sockname | Rest], #state{socket = Socket} = State, Acc) ->
+ssh_info([sockname | Rest], #data{socket = Socket} = State, Acc) ->
     {ok, SockName} = inet:sockname(Socket),
    ssh_info(Rest, State, [{sockname, SockName}|Acc]);
-ssh_info([user | Rest], #state{auth_user = User} = State, Acc) ->
+ssh_info([user | Rest], #data{auth_user = User} = State, Acc) ->
     ssh_info(Rest, State, [{user, User}|Acc]);
 ssh_info([ _ | Rest], State, Acc) ->
     ssh_info(Rest, State, Acc).
 
+
 ssh_channel_info([], _, Acc) ->
     Acc;
 
@@ -1765,43 +1735,49 @@ ssh_channel_info([send_window | Rest], #channel{send_window_size = WinSize,
 ssh_channel_info([ _ | Rest], Channel, Acc) ->
     ssh_channel_info(Rest, Channel, Acc).
 
+
 log_error(Reason) ->
-    Report = io_lib:format("Erlang ssh connection handler failed with reason: "
-			   "~p ~n, Stacktrace: ~p ~n",
-			   [Reason,  erlang:get_stacktrace()]),
-    error_logger:error_report(Report),
-    "Internal error".
-
-not_connected_filter({connection_reply, _Data}) ->
-    true;
-not_connected_filter(_) ->
-    false.
-
-send_replies([], State) ->
-    State;
-send_replies([{connection_reply, Data} | Rest], #state{ssh_params = Ssh0} = State) ->
-    {Packet, Ssh} = ssh_transport:ssh_packet(Data, Ssh0),
-    send_msg(Packet, State),
-    send_replies(Rest, State#state{ssh_params = Ssh});
-send_replies([Msg | Rest], State) ->
-    catch send_reply(Msg),
-    send_replies(Rest, State).
-
-send_reply({channel_data, Pid, Data}) ->
-    Pid ! {ssh_cm, self(), Data};
-send_reply({channel_requst_reply, From, Data}) ->
-    gen_fsm:reply(From, Data);
-send_reply({flow_control, Cache, Channel, From, Msg}) ->
+    Report = io_lib:format("Erlang ssh connection handler failed with reason:~n"
+			   "    ~p~n"
+			   "Stacktrace:~n"
+			   "    ~p~n",
+			   [Reason, erlang:get_stacktrace()]),
+    error_logger:error_report(Report).
+
+
+%%%----------------------------------------------------------------
+not_connected_filter({connection_reply, _Data}) -> true;
+not_connected_filter(_) -> false.
+
+%%%----------------------------------------------------------------
+send_replies(Repls, State) ->
+    lists:foldl(fun get_repl/2,
+		{[],State},
+		Repls).
+
+get_repl({connection_reply,Msg}, {CallRepls,S}) ->
+    {CallRepls, send_msg(Msg,S)};
+get_repl({channel_data,undefined,_Data}, Acc) ->
+    Acc;
+get_repl({channel_data,Pid,Data}, Acc) ->
+    Pid ! {ssh_cm, self(), Data},
+    Acc;
+get_repl({channel_request_reply,From,Data}, {CallRepls,S}) ->
+    {[{reply,From,Data}|CallRepls], S};
+get_repl({flow_control,Cache,Channel,From,Msg}, {CallRepls,S}) ->
     ssh_channel:cache_update(Cache, Channel#channel{flow_control = undefined}),
-    gen_fsm:reply(From, Msg);
-send_reply({flow_control, From, Msg}) ->
-    gen_fsm:reply(From, Msg).
+    {[{reply,From,Msg}|CallRepls], S};
+get_repl({flow_control,From,Msg}, {CallRepls,S}) ->
+    {[{reply,From,Msg}|CallRepls], S};
+get_repl(noreply, Acc) ->
+    Acc;
+get_repl(X, Acc) ->
+    exit({get_repl,X,Acc}).
 
-disconnect_fun({disconnect,Msg}, Opts) ->
-    disconnect_fun(Msg, Opts);
-disconnect_fun(_, undefined) ->
-    ok;
-disconnect_fun(Reason, Opts) ->
+%%%----------------------------------------------------------------
+disconnect_fun({disconnect,Msg}, D) ->
+    disconnect_fun(Msg, D);
+disconnect_fun(Reason,  #data{opts=Opts}) ->
     case proplists:get_value(disconnectfun, Opts) of
 	undefined ->
 	    ok;
@@ -1809,50 +1785,137 @@ disconnect_fun(Reason, Opts) ->
 	    catch Fun(Reason)
      end.
 
-unexpected_fun(UnexpectedMessage, Opts, #ssh{peer={_,Peer}}) ->
+unexpected_fun(UnexpectedMessage, #data{opts = Opts,
+					ssh_params = #ssh{peer = {_,Peer} }
+				       } ) ->
     case proplists:get_value(unexpectedfun, Opts) of
 	undefined ->
 	    report;
 	Fun ->
-	    catch Fun(UnexpectedMessage, Peer) 
+	    catch Fun(UnexpectedMessage, Peer)
     end.
 
 
-check_cache(#state{opts = Opts} = State, Cache) ->
-    %% Check the number of entries in Cache
-    case proplists:get_value(size, ets:info(Cache)) of
-	0 ->
-	    case proplists:get_value(idle_time, Opts, infinity) of
-		infinity ->
-		    State;
-		Time ->
-		    handle_idle_timer(Time, State)
-	    end;
+debug_fun(#ssh_msg_debug{always_display = Display,
+			 message = DbgMsg,
+			 language = Lang},
+	  #data{opts = Opts}) ->
+    case proplists:get_value(ssh_msg_debug_fun, Opts) of
+	undefined ->
+	    ok;
+	Fun ->
+	    catch Fun(self(), Display, DbgMsg, Lang)
+    end.
+
+
+connected_fun(User, Method, #data{ssh_params = #ssh{peer = {_,Peer}},
+				  opts = Opts}) ->
+    case proplists:get_value(connectfun, Opts) of
+	undefined ->
+	    ok;
+	Fun ->
+	    catch Fun(User, Peer, Method)
+    end.
+
+retry_fun(_, undefined, _) ->
+    ok;
+retry_fun(User, Reason, #data{ssh_params = #ssh{opts = Opts,
+						peer = {_,Peer}
+					       }}) ->
+    {Tag,Info} =
+	case Reason of
+	    {error, Error} ->
+		{failfun, Error};
+	    _ ->
+		{infofun, Reason}
+	end,
+    Fun = proplists:get_value(Tag, Opts, fun(_,_)-> ok end),
+    try erlang:fun_info(Fun, arity)
+    of
+	{arity, 2} -> %% Backwards compatible
+	    catch Fun(User, Info);
+	{arity, 3} ->
+	    catch Fun(User, Peer, Info);
 	_ ->
-	    State
+	    ok
+    catch
+	_:_ ->
+	    ok
+    end.
+
+%%%----------------------------------------------------------------
+%%% Cache idle timer that closes the connection if there are no
+%%% channels open for a while.
+
+cache_init_idle_timer(D) ->
+    case proplists:get_value(idle_time, D#data.opts, infinity) of
+	infinity ->
+	    D#data{idle_timer_value = infinity,
+		   idle_timer_ref = infinity	% A flag used later...
+		  };
+	IdleTime ->
+	    %% We dont want to set the timeout on first connect
+	    D#data{idle_timer_value = IdleTime}
     end.
 
-handle_idle_timer(Time, #state{idle_timer_ref = undefined} = State) ->
-    TimerRef = erlang:send_after(Time, self(), {'EXIT', [], "Timeout"}),
-    State#state{idle_timer_ref=TimerRef};
-handle_idle_timer(_, State) ->
-    State.
-
-remove_timer_ref(State) ->
-    case State#state.idle_timer_ref of
-	infinity -> %% If the timer is not activated
-	    State;
-	undefined -> %% If we already has cancelled the timer
-	    State;
-	TimerRef -> %% Timer is active
+
+cache_check_set_idle_timer(D = #data{idle_timer_ref = undefined,
+				     idle_timer_value = IdleTime}) ->
+    %% No timer set - shall we set one?
+    case ssh_channel:cache_info(num_entries, cache(D)) of
+	0 when IdleTime == infinity ->
+	    %% No. Meaningless to set a timer that fires in an infinite time...
+	    D;
+	0 ->
+	    %% Yes, we'll set one since the cache is empty and it should not
+	    %% be that for a specified time
+	    D#data{idle_timer_ref =
+		       erlang:send_after(IdleTime, self(), {'EXIT',[],"Timeout"})};
+	_ ->
+	    %% No - there are entries in the cache
+	    D
+    end;
+cache_check_set_idle_timer(D) ->
+    %% There is already a timer set or the timeout time is infinite
+    D.
+    
+
+cache_cancel_idle_timer(D) ->
+    case D#data.idle_timer_ref of
+	infinity -> 
+	    %% The timer is not activated
+	    D;
+	undefined ->
+	    %% The timer is already cancelled
+	    D;
+	TimerRef -> 
+	    %% The timer is active
 	    erlang:cancel_timer(TimerRef),
-	    State#state{idle_timer_ref = undefined}
+	    D#data{idle_timer_ref = undefined}
     end.
 
-socket_control(Socket, Pid, Transport) ->
-    case Transport:controlling_process(Socket, Pid) of
+
+cache_request_idle_timer_check(D = #data{idle_timer_value = infinity}) ->
+    D;
+cache_request_idle_timer_check(D = #data{idle_timer_value = IdleTime}) ->
+    erlang:send_after(IdleTime, self(), check_cache),
+    D.
+
+%%%----------------------------------------------------------------
+start_channel_request_timer(_,_, infinity) ->
+    ok;
+start_channel_request_timer(Channel, From, Time) ->
+    erlang:send_after(Time, self(), {timeout, {Channel, From}}).
+
+%%%----------------------------------------------------------------
+%%% Connection start and initalization helpers
+
+socket_control(Socket, Pid, Options) ->
+    {_, TransportCallback, _} =		   % For example {_,gen_tcp,_}
+	proplists:get_value(transport, Options, ?DefaultTransport),
+    case TransportCallback:controlling_process(Socket, Pid) of
 	ok ->
-	    send_event(Pid, socket_control);
+	    gen_statem:cast(Pid, socket_control);
 	{error, Reason}	->
 	    {error, Reason}
     end.
@@ -1881,16 +1944,3 @@ handshake(Pid, Ref, Timeout) ->
 	    {error, timeout}
     end.
 
-start_timeout(_,_, infinity) ->
-    ok;
-start_timeout(Channel, From, Time) ->
-    erlang:send_after(Time, self(), {timeout, {Channel, From}}).
-
-getopt(Opt, Socket) ->
-    case inet:getopts(Socket, [Opt]) of
-	{ok, [{Opt, Value}]} ->
-	    {ok, Value};
-	Other ->
-	    {error, {unexpected_getopts_return, Other}}
-    end.
-		
diff --git a/lib/ssh/src/ssh_info.erl b/lib/ssh/src/ssh_info.erl
index 67130d5eac..0c24c09887 100644
--- a/lib/ssh/src/ssh_info.erl
+++ b/lib/ssh/src/ssh_info.erl
@@ -37,7 +37,7 @@ print() ->
     io:format("~s", [string()]).
 
 print(File) when is_list(File) ->
-    {ok,D} = file:open(File, write),
+    {ok,D} = file:open(File, [write]),
     print(D),
     file:close(D);
 print(D) ->
diff --git a/lib/ssh/src/ssh_message.erl b/lib/ssh/src/ssh_message.erl
index 65754956aa..db80d4c9e3 100644
--- a/lib/ssh/src/ssh_message.erl
+++ b/lib/ssh/src/ssh_message.erl
@@ -50,13 +50,7 @@
 -define(Empint(X),       (ssh_bits:mpint(X))/binary ).
 -define(Ebinary(X),      ?STRING(X) ).
 
-%% encode(Msg) ->
-%%     try encode1(Msg)
-%%     catch
-%% 	C:E ->
-%% 	    io:format('***********************~n~p:~p  ~p~n',[C,E,Msg]),
-%% 	    error(E)
-%%     end.
+-define(unicode_list(B), unicode:characters_to_list(B)).
 
 encode(#ssh_msg_global_request{
 	  name = Name,
@@ -176,7 +170,7 @@ encode(#ssh_msg_userauth_pk_ok{
 encode(#ssh_msg_userauth_passwd_changereq{prompt = Prompt,
 					  languge = Lang
 					 })->
-    <<?Ebyte(?SSH_MSG_USERAUTH_PASSWD_CHANGEREQ), ?Estring(Prompt), ?Estring(Lang)>>;
+    <<?Ebyte(?SSH_MSG_USERAUTH_PASSWD_CHANGEREQ), ?Estring_utf8(Prompt), ?Estring(Lang)>>;
 
 encode(#ssh_msg_userauth_info_request{
 	  name = Name,
@@ -184,14 +178,14 @@ encode(#ssh_msg_userauth_info_request{
 	  language_tag = Lang,
 	  num_prompts = NumPromtps,
 	  data = Data}) ->
-    <<?Ebyte(?SSH_MSG_USERAUTH_INFO_REQUEST), ?Estring(Name), ?Estring(Inst), ?Estring(Lang),
+    <<?Ebyte(?SSH_MSG_USERAUTH_INFO_REQUEST), ?Estring_utf8(Name), ?Estring_utf8(Inst), ?Estring(Lang),
       ?Euint32(NumPromtps), ?'E...'(Data)>>;
 
 encode(#ssh_msg_userauth_info_response{
 	  num_responses = Num,
 	  data = Data}) ->
     lists:foldl(fun %%("", Acc) -> Acc;  % commented out since it seem wrong
-		    (Response, Acc) -> <<Acc/binary, ?Estring(Response)>>
+		    (Response, Acc) -> <<Acc/binary, ?Estring_utf8(Response)>>
 		end,
 		<<?Ebyte(?SSH_MSG_USERAUTH_INFO_RESPONSE), ?Euint32(Num)>>,
 		Data);
@@ -201,17 +195,17 @@ encode(#ssh_msg_disconnect{
 	  description = Desc,
 	  language = Lang
 	 }) ->
-    <<?Ebyte(?SSH_MSG_DISCONNECT), ?Euint32(Code), ?Estring(Desc), ?Estring(Lang)>>;
+    <<?Ebyte(?SSH_MSG_DISCONNECT), ?Euint32(Code), ?Estring_utf8(Desc), ?Estring(Lang)>>;
 
 encode(#ssh_msg_service_request{
 	  name = Service
 	 }) ->
-    <<?Ebyte(?SSH_MSG_SERVICE_REQUEST), ?Estring(Service)>>;
+    <<?Ebyte(?SSH_MSG_SERVICE_REQUEST), ?Estring_utf8(Service)>>;
 
 encode(#ssh_msg_service_accept{
 	  name = Service
 	 }) ->
-    <<?Ebyte(?SSH_MSG_SERVICE_ACCEPT), ?Estring(Service)>>;
+    <<?Ebyte(?SSH_MSG_SERVICE_ACCEPT), ?Estring_utf8(Service)>>;
 
 encode(#ssh_msg_newkeys{}) ->
     <<?Ebyte(?SSH_MSG_NEWKEYS)>>;
@@ -283,7 +277,7 @@ encode(#ssh_msg_kex_ecdh_reply{public_host_key = Key, q_s = Q_s, h_sig = Sign})
     <<?Ebyte(?SSH_MSG_KEX_ECDH_REPLY), ?Ebinary(EncKey), ?Empint(Q_s), ?Ebinary(EncSign)>>;
 
 encode(#ssh_msg_ignore{data = Data}) ->
-    <<?Ebyte(?SSH_MSG_IGNORE), ?Estring(Data)>>;
+    <<?Ebyte(?SSH_MSG_IGNORE), ?Estring_utf8(Data)>>;
 
 encode(#ssh_msg_unimplemented{sequence = Seq}) ->
     <<?Ebyte(?SSH_MSG_UNIMPLEMENTED), ?Euint32(Seq)>>;
@@ -291,7 +285,7 @@ encode(#ssh_msg_unimplemented{sequence = Seq}) ->
 encode(#ssh_msg_debug{always_display = Bool,
 		      message = Msg,
 		      language = Lang}) ->
-    <<?Ebyte(?SSH_MSG_DEBUG), ?Eboolean(Bool), ?Estring(Msg), ?Estring(Lang)>>.
+    <<?Ebyte(?SSH_MSG_DEBUG), ?Eboolean(Bool), ?Estring_utf8(Msg), ?Estring(Lang)>>.
 
 
 %% Connection Messages
@@ -330,7 +324,7 @@ decode(<<?BYTE(?SSH_MSG_CHANNEL_OPEN_FAILURE),  ?UINT32(Recipient), ?UINT32(Reas
     #ssh_msg_channel_open_failure{
        recipient_channel = Recipient,
        reason = Reason,
-       description = unicode:characters_to_list(Desc),
+       description = ?unicode_list(Desc),
        lang = Lang
       };
 decode(<<?BYTE(?SSH_MSG_CHANNEL_WINDOW_ADJUST), ?UINT32(Recipient), ?UINT32(Bytes)>>) ->
@@ -363,7 +357,7 @@ decode(<<?BYTE(?SSH_MSG_CHANNEL_REQUEST), ?UINT32(Recipient),
 	 ?DEC_BIN(RequestType,__0), ?BYTE(Bool), Data/binary>>) ->
     #ssh_msg_channel_request{
        recipient_channel = Recipient,
-       request_type = unicode:characters_to_list(RequestType),
+       request_type = ?unicode_list(RequestType),
        want_reply = erl_boolean(Bool),
        data  = Data
       };
@@ -381,9 +375,9 @@ decode(<<?BYTE(?SSH_MSG_USERAUTH_REQUEST),
 	 ?DEC_BIN(User,__0), ?DEC_BIN(Service,__1), ?DEC_BIN(Method,__2),
 	 Data/binary>>) ->
     #ssh_msg_userauth_request{
-       user = unicode:characters_to_list(User),
-       service = unicode:characters_to_list(Service),
-       method = unicode:characters_to_list(Method),
+       user =    ?unicode_list(User),
+       service = ?unicode_list(Service),
+       method =  ?unicode_list(Method),
        data = Data
       };
 
@@ -391,7 +385,7 @@ decode(<<?BYTE(?SSH_MSG_USERAUTH_FAILURE),
 	 ?DEC_BIN(Auths,__0),
 	 ?BYTE(Bool)>>) ->
     #ssh_msg_userauth_failure {
-       authentications = unicode:characters_to_list(Auths),
+       authentications = ?unicode_list(Auths),
        partial_success = erl_boolean(Bool)
       };
 
@@ -493,18 +487,18 @@ decode(<<"ecdh",?BYTE(?SSH_MSG_KEX_ECDH_REPLY),
 
 decode(<<?SSH_MSG_SERVICE_REQUEST, ?DEC_BIN(Service,__0)>>) ->
     #ssh_msg_service_request{
-       name = unicode:characters_to_list(Service)
+       name = ?unicode_list(Service)
       };
 
 decode(<<?SSH_MSG_SERVICE_ACCEPT, ?DEC_BIN(Service,__0)>>) ->
     #ssh_msg_service_accept{
-       name = unicode:characters_to_list(Service)
+       name = ?unicode_list(Service)
       };
 
 decode(<<?BYTE(?SSH_MSG_DISCONNECT), ?UINT32(Code), ?DEC_BIN(Desc,__0), ?DEC_BIN(Lang,__1)>>) ->
     #ssh_msg_disconnect{
        code = Code,
-       description = unicode:characters_to_list(Desc),
+       description = ?unicode_list(Desc),
        language = Lang
       };
 
@@ -512,7 +506,7 @@ decode(<<?BYTE(?SSH_MSG_DISCONNECT), ?UINT32(Code), ?DEC_BIN(Desc,__0), ?DEC_BIN
 decode(<<?BYTE(?SSH_MSG_DISCONNECT), ?UINT32(Code), ?DEC_BIN(Desc,__0)>>) ->
     #ssh_msg_disconnect{
        code = Code,
-       description = unicode:characters_to_list(Desc),
+       description = ?unicode_list(Desc),
        language = <<"en">>
       };
 
@@ -554,7 +548,7 @@ decode_kex_init(<<?BYTE(Bool)>>, Acc, 0) ->
     X = 0,
     list_to_tuple(lists:reverse([X, erl_boolean(Bool) | Acc]));
 decode_kex_init(<<?DEC_BIN(Data,__0), Rest/binary>>, Acc, N) ->
-    Names = string:tokens(unicode:characters_to_list(Data), ","),
+    Names = string:tokens(?unicode_list(Data), ","),
     decode_kex_init(Rest, [Names | Acc], N -1).
 
 
diff --git a/lib/ssh/src/ssh_no_io.erl b/lib/ssh/src/ssh_no_io.erl
index 8144aac66e..1da257ed99 100644
--- a/lib/ssh/src/ssh_no_io.erl
+++ b/lib/ssh/src/ssh_no_io.erl
@@ -27,27 +27,39 @@
 
 -export([yes_no/2, read_password/2, read_line/2, format/2]).
 
+
+-spec yes_no(any(), any()) -> no_return().
+
 yes_no(_, _) ->
-    throw({{no_io_allowed, yes_no},
-	   #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
-			       description = "User interaction is not allowed",
-			       language = "en"}}).
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+			  description = "User interaction is not allowed"},
+      {no_io_allowed, yes_no}).
+
+
+-spec read_password(any(), any()) -> no_return().
 
 read_password(_, _) ->
-    throw({{no_io_allowed, read_password},
-	  #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
-			       description = "User interaction is not allowed",
-			      language = "en"}}).
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+			  description = "User interaction is not allowed"},
+      {no_io_allowed, read_password}).
+
+
+-spec read_line(any(), any()) -> no_return().
 
 read_line(_, _) ->
-    throw({{no_io_allowed, read_line},
-	  #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
-			      description =  "User interaction is not allowed",
-			      language = "en"}} ).
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+			  description =  "User interaction is not allowed"},
+    {no_io_allowed, read_line}).
+
+
+-spec format(any(), any()) -> no_return().
 
 format(_, _) ->
-    throw({{no_io_allowed, format},
-	   #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
-			       description =   "User interaction is not allowed",
-			       language = "en"}}).
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
+			  description =   "User interaction is not allowed"},
+      {no_io_allowed, format}).
     
diff --git a/lib/ssh/src/ssh_transport.erl b/lib/ssh/src/ssh_transport.erl
index c04bd350c7..7cb3b75ac0 100644
--- a/lib/ssh/src/ssh_transport.erl
+++ b/lib/ssh/src/ssh_transport.erl
@@ -265,7 +265,8 @@ new_keys_message(Ssh0) ->
     {SshPacket, Ssh} = 
 	ssh_packet(#ssh_msg_newkeys{}, Ssh0),
     {ok, SshPacket, Ssh}.
-    
+
+
 handle_kexinit_msg(#ssh_msg_kexinit{} = CounterPart, #ssh_msg_kexinit{} = Own,
 			    #ssh{role = client} = Ssh0) ->
     {ok, Algoritms} = select_algorithm(client, Own, CounterPart),  
@@ -275,10 +276,10 @@ handle_kexinit_msg(#ssh_msg_kexinit{} = CounterPart, #ssh_msg_kexinit{} = Own,
 				   Ssh0#ssh{algorithms = Algoritms});
 	_  ->
 	    %% TODO: Correct code?
-	    throw(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-				      description = "Selection of key exchange"
-				      " algorithm failed", 
-				      language = ""})
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+			  description = "Selection of key exchange algorithm failed"
+			 })
     end;
 
 handle_kexinit_msg(#ssh_msg_kexinit{} = CounterPart, #ssh_msg_kexinit{} = Own,
@@ -288,10 +289,10 @@ handle_kexinit_msg(#ssh_msg_kexinit{} = CounterPart, #ssh_msg_kexinit{} = Own,
 	true ->
 	    {ok, Ssh#ssh{algorithms = Algoritms}};
 	_ ->
-	    throw(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-				      description = "Selection of key exchange"
-				      " algorithm failed",
-				      language = ""})
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+			  description = "Selection of key exchange algorithm failed"
+			 })
     end.
 
 
@@ -371,12 +372,12 @@ handle_kexdh_init(#ssh_msg_kexdh_init{e = E},
 				     session_id = sid(Ssh1, H)}};
 
 	true ->
-	    throw({{error,bad_e_from_peer},
-		   #ssh_msg_disconnect{
-		      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-		      description = "Key exchange failed, 'e' out of bounds",
-		      language = ""}
-		   })
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Key exchange failed, 'e' out of bounds"},
+	      {error,bad_e_from_peer}
+	     )
     end.
 
 handle_kexdh_reply(#ssh_msg_kexdh_reply{public_host_key = PeerPubHostKey,
@@ -396,21 +397,20 @@ handle_kexdh_reply(#ssh_msg_kexdh_reply{public_host_key = PeerPubHostKey,
 					    exchanged_hash = H,
 					    session_id = sid(Ssh, H)}};
 		Error ->
-		    throw({Error,
-			   #ssh_msg_disconnect{
-			      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-			      description = "Key exchange failed",
-			      language = "en"}
-			  })
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Key exchange failed"},
+	      Error)
 	    end;
 
 	true ->
-	    throw({{error,bad_f_from_peer},
-		   #ssh_msg_disconnect{
-		      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-		      description = "Key exchange failed, 'f' out of bounds",
-		      language = ""}
-		   })
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Key exchange failed, 'f' out of bounds"},
+	      bad_f_from_peer
+	     )
     end.
 
 
@@ -435,10 +435,11 @@ handle_kex_dh_gex_request(#ssh_msg_kex_dh_gex_request{min = Min0,
 		     keyex_info = {Min, Max, NBits}
 		    }};
 	{error,_} ->
-	    throw(#ssh_msg_disconnect{
-		     code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-		     description = "No possible diffie-hellman-group-exchange group found", 
-		     language = ""})
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+		 description = "No possible diffie-hellman-group-exchange group found"
+		})
     end;
 
 handle_kex_dh_gex_request(#ssh_msg_kex_dh_gex_request_old{n = NBits}, 
@@ -469,19 +470,19 @@ handle_kex_dh_gex_request(#ssh_msg_kex_dh_gex_request_old{n = NBits},
 		     keyex_info = {-1, -1, NBits} % flag for kex_h hash calc
 		    }};
 	{error,_} ->
-	    throw(#ssh_msg_disconnect{
-		     code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-		     description = "No possible diffie-hellman-group-exchange group found", 
-		     language = ""})
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+		 description = "No possible diffie-hellman-group-exchange group found"
+		})
     end;
 
 handle_kex_dh_gex_request(_, _) ->
-  throw({{error,bad_ssh_msg_kex_dh_gex_request},
+    ssh_connection_handler:disconnect(
 	 #ssh_msg_disconnect{
 	    code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-	    description = "Key exchange failed, bad values in ssh_msg_kex_dh_gex_request",
-	    language = ""}
-	}).
+	    description = "Key exchange failed, bad values in ssh_msg_kex_dh_gex_request"},
+      bad_ssh_msg_kex_dh_gex_request).
 
 
 adjust_gex_min_max(Min0, Max0, Opts) ->
@@ -495,10 +496,11 @@ adjust_gex_min_max(Min0, Max0, Opts) ->
 		Min2 =< Max2 ->
 		    {Min2, Max2};
 		Max2 < Min2 ->
-		    throw(#ssh_msg_disconnect{
-			     code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-			     description = "No possible diffie-hellman-group-exchange group possible", 
-			     language = ""})
+		    ssh_connection_handler:disconnect(
+		      #ssh_msg_disconnect{
+			 code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+			 description = "No possible diffie-hellman-group-exchange group possible"
+			})
 	    end
     end.
 		    
@@ -535,20 +537,18 @@ handle_kex_dh_gex_init(#ssh_msg_kex_dh_gex_init{e = E},
 					    session_id = sid(Ssh, H)
 					   }};
 		true ->
-		    throw({{error,bad_K},
-			   #ssh_msg_disconnect{
-			      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-			      description = "Key exchange failed, 'K' out of bounds",
-			      language = ""}
-			  })
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Key exchange failed, 'K' out of bounds"},
+	      bad_K)
 	    end;
 	true ->
-	    throw({{error,bad_e_from_peer},
-		   #ssh_msg_disconnect{
-		      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-		      description = "Key exchange failed, 'e' out of bounds",
-		      language = ""}
-		  })
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Key exchange failed, 'e' out of bounds"},
+	      bad_e_from_peer)
     end.
 
 handle_kex_dh_gex_reply(#ssh_msg_kex_dh_gex_reply{public_host_key = PeerPubHostKey, 
@@ -572,29 +572,28 @@ handle_kex_dh_gex_reply(#ssh_msg_kex_dh_gex_reply{public_host_key = PeerPubHostK
 						    exchanged_hash = H,
 						    session_id = sid(Ssh, H)}};
 			_Error ->
-			    throw(#ssh_msg_disconnect{
-				     code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-				     description = "Key exchange failed",
-				     language = ""}
-				 )
+			    ssh_connection_handler:disconnect(
+			      #ssh_msg_disconnect{
+				 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+				 description = "Key exchange failed"
+				})
 		    end;
 
 		true ->
-		    throw({{error,bad_K},
-			   #ssh_msg_disconnect{
-			      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-			      description = "Key exchange failed, 'K' out of bounds",
-			      language = ""}
-			  })
+		    ssh_connection_handler:disconnect(
+		      #ssh_msg_disconnect{
+			 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+			 description = "Key exchange failed, 'K' out of bounds"},
+		      bad_K)
 	    end;
 	true ->
-	    throw({{error,bad_f_from_peer},
-		   #ssh_msg_disconnect{
-		      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-		      description = "Key exchange failed, 'f' out of bounds",
-		      language = ""}
-		  })
-    end.	       
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Key exchange failed, 'f' out of bounds"},
+	      bad_f_from_peer
+	     )
+    end.
 
 %%%----------------------------------------------------------------
 %%%
@@ -624,12 +623,11 @@ handle_kex_ecdh_init(#ssh_msg_kex_ecdh_init{q_c = PeerPublic},
 				     session_id = sid(Ssh1, H)}}
     catch
 	_:_ ->
-	    throw({{error,invalid_peer_public_key},
-		   #ssh_msg_disconnect{
-		      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-		      description = "Peer ECDH public key is invalid",
-		      language = ""}
-		  })
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Peer ECDH public key is invalid"},
+	      invalid_peer_public_key)
     end.
 
 handle_kex_ecdh_reply(#ssh_msg_kex_ecdh_reply{public_host_key = PeerPubHostKey,
@@ -650,21 +648,19 @@ handle_kex_ecdh_reply(#ssh_msg_kex_ecdh_reply{public_host_key = PeerPubHostKey,
 					    exchanged_hash = H,
 					    session_id = sid(Ssh, H)}};
 		Error ->
-		    throw({Error,
-			   #ssh_msg_disconnect{
-			      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-			      description = "Key exchange failed",
-			      language = ""}
-			  })
+		    ssh_connection_handler:disconnect(
+		       #ssh_msg_disconnect{
+			  code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+			  description = "Key exchange failed"},
+		       Error)
 	    end
     catch
 	_:_ ->
-	    throw({{error,invalid_peer_public_key},
-		   #ssh_msg_disconnect{
-		      code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
-		      description = "Peer ECDH public key is invalid",
-		      language = ""}
-		  })
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{
+		 code = ?SSH_DISCONNECT_KEY_EXCHANGE_FAILED,
+		 description = "Peer ECDH public key is invalid"},
+	      invalid_peer_public_key)
     end.
 
 
@@ -675,9 +671,10 @@ handle_new_keys(#ssh_msg_newkeys{}, Ssh0) ->
 	    {ok, Ssh}
     catch 
 	_C:_Error -> %% TODO: Throw earlier ....
-	    throw(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-				      description = "Install alg failed", 
-				      language = "en"})
+	    ssh_connection_handler:disconnect(
+	      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+				  description = "Install alg failed"
+				 })
     end. 
 
 %% select session id
@@ -929,9 +926,9 @@ select_all(CL, SL) when length(CL) + length(SL) < ?MAX_NUM_ALGORITHMS ->
     lists:map(fun(ALG) -> list_to_atom(ALG) end, (CL -- A));
 select_all(CL, SL) ->
     Err = lists:concat(["Received too many algorithms (",length(CL),"+",length(SL)," >= ",?MAX_NUM_ALGORITHMS,")."]),
-    throw(#ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
-			      description = Err,
-			      language = ""}).
+    ssh_connection_handler:disconnect(
+      #ssh_msg_disconnect{code = ?SSH_DISCONNECT_PROTOCOL_ERROR,
+			  description = Err}).
 
 
 select([], []) ->
@@ -1042,7 +1039,7 @@ handle_packet_part(DecryptedPfx, EncryptedBuffer, TotalNeeded,
 		    {bad_mac, Ssh1};
 		true ->
 		    {Ssh, DecompressedPayload} = decompress(Ssh1, payload(DecryptedPacket)),
-		    {decoded, DecompressedPayload, NextPacketBytes, Ssh}
+		    {packet_decrypted, DecompressedPayload, NextPacketBytes, Ssh}
 	    end;
 	aead ->
 	    PacketLenBin = DecryptedPfx,
@@ -1052,7 +1049,7 @@ handle_packet_part(DecryptedPfx, EncryptedBuffer, TotalNeeded,
 		{Ssh1, DecryptedSfx} ->
                     DecryptedPacket = <<DecryptedPfx/binary, DecryptedSfx/binary>>,
 		    {Ssh, DecompressedPayload} = decompress(Ssh1, payload(DecryptedPacket)),
-		    {decoded, DecompressedPayload, NextPacketBytes, Ssh}
+		    {packet_decrypted, DecompressedPayload, NextPacketBytes, Ssh}
 	    end
     end.
     
diff --git a/lib/ssh/test/ssh_algorithms_SUITE.erl b/lib/ssh/test/ssh_algorithms_SUITE.erl
index bdc980e65c..440308d1b3 100644
--- a/lib/ssh/test/ssh_algorithms_SUITE.erl
+++ b/lib/ssh/test/ssh_algorithms_SUITE.erl
@@ -361,13 +361,15 @@ get_atoms(L) ->
 %%% Test case related
 %%%
 start_std_daemon(Opts, Config) ->
+    ct:log("starting std_daemon",[]),
     {Pid, Host, Port} = ssh_test_lib:std_daemon(Config, Opts),
     ct:log("started ~p:~p  ~p",[Host,Port,Opts]),
     [{srvr_pid,Pid},{srvr_addr,{Host,Port}} | Config].
 
 start_pubkey_daemon(Opts, Config) ->
+    ct:log("starting pubkey_daemon",[]),
     {Pid, Host, Port} = ssh_test_lib:std_daemon1(Config, Opts),
-    ct:log("started1 ~p:~p  ~p",[Host,Port,Opts]),
+    ct:log("started pubkey_daemon ~p:~p  ~p",[Host,Port,Opts]),
     [{srvr_pid,Pid},{srvr_addr,{Host,Port}} | Config].
 
 
diff --git a/lib/ssh/test/ssh_benchmark_SUITE.erl b/lib/ssh/test/ssh_benchmark_SUITE.erl
index 6e1d18cc95..1f11fee350 100644
--- a/lib/ssh/test/ssh_benchmark_SUITE.erl
+++ b/lib/ssh/test/ssh_benchmark_SUITE.erl
@@ -333,52 +333,64 @@ find_time(accept_to_hello, L) ->
     [T0,T1] = find([fun(C=#call{mfa = {ssh_acceptor,handle_connection,5}}) ->
 			    C#call.t_call
 		    end,
-		    fun(C=#call{mfa = {ssh_connection_handler,hello,_},
-				args = [socket_control|_]}) ->
-			    C#call.t_return
-		    end
+		    ?LINE,
+		    fun(C=#call{mfa = {ssh_connection_handler,handle_event,5},
+				args = [_, {version_exchange,_}, _, {hello,_}, _]}) ->
+			    C#call.t_call
+		    end,
+		    ?LINE
 		   ], L, []),
     {accept_to_hello, now2micro_sec(now_diff(T1,T0)), microsec};
 find_time(kex, L) ->
-    [T0,T1] = find([fun(C=#call{mfa = {ssh_connection_handler,hello,_},
-				args = [socket_control|_]}) ->
+    [T0,T1] = find([fun(C=#call{mfa = {ssh_connection_handler,handle_event,5},
+				args = [_, {version_exchange,_}, _, {hello,_}, _]}) ->
 			    C#call.t_call
 		    end,
-		    ?send(#ssh_msg_newkeys{})
+		    ?LINE,
+		    ?send(#ssh_msg_newkeys{}),
+		    ?LINE
 		    ], L, []),
     {kex, now2micro_sec(now_diff(T1,T0)), microsec};
 find_time(kex_to_auth, L) ->
     [T0,T1] = find([?send(#ssh_msg_newkeys{}),
-		    ?recv(#ssh_msg_userauth_request{})
+		    ?LINE,
+		    ?recv(#ssh_msg_userauth_request{}),
+		    ?LINE
 		   ], L, []),
     {kex_to_auth, now2micro_sec(now_diff(T1,T0)), microsec};
 find_time(auth, L) ->
     [T0,T1] = find([?recv(#ssh_msg_userauth_request{}),
-		    ?send(#ssh_msg_userauth_success{})
+		    ?LINE,
+		    ?send(#ssh_msg_userauth_success{}),
+		    ?LINE
 		   ], L, []),
     {auth, now2micro_sec(now_diff(T1,T0)), microsec};
 find_time(to_prompt, L) ->
     [T0,T1] = find([fun(C=#call{mfa = {ssh_acceptor,handle_connection,5}}) ->
 			    C#call.t_call
 		    end,
-		    ?recv(#ssh_msg_channel_request{request_type="env"})
+		    ?LINE,
+		    ?recv(#ssh_msg_channel_request{request_type="env"}),
+		    ?LINE
 		   ], L, []),
     {to_prompt, now2micro_sec(now_diff(T1,T0)), microsec};
 find_time(channel_open_close, L) ->
     [T0,T1] = find([?recv(#ssh_msg_channel_request{request_type="subsystem"}),
-		    ?send(#ssh_msg_channel_close{})
+		    ?LINE,
+		    ?send(#ssh_msg_channel_close{}),
+		    ?LINE
 		   ], L, []),
     {channel_open_close, now2micro_sec(now_diff(T1,T0)), microsec}.
  
 
 
-find([F|Fs], [C|Cs], Acc) when is_function(F,1) ->
+find([F,Id|Fs], [C|Cs], Acc) when is_function(F,1) ->
     try
 	F(C)
     of
 	T -> find(Fs, Cs, [T|Acc])
     catch
-	_:_ -> find([F|Fs], Cs, Acc)
+	_:_ -> find([F,Id|Fs], Cs, Acc)
     end;
 find([], _, Acc) ->
     lists:reverse(Acc).
@@ -444,7 +456,7 @@ erlang_trace() ->
     0 = erlang:trace(new, true, [call,timestamp,{tracer,TracerPid}]),
     [init_trace(MFA, tp(MFA))
      || MFA <- [{ssh_acceptor,handle_connection,5},
-		{ssh_connection_handler,hello,2},
+%%		{ssh_connection_handler,hello,2},
 		{ssh_message,encode,1},
 		{ssh_message,decode,1},
 		{ssh_transport,select_algorithm,3},
@@ -454,6 +466,10 @@ erlang_trace() ->
 		{ssh_message,decode,1},
 		{public_key,dh_gex_group,4} % To find dh_gex group size
 	       ]],
+    init_trace({ssh_connection_handler,handle_event,5},
+	       [{['_', {version_exchange,'_'}, '_', {hello,'_'}, '_'],
+		 [],
+		 [return_trace]}]),
     {ok, TracerPid}.
 
 tp({_M,_F,Arity}) ->
diff --git a/lib/ssh/test/ssh_options_SUITE.erl b/lib/ssh/test/ssh_options_SUITE.erl
index 1d14a16065..4106385d2d 100644
--- a/lib/ssh/test/ssh_options_SUITE.erl
+++ b/lib/ssh/test/ssh_options_SUITE.erl
@@ -493,7 +493,7 @@ ssh_msg_debug_fun_option_client(Config) ->
 					  {user_interaction, false},
 					  {ssh_msg_debug_fun,DbgFun}]),
     %% Beware, implementation knowledge:
-    gen_fsm:send_all_state_event(ConnectionRef,{ssh_msg_debug,false,<<"Hello">>,<<>>}),
+    gen_statem:cast(ConnectionRef,{ssh_msg_debug,false,<<"Hello">>,<<>>}),
     receive
 	{msg_dbg,X={ConnectionRef,false,<<"Hello">>,<<>>}} ->
 	    ct:log("Got expected dbg msg ~p",[X]),
@@ -606,7 +606,7 @@ ssh_msg_debug_fun_option_server(Config) ->
     receive
 	{connection_pid,Server} ->
 	    %% Beware, implementation knowledge:
-	    gen_fsm:send_all_state_event(Server,{ssh_msg_debug,false,<<"Hello">>,<<>>}),
+	    gen_statem:cast(Server,{ssh_msg_debug,false,<<"Hello">>,<<>>}),
 	    receive
 		{msg_dbg,X={_,false,<<"Hello">>,<<>>}} ->
 		    ct:log("Got expected dbg msg ~p",[X]),
diff --git a/lib/ssh/test/ssh_renegotiate_SUITE.erl b/lib/ssh/test/ssh_renegotiate_SUITE.erl
index 90132becbd..f1a909cbd0 100644
--- a/lib/ssh/test/ssh_renegotiate_SUITE.erl
+++ b/lib/ssh/test/ssh_renegotiate_SUITE.erl
@@ -33,7 +33,6 @@
 suite() -> [{ct_hooks,[ts_install_cth]},
 	    {timetrap,{seconds,40}}].
 
-
 all() -> [{group,default_algs},
 	  {group,aes_gcm}
 	 ].
@@ -238,7 +237,7 @@ renegotiate2(Config) ->
 %% get_kex_init - helper function to get key_exchange_init_msg
 get_kex_init(Conn) ->
     %% First, validate the key exchange is complete (StateName == connected)
-    {connected,S} = sys:get_state(Conn),
+    {{connected,_},S} = sys:get_state(Conn),
     %% Next, walk through the elements of the #state record looking
     %% for the #ssh_msg_kexinit record. This method is robust against
     %% changes to either record. The KEXINIT message contains a cookie
diff --git a/lib/ssh/test/ssh_sftp_SUITE.erl b/lib/ssh/test/ssh_sftp_SUITE.erl
index cd6c5f82b9..e06b646bba 100644
--- a/lib/ssh/test/ssh_sftp_SUITE.erl
+++ b/lib/ssh/test/ssh_sftp_SUITE.erl
@@ -38,7 +38,6 @@ suite() ->
     [{ct_hooks,[ts_install_cth]},
      {timetrap,{seconds,40}}].
 
-
 all() -> 
     [{group, not_unicode},
      {group, unicode}
diff --git a/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl b/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl
index 09bef87148..355ce6a8f5 100644
--- a/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl
+++ b/lib/ssh/test/ssh_sftpd_erlclient_SUITE.erl
@@ -39,7 +39,6 @@ suite() ->
     [{ct_hooks,[ts_install_cth]},
      {timetrap,{seconds,40}}].
 
-
 all() -> 
     [close_file, 
      quit, 
diff --git a/lib/ssh/test/ssh_test_lib.erl b/lib/ssh/test/ssh_test_lib.erl
index 4db7d09ccd..69329a5c75 100644
--- a/lib/ssh/test/ssh_test_lib.erl
+++ b/lib/ssh/test/ssh_test_lib.erl
@@ -57,12 +57,16 @@ daemon(Host, Options) ->
     daemon(Host, inet_port(), Options).
 
 daemon(Host, Port, Options) ->
+    ct:log("~p:~p Calling ssh:daemon(~p, ~p, ~p)",[?MODULE,?LINE,Host,Port,Options]),
     case ssh:daemon(Host, Port, Options) of
 	{ok, Pid} when Host == any ->
+	    ct:log("ssh:daemon ok (1)",[]),
 	    {Pid, hostname(), Port};
 	{ok, Pid} ->
+	    ct:log("ssh:daemon ok (2)",[]),
 	    {Pid, Host, Port};
 	Error ->
+	    ct:log("ssh:daemon error ~p",[Error]),
 	    Error
     end.
 
diff --git a/lib/ssh/test/ssh_trpt_test_lib.erl b/lib/ssh/test/ssh_trpt_test_lib.erl
index 4269529ae8..e34071af99 100644
--- a/lib/ssh/test/ssh_trpt_test_lib.erl
+++ b/lib/ssh/test/ssh_trpt_test_lib.erl
@@ -294,12 +294,11 @@ instantiate(X, _S) ->
 %%%================================================================
 %%%
 init_ssh(Role, Socket, Options0) ->
-    Options = [{user_interaction,false}
+    Options = [{user_interaction, false},
+	       {vsn, {2,0}},
+	       {id_string, "ErlangTestLib"}
 	       | Options0],
-    ssh_connection_handler:init_ssh(Role,
-				    {2,0},
-				    lists:concat(["SSH-2.0-ErlangTestLib ",Role]),
-				    Options, Socket).
+    ssh_connection_handler:init_ssh_record(Role, Socket, Options).
 
 mangle_opts(Options) ->
     SysOpts = [{reuseaddr, true},