Merge branch 'hans/ssh/docker_compat_tests/OTP-14194' into maint

* hans/ssh/docker_compat_tests/OTP-14194:
  ssh: Disable test failing if docker command exists
  ssh: Skeleton of build scripts for DropBear image
  ssh: Can use DropBear SSH dockers
  ssh: Remove duplicate test cases from ssh_to_openssh_SUITE
  ssh: Add more tests
  ssh: Change the default list of ssh and ssl version images
  ssh: Enable building openssh 0.9.8[a-l]
  ssh: Add LibreSSL to compat tests

8 files changed, 893 insertions, 594 deletions

diff --git a/lib/ssh/test/ssh_compat_SUITE.erl b/lib/ssh/test/ssh_compat_SUITE.erl
index 74ab5aca3a..82b83dd83d 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,22 @@ 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 +95,56 @@ 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(otp_client, Config) ->
+    Config;
 
-init_per_group(G, Config) ->
-    case lists:member(G, vers()) of
+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
+                                    "dropbear" ++ _ ->
+                                        [password, publickey];
+                                    _ ->
+                                        [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 +167,301 @@ 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
+                 "dropbear" ++ _ ->
+                     ["dbclient -y -y -p ",DestPort," ",ExtraSshArg," ",iptoa(DestIP)," "];
+
+                 _ -> %% 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 +469,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 +496,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 +535,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 +546,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 +611,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 +643,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 +668,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 +700,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 +717,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 +762,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 +784,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 +837,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 +873,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 +928,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 +958,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 +975,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 +988,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 +1017,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 +1073,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_compat_SUITE_data/build_scripts/create-dropbear-ssh b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-dropbear-ssh
new file mode 100755
index 0000000000..85973081d0
--- /dev/null
+++ b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-dropbear-ssh
@@ -0,0 +1,28 @@
+#!/bin/sh
+
+# ./create-dropbear-ssh
+
+# This way of fetching the tar-file separate from the docker commands makes
+# http-proxy handling way easier. The wget command handles the $https_proxy
+# variable while the docker command must have /etc/docker/something changed
+# and the docker server restarted. That is not possible without root access.
+
+# Make a Dockerfile. This method simplifies env variable handling considerably:
+cat - > TempDockerFile <<EOF
+
+    FROM ubuntubuildbase
+
+    WORKDIR /buildroot
+
+    RUN apt-get -y update
+    RUN apt-get -y upgrade
+    RUN apt-get -y install openssh-sftp-server
+%%    RUN echo 81 | apt-get -y install dropbear
+
+EOF
+
+# Build the image:
+docker build -t ssh_compat_suite-ssh-dropbear -f ./TempDockerFile .
+
+# Cleaning
+rm -fr ./TempDockerFile $TMP
diff --git a/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-dropbear-ssh-run b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-dropbear-ssh-run
new file mode 100755
index 0000000000..d98c0cfaa3
--- /dev/null
+++ b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-dropbear-ssh-run
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+# ./create-dropbear-ssh-run
+
+VER=v2016.72
+
+# This way of fetching the tar-file separate from the docker commands makes
+# http-proxy handling way easier. The wget command handles the $https_proxy
+# variable while the docker command must have /etc/docker/something changed
+# and the docker server restarted. That is not possible without root access.
+
+# Make a Dockerfile. This method simplifies env variable handling considerably:
+cat - > TempDockerFile <<EOF
+
+    FROM ssh_compat_suite-ssh-dropbear-installed:${VER}
+
+    WORKDIR /buildroot
+
+    CMD dropbear -F -p 1234
+
+EOF
+
+# Build the image:
+docker build -t ssh_compat_suite-ssh:dropbear${VER} -f ./TempDockerFile .
+
+# Cleaning
+rm -fr ./TempDockerFile $TMP
diff --git a/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssh-image b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssh-image
index 983c57b18b..2e08408841 100755
--- a/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssh-image
+++ b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssh-image
@@ -47,7 +47,8 @@ cat - > TempDockerFile <<EOF
     RUN ./configure --without-pie \
                     --prefix=/buildroot/ssh \
                     --with-ssl-dir=/buildroot/ssl \
-                    --with-pam
+                    --with-pam \
+                    LDFLAGS=-Wl,-R/buildroot/ssl/lib
     RUN  make
     RUN  make install
     RUN  echo UsePAM yes >> /buildroot/ssh/etc/sshd_config
diff --git a/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssl-image b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssl-image
index 66f8358b8a..4ab2a8bddc 100755
--- a/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssl-image
+++ b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create-ssl-image
@@ -23,6 +23,16 @@ case "$1" in
 	;;
 esac
 
+case $1$2 in
+    openssl0.9.8[a-l])
+        CONFIG_FLAGS=no-asm
+	;;
+    *)
+	CONFIG_FLAGS=
+	;;
+esac
+
+
 # This way of fetching the tar-file separate from the docker commands makes
 # http-proxy handling way easier. The wget command handles the $https_proxy
 # variable while the docker command must have /etc/docker/something changed
