ssh: Simplify ssh_connection and ssh_connection_handler and their internal interfaces

3 files changed, 378 insertions, 362 deletions

diff --git a/lib/ssh/src/ssh_connection.erl b/lib/ssh/src/ssh_connection.erl
index 946ae2967b..03336d6b25 100644
--- a/lib/ssh/src/ssh_connection.erl
+++ b/lib/ssh/src/ssh_connection.erl
@@ -40,16 +40,29 @@
 -export([window_change/4, window_change/6,
 	 signal/3, exit_status/3]).
 
-%% Internal application API
--export([channel_data/5, handle_msg/3, channel_eof_msg/1,
-	 channel_close_msg/1, channel_success_msg/1, channel_failure_msg/1, 
+%% Internal SSH application API
+-export([channel_data/5,
+         handle_msg/3,
+         handle_stop/1,
+
+	 channel_adjust_window_msg/2,
+	 channel_close_msg/1,
+	 channel_open_failure_msg/4,
+	 channel_open_msg/5,
 	 channel_status_msg/1,
-	 channel_adjust_window_msg/2, channel_data_msg/3,
-	 channel_open_msg/5, channel_open_confirmation_msg/4,
-	 channel_open_failure_msg/4, channel_request_msg/4,
+         channel_data_msg/3,
+         channel_eof_msg/1,
+         channel_failure_msg/1, 
+         channel_open_confirmation_msg/4,
+         channel_request_msg/4,
+         channel_success_msg/1,
+
 	 request_failure_msg/0, 
-	 request_success_msg/1, bind/4, unbind/3, unbind_channel/2, 
-	 bound_channel/3, encode_ip/1]).
+	 request_success_msg/1,
+
+         bind/4, unbind/3, unbind_channel/2, 
+	 bound_channel/3, encode_ip/1
+        ]).
 
 %%--------------------------------------------------------------------
 %%% API
@@ -232,27 +245,15 @@ exit_status(ConnectionHandler, Channel, Status) ->
 				   "exit-status", false, [?uint32(Status)], 0).
 
 %%--------------------------------------------------------------------
-%%% Internal API
+%%% Internal, that is, ssh application internal API
 %%--------------------------------------------------------------------
-l2b(L) when is_integer(hd(L)) ->
-    try list_to_binary(L)
-    of
-	B -> B
-    catch
-	_:_ -> 
-	    unicode:characters_to_binary(L)
-    end;
-l2b([H|T]) -> 
-    << (l2b(H))/binary, (l2b(T))/binary >>;
-l2b(B) when is_binary(B) ->
-    B;
-l2b([]) ->
-    <<>>.
 
-    
+%%%----------------------------------------------------------------
+%%% Send data on a channel/connection as result of for example
+%%% ssh_connection:send (executed in the ssh_connection_state machine)
+%%%
 
-channel_data(ChannelId, DataType, Data, Connection, From)
-  when is_list(Data)->
+channel_data(ChannelId, DataType, Data, Connection, From) when is_list(Data)->
     channel_data(ChannelId, DataType, l2b(Data), Connection, From);
 
 channel_data(ChannelId, DataType, Data, 
@@ -271,11 +272,18 @@ channel_data(ChannelId, DataType, Data,
 						    SendData)}
 			  end, SendList),
 	    FlowCtrlMsgs = flow_control(Replies, Channel, Cache),
-	    {{replies, Replies ++ FlowCtrlMsgs}, Connection};
+	    {Replies ++ FlowCtrlMsgs, Connection};
 	_ ->
-	    {{replies,[{channel_request_reply,From,{error,closed}}]}, Connection}
+	    {[{channel_request_reply,From,{error,closed}}], Connection}
     end.
 
+%%%----------------------------------------------------------------
+%%% Handle the channel messages on behalf of the ssh_connection_handler
+%%% state machine.
+%%%
+%%% Replies {Reply, UpdatedConnection}
+%%%
+
 handle_msg(#ssh_msg_channel_open_confirmation{recipient_channel = ChannelId, 
 					      sender_channel = RemoteId,
 					      initial_window_size = WindowSz,
@@ -292,8 +300,7 @@ handle_msg(#ssh_msg_channel_open_confirmation{recipient_channel = ChannelId,
 							   ),
 				     send_window_size = WindowSz,
 				     send_packet_size = PacketSz}),
