ssh: Add more tests

2 files changed, 803 insertions, 221 deletions

diff --git a/lib/ssh/test/ssh_compat_SUITE.erl b/lib/ssh/test/ssh_compat_SUITE.erl
index 74ab5aca3a..7694cbd37e 100644
--- a/lib/ssh/test/ssh_compat_SUITE.erl
+++ b/lib/ssh/test/ssh_compat_SUITE.erl
@@ -32,7 +32,8 @@
 -compile(export_all).
 
 -define(USER,"sshtester").
--define(PWD, "foobar").
+-define(PASSWD, "foobar").
+-define(BAD_PASSWD, "NOT-"?PASSWD).
 -define(DOCKER_PFX, "ssh_compat_suite-ssh").
 
 %%--------------------------------------------------------------------
@@ -44,25 +45,23 @@ suite() ->
      {timetrap,{seconds,40}}].
 
 all() ->
-    [{group,G} || G <- vers()].
+    [check_docker_present
+     | [{group,G} || G <- ssh_image_versions()]
+    ].
 
 groups() ->
-    [{G, [], tests()} || G <- vers()].
-
-tests() ->
-    [login_with_password_otp_is_client,
-     login_with_password_otp_is_server,
-     login_with_keyboard_interactive_otp_is_client,
-     login_with_keyboard_interactive_otp_is_server,
-     login_with_all_public_keys_otp_is_client,
-     login_with_all_public_keys_otp_is_server,
-     all_algorithms_otp_is_client,
-     all_algorithms_otp_is_server
+    [{otp_client, [], [login_otp_is_client,
+                       all_algorithms_sftp_exec_reneg_otp_is_client,
+                       send_recv_big_with_renegotiate_otp_is_client
+                      ]},
+     {otp_server, [], [login_otp_is_server,
+                       all_algorithms_sftp_exec_reneg_otp_is_server
+                      ]} |
+     [{G, [], [{group,otp_client}, {group,otp_server}]} || G <- ssh_image_versions()]
     ].
 
 
-
-vers() ->
+ssh_image_versions() ->
     try
         %% Find all useful containers in such a way that undefined command, too low
         %% priviliges, no containers and containers found give meaningful result:
@@ -97,25 +96,54 @@ end_per_suite(Config) ->
     Config.
 
 
+init_per_group(otp_server, Config) ->
+    case proplists:get_value(common_remote_client_algs, Config) of
+        undefined ->
+            SSHver = proplists:get_value(ssh_version, Config, ""),
+            {skip,"No "++SSHver++ " client found in docker"};
+        _ ->
+            Config
+    end;
 
-init_per_group(G, Config) ->
-    case lists:member(G, vers()) of
+init_per_group(otp_client, Config) ->
+    Config;
+
+init_per_group(G, Config0) ->
+    case lists:member(G, ssh_image_versions()) of
 	true ->
+            %% This group is for one of the images
+            Vssh = atom_to_list(G),
+            Cmnt = io_lib:format("+++ ~s +++",[Vssh]),
+            ct:comment("~s",[Cmnt]),
             try start_docker(G) of
                 {ok,ID} ->
-                    ct:log("==> ~p",[G]),
-                    [Vssh|VsslRest] = string:tokens(atom_to_list(G), "-"),
-                    Vssl = lists:flatten(lists:join($-,VsslRest)),
-                    ct:comment("+++ ~s + ~s +++",[Vssh,Vssl]),
+                    ct:log("==> ~p started",[G]),
                     %% Find the algorithms that both client and server supports:
                     {IP,Port} = ip_port([{id,ID}]),
-                    try common_algs([{id,ID}|Config], IP, Port) of
-                        {ok, RemoteServerCommon, RemoteClientCommon} ->
-                            [{ssh_version,Vssh},{ssl_version,Vssl},
-                             {id,ID},
-                             {common_server_algs,RemoteServerCommon},
-                             {common_client_algs,RemoteClientCommon}
-                             |Config];
+                    ct:log("Try contact ~p:~p",[IP,Port]),
+                    Config1 = [{id,ID},
+                               {ssh_version,Vssh}
+                               | Config0],
+                    try common_algs(Config1, IP, Port) of
+                        {ok, ServerHello, RemoteServerCommon, ClientHello, RemoteClientCommon} ->
+                            case chk_hellos([ServerHello,ClientHello], Cmnt) of
+                                Cmnt ->
+                                    ok;
+                                NewCmnt ->
+                                    ct:comment("~s",[NewCmnt])
+                            end,
+                            AuthMethods =
+                                %% This should be obtained by quering the peer, but that
+                                %% is a bit hard. It is possible with ssh_protocol_SUITE
+                                %% techniques, but it can wait.
+                                case Vssh of
+                                    _ ->
+                                        [password, 'keyboard-interactive', publickey]
+                                end,
+                            [{common_remote_server_algs,RemoteServerCommon},
+                             {common_remote_client_algs,RemoteClientCommon},
+                             {common_authmethods,AuthMethods}
+                             |Config1];
                         Other ->
                             ct:log("Error in init_per_group: ~p",[Other]),
                             stop_docker(ID),
@@ -138,188 +166,298 @@ init_per_group(G, Config) ->
             end;
 
 	false ->
-	    Config
+	    Config0
     end.
 
-end_per_group(_, Config) ->
-    catch stop_docker(proplists:get_value(id,Config)),
-    Config.
+end_per_group(G, Config) ->
+    case lists:member(G, ssh_image_versions()) of
+        true ->
+            catch stop_docker(proplists:get_value(id,Config));
+        false ->
+            ok
+    end.
 
 %%--------------------------------------------------------------------
 %% Test Cases --------------------------------------------------------
 %%--------------------------------------------------------------------
-login_with_password_otp_is_client(Config) ->
-    {IP,Port} = ip_port(Config),
-    {ok,C} = ssh:connect(IP, Port, [{auth_methods,"password"},
-                                    {user,?USER},
-                                    {password,?PWD},
-				    {user_dir, new_dir(Config)},
-				    {silently_accept_hosts,true},
-                                    {user_interaction,false}
-				   ]),
-    ssh:close(C).
-
-%%--------------------------------------------------------------------
-login_with_password_otp_is_server(Config) ->
-    {Server, Host, HostPort} =
-        ssh_test_lib:daemon(0,
-                            [{auth_methods,"password"},
-                             {system_dir, setup_local_hostdir('ssh-rsa',Config)},
-                             {user_dir, new_dir(Config)},
-                             {user_passwords, [{?USER,?PWD}]},
-                             {failfun, fun ssh_test_lib:failfun/2}
-                            ]),
-    R = exec_from_docker(Config, Host, HostPort,
-                         "'lists:concat([\"Answer=\",1+2]).\r\n'",
-                         [<<"Answer=3">>],
-                         ""),
-    ssh:stop_daemon(Server),
-    R.
-
-%%--------------------------------------------------------------------
-login_with_keyboard_interactive_otp_is_client(Config) ->
-    {DockerIP,DockerPort} = ip_port(Config),
-    {ok,C} = ssh:connect(DockerIP, DockerPort,
-                         [{auth_methods,"keyboard-interactive"},
-                          {user,?USER},
-                          {password,?PWD},
-                          {user_dir, new_dir(Config)},
-                          {silently_accept_hosts,true},
-                          {user_interaction,false}
-                         ]),
-    ssh:close(C).
-
-%%--------------------------------------------------------------------
-login_with_keyboard_interactive_otp_is_server(Config) ->
-    {Server, Host, HostPort} =
-        ssh_test_lib:daemon(0,
-                            [{auth_methods,"keyboard-interactive"},
-                             {system_dir, setup_local_hostdir('ssh-rsa',Config)},
-                             {user_dir, new_dir(Config)},
-                             {user_passwords, [{?USER,?PWD}]},
-                             {failfun, fun ssh_test_lib:failfun/2}
-                            ]),
-    R = exec_from_docker(Config, Host, HostPort,
-                         "'lists:concat([\"Answer=\",1+3]).\r\n'",
-                         [<<"Answer=4">>],
-                         ""),
-    ssh:stop_daemon(Server),
-    R.
+check_docker_present(_Config) ->
+    ct:log("This testcase is just to show in Monitor that we have a test host with docker installed",[]),
+    {fail, "Test is OK: just showing docker is available"}.
 
 %%--------------------------------------------------------------------
-login_with_all_public_keys_otp_is_client(Config) ->
-    CommonAlgs = [{public_key_from_host,A}
-                  || {public_key,A} <- proplists:get_value(common_server_algs, Config)],
-    {DockerIP,DockerPort} = ip_port(Config),
-    chk_all_algos(CommonAlgs, Config,
-                  fun(_Tag,Alg) ->
-                          ssh:connect(DockerIP, DockerPort,
-                                      [{auth_methods, "publickey"},
-                                       {user, ?USER},
-                                       {user_dir, setup_remote_auth_keys_and_local_priv(Alg, Config)},
-                                       {silently_accept_hosts,true},
-                                       {user_interaction,false}
-                                      ])
+login_otp_is_client(Config) ->
+    {IP,Port} = ip_port(Config),
+    PublicKeyAlgs = [A || {public_key,A} <- proplists:get_value(common_remote_server_algs, Config)],
+    CommonAuths =
+        [{AuthMethod,Alg} || AuthMethod <- proplists:get_value(common_authmethods, Config),
+                             Alg <- case AuthMethod of
+                                        publickey ->
+                                            PublicKeyAlgs;
+                                        _ ->
+                                            [' ']
+                                    end
+        ],
+                                        
+    chk_all_algos(?FUNCTION_NAME, CommonAuths, Config,
+                  fun(AuthMethod,Alg) ->
+                          {Opts,Dir} =
+                              case AuthMethod of
+                                  publickey ->
+                                      {[], setup_remote_auth_keys_and_local_priv(Alg, Config)};
+                                  _ ->
+                                      {[{password,?PASSWD}], new_dir(Config)}
+                              end,
+                          ssh:connect(IP, Port, [{auth_methods, atom_to_list(AuthMethod)},
+                                                 {user,?USER},
+                                                 {user_dir, Dir},
+                                                 {silently_accept_hosts,true},
+                                                 {user_interaction,false}
+                                                 | Opts
+                                                ])
                   end).
+    
 
 %%--------------------------------------------------------------------
-login_with_all_public_keys_otp_is_server(Config) ->
-    CommonAlgs = [{public_key_to_host,A}
-                  || {public_key,A} <- proplists:get_value(common_client_algs, Config)],
-    UserDir = new_dir(Config),
-    {Server, Host, HostPort} =
-        ssh_test_lib:daemon(0,
-                            [{auth_methods, "publickey"},
-                             {system_dir,  setup_local_hostdir('ssh-rsa',Config)},
-                             {user_dir, UserDir},
-                             {user_passwords, [{?USER,?PWD}]},
-                             {failfun, fun ssh_test_lib:failfun/2}
-                            ]),
-
-    R = chk_all_algos(CommonAlgs, Config,
-                      fun(_Tag,Alg) ->
-                              setup_remote_priv_and_local_auth_keys(Alg, clear_dir(UserDir), Config),
-                              exec_from_docker(Config, Host, HostPort,
-                                               "'lists:concat([\"Answer=\",1+4]).\r\n'",
-                                               [<<"Answer=5">>],
-                                               "")
-                      end),
-    ssh:stop_daemon(Server),
-    R.
+login_otp_is_server(Config) ->
+    PublicKeyAlgs = [A || {public_key,A} <- proplists:get_value(common_remote_client_algs, Config)],
+    CommonAuths =
+        [{AuthMethod,Alg} || AuthMethod <- proplists:get_value(common_authmethods, Config),
+                             Alg <- case AuthMethod of
+                                        publickey ->
+                                            PublicKeyAlgs;
+                                        _ ->
+                                            [' ']
+                                    end
+        ],
+    SysDir = setup_local_hostdir(hd(PublicKeyAlgs), Config),
+    chk_all_algos(?FUNCTION_NAME, CommonAuths, Config,
+                  fun(AuthMethod,Alg) ->
+                          {Opts,UsrDir} =
+                              case AuthMethod of
+                                  publickey ->
+                                      {[{user_passwords, [{?USER,?BAD_PASSWD}]}],
+                                       setup_remote_priv_and_local_auth_keys(Alg, Config)
+                                      };
+                                  _ ->
+                                      {[{user_passwords, [{?USER,?PASSWD}]}],
+                                       new_dir(Config)
+                                      }
+                              end,
+                          {Server, Host, HostPort} =
+                              ssh_test_lib:daemon(0,
+                                                  [{auth_methods, atom_to_list(AuthMethod)},
+                                                   {system_dir, SysDir},
+                                                   {user_dir, UsrDir},
+                                                   {failfun, fun ssh_test_lib:failfun/2}
+                                                   | Opts
+                                                  ]),
+                          R = exec_from_docker(Config, Host, HostPort,
+                                               "'lists:concat([\"Answer=\",1+3]).\r\n'",
+                                               [<<"Answer=4">>],
+                                               ""),
+                          ssh:stop_daemon(Server),
+                          R
+                  end).
 
 %%--------------------------------------------------------------------
-all_algorithms_otp_is_client(Config) ->
-    CommonAlgs = proplists:get_value(common_server_algs, Config),
+all_algorithms_sftp_exec_reneg_otp_is_client(Config) ->
+    CommonAlgs = proplists:get_value(common_remote_server_algs, Config),
     {IP,Port} = ip_port(Config),
-    chk_all_algos(CommonAlgs, Config,
+    chk_all_algos(?FUNCTION_NAME, CommonAlgs, Config,
                   fun(Tag, Alg) ->
-                          ssh:connect(IP, Port, [{user,?USER},
-                                                 {password,?PWD},
-                                                 {auth_methods, "password"},
-                                                 {user_dir, new_dir(Config)},
-                                                 {preferred_algorithms, [{Tag,[Alg]}]},
-                                                 {silently_accept_hosts,true},
-                                                 {user_interaction,false}
+                          ConnRes =
+                              ssh:connect(IP, Port, 
+                                          [{user,?USER},
+                                           {password,?PASSWD},
+                                           {auth_methods, "password"},
+                                           {user_dir, new_dir(Config)},
+                                           {preferred_algorithms, [{Tag,[Alg]}]},
+                                           {silently_accept_hosts,true},
+                                           {user_interaction,false}
+                                          ])  ,
+                          test_erl_client_reneg(ConnRes, % Seems that max 10 channels may be open in sshd
+                                                [{exec,1},
+                                                 {sftp,5},
+                                                 {no_subsyst,1},
+                                                 {setenv, 1},
+                                                 {sftp_async,1}
                                                 ])
                   end).
 
 %%--------------------------------------------------------------------
-all_algorithms_otp_is_server(Config) ->
-    CommonAlgs = proplists:get_value(common_client_algs, Config),
+all_algorithms_sftp_exec_reneg_otp_is_server(Config) ->
+    CommonAlgs = proplists:get_value(common_remote_client_algs, Config),
     UserDir = setup_remote_priv_and_local_auth_keys('ssh-rsa', Config),
-    chk_all_algos(CommonAlgs, Config,
+    chk_all_algos(?FUNCTION_NAME, CommonAlgs, Config,
                   fun(Tag,Alg) ->
                           HostKeyAlg = case Tag of
                                            public_key -> Alg;
                                            _ -> 'ssh-rsa'
                                        end,
+                          SftpRootDir = new_dir(Config),
+                          %% ct:log("Rootdir = ~p",[SftpRootDir]),
                           {Server, Host, HostPort} =
                               ssh_test_lib:daemon(0,
                                                   [{preferred_algorithms, [{Tag,[Alg]}]},
                                                    {system_dir, setup_local_hostdir(HostKeyAlg, Config)},
                                                    {user_dir, UserDir},
-                                                   {user_passwords, [{?USER,?PWD}]},
-                                                   {failfun, fun ssh_test_lib:failfun/2}
+                                                   {user_passwords, [{?USER,?PASSWD}]},
+                                                   {failfun, fun ssh_test_lib:failfun/2},
+                                                   {subsystems,
+                                                    [ssh_sftpd:subsystem_spec([{cwd,SftpRootDir},
+                                                                               {root,SftpRootDir}]),
+                                                     {"echo_10",{ssh_echo_server,[10,[{dbg,true}]]}}
+                                                    ]}
                                                   ]),
-                          R = exec_from_docker(Config, Host, HostPort,
-                                               "hi_there.\r\n",
-                                               [<<"hi_there">>],
-                                               ""),
+                          R = do([fun() ->
+                                          exec_from_docker(Config, Host, HostPort,
+                                                           "hi_there.\r\n",
+                                                           [<<"hi_there">>],
+                                                           "")
+                                  end,
+                                  fun() ->
+                                          sftp_tests_erl_server(Config, Host, HostPort, SftpRootDir, UserDir)
+                                  end
+                                 ]),
                           ssh:stop_daemon(Server),
                           R
                   end).
 
 %%--------------------------------------------------------------------
+send_recv_big_with_renegotiate_otp_is_client(Config) ->
+    %% Connect to the remote openssh server:
+    {IP,Port} = ip_port(Config),
+    {ok,C} = ssh:connect(IP, Port, [{user,?USER},
+                                    {password,?PASSWD},
+                                    {user_dir, setup_remote_auth_keys_and_local_priv('ssh-rsa', Config)},
+                                    {silently_accept_hosts,true},
+                                    {user_interaction,false}
+                                   ]),
+
+    %% Open a channel and exec the Linux 'cat' command at the openssh side.
+    %% This 'cat' will read stdin and write to stdout until an eof is read from stdin.
+    {ok, Ch1} = ssh_connection:session_channel(C, infinity),
+    success = ssh_connection:exec(C, Ch1, "cat", infinity),
+
+    %% Build big binary
+    HalfSizeBytes = 100*1000*1000,
+    Data = << <<X:32>> || X <- lists:seq(1, HalfSizeBytes div 4)>>,
+
+    %% Send the data. Must spawn a process to avoid deadlock. The client will block
+    %% until all is sent through the send window. But the server will stop receiveing
+    %% when the servers send-window towards the client is full.
+    %% Since the client can't receive before the server has received all but 655k from the client
+    %% ssh_connection:send/4 is blocking...
+    spawn_link(
+      fun() ->
+              ct:comment("Sending ~p Mbytes with renegotiation in the middle",[2*byte_size(Data)/1000000]),
+              %% ct:log("sending first ~p bytes",[byte_size(Data)]),
+              ok = ssh_connection:send(C, Ch1, Data, 10000),
+              %% ct:log("Init renegotiation test",[]),
+              Kex1 = renegotiate_test(init, C),
+              %% ct:log("sending next ~p bytes",[byte_size(Data)]),
+              ok = ssh_connection:send(C, Ch1, Data, 10000),
+              %% ct:log("Finnish renegotiation test",[]),
+              renegotiate_test(Kex1, C),
+              %% ct:log("sending eof",[]),
+              ok = ssh_connection:send_eof(C, Ch1)
+              %%, ct:log("READY, sent ~p bytes",[2*byte_size(Data)])
+      end),
+
+    {eof,ReceivedData} =
+        loop_until(fun({eof,_}) -> true;
+                      (_      ) -> false
+                   end,
+                   fun(Acc) ->
+                           %%ct:log("Get more ~p",[ ExpectedSize-byte_size(Acc) ]),
+                           receive
+                               {ssh_cm, C, {eof,Ch}} when Ch==Ch1 ->
+                                   %% ct:log("eof received",[]),
+                                   {eof,Acc};
+
+                               {ssh_cm, C, {data,Ch,0,B}} when Ch==Ch1,
+                                                               is_binary(B) ->
+                                   %% ct:log("(1) Received ~p bytes (total ~p), missing ~p bytes",
+                                   %%        [byte_size(B),
+                                   %%         byte_size(B)+byte_size(Acc),
+                                   %%         2*byte_size(Data)-(byte_size(B)+byte_size(Acc))]),
+                                   ssh_connection:adjust_window(C, Ch1, byte_size(B)),
+                                   <<Acc/binary, B/binary>>
+                           end
+                   end,
+                   <<>>),
+
+    ExpectedData = <<Data/binary, Data/binary>>,
+    case ReceivedData of
+        ExpectedData ->
+            %% ct:log("Correct data returned",[]),
+            %% receive close messages
+            loop_until(fun(Left) -> %% ct:log("Expect: ~p",[Left]),
+                                    Left == []
+                       end,
+                       fun([Next|Rest]) ->
+                               receive
+                                  {ssh_cm,C,Next} -> Rest
+                               end 
+                       end,
+                       [%% Already received: {eof, Ch1},
+                        {exit_status,Ch1,0},
+                        {closed,Ch1}]
+                      ),
+            ok;
+        _ when is_binary(ReceivedData) ->
+            ct:fail("~p bytes echoed but ~p expected", [byte_size(ReceivedData), 2*byte_size(Data)])
+    end.
+
+%%--------------------------------------------------------------------
 %% Utilities ---------------------------------------------------------
 %%--------------------------------------------------------------------
-exec_from_docker(WhatEver, {0,0,0,0}, HostPort, Command, Expects, ExtraSshArg) ->
-    exec_from_docker(WhatEver, host_ip(), HostPort, Command, Expects, ExtraSshArg);
 
+%%--------------------------------------------------------------------
+%%
+%% A practical meta function
+%% 
+loop_until(CondFun, DoFun, Acc) ->
+    case CondFun(Acc) of
+        true ->
+            Acc;
+        false ->
+            loop_until(CondFun, DoFun, DoFun(Acc))
+    end.
+
+%%--------------------------------------------------------------------
+%%
+%% Exec the Command in the docker.  Add the arguments ExtraSshArg in the
+%% ssh command.
+%%
+%% If Expects is returned, then return 'ok', else return {fail,Msg}.
+%% 
 exec_from_docker(Config, HostIP, HostPort, Command, Expects, ExtraSshArg) when is_binary(hd(Expects)),
                                                                                is_list(Config) ->
     {DockerIP,DockerPort} = ip_port(Config),
     {ok,C} = ssh:connect(DockerIP, DockerPort,
                          [{user,?USER},
-                          {password,?PWD},
+                          {password,?PASSWD},
                           {user_dir, new_dir(Config)},
                           {silently_accept_hosts,true},
                           {user_interaction,false}
                          ]),
-    R = exec_from_docker(C, HostIP, HostPort, Command, Expects, ExtraSshArg),
+    R = exec_from_docker(C, HostIP, HostPort, Command, Expects, ExtraSshArg, Config),
     ssh:close(C),
-    R;
-
-exec_from_docker(C, HostIP, HostPort, Command, Expects, ExtraSshArg) when is_binary(hd(Expects)) ->
-    SSH_from_docker =
-        lists:concat(["sshpass -p ",?PWD," ",
-                      "/buildroot/ssh/bin/ssh -p ",HostPort," -o 'CheckHostIP=no' -o 'StrictHostKeyChecking=no' ",
-                      ExtraSshArg," ",
-                      inet_parse:ntoa(HostIP)," "
-                     ]),
-    ExecCommand = SSH_from_docker ++ Command,
-    R = exec(C, ExecCommand),
-    case R of
-        {ok,{ExitStatus,Result}} when ExitStatus == 0 ->
+    R.
+
+exec_from_docker(C, DestIP, DestPort, Command, Expects, ExtraSshArg, Config) when is_binary(hd(Expects)) ->
+    ExecCommand =
+        lists:concat(
+          ["sshpass -p ",?PASSWD," "
+           | case proplists:get_value(ssh_version,Config) of
+                 _ -> %% OpenSSH or compatible
+                     ["/buildroot/ssh/bin/ssh -o 'CheckHostIP=no' -o 'StrictHostKeyChecking=no' ",
+                      ExtraSshArg," -p ",DestPort," ",iptoa(DestIP)," "]
+             end]) ++ Command,
+
+    case exec(C, ExecCommand) of
+        {ok,{ExitStatus,Result}} = R when ExitStatus == 0 ->
             case binary:match(Result, Expects) of
                 nomatch ->
                     ct:log("Result of~n    ~s~nis~n    ~p",[ExecCommand,R]),
@@ -327,28 +465,26 @@ exec_from_docker(C, HostIP, HostPort, Command, Expects, ExtraSshArg) when is_bin
                 _ ->
                     ok
             end;
-        {ok,_} ->
+        {ok,_} = R ->
             ct:log("Result of~n    ~s~nis~n    ~p",[ExecCommand,R]),
             {fail, "Exit status =/= 0"};
-        _ ->
+        R ->
             ct:log("Result of~n    ~s~nis~n    ~p",[ExecCommand,R]),
             {fail, "Couldn't login to host"}
     end.
 
 
-
-
 exec(C, Cmd) ->
-    ct:log("~s",[Cmd]),
+    %% ct:log("~s",[Cmd]),
     {ok,Ch} = ssh_connection:session_channel(C, 10000),
     success = ssh_connection:exec(C, Ch, Cmd, 10000),
-    exec_result(C, Ch).
+    result_of_exec(C, Ch).
 
 
-exec_result(C, Ch) ->
-    exec_result(C, Ch, undefined, <<>>).
+result_of_exec(C, Ch) ->
+    result_of_exec(C, Ch, undefined, <<>>).
 
-exec_result(C, Ch, ExitStatus, Acc) ->
+result_of_exec(C, Ch, ExitStatus, Acc) ->
     receive
         {ssh_cm,C,{closed,Ch}} ->
             %%ct:log("CHAN ~p got *closed*",[Ch]),
@@ -356,29 +492,37 @@ exec_result(C, Ch, ExitStatus, Acc) ->
 
         {ssh_cm,C,{exit_status,Ch,ExStat}} when ExitStatus == undefined ->
             %%ct:log("CHAN ~p got *exit status ~p*",[Ch,ExStat]),
-            exec_result(C, Ch, ExStat, Acc);
+            result_of_exec(C, Ch, ExStat, Acc);
 
         {ssh_cm,C,{data,Ch,_,Data}=_X} when ExitStatus == undefined ->
             %%ct:log("CHAN ~p got ~p",[Ch,_X]),
-            exec_result(C, Ch, ExitStatus, <<Acc/binary, Data/binary>>);
+            result_of_exec(C, Ch, ExitStatus, <<Acc/binary, Data/binary>>);
 
         _Other ->
             %%ct:log("OTHER: ~p",[_Other]),
-            exec_result(C, Ch, ExitStatus, Acc)
+            result_of_exec(C, Ch, ExitStatus, Acc)
 
     after 5000 ->
-            %%ct:log("NO MORE, received so far:~n~s",[Acc]),
+            ct:log("NO MORE, received so far:~n~s",[Acc]),
             {error, timeout}
     end.
 
 
-chk_all_algos(CommonAlgs, Config, DoTestFun) when is_function(DoTestFun,2) ->
+%%--------------------------------------------------------------------
+%%
+%% Loop through all {Tag,Alg} pairs in CommonAlgs, call DoTestFun(Tag,Alg) which
+%% returns one of {ok,C}, ok, or Other.
+%%
+%% The chk_all_algos returns 'ok' or {fail,FaledAlgosList}
+%% 
+
+chk_all_algos(FunctionName, CommonAlgs, Config, DoTestFun) when is_function(DoTestFun,2) ->
     ct:comment("~p algorithms",[length(CommonAlgs)]),
     %% Check each algorithm
     Failed =
         lists:foldl(
           fun({Tag,Alg}, FailedAlgos) ->
-                  ct:log("Try ~p",[Alg]),
+                  %% ct:log("Try ~p",[Alg]),
                   case DoTestFun(Tag,Alg) of
                       {ok,C} ->
                           ssh:close(C),
@@ -387,10 +531,10 @@ chk_all_algos(CommonAlgs, Config, DoTestFun) when is_function(DoTestFun,2) ->
                           FailedAlgos;
                       Other ->
                           ct:log("FAILED! ~p ~p: ~p",[Tag,Alg,Other]),
-                          [Alg|FailedAlgos]
+                          [{Alg,Other}|FailedAlgos]
                   end
           end, [], CommonAlgs),
-    ct:pal("~s", [format_result_table_use_all_algos(Config, CommonAlgs, Failed)]),
+    ct:pal("~s", [format_result_table_use_all_algos(FunctionName, Config, CommonAlgs, Failed)]),
     case Failed of
         [] ->
             ok;
@@ -398,6 +542,41 @@ chk_all_algos(CommonAlgs, Config, DoTestFun) when is_function(DoTestFun,2) ->
             {fail, Failed}
     end.
 
+
+
+%%%----------------------------------------------------------------
+%%%
+%%% Call all Funs as Fun() which returns 'ok', {ok,C} or Other.
+%%% do/1 returns 'ok' or the first encountered value that is not
+%%% successful.
+%%%
+
+do(Funs) ->
+    do(Funs, 1).
+
+do([Fun|Funs], N) ->
+    case Fun() of
+        ok ->
+            %% ct:log("Fun ~p ok",[N]),
+            do(Funs, N-1);
+        {ok,C} ->
+            %% ct:log("Fun ~p {ok,C}",[N]),
+            ssh:close(C),
+            do(Funs, N-1);
+        Other ->
+            ct:log("Fun ~p FAILED:~n~p",[N, Other]),
+            Other
+    end;
+
+do([], _) ->
+    %% ct:log("All Funs ok",[]),
+    ok.
+
+%%--------------------------------------------------------------------
+%%
+%% Functions to set up local and remote host's and user's keys and directories
+%% 
+
 setup_local_hostdir(KeyAlg, Config) ->
     setup_local_hostdir(KeyAlg, new_dir(Config), Config).
 setup_local_hostdir(KeyAlg, HostDir, Config) ->
@@ -428,7 +607,7 @@ setup_remote_auth_keys_and_local_priv(KeyAlg, IP, Port, UserDir, Config) ->
     ok = file:write_file(DstFile++".pub", Publ),
     %% Remote auth_methods with public key
     {ok,Ch,Cc} = ssh_sftp:start_channel(IP, Port, [{user,     ?USER  },
-                                                   {password, ?PWD   },
+                                                   {password, ?PASSWD   },
                                                    {auth_methods, "password"},
                                                    {silently_accept_hosts,true},
                                                    {user_interaction,false}
@@ -460,7 +639,7 @@ setup_remote_priv_and_local_auth_keys(KeyAlg, IP, Port, UserDir, Config) ->
     ok = file:write_file(AuthKeyFile, Publ),
     %% Remote private and public key
     {ok,Ch,Cc} = ssh_sftp:start_channel(IP, Port, [{user,     ?USER  },
-                                                   {password, ?PWD   },
+                                                   {password, ?PASSWD   },
                                                    {auth_methods, "password"},
                                                    {silently_accept_hosts,true},
                                                    {user_interaction,false}
@@ -485,6 +664,7 @@ priv_pub_keys(KeySubDir, Type, Config, KeyAlg) ->
     {ok, {Priv,Publ}}.
 
 
+%%%---------------- The default filenames
 src_filename(user, 'ssh-rsa'            ) -> "id_rsa";
 src_filename(user, 'rsa-sha2-256'       ) -> "id_rsa";
 src_filename(user, 'rsa-sha2-512'       ) -> "id_rsa";
@@ -516,7 +696,11 @@ dst_filename(host, 'ecdsa-sha2-nistp384') -> "ssh_host_ecdsa_key";
 dst_filename(host, 'ecdsa-sha2-nistp521') -> "ssh_host_ecdsa_key".
 
 
-format_result_table_use_all_algos(Config, CommonAlgs, Failed) ->
+%%--------------------------------------------------------------------
+%%
+%% Format the result table for chk_all_algos/4
+%% 
+format_result_table_use_all_algos(FunctionName, Config, CommonAlgs, Failed) ->
     %% Write a nice table with the result
     AlgHead = 'Algorithm',
     AlgWidth = lists:max([length(atom_to_list(A)) || {_,A} <- CommonAlgs]),
@@ -529,23 +713,25 @@ format_result_table_use_all_algos(Config, CommonAlgs, Failed) ->
                         end,
                   {io_lib:format('~s     ~*s ~s~n',
                                  [Tag, -AlgWidth, A,
-                                  case lists:member(A,Failed) of
-                                      true -> "<<<< FAIL <<<<";
-                                      false-> "(ok)"
+                                  case proplists:get_value(A,Failed) of
+                                      undefined -> "(ok)";
+                                      Err -> io_lib:format("<<<< FAIL <<<< ~p",[Err])
                                   end]),
                    T}
           end, undefined, CommonAlgs),
 
     Vssh = proplists:get_value(ssh_version,Config,""),
-    Vssl = proplists:get_value(ssl_version,Config,""),
-    io_lib:format("~nResults, Peer versions: ~s and ~s~n"
+    io_lib:format("~nResults of ~p, Peer version: ~s~n~n"
                   "Tag  ~*s Result~n"
                   "=====~*..=s=======~n~s"
-                 ,[Vssh,Vssl,
-                   -AlgWidth,AlgHead,
+                 ,[FunctionName, Vssh,
+                   -AlgWidth, AlgHead,
                    AlgWidth, "", ResultTable]).
 
-
+%%--------------------------------------------------------------------
+%%
+%% Docker handling: start_docker/1 and stop_docker/1
+%% 
 start_docker(Ver) ->
     Cmnd = lists:concat(["docker run -itd --rm -p 1234 ",?DOCKER_PFX,":",Ver]),
     Id0 = os:cmd(Cmnd),
@@ -572,6 +758,10 @@ is_docker_sha(L) ->
                  (_) -> false
               end, L).
 
+%%--------------------------------------------------------------------
+%%
+%% Misc docker info functions
+
 ip_port(Config) ->
     {_Ver,{IP,Port},_} = proplists:get_value(id,Config),
     {IP,Port}.
@@ -590,6 +780,23 @@ ip(Id) ->
     {ok,IP} = inet:parse_address(IPstr),
     IP.
 
+%%--------------------------------------------------------------------
+%%
+%%  Normalize the host returned from ssh_test_lib
+
+iptoa({0,0,0,0}) -> inet_parse:ntoa(host_ip());
+iptoa(IP) -> inet_parse:ntoa(IP).
+
+host_ip() ->
+    {ok,Name} = inet:gethostname(),
+    {ok,#hostent{h_addr_list = [IP|_]}} = inet_res:gethostbyname(Name),
+    IP.
+
+%%--------------------------------------------------------------------
+%%
+%% Create a new fresh directory or clear an existing one
+%% 
+
 new_dir(Config) ->
     PrivDir = proplists:get_value(priv_dir, Config),
     SubDirName = integer_to_list(erlang:system_time()),
@@ -626,20 +833,34 @@ delete_all_contents(Dir) ->
                       end
               end, Fs).
 
+%%--------------------------------------------------------------------
+%%
+%% Find the intersection of algoritms for otp ssh and the docker ssh.
+%% Returns {ok, ServerHello, Server, ClientHello, Client} where Server are the algorithms common
+%% with the docker server and analogous for Client.
+%%
+%% Client may be undefined if no usable client is found.
+%%
+%% Both Server and Client are lists of {Tag,AlgName}.
+%% 
+
 common_algs(Config, IP, Port) ->
     case remote_server_algs(IP, Port) of
-        {ok, {RemoteHelloBin, RemoteServerKexInit}} ->
+        {ok, {ServerHello, RemoteServerKexInit}} ->
+            RemoteServerAlgs = kexint_msg2default_algorithms(RemoteServerKexInit),
+            Server = find_common_algs(RemoteServerAlgs,
+                                      use_algorithms(ServerHello)),
+            ct:log("Remote server:~n~p~n~p",[ServerHello, RemoteServerAlgs]),
             case remote_client_algs(Config) of
-                {ok,{_Hello,RemoteClientKexInit}} ->
-                    RemoteServerAlgs = kexint_msg2default_algorithms(RemoteServerKexInit),
-                    Server = find_common_algs(RemoteServerAlgs,
-                                              use_algorithms(RemoteHelloBin)),
+                {ok,{ClientHello,RemoteClientKexInit}} ->
                     RemoteClientAlgs = kexint_msg2default_algorithms(RemoteClientKexInit),
                     Client = find_common_algs(RemoteClientAlgs,
-                                              use_algorithms(RemoteHelloBin)),
-                    ct:log("Docker server algorithms:~n ~p~n~nDocker client algorithms:~n ~p",
-                           [RemoteServerAlgs,RemoteClientAlgs]),
-                    {ok, Server, Client};
+                                              use_algorithms(ClientHello)),
+                    ct:log("Remote client:~n~p~n~p",[ClientHello, RemoteClientAlgs]),
+                    {ok, ServerHello, Server, ClientHello, Client};
+                {error,_} =TO ->
+                    ct:log("Remote client algs can't be found: ~p",[TO]),
+                    {ok, ServerHello, Server, undefined, undefined};
                 Other ->
                     Other
             end;
@@ -648,6 +869,24 @@ common_algs(Config, IP, Port) ->
     end.
 
 
+chk_hellos(Hs, Str) ->
+    lists:foldl(
+      fun(H, Acc) ->
+              try binary:split(H, <<"-">>, [global])
+              of
+                  %% [<<"SSH">>,<<"2.0">>|_] ->
+                  %%     Acc;
+                  [<<"SSH">>,OldVer = <<"1.",_/binary>>|_] ->
+                      io_lib:format("~s, Old SSH ver ~s",[Acc,OldVer]);
+                  _ ->
+                      Acc
+              catch
+                  _:_ ->
+                      Acc
+              end
+      end, Str, Hs).
+              
+
 find_common_algs(Remote, Local) ->
     [{T,V} || {T,Vs} <- ssh_test_lib:extract_algos(
                           ssh_test_lib:intersection(Remote,
@@ -685,12 +924,18 @@ kexint_msg2default_algorithms(#ssh_msg_kexinit{kex_algorithms = Kex,
                     {server2client,ssh_test_lib:to_atoms(CompS2C)}]}].
 
 
-
+%%--------------------------------------------------------------------
+%%
+%% Find the algorithms supported by the remote server
+%%
+%% Connect with tcp to the server, send a hello and read the returned
+%% server hello and kexinit message.
+%% 
 remote_server_algs(IP, Port) ->
     case try_gen_tcp_connect(IP, Port, 5) of
         {ok,S} ->
             ok = gen_tcp:send(S, "SSH-2.0-CheckAlgs\r\n"),
-            receive_hello(S, <<>>);
+            receive_hello(S);
         {error,Error} ->
             {error,Error}
     end.
@@ -709,6 +954,13 @@ try_gen_tcp_connect(_, _, _) ->
     {error, "No contact"}.
 
 
+%%--------------------------------------------------------------------
+%%
+%% Find the algorithms supported by the remote client
+%%
+%% Set up a fake ssh server and make the remote client connect to it. Use
+%% hello message and the kexinit message.
+%% 
 remote_client_algs(Config) ->
     Parent = self(),
     Ref = make_ref(),
@@ -719,7 +971,7 @@ remote_client_algs(Config) ->
               Parent ! {addr,Ref,IP,Port},
               {ok,S} = gen_tcp:accept(Sl),
               ok = gen_tcp:send(S, "SSH-2.0-CheckAlgs\r\n"),
-              Parent ! {Ref,receive_hello(S, <<>>)}
+              Parent ! {Ref,receive_hello(S)}
       end),
     receive
         {addr,Ref,IP,Port} ->
@@ -732,14 +984,28 @@ remote_client_algs(Config) ->
             receive
                 {Ref, Result} ->
                     Result
-            after 15000 ->
-                    {error, timeout2}
+            after 5000 ->
+                    {error, {timeout,2}}
             end
-    after 15000 ->
-            {error, timeout1}
+    after 5000 ->
+            {error, {timeout,1}}
     end.
 
 
+%%% Receive a few packets from the remote server or client and find what is supported:
+
+receive_hello(S) ->
+    try
+        receive_hello(S, <<>>)
+    of
+        Result ->
+            Result
+    catch
+        Class:Error ->
+            ST = erlang:get_stacktrace(),
+            {error, {Class,Error,ST}}
+    end.
+        
 
 receive_hello(S, Ack) ->
     %% The Ack is to collect bytes until the full message is received
@@ -747,20 +1013,19 @@ receive_hello(S, Ack) ->
         {tcp, S, Bin0} when is_binary(Bin0) ->
             case binary:split(<<Ack/binary, Bin0/binary>>, [<<"\r\n">>,<<"\r">>,<<"\n">>]) of
                 [Hello = <<"SSH-2.0-",_/binary>>, NextPacket] ->
-                    ct:log("Got 2.0 hello (~p), ~p bytes to next msg",[Hello,size(NextPacket)]),
+                    %% ct:log("Got 2.0 hello (~p), ~p bytes to next msg",[Hello,size(NextPacket)]),
                     {ok, {Hello, receive_kexinit(S, NextPacket)}};
 
                 [Hello = <<"SSH-1.99-",_/binary>>, NextPacket] ->
-                    ct:comment("Old SSH ~s",["1.99"]),
-                    ct:log("Got 1.99 hello (~p), ~p bytes to next msg",[Hello,size(NextPacket)]),
+                    %% ct:log("Got 1.99 hello (~p), ~p bytes to next msg",[Hello,size(NextPacket)]),
                     {ok, {Hello, receive_kexinit(S, NextPacket)}};
 
                 [Bin] when size(Bin) < 256 ->
-                    ct:log("Got part of hello (~p chars):~n~s~n~s",[size(Bin),Bin,
-                                                                    [io_lib:format('~2.16.0b ',[C])
-                                                                     || C <- binary_to_list(Bin0)
-                                                                    ]
-                                                                   ]),
+                    %% ct:log("Got part of hello (~p chars):~n~s~n~s",[size(Bin),Bin,
+                    %%                                                 [io_lib:format('~2.16.0b ',[C])
+                    %%                                                  || C <- binary_to_list(Bin0)
+                    %%                                                 ]
+                    %%                                                ]),
                     receive_hello(S, Bin0);
 
                 _ ->
@@ -804,11 +1069,326 @@ receive_kexinit(S, Ack) ->
             throw(timeout)
     end.
 
+%%%----------------------------------------------------------------
+%%% Test of sftp from the OpenSSH client side
+%%%
 
+sftp_tests_erl_server(Config, ServerIP, ServerPort, ServerRootDir, UserDir) ->
+    try
+        Cmnds = prepare_local_directory(ServerRootDir),
+        call_sftp_in_docker(Config, ServerIP, ServerPort, Cmnds, UserDir),
+        check_local_directory(ServerRootDir)
+    catch
+        Class:Error ->
+            ST = erlang:get_stacktrace(),
+            {error, {Class,Error,ST}}
+    end.
 
-host_ip() ->
-    {ok,Name} = inet:gethostname(),
-    {ok,#hostent{h_addr_list = [IP|_]}} = inet_res:gethostbyname(Name),
-    IP.
 
+prepare_local_directory(ServerRootDir) ->
+    file:write_file(filename:join(ServerRootDir,"tst1"),
+                    <<"Some test text">>
+                   ),
+    ["get tst1",
+     "put tst1 tst2",
+     "put tst1 tst3",
+     "rename tst1 ex_tst1",
+     "rm tst3",
+     "mkdir mydir",
+     "cd mydir",
+     "put tst1 file_1",
+     "put tst1 unreadable_file",
+     "chmod 222 unreadable_file",
+     "exit"].
+
+check_local_directory(ServerRootDir) ->
+    case lists:sort(ok(file:list_dir(ServerRootDir)) -- [".",".."]) of
+        ["ex_tst1","mydir","tst2"] ->
+            {ok,Expect} = file:read_file(filename:join(ServerRootDir,"ex_tst1")),
+            case file:read_file(filename:join(ServerRootDir,"tst2")) of
+                {ok,Expect} ->
+                    case lists:sort(ok(file:list_dir(filename:join(ServerRootDir,"mydir"))) -- [".",".."]) of
+                        ["file_1","unreadable_file"] ->
+                            case file:read_file(filename:join([ServerRootDir,"mydir","file_1"])) of
+                                {ok,Expect} ->
+                                    case file:read_file(filename:join([ServerRootDir,"mydir","unreadable_file"])) of
+                                        {error,_} ->
+                                            ok;
+                                        {ok,_} ->
+                                            {error, {could_read_unreadable,"mydir/unreadable_file"}}
+                                    end;
+                                {ok,Other} ->
+                                    ct:log("file_1:~n~s~nExpected:~n~s",[Other,Expect]),
+                                    {error, {bad_contents_in_file,"mydir/file_1"}}
+                            end;
+                        Other ->
+                            ct:log("Directory ~s~n~p",[filename:join(ServerRootDir,"mydir"),Other]),
+                            {error,{bad_dir_contents,"mydir"}}
+                    end;
+                {ok,Other} ->
+                    ct:log("tst2:~n~s~nExpected:~n~s",[Other,Expect]),
+                    {error, {bad_contents_in_file,"tst2"}}
+            end;
+        ["tst1"] ->
+            {error,{missing_file,"tst2"}};
+        Other ->
+            ct:log("Directory ~s~n~p",[ServerRootDir,Other]),
+            {error,{bad_dir_contents,"/"}}
+    end.
+
+call_sftp_in_docker(Config, ServerIP, ServerPort, Cmnds, UserDir) ->
+    {DockerIP,DockerPort} = ip_port(Config),
+    {ok,C} = ssh:connect(DockerIP, DockerPort,
+                         [{user,?USER},
+                          {password,?PASSWD},
+                          {user_dir, UserDir},
+                          {silently_accept_hosts,true},
+                          {user_interaction,false}
+                         ]),
+
+    %% Make commands for "expect" in the docker:
+    PreExpectCmnds = ["spawn /buildroot/ssh/bin/sftp -oPort="++integer_to_list(ServerPort)++
+                          " -oCheckHostIP=no -oStrictHostKeyChecking=no " ++
+                          iptoa(ServerIP)++"\n"
+                     ],
+    PostExpectCmnds= [],
+    ExpectCmnds = 
+        PreExpectCmnds ++
+        ["expect \"sftp>\" {send \""++Cmnd++"\n\"}\n" || Cmnd <- Cmnds] ++
+        PostExpectCmnds,
+    
+    %% Make an commands file in the docker
+    {ok,Ch} = ssh_sftp:start_channel(C, [{timeout,10000}]),
+    ok = ssh_sftp:write_file(Ch, "commands", erlang:iolist_to_binary(ExpectCmnds)),
+    ok = ssh_sftp:stop_channel(Ch),
+
+    %% Call expect in the docker
+    {ok, Ch1} = ssh_connection:session_channel(C, infinity),
+    Kex1 = renegotiate_test(init, C),
+    success = ssh_connection:exec(C, Ch1, "expect commands", infinity),
+
+    renegotiate_test(Kex1, C),
+    recv_log_msgs(C, Ch1),
+
+    %% Done.
+    ssh:close(C).
 
+recv_log_msgs(C, Ch) ->
+    receive
+        {ssh_cm,C,{closed,Ch}} ->
+            %% ct:log("Channel closed ~p",[{closed,1}]),
+            ok;
+        {ssh_cm,C,{data,Ch,1,Msg}} ->
+            ct:log("*** ERROR from docker:~n~s",[Msg]),
+            recv_log_msgs(C, Ch);
+        {ssh_cm,C,_Msg} ->
+            %% ct:log("Got ~p",[_Msg]),
+            recv_log_msgs(C, Ch)
+    end.
+
+%%%----------------------------------------------------------------
+%%%----------------------------------------------------------------
+%%%
+%%% Tests from the Erlang client side
+%%%
+%%%----------------------------------------------------------------
+%%%----------------------------------------------------------------
+test_erl_client_reneg({ok,C}, Spec) ->
+    %% Start the test processes on the connection C:
+    Parent = self(),
+    Pids = [spawn(
+              fun() ->
+                      Parent ! {self(), TestType, Id, one_test_erl_client(TestType,Id,C)}
+              end
+             ) 
+            || {TestType,N} <- Spec,
+               Id <- lists:seq(1,N)],
+
+    Kex1 = renegotiate_test(init, C),
+
+    %% Collect the results:
+    case lists:filter(
+           fun(R) -> R=/=ok end,
+           [receive
+                {Pid,_TestType,_Id,ok} ->
+                    %% ct:log("Test ~p:~p passed!", [_TestType,_Id]),
+                    ok;
+                {Pid,TestType,Id,OtherResult} ->
+                    ct:log("~p:~p ~p ~p~n~p",[?MODULE,?LINE,TestType,Id,OtherResult]),
+                    {error,TestType,Id}
+            end || Pid <- Pids])
+    of
+        [] ->
+            renegotiate_test(Kex1, C),
+            {ok,C};
+        Other ->
+            renegotiate_test(Kex1, C),
+            Other
+    end;
+
+test_erl_client_reneg(Error, _) ->
+    Error.
+
+
+one_test_erl_client(exec, Id, C) ->
+    {ok, Ch} = ssh_connection:session_channel(C, infinity),
+    success = ssh_connection:exec(C, Ch, "echo Hi there", 5000),
+    case loop_until(fun({eof,_}) -> true;
+                       (_      ) -> false
+                    end,
+                    fun(Acc) ->
+                            receive
+                                {ssh_cm, C, {eof,Ch}} ->
+                                    {eof,Acc};
+                                {ssh_cm, C, {data,Ch,0,B}} when is_binary(B) ->
+                                    <<Acc/binary, B/binary>>
+                            end
+                    end,
+                    <<>>) of
+        {eof,<<"Hi there\n">>} ->
+            ok;
+        Other ->
+            ct:pal("exec Got other ~p", [Other]),
+            {error, {exec,Id,bad_msg,Other,undefined}}
+    end;
+
+one_test_erl_client(no_subsyst, Id, C) ->
+    {ok, Ch} = ssh_connection:session_channel(C, infinity),
+    case ssh_connection:subsystem(C, Ch, "foo", infinity) of
+        failure ->
+            ok;
+        Other ->
+            ct:pal("no_subsyst Got other ~p", [Other]),
+            {error, {no_subsyst,Id,bad_ret,Other,undefined}}
+    end;
+
+one_test_erl_client(setenv, Id, C) ->
+    {ok, Ch} = ssh_connection:session_channel(C, infinity),
+    Var = "ENV_TEST",
+    Value = lists:concat(["env_test_",Id,"_",erlang:system_time()]),
+    Env = case ssh_connection:setenv(C, Ch, Var, Value, infinity) of
+	      success -> binary_to_list(Value++"\n");
+	      failure -> <<"\n">>
+	  end,
+    success = ssh_connection:exec(C, Ch, "echo $"++Var, 5000),
+    case loop_until(fun({eof,_}) -> true;
+                       (_      ) -> false
+                    end,
+                    fun(Acc) ->
+                            receive
+                                {ssh_cm, C, {eof,Ch}} ->
+                                    {eof,Acc};
+                                {ssh_cm, C, {data,Ch,0,B}} when is_binary(B) ->
+                                    <<Acc/binary, B/binary>>
+                            end
+                    end,
+                    <<>>) of
+        {eof,Env} ->
+            ok;
+        Other ->
+            ct:pal("setenv Got other ~p", [Other]),
+            {error, {setenv,Id,bad_msg,Other,undefined}}
+    end;
+
+one_test_erl_client(SFTP, Id, C) when SFTP==sftp ; SFTP==sftp_async ->
+    try
+        {ok,Ch} = ssh_sftp:start_channel(C, [{timeout,10000}]),
+        %% A new fresh name of a new file tree:
+        RootDir = lists:concat(["r_",Id,"_",erlang:system_time()]),
+        %% Check that it does not exist:
+        false = lists:member(RootDir, ok(ssh_sftp:list_dir(Ch, "."))),
+        %% Create it:
+        ok = ssh_sftp:make_dir(Ch, RootDir),
+        {ok, #file_info{type=directory, access=read_write}} = ssh_sftp:read_file_info(Ch, RootDir),
+        R = do_sftp_tests_erl_client(SFTP, C, Ch, Id, RootDir),
+        catch ssh_sftp:stop_channel(Ch),
+        R
+    catch
+        Class:Error ->
+            ST = erlang:get_stacktrace(),
+            {error, {SFTP,Id,Class,Error,ST}}
+    end.
+
+
+
+do_sftp_tests_erl_client(sftp_async, _C, Ch, _Id, RootDir) ->
+    FileName1 = "boring_name",
+    F1 = filename:join(RootDir, FileName1),
+    %% Open a new handle and start writing:
+    {ok,Handle1} = ssh_sftp:open(Ch, F1, [write,binary]),
+    {async,Aref1} = ssh_sftp:awrite(Ch, Handle1, <<0:250000/unsigned-unit:8>>),
+    wait_for_async_result(Aref1);
+
+do_sftp_tests_erl_client(sftp, _C, Ch, _Id, RootDir) ->
+    FileName0 = "f0",
+    F0 = filename:join(RootDir, FileName0),
+
+    %% Create and write a file:
+    ok = ssh_sftp:write_file(Ch,
+                             F0 = filename:join(RootDir, FileName0),
+                             Data0 = mkbin(1234,240)),
+    {ok,Data0} = ssh_sftp:read_file(Ch, F0),
+    {ok, #file_info{type=regular, access=read_write, size=1234}} = ssh_sftp:read_file_info(Ch, F0),
+
+    %% Re-write:
+    {ok,Handle0} = ssh_sftp:open(Ch, F0, [write,read,binary]),
+    ok = ssh_sftp:pwrite(Ch, Handle0, 16, Data0_1=mkbin(10,255)),
+
+    <<B1:16/binary, _:10/binary, B2:(1234-26)/binary>> = Data0,
+    FileContents = <<B1:16/binary, Data0_1:10/binary, B2:(1234-26)/binary>>,
+
+    <<_:1/binary, Part:25/binary, _/binary>> = FileContents,
+    {ok, Part} = ssh_sftp:pread(Ch, Handle0, 1, 25),
+
+    %% Check:
+    {ok, FileContents} = ssh_sftp:pread(Ch, Handle0, 0, 1234),
+    ok = ssh_sftp:close(Ch, Handle0),
+
+    %% Check in another way:
+    {ok, FileContents} = ssh_sftp:read_file(Ch, F0),
+
+    %% Remove write access rights and check that it can't be written:
+    ok = ssh_sftp:write_file_info(Ch, F0, #file_info{mode=8#400}), %read}),
+    {ok, #file_info{type=regular, access=read}} = ssh_sftp:read_file_info(Ch, F0),
+    {error,permission_denied} = ssh_sftp:write_file(Ch, F0, mkbin(10,14)),
+
+    %% Test deletion of file and dir:
+    [FileName0] = ok(ssh_sftp:list_dir(Ch, RootDir)) -- [".", ".."],
+    ok = ssh_sftp:delete(Ch, F0),
+    [] = ok(ssh_sftp:list_dir(Ch, RootDir)) -- [".", ".."],
+    ok = ssh_sftp:del_dir(Ch, RootDir),
+    false = lists:member(RootDir, ok(ssh_sftp:list_dir(Ch, "."))),
+    ok.
+
+
+wait_for_async_result(Aref) ->
+    receive
+        {async_reply, Aref, Result} ->
+            Result
+    after
+        60000 ->
+            timeout
+    end.
+
+
+mkbin(Size, Byte) ->
+    list_to_binary(lists:duplicate(Size,Byte)).
+
+ok({ok,X}) -> X.
+    
+%%%----------------------------------------------------------------
+renegotiate_test(init, ConnectionRef) ->
+    Kex1 = ssh_test_lib:get_kex_init(ConnectionRef),
+    ssh_connection_handler:renegotiate(ConnectionRef),
+    %%ct:log("Renegotiate test initiated!",[]),
+    Kex1;
+
+renegotiate_test(Kex1, ConnectionRef) ->
+    case ssh_test_lib:get_kex_init(ConnectionRef) of
+        Kex1 ->
+            ct:log("Renegotiate test failed, Kex1 == Kex2!",[]),
+            error(renegotiate_failed);
+        _ ->
+            %% ct:log("Renegotiate test passed!",[]),
+            ok
+    end.
diff --git a/lib/ssh/test/ssh_test_lib.erl b/lib/ssh/test/ssh_test_lib.erl
index 2d7bf75847..f97c3b1352 100644
--- a/lib/ssh/test/ssh_test_lib.erl
+++ b/lib/ssh/test/ssh_test_lib.erl
@@ -53,7 +53,7 @@ daemon(Host, Options) ->
 
 
 daemon(Host, Port, Options) ->
-    ct:log("~p:~p Calling ssh:daemon(~p, ~p, ~p)",[?MODULE,?LINE,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} ->
             {ok,L} = ssh:daemon_info(Pid),
@@ -199,15 +199,17 @@ init_io_server(TestCase) ->
 
 loop_io_server(TestCase, Buff0) ->
      receive
-	 {input, TestCase, Line} ->
+	 {input, TestCase, Line} = _INP ->
+             %%ct:log("io_server ~p:~p ~p got ~p",[?MODULE,?LINE,self(),_INP]),
 	     loop_io_server(TestCase, Buff0 ++ [Line]);
-	 {io_request, From, ReplyAs, Request} ->
+	 {io_request, From, ReplyAs, Request} = _REQ->
+             %%ct:log("io_server ~p:~p ~p got ~p",[?MODULE,?LINE,self(),_REQ]),
 	     {ok, Reply, Buff} = io_request(Request, TestCase, From,
 					    ReplyAs, Buff0),
 	     io_reply(From, ReplyAs, Reply),
 	     loop_io_server(TestCase, Buff);
 	 {'EXIT',_, _} = _Exit ->
-%%	     ct:log("ssh_test_lib:loop_io_server/2 got ~p",[_Exit]),
+	     ct:log("ssh_test_lib:loop_io_server/2 got ~p",[_Exit]),
 	     ok
     after 
 	30000 -> ct:fail("timeout ~p:~p",[?MODULE,?LINE])