@@ -42,10 +52,10 @@ cat - > TempDockerFile <<EOF
 
     WORKDIR ${FAM}-${VER}
 
-    RUN  ./config --prefix=/buildroot/ssl
+    RUN  ./config --prefix=/buildroot/ssl ${CONFIG_FLAGS}
 
     RUN  make
-    RUN  make install
+    RUN  make install_sw
 
     RUN  echo Built ${FAM}-${VER}
 EOF
diff --git a/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create_all b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create_all
index 16b9c21d9f..0dcf8cb570 100755
--- a/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create_all
+++ b/lib/ssh/test/ssh_compat_SUITE_data/build_scripts/create_all
@@ -3,19 +3,21 @@
 UBUNTU_VERSION=16.04
 
 SSH_SSL_VERSIONS=(\
-        openssh 4.4p1  openssl 0.9.8zh \
-        openssh 4.5p1  openssl 0.9.8zh \
-        openssh 5.0p1  openssl 0.9.8zh \
-        openssh 6.2p2  openssl 0.9.8zh \
-        openssh 6.3p1  openssl 0.9.8zh \
-                                       \
-        openssh 7.1p1  openssl 1.0.0t  \
-                                       \
-        openssh 7.1p1  openssl 1.0.1p  \
-                                       \
-        openssh 6.6p1  openssl 1.0.2n  \
-        openssh 7.1p1  openssl 1.0.2n  \
-        openssh 7.6p1  openssl 1.0.2n  \
+        openssh 4.4p1  openssl  0.9.8c  \
+        openssh 4.5p1  openssl  0.9.8m  \
+        openssh 5.0p1  openssl  0.9.8za \
+        openssh 6.2p2  openssl  0.9.8c  \
+        openssh 6.3p1  openssl  0.9.8zh \
+                                        \
+        openssh 7.1p1  openssl  1.0.0a  \
+                                        \
+        openssh 7.1p1  openssl  1.0.1p  \
+                                        \
+        openssh 6.6p1  openssl  1.0.2n  \
+        openssh 7.1p1  openssl  1.0.2n  \
+        openssh 7.6p1  openssl  1.0.2n  \
+                                        \
+        openssh 7.6p1  libressl 2.6.4   \
 	)
 
 if [ "x$1" == "x-b" ]
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])
diff --git a/lib/ssh/test/ssh_to_openssh_SUITE.erl b/lib/ssh/test/ssh_to_openssh_SUITE.erl
index b20764ce47..9df404d7ed 100644
--- a/lib/ssh/test/ssh_to_openssh_SUITE.erl
+++ b/lib/ssh/test/ssh_to_openssh_SUITE.erl
@@ -48,19 +48,9 @@ all() ->
     end.
 
 groups() -> 