-    {Reply, Connection} = reply_msg(Channel, Connection0, {open, ChannelId}),
-    {{replies, [Reply]}, Connection};
+    reply_msg(Channel, Connection0, {open, ChannelId});
  
 handle_msg(#ssh_msg_channel_open_failure{recipient_channel = ChannelId,
 					 reason = Reason,
@@ -302,36 +309,16 @@ handle_msg(#ssh_msg_channel_open_failure{recipient_channel = ChannelId,
 	   #connection{channel_cache = Cache} = Connection0, _) ->
     Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
     ssh_channel:cache_delete(Cache, ChannelId),
-    {Reply, Connection} = 
-	reply_msg(Channel, Connection0, {open_error, Reason, Descr, Lang}),
-    {{replies, [Reply]}, Connection};
+    reply_msg(Channel, Connection0, {open_error, Reason, Descr, Lang});
 
-handle_msg(#ssh_msg_channel_success{recipient_channel = ChannelId},
-	   #connection{channel_cache = Cache} = Connection0, _) ->
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    case reply_msg(Channel, Connection0, success) of
-	{[], Connection} ->
-	    {noreply, Connection};
-	{Reply, Connection} ->
-	    {{replies, [Reply]}, Connection}
-    end;
-
-handle_msg(#ssh_msg_channel_failure{recipient_channel = ChannelId},
-	   #connection{channel_cache = Cache} = Connection0, _) ->
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    case reply_msg(Channel, Connection0, failure) of
-	{[], Connection} ->
-	    {noreply, Connection};
-	{Reply, Connection} ->
-	    {{replies, [Reply]}, Connection}
-    end;
+handle_msg(#ssh_msg_channel_success{recipient_channel = ChannelId}, Connection, _) ->
+    reply_msg(ChannelId, Connection, success);
 
+handle_msg(#ssh_msg_channel_failure{recipient_channel = ChannelId}, Connection, _) ->
+    reply_msg(ChannelId, Connection, failure);
 
-handle_msg(#ssh_msg_channel_eof{recipient_channel = ChannelId}, 
-	    #connection{channel_cache = Cache} = Connection0, _) ->
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    {Reply, Connection} = reply_msg(Channel, Connection0, {eof, ChannelId}),
-    {{replies, [Reply]}, Connection};
+handle_msg(#ssh_msg_channel_eof{recipient_channel = ChannelId}, Connection, _) ->
+    reply_msg(ChannelId, Connection, {eof, ChannelId});
    
 handle_msg(#ssh_msg_channel_close{recipient_channel = ChannelId},   
 	   #connection{channel_cache = Cache} = Connection0, _) ->
@@ -358,42 +345,23 @@ handle_msg(#ssh_msg_channel_close{recipient_channel = ChannelId},
 			    [{flow_control, From, {error, closed}}]
 		    end,
 
-		Replies = ConnReplyMsgs ++ [CloseMsg] ++ SendReplyMsgs,
-		{{replies, Replies}, Connection};
+		Replies = ConnReplyMsgs ++ CloseMsg ++ SendReplyMsgs,
+		{Replies, Connection};
 
 	    undefined ->
-		{{replies, []}, Connection0}
+		{[], Connection0}
 	end;
 
 handle_msg(#ssh_msg_channel_data{recipient_channel = ChannelId,
 				 data = Data}, 
-	   #connection{channel_cache = Cache} = Connection0, _) ->
-    
-    case ssh_channel:cache_lookup(Cache, ChannelId) of
-	#channel{recv_window_size = Size} = Channel ->
-	    WantedSize = Size - size(Data),
-	    ssh_channel:cache_update(Cache, Channel#channel{
-					      recv_window_size = WantedSize}),
-	    {Replies, Connection} =
-		channel_data_reply(Cache, Channel, Connection0, 0, Data),
-	    {{replies, Replies}, Connection};
-	undefined ->
-	    {noreply, Connection0}
-    end;
+	   Connection, _) ->
+    channel_data_reply_msg(ChannelId, Connection, 0, Data);
 
 handle_msg(#ssh_msg_channel_extended_data{recipient_channel = ChannelId,
 					  data_type_code = DataType,
 					  data = Data}, 
-	   #connection{channel_cache = Cache} = Connection0, _) ->
-    
-    #channel{recv_window_size = Size} = Channel =
-	ssh_channel:cache_lookup(Cache, ChannelId), 
-    WantedSize = Size - size(Data),
-    ssh_channel:cache_update(Cache, Channel#channel{
-				      recv_window_size = WantedSize}),
-    {Replies, Connection} = 
-	channel_data_reply(Cache, Channel, Connection0, DataType, Data),
-    {{replies, Replies}, Connection};
+	   Connection, _) ->
+    channel_data_reply_msg(ChannelId, Connection, DataType, Data);
 
 handle_msg(#ssh_msg_channel_window_adjust{recipient_channel = ChannelId,
 					  bytes_to_add = Add}, 
@@ -409,7 +377,7 @@ handle_msg(#ssh_msg_channel_window_adjust{recipient_channel = ChannelId,
 				{connection_reply, channel_data_msg(RemoteId, Type, Data)}
 			end, SendList),
     FlowCtrlMsgs = flow_control(Channel, Cache),
-    {{replies, Replies ++ FlowCtrlMsgs}, Connection};
+    {Replies ++ FlowCtrlMsgs, Connection};
 
 handle_msg(#ssh_msg_channel_open{channel_type = "session" = Type,
 				 sender_channel = RemoteId,
@@ -430,8 +398,7 @@ handle_msg(#ssh_msg_channel_open{channel_type = "session" = Type,
 		    FailMsg = channel_open_failure_msg(RemoteId, 
 						       ?SSH_OPEN_CONNECT_FAILED,
 						       "Connection refused", "en"),
-		    {{replies, [{connection_reply, FailMsg}]},
-		     Connection0}
+		    {[{connection_reply, FailMsg}], Connection0}
 	    end;
 
 	MinAcceptedPackSz > PacketSz ->
@@ -439,7 +406,7 @@ handle_msg(#ssh_msg_channel_open{channel_type = "session" = Type,
 					       ?SSH_OPEN_ADMINISTRATIVELY_PROHIBITED,
 					       lists:concat(["Maximum packet size below ",MinAcceptedPackSz,
 							      " not supported"]), "en"),
-	    {{replies, [{connection_reply, FailMsg}]}, Connection0}
+	    {[{connection_reply, FailMsg}], Connection0}
     end;
 
 handle_msg(#ssh_msg_channel_open{channel_type = "session",
@@ -452,34 +419,30 @@ handle_msg(#ssh_msg_channel_open{channel_type = "session",
     FailMsg = channel_open_failure_msg(RemoteId, 
 				       ?SSH_OPEN_CONNECT_FAILED,
 				       "Connection refused", "en"),
-    {{replies, [{connection_reply, FailMsg}]},
-     Connection};
+    {[{connection_reply, FailMsg}], Connection};
 
 handle_msg(#ssh_msg_channel_open{sender_channel = RemoteId}, Connection, _) ->
     FailMsg = channel_open_failure_msg(RemoteId, 
 				       ?SSH_OPEN_ADMINISTRATIVELY_PROHIBITED,
 				       "Not allowed", "en"),
-    {{replies, [{connection_reply, FailMsg}]}, Connection};
+    {[{connection_reply, FailMsg}], Connection};
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "exit-status",
 				    data = Data},
-	   #connection{channel_cache = Cache} = Connection, _) ->
+           Connection, _) ->
     <<?UINT32(Status)>> = Data,
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    {Reply, Connection} = 
-	reply_msg(Channel, Connection, {exit_status, ChannelId, Status}),
-    {{replies, [Reply]}, Connection};
+    reply_msg(ChannelId, Connection, {exit_status, ChannelId, Status});
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "exit-signal",
 				    want_reply = false,
 				    data = Data},  
-	   #connection{channel_cache = Cache} = Connection0, _) ->
-    <<?UINT32(SigLen), SigName:SigLen/binary,
-     ?BOOLEAN(_Core), 
-     ?UINT32(ErrLen), Err:ErrLen/binary,
-     ?UINT32(LangLen), Lang:LangLen/binary>> = Data,
+           #connection{channel_cache = Cache} = Connection0, _) ->
+    <<?DEC_BIN(SigName, _SigLen),
+      ?BOOLEAN(_Core), 
+      ?DEC_BIN(Err, _ErrLen),
+      ?DEC_BIN(Lang, _LangLen)>> = Data,
     Channel = ssh_channel:cache_lookup(Cache, ChannelId),
     RemoteId =  Channel#channel.remote_id,
     {Reply, Connection} =  reply_msg(Channel, Connection0, 
@@ -488,52 +451,41 @@ handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				      binary_to_list(Err),
 				      binary_to_list(Lang)}),
     CloseMsg = channel_close_msg(RemoteId),
-    {{replies, [{connection_reply, CloseMsg}, Reply]},
-     Connection};
+    {[{connection_reply, CloseMsg}|Reply], Connection};
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "xon-xoff",
 				    want_reply = false,
 				    data = Data},
-	   #connection{channel_cache = Cache} = Connection, _) ->
+           Connection, _) ->
     <<?BOOLEAN(CDo)>> = Data,
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    {Reply, Connection} = 
-	reply_msg(Channel, Connection, {xon_xoff, ChannelId, CDo=/= 0}),
-    {{replies, [Reply]}, Connection};
+    reply_msg(ChannelId, Connection, {xon_xoff, ChannelId, CDo=/= 0});
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "window-change",
 				    want_reply = false,
 				    data = Data}, 
-	   #connection{channel_cache = Cache} = Connection0, _) ->
+           Connection0, _) ->
     <<?UINT32(Width),?UINT32(Height),
-     ?UINT32(PixWidth), ?UINT32(PixHeight)>> = Data,
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    {Reply, Connection} = 
-	reply_msg(Channel, Connection0, {window_change, ChannelId,
-					 Width, Height,
-					 PixWidth, PixHeight}),
-    {{replies, [Reply]}, Connection};
+      ?UINT32(PixWidth), ?UINT32(PixHeight)>> = Data,
+    reply_msg(ChannelId, Connection0, {window_change, ChannelId,
+                                       Width, Height,
+                                       PixWidth, PixHeight});
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "signal",
 				    data = Data}, 
-	   #connection{channel_cache = Cache} = Connection0, _) ->
-    <<?UINT32(SigLen), SigName:SigLen/binary>> = Data,
-    
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    {Reply, Connection} = 
-	reply_msg(Channel, Connection0, {signal, ChannelId,
-					 binary_to_list(SigName)}),
-    {{replies, [Reply]}, Connection};
+           Connection0, _) ->
+    <<?DEC_BIN(SigName, _SigLen)>> = Data,
+    reply_msg(ChannelId, Connection0, {signal, ChannelId,
+                                       binary_to_list(SigName)});
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "subsystem",
 				    want_reply = WantReply,
 				    data = Data},
 	   #connection{channel_cache = Cache} = Connection, server) ->
