anchor.diff:      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
   			 ]}
       ].
   
  
positive.code:     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, 'zlib@openssh.com',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) ->
  
negative.code: 	throw:{skip,R} -> {skip,R}
      end.
  
  %%--------------------------------------------------------------------
  %%% Internal functions -----------------------------------------------
  %%--------------------------------------------------------------------
  