-    [{erlang_client, [], [erlang_shell_client_openssh_server,
-			  erlang_client_openssh_server_exec_compressed,
-			  erlang_client_openssh_server_setenv,
-			  erlang_client_openssh_server_publickey_dsa,
-			  erlang_client_openssh_server_publickey_rsa,
-			  erlang_client_openssh_server_password,
-			  erlang_client_openssh_server_kexs,
-			  erlang_client_openssh_server_nonexistent_subsystem,
-			  erlang_client_openssh_server_renegotiate
+    [{erlang_client, [], [erlang_shell_client_openssh_server
 			 ]},
-     {erlang_server, [], [erlang_server_openssh_client_public_key_dsa,
-			  erlang_server_openssh_client_public_key_rsa,
-			  erlang_server_openssh_client_renegotiate
+     {erlang_server, [], [erlang_server_openssh_client_renegotiate
 			 ]}
     ].
 
@@ -100,15 +90,6 @@ end_per_group(_, Config) ->
     Config.
 
 
-init_per_testcase(erlang_server_openssh_client_public_key_dsa, Config) ->
-    chk_key(sshc, 'ssh-dss', ".ssh/id_dsa", Config);
-init_per_testcase(erlang_server_openssh_client_public_key_rsa, Config) ->
-    chk_key(sshc, 'ssh-rsa', ".ssh/id_rsa", Config);
-init_per_testcase(erlang_client_openssh_server_publickey_dsa, Config) ->
-    chk_key(sshd, 'ssh-dss', ".ssh/id_dsa", Config);
-init_per_testcase(erlang_client_openssh_server_publickey_rsa, Config) ->
-    chk_key(sshd, 'ssh-rsa', ".ssh/id_rsa", Config);
-
 init_per_testcase(erlang_server_openssh_client_renegotiate, Config) ->
     case os:type() of
 	{unix,_} -> ssh:start(), Config;
@@ -122,27 +103,6 @@ end_per_testcase(_TestCase, _Config) ->
     ssh:stop(),
     ok.
 
-
-chk_key(Pgm, Name, File, Config) ->
-    case ssh_test_lib:openssh_supports(Pgm, public_key, Name) of
-	false ->
-	    {skip,lists:concat(["openssh client does not support ",Name])};
-	true ->
-	    {ok,[[Home]]} = init:get_argument(home),
-	    KeyFile =  filename:join(Home, File),
-	    case file:read_file(KeyFile) of
-		{ok, Pem} ->
-		    case public_key:pem_decode(Pem) of
-			[{_,_, not_encrypted}] ->
-			    init_per_testcase('__default__',Config);
-			_ ->
-			    {skip, {error, "Has pass phrase can not be used by automated test case"}} 
-		    end;
-		_ ->
-		    {skip, lists:concat(["no ~/",File])}  
-	    end
-    end.
-
 %%--------------------------------------------------------------------
 %% Test Cases --------------------------------------------------------
 %%--------------------------------------------------------------------
@@ -160,219 +120,6 @@ erlang_shell_client_openssh_server(Config) when is_list(Config) ->
     receive_logout(),
     receive_normal_exit(Shell).
    
-%--------------------------------------------------------------------
-erlang_client_openssh_server_exec() ->
-    [{doc, "Test api function ssh_connection:exec"}].
-
-erlang_client_openssh_server_exec(Config) when is_list(Config) ->
-    ConnectionRef = ssh_test_lib:connect(?SSH_DEFAULT_PORT, [{silently_accept_hosts, true},
-							     {user_interaction, false}]),
-    {ok, ChannelId0} = ssh_connection:session_channel(ConnectionRef, infinity),
-    success = ssh_connection:exec(ConnectionRef, ChannelId0,
-				  "echo testing", infinity),
-    Data0 = {ssh_cm, ConnectionRef, {data, ChannelId0, 0, <<"testing\n">>}},
-    case ssh_test_lib:receive_exec_result(Data0) of
-	expected ->
-	    ssh_test_lib:receive_exec_end(ConnectionRef, ChannelId0);
-	{unexpected_msg,{ssh_cm, ConnectionRef, {exit_status, ChannelId0, 0}}
-	 = ExitStatus0} ->
-	    ct:log("0: Collected data ~p", [ExitStatus0]),
-	    ssh_test_lib:receive_exec_result(Data0,
-					     ConnectionRef, ChannelId0);
-	Other0 ->
-	    ct:fail(Other0)
-    end,
-
-    {ok, ChannelId1} = ssh_connection:session_channel(ConnectionRef, infinity),
-    success = ssh_connection:exec(ConnectionRef, ChannelId1,
-				  "echo testing1", infinity),
-    Data1 = {ssh_cm, ConnectionRef, {data, ChannelId1, 0, <<"testing1\n">>}},
-    case ssh_test_lib:receive_exec_result(Data1) of
-	expected ->
-	    ssh_test_lib:receive_exec_end(ConnectionRef, ChannelId1);
-	{unexpected_msg,{ssh_cm, ConnectionRef, {exit_status, ChannelId1, 0}}
-	 = ExitStatus1} ->
-	    ct:log("0: Collected data ~p", [ExitStatus1]),
-	    ssh_test_lib:receive_exec_result(Data1,
-					     ConnectionRef, ChannelId1);
-	Other1 ->
-	    ct:fail(Other1)
-    end.
-
-%%--------------------------------------------------------------------
-erlang_client_openssh_server_exec_compressed() ->
-    [{doc, "Test that compression option works"}].
-
-erlang_client_openssh_server_exec_compressed(Config) when is_list(Config) ->
-    CompressAlgs = [zlib, '[email protected]',none],
-    case ssh_test_lib:ssh_supports(CompressAlgs, compression) of
-	{false,L} ->
-	    {skip, io_lib:format("~p compression is not supported",[L])};
-
-	true ->
-	    ConnectionRef = ssh_test_lib:connect(?SSH_DEFAULT_PORT, [{silently_accept_hosts, true},
-								     {user_interaction, false},
-								     {preferred_algorithms,
-								      [{compression,CompressAlgs}]}]),
-	    {ok, ChannelId} = ssh_connection:session_channel(ConnectionRef, infinity),
-	    success = ssh_connection:exec(ConnectionRef, ChannelId,
-					  "echo testing", infinity),
-	    Data = {ssh_cm, ConnectionRef, {data, ChannelId, 0, <<"testing\n">>}},
-	    case ssh_test_lib:receive_exec_result(Data) of
-		expected ->
-		    ssh_test_lib:receive_exec_end(ConnectionRef, ChannelId);
-		{unexpected_msg,{ssh_cm, ConnectionRef,
-				 {exit_status, ChannelId, 0}} = ExitStatus} ->
-		    ct:log("0: Collected data ~p", [ExitStatus]),
-		    ssh_test_lib:receive_exec_result(Data,  ConnectionRef, ChannelId);
-		Other ->
-		    ct:fail(Other)
-	    end
-    end.
-
-%%--------------------------------------------------------------------
-erlang_client_openssh_server_kexs() ->
-    [{doc, "Test that we can connect with different KEXs."}].
-
-erlang_client_openssh_server_kexs(Config) when is_list(Config) ->
-    KexAlgos = try proplists:get_value(kex, proplists:get_value(common_algs,Config))
-	       catch _:_ -> []
-	       end,
-    comment(KexAlgos),
-    case KexAlgos of
-	[] -> {skip, "No common kex algorithms"};
-	_ ->
-	    Success =
-		lists:foldl(
-		  fun(Kex, Acc) ->
-			  ConnectionRef = 
-			      ssh_test_lib:connect(?SSH_DEFAULT_PORT, [{silently_accept_hosts, true},
-								       {user_interaction, false},
-								       {preferred_algorithms,
-									[{kex,[Kex]}]}]),
-
-			  {ok, ChannelId} =
-			      ssh_connection:session_channel(ConnectionRef, infinity),
-			  success =
-			      ssh_connection:exec(ConnectionRef, ChannelId,
-						  "echo testing", infinity),
-
-			  ExpectedData = {ssh_cm, ConnectionRef, {data, ChannelId, 0, <<"testing\n">>}},
-			  case ssh_test_lib:receive_exec_result(ExpectedData) of
-			      expected ->
-				  ssh_test_lib:receive_exec_end(ConnectionRef, ChannelId),
-				  Acc;
-			      {unexpected_msg,{ssh_cm, ConnectionRef,
-					       {exit_status, ChannelId, 0}} = ExitStatus} ->
-				  ct:log("0: Collected data ~p", [ExitStatus]),
-				  ssh_test_lib:receive_exec_result(ExpectedData,  ConnectionRef, ChannelId),
-				  Acc;
-			      Other ->
-				  ct:log("~p failed: ~p",[Kex,Other]),
-				  false
-			  end
-		  end, true, KexAlgos),
-	    case Success of
-		true ->
-		    ok;
-		false ->
-		    {fail, "Kex failed for one or more algos"}
-	    end
-    end.
-
-%%--------------------------------------------------------------------
-erlang_client_openssh_server_setenv() ->
-    [{doc, "Test api function ssh_connection:setenv"}].
-
-erlang_client_openssh_server_setenv(Config) when is_list(Config) ->
-    ConnectionRef =
-	ssh_test_lib:connect(?SSH_DEFAULT_PORT, [{silently_accept_hosts, true},
-						 {user_interaction, false}]),
-    {ok, ChannelId} =
-	ssh_connection:session_channel(ConnectionRef, infinity),
-    Env = case ssh_connection:setenv(ConnectionRef, ChannelId,
-				     "ENV_TEST", "testing_setenv",
-				     infinity) of
-	      success ->
-		  <<"tesing_setenv\n">>;
-	      failure ->
-		  <<"\n">>
-	  end,
-    success = ssh_connection:exec(ConnectionRef, ChannelId,
-				  "echo $ENV_TEST", infinity),
-    Data = {ssh_cm, ConnectionRef, {data, ChannelId, 0, Env}},
-    case ssh_test_lib:receive_exec_result(Data) of
-	expected ->
-	    ssh_test_lib:receive_exec_end(ConnectionRef, ChannelId);
-	{unexpected_msg,{ssh_cm, ConnectionRef,
-			 {data,0,1, UnxpectedData}}} ->
-	    %% Some os may return things as
-	    %% ENV_TEST: Undefined variable.\n"
-	    ct:log("UnxpectedData: ~p", [UnxpectedData]),
-	    ssh_test_lib:receive_exec_end(ConnectionRef, ChannelId);
-	{unexpected_msg,{ssh_cm, ConnectionRef, {exit_status, ChannelId, 0}}
-	 = ExitStatus} ->
-	    ct:log("0: Collected data ~p", [ExitStatus]),
-	    ssh_test_lib:receive_exec_result(Data,
-					     ConnectionRef, ChannelId);
-	Other ->
-	    ct:fail(Other)
-    end.
-
-%%--------------------------------------------------------------------
-
-%% setenv not meaningfull on erlang ssh daemon!
-
-%%--------------------------------------------------------------------
-erlang_client_openssh_server_publickey_rsa(Config) ->
-    erlang_client_openssh_server_publickey_X(Config, 'ssh-rsa').
-    
-erlang_client_openssh_server_publickey_dsa(Config) ->
-    erlang_client_openssh_server_publickey_X(Config, 'ssh-dss').
-
-
-erlang_client_openssh_server_publickey_X(_Config, Alg) ->
-    ConnectionRef =
-        ssh_test_lib:connect(?SSH_DEFAULT_PORT,
-                             [{pref_public_key_algs, [Alg]},
-                              {user_interaction, false},
-                              {auth_methods, "publickey"},
-                              silently_accept_hosts]),
-    {ok, Channel} =
-        ssh_connection:session_channel(ConnectionRef, infinity),
-    ok = ssh_connection:close(ConnectionRef, Channel),
-    ok = ssh:close(ConnectionRef).
-
-%%--------------------------------------------------------------------
-erlang_server_openssh_client_public_key_dsa() ->
-    [{timetrap, {seconds,(?TIMEOUT div 1000)+10}}].
-erlang_server_openssh_client_public_key_dsa(Config) when is_list(Config) ->
-    erlang_server_openssh_client_public_key_X(Config, 'ssh-dss').
-
-erlang_server_openssh_client_public_key_rsa() -> 
-    [{timetrap, {seconds,(?TIMEOUT div 1000)+10}}].
-erlang_server_openssh_client_public_key_rsa(Config) when is_list(Config) ->
-    erlang_server_openssh_client_public_key_X(Config, 'ssh-rsa').
-
-
-erlang_server_openssh_client_public_key_X(Config, Alg) ->
-    SystemDir = proplists:get_value(data_dir, Config),
-    PrivDir = proplists:get_value(priv_dir, Config),
-    KnownHosts = filename:join(PrivDir, "known_hosts"),
-    {Pid, Host, Port} = ssh_test_lib:daemon([{system_dir, SystemDir},
-                                             {preferred_algorithms,[{public_key, [Alg]}]},
-                                             {auth_methods, "publickey"},
-					     {failfun, fun ssh_test_lib:failfun/2}]),
-    ct:sleep(500),
-
-    Cmd = ssh_test_lib:open_sshc_cmd(Host, Port,
-                                     [" -o UserKnownHostsFile=", KnownHosts,
-                                      " -o StrictHostKeyChecking=no"],
-                                     "1+1."),
-    OpenSsh = ssh_test_lib:open_port({spawn, Cmd}),
-    ssh_test_lib:rcv_expected({data,<<"2\n">>}, OpenSsh, ?TIMEOUT),
-    ssh:stop_daemon(Pid).
-
 %%--------------------------------------------------------------------
 %% Test that the Erlang/OTP server can renegotiate with openSSH
 erlang_server_openssh_client_renegotiate(Config) ->
@@ -430,108 +177,6 @@ erlang_server_openssh_client_renegotiate(Config) ->
     end.
 
 %%--------------------------------------------------------------------
-erlang_client_openssh_server_renegotiate(_Config) ->
-    process_flag(trap_exit, true),
-    IO = ssh_test_lib:start_io_server(),
-    Ref = make_ref(),
-    Parent = self(),
-
-    Shell = 
-	spawn_link(
-	  fun() ->
-		  Host = ssh_test_lib:hostname(),
-		  Options = [{user_interaction, false},
-			     {silently_accept_hosts,true}],
-		  group_leader(IO, self()),
-		  {ok, ConnRef} = ssh:connect(Host, ?SSH_DEFAULT_PORT, Options),
-                  ct:log("Parent = ~p, IO = ~p, Shell = ~p, ConnRef = ~p~n",[Parent, IO, self(), ConnRef]),
-		  case ssh_connection:session_channel(ConnRef, infinity) of
-		      {ok,ChannelId}  ->
-			  success = ssh_connection:ptty_alloc(ConnRef, ChannelId, []),
-			  Args = [{channel_cb, ssh_shell},
-				  {init_args,[ConnRef, ChannelId]},
-				  {cm, ConnRef}, {channel_id, ChannelId}],
-			  {ok, State} = ssh_channel:init([Args]),
-			  Parent ! {ok, Ref, ConnRef},
-			  ssh_channel:enter_loop(State);
-		      Error ->
-			  Parent ! {error, Ref, Error}
-		  end,
-		  receive
-		      nothing -> ok
-		  end
-	  end),
-
-    receive
-	{error, Ref, Error} ->
-	    ct:fail("Error=~p",[Error]);
-	{ok, Ref, ConnectionRef} ->
-	    IO ! {input, self(), "echo Hej1\n"},
-	    receive_data("Hej1", ConnectionRef),
-	    Kex1 = ssh_test_lib:get_kex_init(ConnectionRef),
-	    ssh_connection_handler:renegotiate(ConnectionRef),
-	    IO ! {input, self(), "echo Hej2\n"},
-	    receive_data("Hej2", ConnectionRef),
-	    Kex2 = ssh_test_lib:get_kex_init(ConnectionRef),
-	    IO ! {input, self(), "exit\n"},
-	    receive_logout(),
-	    receive_normal_exit(Shell),
-	    true = (Kex1 =/= Kex2)
-    end.
-
-%%--------------------------------------------------------------------
-erlang_client_openssh_server_password() ->
-    [{doc, "Test client password option"}].
-erlang_client_openssh_server_password(Config) when is_list(Config) ->
-    %% to make sure we don't public-key-auth
-    UserDir = proplists:get_value(data_dir, Config),
-    {error, Reason0} =
-	ssh:connect(any, ?SSH_DEFAULT_PORT, [{silently_accept_hosts, true},
-					     {user, "foo"},
-					     {password, "morot"},
-					     {user_interaction, false},
-					     {user_dir, UserDir}]),
-    
-    ct:log("Test of user foo that does not exist. "
-		       "Error msg: ~p~n", [Reason0]),
-
-    User = string:strip(os:cmd("whoami"), right, $\n),
-
-    case length(string:tokens(User, " ")) of
-	1 ->
-	    {error, Reason1} =
-		ssh:connect(any, ?SSH_DEFAULT_PORT,
-			    [{silently_accept_hosts, true},
-			     {user, User},
-			     {password, "foo"},
-			     {user_interaction, false},
-			     {user_dir, UserDir}]),
-	    ct:log("Test of wrong Pasword.  "
-			       "Error msg: ~p~n", [Reason1]);
-	_ ->
-	    ct:log("Whoami failed reason: ~n", [])
-	end.
-
-%%--------------------------------------------------------------------
-
-erlang_client_openssh_server_nonexistent_subsystem() ->
-    [{doc, "Test client password option"}].
-erlang_client_openssh_server_nonexistent_subsystem(Config) when is_list(Config) ->
-
-    ConnectionRef = ssh_test_lib:connect(?SSH_DEFAULT_PORT,
-					 [{user_interaction, false},
-					  silently_accept_hosts]),
-
-    {ok, ChannelId} = ssh_connection:session_channel(ConnectionRef, infinity),
-
-    failure = ssh_connection:subsystem(ConnectionRef, ChannelId, "foo", infinity).
-
-%%--------------------------------------------------------------------
-%
-%% Not possible to send password with openssh without user interaction
-%%
-%%--------------------------------------------------------------------
-%%--------------------------------------------------------------------
 %%% Internal functions -----------------------------------------------
 %%--------------------------------------------------------------------
 receive_data(Data, Conn) ->