-    <<?UINT32(SsLen), SsName:SsLen/binary>> = Data,
+    <<?DEC_BIN(SsName,_SsLen)>> = Data,
     
     #channel{remote_id = RemoteId} = Channel0 = 
 	ssh_channel:cache_lookup(Cache, ChannelId), 
@@ -547,92 +499,77 @@ handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 	ssh_channel:cache_update(Cache, Channel),
 	Reply = {connection_reply,
 		 channel_success_msg(RemoteId)},
-	{{replies, [Reply]}, Connection}
+	{[Reply], Connection}
     catch
 	_:_ ->
-	    ErrorReply = {connection_reply,
-			  channel_failure_msg(RemoteId)},
-	    {{replies, [ErrorReply]}, Connection}
+	    ErrorReply = {connection_reply, channel_failure_msg(RemoteId)},
+	    {[ErrorReply], Connection}
     end;	
 
 handle_msg(#ssh_msg_channel_request{request_type = "subsystem"},
 	   Connection, client) ->
     %% The client SHOULD ignore subsystem requests. See RFC 4254 6.5.
-    {{replies, []}, Connection};
+    {[], Connection};
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "pty-req",
 				    want_reply = WantReply,
 				    data = Data},
-	   #connection{channel_cache = Cache} = Connection, server) ->
-    <<?UINT32(TermLen), BTermName:TermLen/binary,
-     ?UINT32(Width),?UINT32(Height),
-     ?UINT32(PixWidth), ?UINT32(PixHeight),
-     Modes/binary>> = Data,
+	   Connection, server) ->
+    <<?DEC_BIN(BTermName,_TermLen),
+      ?UINT32(Width),?UINT32(Height),
+      ?UINT32(PixWidth), ?UINT32(PixHeight),
+      Modes/binary>> = Data,
     TermName = binary_to_list(BTermName),
-   
     PtyRequest = {TermName, Width, Height,
 		  PixWidth, PixHeight, decode_pty_opts(Modes)},
-    
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    handle_cli_msg(Connection, Channel,
+    handle_cli_msg(Connection, ChannelId,
 		   {pty, ChannelId, WantReply, PtyRequest});
 
 handle_msg(#ssh_msg_channel_request{request_type = "pty-req"},
 	   Connection, client) ->
     %% The client SHOULD ignore pty requests. See RFC 4254 6.2.
-    {{replies, []}, Connection};
+    {[], Connection};
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "shell",
 				    want_reply = WantReply},
-	   #connection{channel_cache = Cache} = Connection, server) ->
-      
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    
-    handle_cli_msg(Connection, Channel,
+	   Connection, server) ->
+    handle_cli_msg(Connection, ChannelId,
 		   {shell, ChannelId, WantReply});
  
 handle_msg(#ssh_msg_channel_request{request_type = "shell"},
 	   Connection, client) ->
     %% The client SHOULD ignore shell requests. See RFC 4254 6.5.
-    {{replies, []}, Connection};
+    {[], Connection};
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = "exec",
 				    want_reply = WantReply,
 				    data = Data},
-	   #connection{channel_cache = Cache} = Connection, server) ->
-    <<?UINT32(Len), Command:Len/binary>> = Data,
-     
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    
-    handle_cli_msg(Connection, Channel,
+	   Connection, server) ->
+    <<?DEC_BIN(Command, _Len)>> = Data,
+    handle_cli_msg(Connection, ChannelId,
 		   {exec, ChannelId, WantReply, binary_to_list(Command)});
 	
 handle_msg(#ssh_msg_channel_request{request_type = "exec"},
 	   Connection, client) ->
     %% The client SHOULD ignore exec requests. See RFC 4254 6.5.
-    {{replies, []}, Connection};
+    {[], Connection};
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
   				    request_type = "env",
   				    want_reply = WantReply,
   				    data = Data}, 
-	   #connection{channel_cache = Cache} = Connection, server) ->
-    
-    <<?UINT32(VarLen), 
-     Var:VarLen/binary, ?UINT32(ValueLen), Value:ValueLen/binary>> = Data,
-    
-    Channel = ssh_channel:cache_lookup(Cache, ChannelId), 
-    
-    handle_cli_msg(Connection, Channel,
+	   Connection, server) ->
+    <<?DEC_BIN(Var,_VarLen), ?DEC_BIN(Value,_ValLen)>> = Data,
+    handle_cli_msg(Connection, ChannelId,
  		   {env, ChannelId, WantReply, Var, Value});
 
 handle_msg(#ssh_msg_channel_request{request_type = "env"},
 	   Connection, client) ->
     %% The client SHOULD ignore env requests. 
-    {{replies, []}, Connection};
+    {[], Connection};
 
 handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 				    request_type = _Other,
@@ -642,13 +579,12 @@ handle_msg(#ssh_msg_channel_request{recipient_channel = ChannelId,
 		case ssh_channel:cache_lookup(Cache, ChannelId) of
 		    #channel{remote_id = RemoteId}  -> 
 			FailMsg = channel_failure_msg(RemoteId),
-			{{replies, [{connection_reply, FailMsg}]},
-			 Connection};
+			{[{connection_reply, FailMsg}], Connection};
 		    undefined -> %% Chanel has been closed
-			{noreply, Connection}
+			{[], Connection}
 		end;
        true ->
-	    {noreply, Connection}
+	    {[], Connection}
     end;
 
 handle_msg(#ssh_msg_global_request{name = _Type,
@@ -656,79 +592,53 @@ handle_msg(#ssh_msg_global_request{name = _Type,
 				   data = _Data}, Connection, _) ->
     if WantReply == true ->
 	    FailMsg = request_failure_msg(),
-	    {{replies, [{connection_reply, FailMsg}]},
-	     Connection};
+	    {[{connection_reply, FailMsg}], Connection};
        true ->
-	    {noreply, Connection}  
+	    {[], Connection}  
     end;
 
 handle_msg(#ssh_msg_request_failure{},
 	   #connection{requests = [{_, From} | Rest]} = Connection, _) ->
-    {{replies, [{channel_request_reply, From, {failure, <<>>}}]},
+    {[{channel_request_reply, From, {failure, <<>>}}],
      Connection#connection{requests = Rest}};
 handle_msg(#ssh_msg_request_success{data = Data},
 	   #connection{requests = [{_, From} | Rest]} = Connection, _) ->
-    {{replies, [{channel_request_reply, From, {success, Data}}]},
+    {[{channel_request_reply, From, {success, Data}}],
      Connection#connection{requests = Rest}};
 
 handle_msg(#ssh_msg_disconnect{code = Code,
-			       description = Description,
-			       language = _Lang },
-	   #connection{channel_cache = Cache} = Connection0, _) ->
-    {Connection, Replies} = 
-	ssh_channel:cache_foldl(fun(Channel, {Connection1, Acc}) ->
-					{Reply, Connection2} =  
-					    reply_msg(Channel,
-						      Connection1,
-						      {closed, Channel#channel.local_id}),
-					{Connection2, [Reply | Acc]}
-				end, {Connection0, []}, Cache),
-    
-    ssh_channel:cache_delete(Cache),
-    {disconnect, {Code, Description}, {{replies, Replies}, Connection}}.
-
-handle_cli_msg(#connection{channel_cache = Cache} = Connection,
-	       #channel{user = undefined, 
-			remote_id = RemoteId,
-			local_id = ChannelId} = Channel0, Reply0) -> 
-    case (catch start_cli(Connection, ChannelId)) of
-	{ok, Pid} ->
-	    erlang:monitor(process, Pid),
-	    Channel = Channel0#channel{user = Pid},
-	    ssh_channel:cache_update(Cache, Channel),
-	    {Reply, Connection1} = reply_msg(Channel, Connection, Reply0),
- 	    {{replies, [Reply]}, Connection1};
-	_Other ->
-	    Reply = {connection_reply,
-		     channel_failure_msg(RemoteId)},
-	    {{replies, [Reply]}, Connection}
-    end;
+			       description = Description},
+	   Connection, _) ->
+    {disconnect, {Code, Description}, handle_stop(Connection)}.
 
-handle_cli_msg(Connection0, Channel, Reply0) ->
-    {Reply, Connection} =  reply_msg(Channel, Connection0, Reply0),
-    {{replies, [Reply]}, Connection}.
 
-channel_eof_msg(ChannelId) ->
-    #ssh_msg_channel_eof{recipient_channel = ChannelId}.
-
-channel_close_msg(ChannelId) ->
-    #ssh_msg_channel_close {recipient_channel = ChannelId}.
-
-channel_status_msg({success, ChannelId}) ->
-    channel_success_msg(ChannelId);
-channel_status_msg({failure, ChannelId}) ->
-    channel_failure_msg(ChannelId).
-
-channel_success_msg(ChannelId) ->
-    #ssh_msg_channel_success{recipient_channel = ChannelId}.
-
-channel_failure_msg(ChannelId) ->
-    #ssh_msg_channel_failure{recipient_channel = ChannelId}.
+%%%----------------------------------------------------------------
+%%% Returns pending responses to be delivered to the peer when a
+%%% Channel/Connection closes
+%%%
+handle_stop(#connection{channel_cache = Cache} = Connection0) ->
+    {Connection, Replies} = 
+	ssh_channel:cache_foldl(
+          fun(Channel, {Connection1, Acc}) ->
+                  {Reply, Connection2} =
+                      reply_msg(Channel, Connection1,
+                                {closed, Channel#channel.local_id}),
+                  {Connection2, Reply ++ Acc}
+          end, {Connection0, []}, Cache),
+    ssh_channel:cache_delete(Cache),
+    {Replies, Connection}.
 
+%%%----------------------------------------------------------------
+%%% channel_*_msg(...)
+%%% Returns a #ssh_msg_....{} for channel operations.
+%%%
 channel_adjust_window_msg(ChannelId, Bytes) ->
     #ssh_msg_channel_window_adjust{recipient_channel = ChannelId,
 				   bytes_to_add = Bytes}.
 
+channel_close_msg(ChannelId) ->
+    #ssh_msg_channel_close {recipient_channel = ChannelId}.
+
 channel_data_msg(ChannelId, 0, Data) ->
     #ssh_msg_channel_data{recipient_channel = ChannelId,
 			  data = Data};
@@ -737,6 +647,12 @@ channel_data_msg(ChannelId, Type, Data) ->
 				    data_type_code = Type,
 				    data = Data}.
 
+channel_eof_msg(ChannelId) ->
+    #ssh_msg_channel_eof{recipient_channel = ChannelId}.
+
+channel_failure_msg(ChannelId) ->
+    #ssh_msg_channel_failure{recipient_channel = ChannelId}.
+
 channel_open_msg(Type, ChannelId, WindowSize, MaxPacketSize, Data) ->
     #ssh_msg_channel_open{channel_type = Type,
 			  sender_channel = ChannelId,
@@ -757,18 +673,34 @@ channel_open_failure_msg(RemoteId, Reason, Description, Lang) ->
 				  description = Description,
 				  lang = Lang}.
 
+channel_status_msg({success, ChannelId}) ->
+    channel_success_msg(ChannelId);
+
+channel_status_msg({failure, ChannelId}) ->
+    channel_failure_msg(ChannelId).
+
 channel_request_msg(ChannelId, Type, WantReply, Data) ->
     #ssh_msg_channel_request{recipient_channel = ChannelId,
 			     request_type = Type,
 			     want_reply = WantReply,
 			     data = Data}.
 
+channel_success_msg(ChannelId) ->
+    #ssh_msg_channel_success{recipient_channel = ChannelId}.
+
+%%%----------------------------------------------------------------
+%%% request_*_msg(...)
+%%% Returns a #ssh_msg_....{} for request responses.
+%%%
 request_failure_msg() ->
     #ssh_msg_request_failure{}.
 
 request_success_msg(Data) ->
     #ssh_msg_request_success{data = Data}.
 
+%%%----------------------------------------------------------------
+%%%
+%%%
 bind(IP, Port, ChannelPid, Connection) ->
     Binds = [{{IP, Port}, ChannelPid}
 	     | lists:keydelete({IP, Port}, 1, 
@@ -808,6 +740,68 @@ encode_ip(Addr) when is_list(Addr) ->
 	    end
     end.
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+%%% Internal functions
+%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%----------------------------------------------------------------
+%%% Create the channel data when an ssh_msg_open_channel message
+%%% of "session" typ is handled
+%%%
+setup_session(#connection{channel_cache = Cache,
+                          channel_id_seed = NewChannelID
+			 } = C,
+	      RemoteId, Type, WindowSize, PacketSize) ->
+    NextChannelID = NewChannelID + 1,
+    Channel =
+        #channel{type = Type,
+                 sys = "ssh",
+                 local_id = NewChannelID,
+                 recv_window_size = ?DEFAULT_WINDOW_SIZE,
+                 recv_packet_size = ?DEFAULT_PACKET_SIZE,
+                 send_window_size = WindowSize,
+                 send_packet_size = PacketSize,
+                 send_buf = queue:new(),
+                 remote_id = RemoteId
+                },
+    ssh_channel:cache_update(Cache, Channel),
+    OpenConfMsg = channel_open_confirmation_msg(RemoteId, NewChannelID,
+						?DEFAULT_WINDOW_SIZE, 
+						?DEFAULT_PACKET_SIZE),
+    Reply = {connection_reply, OpenConfMsg},
+    {[Reply], C#connection{channel_id_seed = NextChannelID}}.
+
+
+%%%----------------------------------------------------------------
+%%% Start a cli or subsystem
+%%%
+start_cli(#connection{options = Options, 
+		      cli_spec = CliSpec,
+		      exec = Exec,
+		      sub_system_supervisor = SubSysSup}, ChannelId) ->
+    case CliSpec of
+        no_cli ->
+            {error, cli_disabled};
+        {CbModule, Args} ->
+            start_channel(CbModule, ChannelId, Args, SubSysSup, Exec, Options)
+    end.
+
+
+start_subsystem(BinName, #connection{options = Options,
+                                     sub_system_supervisor = SubSysSup},
+	       #channel{local_id = ChannelId}, _ReplyMsg) ->
+    Name = binary_to_list(BinName),
+    case check_subsystem(Name, Options) of
+	{Callback, Opts} when is_atom(Callback), Callback =/= none ->
+	    start_channel(Callback, ChannelId, Opts, SubSysSup, Options);
+	{Other, _} when Other =/= none ->
+	    {error, legacy_option_not_supported}
+    end.
+
+
+%%% Helpers for starting cli/subsystems
 start_channel(Cb, Id, Args, SubSysSup, Opts) ->
     start_channel(Cb, Id, Args, SubSysSup, undefined, Opts).
 
@@ -827,33 +821,6 @@ max_num_channels_not_exceeded(ChannelSup, Opts) ->
     %% Note that NumChannels is BEFORE starting a new one
     NumChannels < MaxNumChannels.
 
-%%--------------------------------------------------------------------
-%%% Internal functions
-%%--------------------------------------------------------------------
-setup_session(#connection{channel_cache = Cache
-			 } = Connection0, 
-	      RemoteId,
-	      Type, WindowSize, PacketSize) ->
-    {ChannelId, Connection} = new_channel_id(Connection0),
-
-    Channel = #channel{type = Type,
-		       sys = "ssh",
-		       local_id = ChannelId,
-		       recv_window_size = ?DEFAULT_WINDOW_SIZE,
-		       recv_packet_size = ?DEFAULT_PACKET_SIZE,
-		       send_window_size = WindowSize,
-		       send_packet_size = PacketSize,
-		       send_buf = queue:new(),
-		       remote_id = RemoteId
-		      },
-    ssh_channel:cache_update(Cache, Channel),
-    OpenConfMsg = channel_open_confirmation_msg(RemoteId, ChannelId,
-						?DEFAULT_WINDOW_SIZE, 
-						?DEFAULT_PACKET_SIZE),
-
-    {{replies, [{connection_reply, OpenConfMsg}]}, Connection}.
-
-
 check_subsystem("sftp"= SsName, Options) ->
     case ?GET_OPT(subsystems, Options) of
 	no_subsys -> 	% FIXME: Can 'no_subsys' ever be matched?
@@ -872,64 +839,10 @@ check_subsystem(SsName, Options) ->
 	    Value
     end.
 
-start_cli(#connection{cli_spec = no_cli}, _) ->
-    {error, cli_disabled};
-start_cli(#connection{options = Options,
-		      cli_spec = {CbModule, Args},
-		      exec = Exec,
-		      sub_system_supervisor = SubSysSup}, ChannelId) ->
-    start_channel(CbModule, ChannelId, Args, SubSysSup, Exec, Options).
-
-start_subsystem(BinName, #connection{options = Options,
-				    sub_system_supervisor = SubSysSup},
-	       #channel{local_id = ChannelId}, _ReplyMsg) ->
-    Name = binary_to_list(BinName),
-    case check_subsystem(Name, Options) of
-	{Callback, Opts} when is_atom(Callback), Callback =/= none ->
-	    start_channel(Callback, ChannelId, Opts, SubSysSup, Options);
-	{Other, _} when Other =/= none ->
-	    {error, legacy_option_not_supported}
-    end.
-
-channel_data_reply(_, #channel{local_id = ChannelId} = Channel, 
-		   Connection0, DataType, Data) ->
-    {Reply, Connection} =
-	reply_msg(Channel, Connection0, {data, ChannelId, DataType, Data}),
-    {[Reply], Connection}.
-
-new_channel_id(Connection) ->
-    ID = Connection#connection.channel_id_seed,
-    {ID, Connection#connection{channel_id_seed = ID + 1}}.
-
-reply_msg(Channel, Connection, {open, _} = Reply) ->
-    request_reply_or_data(Channel, Connection, Reply);
-reply_msg(Channel, Connection, {open_error, _, _, _} = Reply) ->
-    request_reply_or_data(Channel, Connection, Reply);
-reply_msg(Channel, Connection, success = Reply) ->
-    request_reply_or_data(Channel, Connection, Reply);
-reply_msg(Channel, Connection, failure = Reply) ->
-    request_reply_or_data(Channel, Connection, Reply);
-reply_msg(Channel, Connection, {closed, _} = Reply) ->
-    request_reply_or_data(Channel, Connection, Reply);
-reply_msg(undefined, Connection, _Reply) ->
-    {noreply, Connection};
-reply_msg(#channel{user = ChannelPid}, Connection, Reply) ->
-    {{channel_data, ChannelPid, Reply}, Connection}.
-
-
-request_reply_or_data(#channel{local_id = ChannelId, user = ChannelPid}, 
-		      #connection{requests = Requests} = 
-		      Connection, Reply) -> 
-    case lists:keysearch(ChannelId, 1, Requests) of
-	{value, {ChannelId, From}} ->
-	    {{channel_request_reply, From, Reply}, 
-	     Connection#connection{requests = 
-				       lists:keydelete(ChannelId, 1, Requests)}};
-	false when (Reply == success) or (Reply == failure) ->
-	    {[], Connection};
-	false ->
-	    {{channel_data, ChannelPid, Reply}, Connection}
-    end.
+%%%----------------------------------------------------------------
+%%%
+%%% Send-window handling
+%%%
 
 update_send_window(Channel, _, undefined,
 		   #connection{channel_cache = Cache}) ->
@@ -984,6 +897,11 @@ handle_send_window({Type, Data}, _, PacketSize, WindowSize, Acc) ->
     <<Msg1:PacketSize/binary, Msg2/binary>> = Data,
     {WindowSize - PacketSize, [{Type, Msg1} | Acc], {Type, Msg2}}.
 
+%%%----------------------------------------------------------------
+%%%
+%%% Flow control
+%%% 
+
 flow_control(Channel, Cache) ->
     flow_control([window_adjusted], Channel, Cache).
 
@@ -1002,6 +920,11 @@ flow_control([_|_], #channel{flow_control = From,
 flow_control(_,_,_) ->
     [].
 
+%%%----------------------------------------------------------------
+%%%
+%%% Pseudo terminal stuff
+%%% 
+
 pty_req(ConnectionHandler, Channel, Term, Width, Height,
 	 PixWidth, PixHeight, PtyOpts, TimeOut) ->
     ssh_connection_handler:request(ConnectionHandler,
@@ -1027,8 +950,7 @@ pty_default_dimensions(Dimension, TermData) ->
 
 encode_pty_opts(Opts) ->
     Bin = list_to_binary(encode_pty_opts2(Opts)),
-    Len = size(Bin),
-    <<?UINT32(Len), Bin/binary>>.
+    <<?STRING(Bin)>>.
 
 encode_pty_opts2([]) -> 
     [?TTY_OP_END];
@@ -1147,7 +1069,7 @@ decode_pty_opts(<<>>) ->
     [];
 decode_pty_opts(<<0, 0, 0, 0>>) ->
     [];
-decode_pty_opts(<<?UINT32(Len), Modes:Len/binary>>) ->
+decode_pty_opts(<<?DEC_BIN(Modes,_Len)>>) ->
     decode_pty_opts2(Modes);
 decode_pty_opts(Binary) ->
     decode_pty_opts2(Binary).
@@ -1224,3 +1146,104 @@ backwards_compatible([{pixel_hight, Value} | Rest], Acc) ->
     backwards_compatible(Rest, [{height, Value} | Acc]);
 backwards_compatible([Value| Rest], Acc) ->
     backwards_compatible(Rest, [ Value | Acc]).
+
+
+%%%----------------------------------------------------------------
+%%%
+%%% Common part of handling channel messages meant for a cli (like "env", "exec" etc)
+%%% Called at the finnish of handle_msg(#ssh_msg_channel_request,...)
+%%%
+
+handle_cli_msg(C0, ChId, Reply0) ->
+    Cache = C0#connection.channel_cache,
+    Ch0 = ssh_channel:cache_lookup(Cache, ChId),
+    case Ch0#channel.user of
+        undefined ->
+            case (catch start_cli(C0, ChId)) of
+                {ok, Pid} ->
+                    erlang:monitor(process, Pid),
+                    Ch = Ch0#channel{user = Pid},
+                    ssh_channel:cache_update(Cache, Ch),
+                    reply_msg(Ch, C0, Reply0);
+                _Other ->
+                    Reply = {connection_reply, channel_failure_msg(Ch0#channel.remote_id)},
+                    {[Reply], C0}
+            end;
+        
+        _ ->
+            reply_msg(Ch0, C0, Reply0)
+    end.
+
+%%%----------------------------------------------------------------
+%%%
+%%% Request response handling on return to the calling ssh_connection_handler
+%%% state machine.
+%%% 
+
+channel_data_reply_msg(ChannelId, Connection, DataType, Data) ->
+    case ssh_channel:cache_lookup(Connection#connection.channel_cache, ChannelId) of
+	#channel{recv_window_size = Size} = Channel ->
+	    WantedSize = Size - size(Data),
+	    ssh_channel:cache_update(Connection#connection.channel_cache, 
+                                     Channel#channel{recv_window_size = WantedSize}),
+            reply_msg(Channel, Connection, {data, ChannelId, DataType, Data});
+	undefined ->
+	    {[], Connection}
+    end.
+
+
+reply_msg(ChId, C, Reply) when is_integer(ChId) ->
+    reply_msg(ssh_channel:cache_lookup(C#connection.channel_cache, ChId), C, Reply);
+
+reply_msg(Channel, Connection, {open, _} = Reply) ->
+    request_reply_or_data(Channel, Connection, Reply);
+reply_msg(Channel, Connection, {open_error, _, _, _} = Reply) ->
+    request_reply_or_data(Channel, Connection, Reply);
+reply_msg(Channel, Connection, success = Reply) ->
+    request_reply_or_data(Channel, Connection, Reply);
+reply_msg(Channel, Connection, failure = Reply) ->
+    request_reply_or_data(Channel, Connection, Reply);
+reply_msg(Channel, Connection, {closed, _} = Reply) ->
+    request_reply_or_data(Channel, Connection, Reply);
+reply_msg(undefined, Connection, _Reply) ->
+    {[], Connection};
+reply_msg(#channel{user = ChannelPid}, Connection, Reply) ->
+    {[{channel_data, ChannelPid, Reply}], Connection}.
+
+
+request_reply_or_data(#channel{local_id = ChannelId, user = ChannelPid}, 
+		      #connection{requests = Requests} = 
+		      Connection, Reply) -> 
+    case lists:keysearch(ChannelId, 1, Requests) of
+	{value, {ChannelId, From}} ->
+	    {[{channel_request_reply, From, Reply}],
+	     Connection#connection{requests = 
+				       lists:keydelete(ChannelId, 1, Requests)}};
+	false when (Reply == success) or (Reply == failure) ->
+	    {[], Connection};
+	false ->
+	    {[{channel_data, ChannelPid, Reply}], Connection}
+    end.
+
+
+
+%%%----------------------------------------------------------------
+%%% l(ist)2b(inary)
+%%%
+l2b(L) when is_integer(hd(L)) ->
+    try list_to_binary(L)
+    of
+	B -> B
+    catch
+	_:_ -> 
+	    unicode:characters_to_binary(L)
+    end;
+l2b([H|T]) -> 
+    << (l2b(H))/binary, (l2b(T))/binary >>;
+l2b(B) when is_binary(B) ->
+    B;
+l2b([]) ->
+    <<>>.
+
+    
+
diff --git a/lib/ssh/src/ssh_connection_handler.erl b/lib/ssh/src/ssh_connection_handler.erl
index 852e70d9e2..f47ab41624 100644
--- a/lib/ssh/src/ssh_connection_handler.erl
+++ b/lib/ssh/src/ssh_connection_handler.erl
@@ -960,9 +960,9 @@ handle_event(_, {#ssh_msg_kexinit{},_}, {connected,Role}, D0) ->
     {next_state, {kexinit,Role,renegotiate}, D, [postpone]};
 
 handle_event(_, #ssh_msg_disconnect{description=Desc} = Msg, StateName, D0) ->
-    {disconnect, _, {{replies,Replies}, _}} =
+    {disconnect, _, RepliesCon} =
 	ssh_connection:handle_msg(Msg, D0#data.connection_state, role(StateName)),
-    {Actions,D} = send_replies(Replies, D0),
+    {Actions,D} = send_replies(RepliesCon, D0),
     disconnect_fun(Desc, D),
     {stop_and_reply, {shutdown,Desc}, Actions, D};
 
@@ -1159,14 +1159,9 @@ handle_event({call,From}, {info, ChannelPid}, _, D) ->
 	       end, [], cache(D)),
     {keep_state_and_data, [{reply, From, {ok,Result}}]};
 
-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"},
-				  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,From}, stop, _StateName, D0) ->
+    {Repls,D} = send_replies(ssh_connection:handle_stop(D0#data.connection_state), D0),
+    {stop_and_reply, normal, [{reply,From,ok}|Repls], D};
 
 handle_event({call,_}, _, StateName, _) when not ?CONNECTED(StateName) ->
     {keep_state_and_data, [postpone]};
@@ -1195,9 +1190,8 @@ handle_event({call,From}, {request, ChannelId, Type, Data, Timeout}, StateName,
 
 handle_event({call,From}, {data, ChannelId, Type, Data, Timeout}, StateName, D0) 
   when ?CONNECTED(StateName) ->
-    {{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}),
+    {Repls,D} = send_replies(ssh_connection:channel_data(ChannelId, Type, Data, D0#data.connection_state, From),
+                             D0),
     start_channel_request_timer(ChannelId, From, Timeout), % FIXME: No message exchange so why?
     {keep_state, D, Repls};
 
@@ -1373,9 +1367,7 @@ handle_event(info, {timeout, {_, From} = Request}, _,
 
 %%% Handle that ssh channels user process goes down
 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};
+    {keep_state, handle_channel_down(ChannelPid, D0)};
 
 %%% So that terminate will be run when supervisor is shutdown
 handle_event(info, {'EXIT', _Sup, Reason}, _, _) ->
@@ -1677,7 +1669,20 @@ handle_connection_msg(Msg, StateName, D0 = #data{starter = User,
     Renegotiation = renegotiation(StateName),
     Role = role(StateName),
     try ssh_connection:handle_msg(Msg, Connection0, Role) of
-	{{replies, Replies}, Connection} ->
+	{disconnect, Reason0, RepliesConn} ->
+            {Repls, D} = send_replies(RepliesConn, D0),
+            case {Reason0,Role} of
+                {{_, Reason}, client} when ((StateName =/= {connected,client}) and (not Renegotiation)) ->
+		   User ! {self(), not_connected, Reason};
+                _ ->
+                    ok
+            end,
+            {stop_and_reply, {shutdown,normal}, Repls, D};
+
+	{[], Connection} ->
+	    {keep_state, D0#data{connection_state = Connection}};
+
+	{Replies, Connection} when is_list(Replies) ->
 	    {Repls, D} = 
 		case StateName of
 		    {connected,_} ->
@@ -1686,30 +1691,15 @@ handle_connection_msg(Msg, StateName, D0 = #data{starter = User,
 			{ConnReplies, NonConnReplies} = lists:splitwith(fun not_connected_filter/1, Replies),
 			send_replies(NonConnReplies, D0#data{event_queue = Qev0 ++ ConnReplies})
 		end,
-	    {keep_state, D, Repls};
-
-	{noreply, Connection} ->
-	    {keep_state, D0#data{connection_state = Connection}};
-
-	{disconnect, Reason0, {{replies, Replies}, Connection}} ->
-	   {Repls, D} = send_replies(Replies, D0#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_and_reply, {shutdown,normal}, Repls, D#data{connection_state = Connection}}
+	    {keep_state, D, Repls}
 
     catch
-	_:Error ->
-	    {disconnect, _Reason, {{replies, Replies}, Connection}} =
-		ssh_connection:handle_msg(
-		  #ssh_msg_disconnect{code = ?SSH_DISCONNECT_BY_APPLICATION,
-				      description = "Internal error"},
-		  Connection0, Role),
-	    {Repls, D} = send_replies(Replies, D0#data{connection_state = Connection}),
-	    {stop_and_reply, {shutdown,Error}, Repls, D#data{connection_state = Connection}}
+	Class:Error ->
+            {Repls, D1} = send_replies(ssh_connection:handle_stop(Connection0), D0),
+            {Shutdown, D} = ?send_disconnect(?SSH_DISCONNECT_BY_APPLICATION,
+                                             io_lib:format("Internal error: ~p:~p",[Class,Error]),
+                                             StateName, D1),
+            {stop_and_reply, Shutdown, Repls, D}
     end.
 
 
@@ -1819,15 +1809,16 @@ handle_request(ChannelId, Type, Data, WantReply, From, D) ->
 
 %%%----------------------------------------------------------------
 handle_channel_down(ChannelPid, D) ->
+    Cache = cache(D),
     ssh_channel:cache_foldl(
-	       fun(Channel, Acc) when Channel#channel.user == ChannelPid ->
-		       ssh_channel:cache_delete(cache(D),
-						Channel#channel.local_id),
-		       Acc;
-		  (_,Acc) ->
-		       Acc
-	       end, [], cache(D)),
-    {{replies, []}, cache_check_set_idle_timer(D)}.
+      fun(#channel{user=U,
+                   local_id=Id}, Acc) when U == ChannelPid ->
+              ssh_channel:cache_delete(Cache, Id),
+              Acc;
+         (_,Acc) ->
+              Acc
+      end, [], Cache),
+    cache_check_set_idle_timer(D).
 
 
 update_sys(Cache, Channel, Type, ChannelPid) ->
@@ -1911,10 +1902,11 @@ not_connected_filter({connection_reply, _Data}) -> true;
 not_connected_filter(_) -> false.
 
 %%%----------------------------------------------------------------
+
+send_replies({Repls,C = #connection{}}, D) when is_list(Repls) ->
+    send_replies(Repls, D#data{connection_state=C});
 send_replies(Repls, State) ->
-    lists:foldl(fun get_repl/2,
-		{[],State},
-		Repls).
+    lists:foldl(fun get_repl/2, {[],State}, Repls).
 
 get_repl({connection_reply,Msg}, {CallRepls,S}) ->
     if is_record(Msg, ssh_msg_channel_success) ->
@@ -1935,8 +1927,10 @@ get_repl({flow_control,Cache,Channel,From,Msg}, {CallRepls,S}) ->
     {[{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(noreply, Acc) ->
+%%     Acc;
+%% get_repl([], Acc) ->
+%%     Acc;
 get_repl(X, Acc) ->
     exit({get_repl,X,Acc}).
 
diff --git a/lib/ssh/test/ssh_algorithms_SUITE.erl b/lib/ssh/test/ssh_algorithms_SUITE.erl
index de6e448ebd..0b18bee9d7 100644
--- a/lib/ssh/test/ssh_algorithms_SUITE.erl
+++ b/lib/ssh/test/ssh_algorithms_SUITE.erl
@@ -257,8 +257,7 @@ try_exec_simple_group(Group, Config) ->
     of
 	_ -> ct:fail("Exec though no group available")
     catch
-	error:{badmatch,{error,"No possible diffie-hellman-group-exchange group found"}} -> ok;
-	error:{badmatch,{error,"Connection closed"}} -> ok
+        error:{badmatch,{error,"Key exchange failed"}} -> ok
     end.
 
 %%--------------------------------------------------------------------