Merge branch 'ia/ssl/remove-old-ssl/OTP-7048'

* ia/ssl/remove-old-ssl/OTP-7048:
  Remove old ssl implementation and deprecated function ssl:peercert/1

Conflicts:
	lib/ssl/test/Makefile

14 files changed, 3 insertions, 3771 deletions

diff --git a/lib/ssl/test/Makefile b/lib/ssl/test/Makefile
index 38bc529445..23a9a23190 100644
--- a/lib/ssl/test/Makefile
+++ b/lib/ssl/test/Makefile
@@ -43,26 +43,15 @@ MODULES = \
 	ssl_to_openssl_SUITE \
 	ssl_session_cache_SUITE	\
 	ssl_dist_SUITE \
-	ssl_test_MACHINE \
-	old_ssl_active_SUITE \
-	old_ssl_active_once_SUITE \
-	old_ssl_passive_SUITE \
-	old_ssl_verify_SUITE \
-	old_ssl_peer_cert_SUITE \
-	old_ssl_misc_SUITE \
-	old_ssl_protocol_SUITE \
-	old_transport_accept_SUITE \
-	old_ssl_dist_SUITE \
 	make_certs\
 	erl_make_certs
 
 
 ERL_FILES = $(MODULES:%=%.erl)
 
-HRL_FILES = ssl_test_MACHINE.hrl 
+HRL_FILES =
 
 HRL_FILES_SRC = \
-	ssl_int.hrl \
 	ssl_internal.hrl\
 	ssl_alert.hrl \
 	ssl_handshake.hrl \
diff --git a/lib/ssl/test/old_ssl_active_SUITE.erl b/lib/ssl/test/old_ssl_active_SUITE.erl
deleted file mode 100644
index 52ff0bcc5d..0000000000
--- a/lib/ssl/test/old_ssl_active_SUITE.erl
+++ /dev/null
@@ -1,395 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 1999-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_ssl_active_SUITE).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,
-	 end_per_testcase/2,
-	 cinit_return_chkclose/1,
-	 sinit_return_chkclose/1,
-	 cinit_big_return_chkclose/1,
-	 sinit_big_return_chkclose/1,
-	 cinit_big_echo_chkclose/1,
-	 cinit_huge_echo_chkclose/1,
-	 sinit_big_echo_chkclose/1,
-	 cinit_few_echo_chkclose/1,
-	 cinit_many_echo_chkclose/1,
-	 cinit_cnocert/1
-	]).
-
--import(ssl_test_MACHINE, [mk_ssl_cert_opts/1, test_one_listener/7,
-			   test_server_only/6]).
-
--include_lib("test_server/include/test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
--define(MANYCONNS, ssl_test_MACHINE:many_conns()).
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = ssl_test_lib:timetrap(?DEFAULT_TIMEOUT),
-    [{watchdog, WatchDog}| Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [cinit_return_chkclose, sinit_return_chkclose,
-     cinit_big_return_chkclose, sinit_big_return_chkclose,
-     cinit_big_echo_chkclose, cinit_huge_echo_chkclose,
-     sinit_big_echo_chkclose, cinit_few_echo_chkclose,
-     cinit_many_echo_chkclose, cinit_cnocert].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(doc) ->
-    "Want to se what Config contains, and record the number of available "
-	"file descriptors";
-init_per_suite(suite) ->
-    [];
-init_per_suite(Config) ->
-    io:format("Config: ~p~n", [Config]),
-    case os:type() of
-	{unix, _} ->
-	    ?line io:format("Max fd value: ~s", [os:cmd("ulimit -n")]);
-	_ ->
-	    ok
-    end, 
-    %% XXX Also record: Erlang/SSL version, version of OpenSSL, 
-    %% operating system, version of OTP, Erts, kernel and stdlib. 
-
-    %% Check if SSL exists. If this case fails, all other cases are skipped
-    case catch crypto:start() of
-	ok ->
-	    application:start(public_key),
-	    case ssl:start() of
-		ok -> ssl:stop();
-		{error, {already_started, _}} -> ssl:stop();
-		Error -> ?t:fail({failed_starting_ssl,Error})
-	    end,
-	    Config;
-	_Else ->
-	    {skip,"Could not start crypto!"}
-    end.
-
-end_per_suite(doc) ->
-    "This test case has no mission other than closing the conf case";
-end_per_suite(suite) ->
-    [];
-end_per_suite(Config) ->
-    crypto:stop(),
-    Config.
-
-cinit_return_chkclose(doc) ->
-    "Client sends 1000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-cinit_return_chkclose(suite) ->
-    [];
-cinit_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-sinit_return_chkclose(doc) ->
-    "Server sends 1000 bytes to client, that receives them, sends them "
-	"back, and closes. Server waits for close. Both have certs.";
-sinit_return_chkclose(suite) ->
-    [];
-sinit_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, [{ssl_imp, old}|SsslOpts]},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize},
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, [{ssl_imp, old}|CsslOpts]},
-	     {connect, {Host, LPort}},
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-cinit_big_return_chkclose(doc) ->
-    "Client sends 50000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-cinit_big_return_chkclose(suite) ->
-    [];
-cinit_big_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-sinit_big_return_chkclose(doc) ->
-    "Server sends 50000 bytes to client, that receives them, sends them "
-	"back, and closes. Server waits for close. Both have certs.";
-sinit_big_return_chkclose(suite) ->
-    [];
-sinit_big_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-cinit_big_echo_chkclose(doc) ->
-    "Client sends 50000 bytes to server, that echoes them back "
-	"and closes. Client waits for close. Both have certs.";
-cinit_big_echo_chkclose(suite) ->
-    [];
-cinit_big_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-cinit_huge_echo_chkclose(doc) ->
-    "Client sends 500000 bytes to server, that echoes them back "
-	"and closes. Client waits for close. Both have certs.";
-cinit_huge_echo_chkclose(suite) ->
-    [];
-cinit_huge_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 500000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-sinit_big_echo_chkclose(doc) ->
-    "Server sends 50000 bytes to client, that echoes them back "
-	"and closes. Server waits for close. Both have certs.";
-sinit_big_echo_chkclose(suite) ->
-    [];
-sinit_big_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {echo, DataSize},
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-
-%% This case is repeated several times.
-
-cinit_few_echo_chkclose(X) -> cinit_many_echo_chkclose(X, 7).
-
-cinit_many_echo_chkclose(X) -> cinit_many_echo_chkclose(X, ?MANYCONNS).
-
-cinit_many_echo_chkclose(doc, _NConns) ->
-    "N client sends 10000 bytes to server, that echoes them back "
-	"and closes. Clients wait for close. All have certs.";
-cinit_many_echo_chkclose(suite, _NConns) ->
-    [];
-cinit_many_echo_chkclose(Config, NConns) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 10000, LPort = 3456,
-    Timeout = 80000,
-
-    io:format("~w connections", [NConns]),
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-
-cinit_cnocert(doc) ->
-    "Client sends 1000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Client has no cert, "
-	"but server has.";
-cinit_cnocert(suite) ->
-    [];
-cinit_cnocert(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3457,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {_CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE, 
-			    Config).
-
-
diff --git a/lib/ssl/test/old_ssl_active_once_SUITE.erl b/lib/ssl/test/old_ssl_active_once_SUITE.erl
deleted file mode 100644
index c7beadb301..0000000000
--- a/lib/ssl/test/old_ssl_active_once_SUITE.erl
+++ /dev/null
@@ -1,417 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2002-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_ssl_active_once_SUITE).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,
-	 end_per_testcase/2,
-	 server_accept_timeout/1,
-	 cinit_return_chkclose/1,
-	 sinit_return_chkclose/1,
-	 cinit_big_return_chkclose/1,
-	 sinit_big_return_chkclose/1,
-	 cinit_big_echo_chkclose/1,
-	 cinit_huge_echo_chkclose/1,
-	 sinit_big_echo_chkclose/1,
-	 cinit_few_echo_chkclose/1,
-	 cinit_many_echo_chkclose/1,
-	 cinit_cnocert/1
-	]).
-
--import(ssl_test_MACHINE, [mk_ssl_cert_opts/1, test_one_listener/7,
-			   test_server_only/6]).
--include_lib("test_server/include/test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
--define(MANYCONNS, ssl_test_MACHINE:many_conns()).
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = ssl_test_lib:timetrap(?DEFAULT_TIMEOUT),
-    [{watchdog, WatchDog}| Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [server_accept_timeout, cinit_return_chkclose,
-     sinit_return_chkclose, cinit_big_return_chkclose,
-     sinit_big_return_chkclose, cinit_big_echo_chkclose,
-     cinit_huge_echo_chkclose, sinit_big_echo_chkclose,
-     cinit_few_echo_chkclose, cinit_many_echo_chkclose,
-     cinit_cnocert].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(doc) ->
-    "Want to se what Config contains.";
-init_per_suite(suite) ->
-    [];
-init_per_suite(Config) ->
-    io:format("Config: ~p~n", [Config]),
-
-    %% Check if SSL exists. If this case fails, all other cases are skipped
-    case catch crypto:start() of
-	ok ->
-	    application:start(public_key),
-	    case ssl:start() of
-		ok -> ssl:stop();
-		{error, {already_started, _}} -> ssl:stop();
-		Error -> ?t:fail({failed_starting_ssl,Error})
-	    end,
-	    Config;
-	_Else ->
-	    {skip,"Could not start crypto"}
-    end.
-
-end_per_suite(doc) ->
-    "This test case has no mission other than closing the conf case";
-end_per_suite(suite) ->
-    [];
-end_per_suite(Config) ->
-    crypto:stop(),
-    Config.
-
-server_accept_timeout(doc) ->
-    "Server has one pending accept with timeout. Checks that return "
-	"value is {error, timeout}.";
-server_accept_timeout(suite) ->
-    [];
-server_accept_timeout(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    LPort = 3456,
-    Timeout = 40000, NConns = 1,
-    AccTimeout = 3000,
-
-    ?line {ok, {_, SsslOpts}} = mk_ssl_cert_opts(Config),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, AccTimeout}, 
-	     accept_timeout],
-    ?line test_server_only(NConns, LCmds, ACmds, Timeout, ?MODULE,
-			   Config).
-
-cinit_return_chkclose(doc) ->
-    "Client sends 1000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-cinit_return_chkclose(suite) ->
-    [];
-cinit_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout},
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-sinit_return_chkclose(doc) ->
-    "Server sends 1000 bytes to client, that receives them, sends them "
-	"back, and closes. Server waits for close. Both have certs.";
-sinit_return_chkclose(suite) ->
-    [];
-sinit_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_big_return_chkclose(doc) ->
-    "Client sends 50000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-cinit_big_return_chkclose(suite) ->
-    [];
-cinit_big_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    %% Set {active, false} so that accept is passive to begin with. 
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},	
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {sockopts, [{active, once}]},	% {active, once} here.
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-sinit_big_return_chkclose(doc) ->
-    "Server sends 50000 bytes to client, that receives them, sends them "
-	"back, and closes. Server waits for close. Both have certs.";
-sinit_big_return_chkclose(suite) ->
-    [];
-sinit_big_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_big_echo_chkclose(doc) ->
-    "Client sends 50000 bytes to server, that echoes them back "
-	"and closes. Client waits for close. Both have certs.";
-cinit_big_echo_chkclose(suite) ->
-    [];
-cinit_big_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_huge_echo_chkclose(doc) ->
-    "Client sends 500000 bytes to server, that echoes them back "
-	"and closes. Client waits for close. Both have certs.";
-cinit_huge_echo_chkclose(suite) ->
-    [];
-cinit_huge_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 500000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-sinit_big_echo_chkclose(doc) ->
-    "Server sends 50000 bytes to client, that echoes them back "
-	"and closes. Server waits for close. Both have certs.";
-sinit_big_echo_chkclose(suite) ->
-    [];
-sinit_big_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {echo, DataSize},
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_few_echo_chkclose(X) -> cinit_many_echo_chkclose(X, 7).
-
-cinit_many_echo_chkclose(X) -> cinit_many_echo_chkclose(X, ?MANYCONNS).
-
-cinit_many_echo_chkclose(doc, _NConns) ->
-    "client send 10000 bytes to server, that echoes them back "
-	"and closes. Clients wait for close. All have certs.";
-cinit_many_echo_chkclose(suite, _NConns) ->
-    [];
-cinit_many_echo_chkclose(Config, NConns) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 10000, LPort = 3456,
-    Timeout = 80000,
-
-    io:format("~w connections", [NConns]),
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_cnocert(doc) ->
-    "Client sends 1000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Client has no cert, "
-	"but server has.";
-cinit_cnocert(suite) ->
-    [];
-cinit_cnocert(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3457,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {_CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, once}]},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-
diff --git a/lib/ssl/test/old_ssl_dist_SUITE.erl b/lib/ssl/test/old_ssl_dist_SUITE.erl
deleted file mode 100644
index 4544fb616a..0000000000
--- a/lib/ssl/test/old_ssl_dist_SUITE.erl
+++ /dev/null
@@ -1,617 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2007-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
-
-
-%%%-------------------------------------------------------------------
-%%% File    : ssl_dist_SUITE.erl
-%%% Author  : Rickard Green
-%%% Description : Test that the Erlang distribution works over ssl.
-%%%
-%%% Created : 15 Nov 2007 by Rickard Green
-%%%-------------------------------------------------------------------
--module(old_ssl_dist_SUITE).
-
--include_lib("test_server/include/test_server.hrl").
-
--define(DEFAULT_TIMETRAP_SECS, 240).
-
--define(AWAIT_SLL_NODE_UP_TIMEOUT, 30000).
-
--export([all/0, suite/0,groups/0,init_per_group/2,end_per_group/2]).
--export([init_per_suite/1,
-	 end_per_suite/1,
-	 init_per_testcase/2,
-	 end_per_testcase/2]).
--export([cnct2tstsrvr/1]).
-
--export([basic/1]).
-
--record(node_handle, {connection_handler, socket, name, nodename}).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [basic].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(Config) ->
-    try crypto:start() of
-	ok ->
-	    add_ssl_opts_config(Config)
-    catch _:_ ->
-	    {skip, "Crypto did not start"}
-    end.
-
-end_per_suite(Config) ->
-    application:stop(crypto),
-    Config.
-
-init_per_testcase(Case, Config) when list(Config) ->
-    Dog = ?t:timetrap(?t:seconds(?DEFAULT_TIMETRAP_SECS)),
-    [{watchdog, Dog},{testcase, Case}|Config].
-
-end_per_testcase(_Case, Config) when list(Config) ->
-    Dog = ?config(watchdog, Config),
-    ?t:timetrap_cancel(Dog),
-    ok.
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%                                                                       %%
-%% Testcases                                                             %%
-%%                                                                       %%
-
-basic(doc) ->
-    ["Test that two nodes can connect via ssl distribution"];
-basic(suite) ->
-    [];
-basic(Config) when is_list(Config) ->
-    ?line NH1 = start_ssl_node(Config),
-    ?line Node1 = NH1#node_handle.nodename,
-    ?line NH2 = start_ssl_node(Config),
-    ?line Node2 = NH2#node_handle.nodename,
-
-    ?line pong = apply_on_ssl_node(NH1, fun () -> net_adm:ping(Node2) end),
-
-    ?line [Node2] = apply_on_ssl_node(NH1, fun () -> nodes() end),
-    ?line [Node1] = apply_on_ssl_node(NH2, fun () -> nodes() end),
-
-    %% The test_server node has the same cookie as the ssl nodes
-    %% but it should not be able to communicate with the ssl nodes
-    %% via the erlang distribution.
-    ?line pang = net_adm:ping(Node1),
-    ?line pang = net_adm:ping(Node2),
-
-
-    %%
-    %% Check that we are able to communicate over the erlang
-    %% distribution between the ssl nodes.
-    %%
-    ?line Ref = make_ref(),
-    ?line spawn(fun () ->
-			apply_on_ssl_node(
-			  NH1,
-			  fun () -> 
-				  tstsrvr_format("Hi from ~p!~n",
-						 [node()]),
-				  send_to_tstcntrl({Ref, self()}),
-				  receive
-				      {From, ping} ->
-					  From ! {self(), pong}
-				  end
-			  end)
-		end),
-    ?line receive
-	      {Ref, SslPid} ->
-		  ?line ok = apply_on_ssl_node(
-			       NH2,
-			       fun () ->
-				       tstsrvr_format("Hi from ~p!~n",
-						      [node()]),
-				       SslPid ! {self(), ping},
-				       receive
-					   {SslPid, pong} ->
-					       ok
-				       end
-			       end)
-	  end,
-
-    ?line stop_ssl_node(NH1),
-    ?line stop_ssl_node(NH2),
-    ?line success(Config).
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%                                                                       %%
-%% Internal functions                                                    %%
-%%                                                                       %%
-
-%%
-%% ssl_node side api
-%%
-
-tstsrvr_format(Fmt, ArgList) ->
-    send_to_tstsrvr({format, Fmt, ArgList}).
-
-send_to_tstcntrl(Message) ->
-    send_to_tstsrvr({message, Message}).
-
-
-%%
-%% test_server side api
-%%
-
-apply_on_ssl_node(Node, M, F, A) when atom(M), atom(F), list(A) ->
-    Ref = make_ref(),
-    send_to_ssl_node(Node, {apply, self(), Ref, M, F, A}),
-    receive
-	{Ref, Result} ->
-	    Result
-    end.
-
-apply_on_ssl_node(Node, Fun) when is_function(Fun, 0) ->
-    Ref = make_ref(),
-    send_to_ssl_node(Node, {apply, self(), Ref, Fun}),
-    receive
-	{Ref, Result} ->
-	    Result
-    end.
-
-stop_ssl_node(#node_handle{connection_handler = Handler,
-			   socket = Socket,
-			   name = Name}) ->
-    ?t:format("Trying to stop ssl node ~s.~n", [Name]),
-    Mon = erlang:monitor(process, Handler),
-    unlink(Handler),
-    case gen_tcp:send(Socket, term_to_binary(stop)) of
-	ok ->
-	    receive
-		{'DOWN', Mon, process, Handler, Reason} ->
-		    case Reason of
-			normal -> ok;
-			_ -> exit(Reason)
-		    end
-	    end;
-	Error ->
-	    erlang:demonitor(Mon, [flush]),
-	    exit(Error)
-    end.
-
-start_ssl_node(Config) ->
-    start_ssl_node(Config, "").
-
-start_ssl_node(Config, XArgs) ->
-    Name = mk_node_name(Config),
-    SSL = ?config(ssl_opts, Config),
-    SSLDistOpts = setup_dist_opts(Name, ?config(priv_dir, Config)),
-    start_ssl_node_raw(Name, SSL ++ " " ++ SSLDistOpts ++ XArgs).
-
-start_ssl_node_raw(Name, Args) ->
-    {ok, LSock} = gen_tcp:listen(0,
-				 [binary, {packet, 4}, {active, false}]),
-    {ok, ListenPort} = inet:port(LSock),
-    CmdLine = mk_node_cmdline(ListenPort, Name, Args),
-    ?t:format("Attempting to start ssl node ~s: ~s~n", [Name, CmdLine]),
-    case open_port({spawn, CmdLine}, []) of
-	Port when port(Port) ->
-	    unlink(Port),
-	    erlang:port_close(Port),
-	    case await_ssl_node_up(Name, LSock) of
-		#node_handle{} = NodeHandle ->
-		    ?t:format("Ssl node ~s started.~n", [Name]),
-		    NodeName = list_to_atom(Name ++ "@" ++ host_name()),
-		    NodeHandle#node_handle{nodename = NodeName};
-		Error ->
-		    exit({failed_to_start_node, Name, Error})
-	    end;
-	Error ->
-	    exit({failed_to_start_node, Name, Error})
-    end.
-
-%%
-%% command line creation
-%%
-
-host_name() ->
-    [$@ | Host] = lists:dropwhile(fun ($@) -> false; (_) -> true end,
-				  atom_to_list(node())),
-    Host.
-
-mk_node_name(Config) ->
-    {A, B, C} = erlang:now(),
-    Case = ?config(testcase, Config),
-    atom_to_list(?MODULE)
-	++ "_"
-	++ atom_to_list(Case)
-	++ "_"
-	++ integer_to_list(A)
-	++ "-"
-	++ integer_to_list(B)
-	++ "-"
-	++ integer_to_list(C).
-
-mk_node_cmdline(ListenPort, Name, Args) ->
-    Static = "-detached -noinput",
-    Pa = filename:dirname(code:which(?MODULE)),
-    Prog = case catch init:get_argument(progname) of
-	       {ok,[[P]]} -> P;
-	       _ -> exit(no_progname_argument_found)
-	   end,
-    NameSw = case net_kernel:longnames() of
-		 false -> "-sname ";
-		 _ -> "-name "
-	     end,
-    {ok, Pwd} = file:get_cwd(),
-    Prog ++ " "
-	++ Static ++ " "
-	++ NameSw ++ " " ++ Name ++ " "
-	++ "-pa " ++ Pa ++ " " 
- 	++ "-run application start crypto -run application start public_key "
-	++ "-run " ++ atom_to_list(?MODULE) ++ " cnct2tstsrvr "
-	++ host_name() ++ " "
-	++ integer_to_list(ListenPort) ++ " "
-	++ Args ++ " "
-	++ "-env ERL_CRASH_DUMP " ++ Pwd ++ "/erl_crash_dump." ++ Name ++ " "
-	++ "-setcookie " ++ atom_to_list(erlang:get_cookie()).
-
-%%
-%% Connection handler test_server side
-%%
-
-await_ssl_node_up(Name, LSock) ->
-    case gen_tcp:accept(LSock, ?AWAIT_SLL_NODE_UP_TIMEOUT) of
-	timeout ->
-	    gen_tcp:close(LSock),
-	    ?t:format("Timeout waiting for ssl node ~s to come up~n",
-		      [Name]),
-	    timeout;
-	{ok, Socket} ->
-	    gen_tcp:close(LSock),
-	    case gen_tcp:recv(Socket, 0) of
-		{ok, Bin} ->
-		    check_ssl_node_up(Socket, Name, Bin);
-		{error, closed} ->
-		    gen_tcp:close(Socket),
-		    exit({lost_connection_with_ssl_node_before_up, Name})
-	    end;
-	{error, Error} ->
-	    gen_tcp:close(LSock),
-	    exit({accept_failed, Error})
-    end.
-
-check_ssl_node_up(Socket, Name, Bin) ->
-    case catch binary_to_term(Bin) of
-	{'EXIT', _} ->
-	    gen_tcp:close(Socket),
-	    exit({bad_data_received_from_ssl_node, Name, Bin});
-	{ssl_node_up, NodeName} ->
-	    case list_to_atom(Name++"@"++host_name()) of
-		NodeName ->
-		    Parent = self(),
-		    Go = make_ref(),
-		    %% Spawn connection handler on test server side
-		    Pid = spawn_link(
-			    fun () ->
-				    receive Go -> ok end,
-				    tstsrvr_con_loop(Name, Socket, Parent)
-			    end),
-		    ok = gen_tcp:controlling_process(Socket, Pid),
-		    Pid ! Go,
-		    #node_handle{connection_handler = Pid,
-				 socket = Socket,
-				 name = Name};
-		_ ->
-		    exit({unexpected_ssl_node_connected, NodeName})
-	    end;
-	Msg ->
-	    exit({unexpected_msg_instead_of_ssl_node_up, Name, Msg})
-    end.
-
-send_to_ssl_node(#node_handle{connection_handler = Hndlr}, Term) ->
-    Hndlr ! {relay_to_ssl_node, term_to_binary(Term)},
-    ok.
-
-tstsrvr_con_loop(Name, Socket, Parent) ->
-    inet:setopts(Socket,[{active,once}]),
-    receive
-	{relay_to_ssl_node, Data} when is_binary(Data) ->
-	    case gen_tcp:send(Socket, Data) of
-		ok ->
-		    ok;
-		_Error ->
-		    gen_tcp:close(Socket),
-		    exit({failed_to_relay_data_to_ssl_node, Name, Data})
-	    end;
-	{tcp, Socket, Bin} ->
-	    case catch binary_to_term(Bin) of
-		{'EXIT', _} ->
-		    gen_tcp:close(Socket),
-		    exit({bad_data_received_from_ssl_node, Name, Bin});
-		{format, FmtStr, ArgList} ->
-		    ?t:format(FmtStr, ArgList);
-		{message, Msg} ->
-		    Parent ! Msg;
-		{apply_res, To, Ref, Res} ->
-		    To ! {Ref, Res};
-		bye ->
-		    ?t:format("Ssl node ~s stopped.~n", [Name]),
-		    gen_tcp:close(Socket),
-		    exit(normal);
-		Unknown ->
-		    exit({unexpected_message_from_ssl_node, Name, Unknown})
-	    end;
-	{tcp_closed, Socket} ->
-	    gen_tcp:close(Socket),
-	    exit({lost_connection_with_ssl_node, Name})
-    end,
-    tstsrvr_con_loop(Name, Socket, Parent).
-
-%%
-%% Connection handler ssl_node side
-%%
-
-% cnct2tstsrvr() is called via command line arg -run ...
-cnct2tstsrvr([Host, Port]) when list(Host), list(Port) ->
-    %% Spawn connection handler on ssl node side
-    ConnHandler
-	= spawn(fun () ->
-			case catch gen_tcp:connect(Host,
-						   list_to_integer(Port),
-						   [binary,
-						    {packet, 4},
-						    {active, false}]) of
-			    {ok, Socket} ->
-				notify_ssl_node_up(Socket),
-				ets:new(test_server_info,
-					[set,
-					 public,
-					 named_table,
-					 {keypos, 1}]),
-				ets:insert(test_server_info,
-					   {test_server_handler, self()}),
-				ssl_node_con_loop(Socket);
-			    _Error ->
-				halt("Failed to connect to test server")
-			end
-		end),
-    spawn(fun () ->
-		  Mon = erlang:monitor(process, ConnHandler),
-		  receive
-		      {'DOWN', Mon, process, ConnHandler, Reason} ->
-			  receive after 1000 -> ok end,
-			  halt("test server connection handler terminated: "
-			       ++
-			       lists:flatten(io_lib:format("~p", [Reason])))
-		  end
-	  end).
-
-notify_ssl_node_up(Socket) ->
-    case catch gen_tcp:send(Socket,
-			    term_to_binary({ssl_node_up, node()})) of
-	ok -> ok;
-	_ -> halt("Failed to notify test server that I'm up")
-    end.
-
-send_to_tstsrvr(Term) ->
-    case catch ets:lookup_element(test_server_info, test_server_handler, 2) of
-	Hndlr when pid(Hndlr) ->
-	    Hndlr ! {relay_to_test_server, term_to_binary(Term)}, ok;
-	_ ->
-	    receive after 200 -> ok end,
-	    send_to_tstsrvr(Term)
-    end.
-
-ssl_node_con_loop(Socket) ->
-    inet:setopts(Socket,[{active,once}]),
-    receive
-	{relay_to_test_server, Data} when is_binary(Data) ->
-	    case gen_tcp:send(Socket, Data) of
-		ok ->
-		    ok;
-		_Error ->
-		    gen_tcp:close(Socket),
-		    halt("Failed to relay data to test server")
-	    end;
-	{tcp, Socket, Bin} ->
-	    case catch binary_to_term(Bin) of
-		{'EXIT', _} ->
-		    gen_tcp:close(Socket),
-		    halt("test server sent me bad data");
-		{apply, From, Ref, M, F, A} ->
-		    spawn_link(
-		      fun () ->
-			      send_to_tstsrvr({apply_res,
-					       From,
-					       Ref,
-					       (catch apply(M, F, A))})
-			  end);
-		{apply, From, Ref, Fun} ->
-		    spawn_link(fun () ->
-				       send_to_tstsrvr({apply_res,
-							From,
-							Ref,
-							(catch Fun())})
-			       end);
-		stop ->
-		    gen_tcp:send(Socket, term_to_binary(bye)),
-		    gen_tcp:close(Socket),
-		    init:stop(),
-		    receive after infinity -> ok end;
-		_Unknown ->
-		    halt("test server sent me an unexpected message")
-	    end;
-	{tcp_closed, Socket} ->
-	    halt("Lost connection to test server")
-    end,
-    ssl_node_con_loop(Socket).
-
-%%
-%% Setup ssl dist info
-%%
-
-rand_bin(N) ->
-    rand_bin(N, []).
-
-rand_bin(0, Acc) ->
-    Acc;
-rand_bin(N, Acc) ->
-    rand_bin(N-1, [random:uniform(256)-1|Acc]).
-
-make_randfile(Dir) ->
-    {ok, IoDev} = file:open(filename:join([Dir, "RAND"]), [write]),
-    {A, B, C} = erlang:now(),
-    random:seed(A, B, C),
-    ok = file:write(IoDev, rand_bin(1024)),
-    file:close(IoDev).
-
-append_files(FileNames, ResultFileName) ->
-    {ok, ResultFile} = file:open(ResultFileName, [write]),
-    do_append_files(FileNames, ResultFile).
-
-do_append_files([], RF) ->
-    ok = file:close(RF);
-do_append_files([F|Fs], RF) ->
-    {ok, Data} = file:read_file(F),
-    ok = file:write(RF, Data),
-    do_append_files(Fs, RF).
-			    
-setup_dist_opts(Name, PrivDir) ->
-    NodeDir = filename:join([PrivDir, Name]),
-    RGenDir = filename:join([NodeDir, "rand_gen"]),
-    ok = file:make_dir(NodeDir),
-    ok = file:make_dir(RGenDir),
-    make_randfile(RGenDir),
-    make_certs:all(RGenDir, NodeDir),
-    SDir = filename:join([NodeDir, "server"]),
-    SC = filename:join([SDir, "cert.pem"]),
-    SK = filename:join([SDir, "key.pem"]),
-    SKC = filename:join([SDir, "keycert.pem"]),
-    append_files([SK, SC], SKC),
-    CDir = filename:join([NodeDir, "client"]),
-    CC = filename:join([CDir, "cert.pem"]),
-    CK = filename:join([CDir, "key.pem"]),
-    CKC = filename:join([CDir, "keycert.pem"]),
-    append_files([CK, CC], CKC),
-    "-proto_dist inet_ssl "
-	++ "-ssl_dist_opt server_certfile " ++ SKC ++ " "
-	++ "-ssl_dist_opt client_certfile " ++ CKC ++ " "
-.%	++ "-ssl_dist_opt verify 1 depth 1".
-
-%%
-%% Start scripts etc...
-%%
-
-add_ssl_opts_config(Config) ->
-    %%
-    %% Start with boot scripts if on an installed system; otherwise,
-    %% just point out ssl ebin with -pa.
-    %%
-    try
-	Dir = ?config(priv_dir, Config),
-	LibDir = code:lib_dir(),
-	Apps = application:which_applications(),
-	{value, {stdlib, _, STDL_VSN}} = lists:keysearch(stdlib, 1, Apps),
-	{value, {kernel, _, KRNL_VSN}} = lists:keysearch(kernel, 1, Apps),
-	StdlDir = filename:join([LibDir, "stdlib-" ++ STDL_VSN]),
-	KrnlDir = filename:join([LibDir, "kernel-" ++ KRNL_VSN]),
-	{ok, _} = file:read_file_info(StdlDir),
-	{ok, _} = file:read_file_info(KrnlDir),
-	SSL_VSN = vsn(ssl),
-	VSN_CRYPTO = vsn(crypto),
-	VSN_PKEY = vsn(public_key),
-	
-	SslDir = filename:join([LibDir, "ssl-" ++ SSL_VSN]),
-	{ok, _} = file:read_file_info(SslDir),
-	%% We are using an installed otp system, create the boot script.
-	Script = filename:join(Dir, atom_to_list(?MODULE)),
-	{ok, RelFile} = file:open(Script ++ ".rel", [write]),
-        io:format(RelFile,
-		  "{release, ~n"
-		  " {\"SSL distribution test release\", \"~s\"},~n"
-		  " {erts, \"~s\"},~n"
-		  " [{kernel, \"~s\"},~n"
-		  "  {stdlib, \"~s\"},~n"
-		  "  {crypto, \"~s\"},~n"
-		  "  {public_key, \"~s\"},~n"
-		  "  {ssl, \"~s\"}]}.~n",
-		  [case catch erlang:system_info(otp_release) of
-		       {'EXIT', _} -> "R11B";
-		       Rel -> Rel
-		   end,
-		   erlang:system_info(version),
-		   KRNL_VSN,
-		   STDL_VSN,
-		   VSN_CRYPTO,
-		   VSN_PKEY,
-		   SSL_VSN]),
-	ok = file:close(RelFile),
-	ok = systools:make_script(Script, []),
-	[{ssl_opts, "-boot " ++ Script} | Config]
-    catch
-	_:_ ->
-	    [{ssl_opts, "-pa " ++ filename:dirname(code:which(ssl))}
-	     | add_comment_config(
-		 "Bootscript wasn't used since the test wasn't run on an "
-		 "installed OTP system.",
-		 Config)]
-    end.
-
-%%
-%% Add common comments to config
-%%
-
-add_comment_config(Comment, []) ->
-    [{comment, Comment}];
-add_comment_config(Comment, [{comment, OldComment} | Cs]) ->
-    [{comment, Comment ++ " " ++ OldComment} | Cs];
-add_comment_config(Comment, [C|Cs]) ->
-    [C|add_comment_config(Comment, Cs)].
-
-%%
-%% Call when test case success
-%%
-
-success(Config) ->
-    case lists:keysearch(comment, 1, Config) of
-	{value, {comment, _} = Res} -> Res;
-	_ -> ok
-    end.
-
-vsn(App) ->
-    application:start(App),
-    try
-	{value,
-	 {ssl,
-	  _,
-	  VSN}} = lists:keysearch(App,
-				  1,
-				  application:which_applications()),
-	VSN
-     after
-	 application:stop(ssl)
-     end.
diff --git a/lib/ssl/test/old_ssl_misc_SUITE.erl b/lib/ssl/test/old_ssl_misc_SUITE.erl
deleted file mode 100644
index ea03e83867..0000000000
--- a/lib/ssl/test/old_ssl_misc_SUITE.erl
+++ /dev/null
@@ -1,117 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2003-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_ssl_misc_SUITE).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,
-	 end_per_testcase/2,
-	 seed/1,
-	 app/1
-	]).
-
--import(ssl_test_MACHINE, [mk_ssl_cert_opts/1, test_one_listener/7,
-			   test_server_only/6]).
--include_lib("test_server/include/test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
--define(MANYCONNS, 5).
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = ssl_test_lib:timetrap(?DEFAULT_TIMEOUT),
-    [{watchdog, WatchDog}| Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [seed, app].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(doc) ->
-    "Want to se what Config contains.";
-init_per_suite(suite) ->
-    [];
-init_per_suite(Config) ->
-    io:format("Config: ~p~n", [Config]),
-
-    %% Check if SSL exists. If this case fails, all other cases are skipped
-    case catch crypto:start() of
-	ok ->
-	    application:start(public_key),
-	    case ssl:start() of
-		ok -> ssl:stop();
-		{error, {already_started, _}} -> ssl:stop();
-		Error -> ?t:fail({failed_starting_ssl,Error})
-	    end,
-	    Config;
-	_Else ->
-	    {skip,"Could not start crypto!"}
-    end.
-
-end_per_suite(doc) ->
-    "This test case has no mission other than closing the conf case";
-end_per_suite(suite) ->
-    [];
-end_per_suite(Config) ->
-    crypto:stop(),
-    Config.
-
-seed(doc) ->
-    "Test that ssl:seed/1 works.";
-seed(suite) ->
-    [];
-seed(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {_, SsslOpts}} = mk_ssl_cert_opts(Config),
-
-    LCmds = [{seed, "tjosan"},
-	     {sockopts, [{backlog, NConns}, {active, once}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ?line test_server_only(NConns, LCmds, [], Timeout, ?MODULE,
-			   Config).
-
-app(doc) ->
-    "Test that the ssl app file is ok";
-app(suite) ->
-    [];
-app(Config) when list(Config) ->
-    ?line ok = test_server:app_test(ssl).
-
-
diff --git a/lib/ssl/test/old_ssl_passive_SUITE.erl b/lib/ssl/test/old_ssl_passive_SUITE.erl
deleted file mode 100644
index 7b54fe876a..0000000000
--- a/lib/ssl/test/old_ssl_passive_SUITE.erl
+++ /dev/null
@@ -1,382 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 1999-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_ssl_passive_SUITE).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, 
-	 end_per_suite/1, init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,
-	 end_per_testcase/2,
-	 server_accept_timeout/1,
-	 cinit_return_chkclose/1,
-	 sinit_return_chkclose/1,
-	 cinit_big_return_chkclose/1,
-	 sinit_big_return_chkclose/1,
-	 cinit_big_echo_chkclose/1,
-	 sinit_big_echo_chkclose/1,
-	 cinit_few_echo_chkclose/1,
-	 cinit_many_echo_chkclose/1,
-	 cinit_cnocert/1
-	 ]).
-
--import(ssl_test_MACHINE, [mk_ssl_cert_opts/1, test_one_listener/7,
-			   test_server_only/6]).
-
--include_lib("test_server/include/test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
--define(MANYCONNS, ssl_test_MACHINE:many_conns()).
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = ssl_test_lib:timetrap(?DEFAULT_TIMEOUT),
-    [{watchdog, WatchDog}| Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [server_accept_timeout, cinit_return_chkclose,
-     sinit_return_chkclose, cinit_big_return_chkclose,
-     sinit_big_return_chkclose, cinit_big_echo_chkclose,
-     sinit_big_echo_chkclose, cinit_few_echo_chkclose,
-     cinit_many_echo_chkclose, cinit_cnocert].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(doc) ->
-    "Want to se what Config contains.";
-init_per_suite(suite) ->
-    [];
-init_per_suite(Config) ->
-    io:format("Config: ~p~n", [Config]),
-
-    %% Check if SSL exists. If this case fails, all other cases are skipped
-    case catch crypto:start() of
-	ok ->
-	    application:start(public_key),
-	    case ssl:start() of
-		ok -> ssl:stop();
-		{error, {already_started, _}} -> ssl:stop();
-		Error -> ?t:fail({failed_starting_ssl,Error})
-	    end,
-	    Config;
-	_Else ->
-	    {skip,"Could not start crypto"}
-    end.
-
-end_per_suite(doc) ->
-    "This test case has no mission other than closing the conf case";
-end_per_suite(suite) ->
-    [];
-end_per_suite(Config) ->
-    crypto:stop(),
-    Config.
-
-server_accept_timeout(doc) ->
-    "Server has one pending accept with timeout. Checks that return "
-	"value is {error, timeout}.";
-server_accept_timeout(suite) ->
-    [];
-server_accept_timeout(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    LPort = 3456,
-    Timeout = 40000, NConns = 1,
-    AccTimeout = 3000,
-
-    ?line {ok, {_, SsslOpts}} = mk_ssl_cert_opts(Config),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, AccTimeout}, 
-	     accept_timeout],
-    ?line test_server_only(NConns, LCmds, ACmds, Timeout, ?MODULE, Config).
-
-cinit_return_chkclose(doc) ->
-    "Client sends 1000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-cinit_return_chkclose(suite) ->
-    [];
-cinit_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout},
-	     {sockopts, [{active, false}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-sinit_return_chkclose(doc) ->
-    "Server sends 1000 bytes to client, that receives them, sends them "
-	"back, and closes. Server waits for close. Both have certs.";
-sinit_return_chkclose(suite) ->
-    [];
-sinit_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, false}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_big_return_chkclose(doc) ->
-    "Client sends 50000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-cinit_big_return_chkclose(suite) ->
-    [];
-cinit_big_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, false}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-sinit_big_return_chkclose(doc) ->
-    "Server sends 50000 bytes to client, that receives them, sends them "
-	"back, and closes. Server waits for close. Both have certs.";
-sinit_big_return_chkclose(suite) ->
-    [];
-sinit_big_return_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, false}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_big_echo_chkclose(doc) ->
-    "Client sends 50000 bytes to server, that echoes them back "
-	"and closes. Client waits for close. Both have certs.";
-cinit_big_echo_chkclose(suite) ->
-    [];
-cinit_big_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, false}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-sinit_big_echo_chkclose(doc) ->
-    "Server sends 50000 bytes to client, that echoes them back "
-	"and closes. Server waits for close. Both have certs.";
-sinit_big_echo_chkclose(suite) ->
-    [];
-sinit_big_echo_chkclose(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 50000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, false}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {echo, DataSize},
-	     close],
-
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-
-cinit_few_echo_chkclose(X) -> cinit_many_echo_chkclose(X, 7).
-
-cinit_many_echo_chkclose(X) -> cinit_many_echo_chkclose(X, ?MANYCONNS).
-
-cinit_many_echo_chkclose(doc, _NConns) ->
-    "clients send 10000 bytes to server, that echoes them back "
-	"and closes. Clients wait for close. All have certs.";
-cinit_many_echo_chkclose(suite, _NConns) ->
-    [];
-cinit_many_echo_chkclose(Config, NConns) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 10000, LPort = 3456,
-    Timeout = 80000,
-
-    io:format("~w connections", [NConns]),
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {echo, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, false}]},
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
-cinit_cnocert(doc) ->
-    "Client sends 1000 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Client has no cert, "
-	"but server has.";
-cinit_cnocert(suite) ->
-    [];
-cinit_cnocert(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3457,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {_CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}, {active, false}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize}, {send, DataSize}, 
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sockopts, [{active, false}]},
-	     {connect, {Host, LPort}},
-	     {send, DataSize}, {recv, DataSize}, 
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, ?MODULE,
-			    Config).
-
diff --git a/lib/ssl/test/old_ssl_peer_cert_SUITE.erl b/lib/ssl/test/old_ssl_peer_cert_SUITE.erl
deleted file mode 100644
index ee19bad175..0000000000
--- a/lib/ssl/test/old_ssl_peer_cert_SUITE.erl
+++ /dev/null
@@ -1,191 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2003-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_ssl_peer_cert_SUITE).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,
-	 end_per_testcase/2,
-	 cinit_plain/1,
-	 cinit_both_verify/1,
-	 cinit_cnocert/1
-	 ]).
-
--import(ssl_test_MACHINE, [mk_ssl_cert_opts/1, test_one_listener/7,
-			   test_server_only/6]).
--include_lib("test_server/include/test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = ssl_test_lib:timetrap(?DEFAULT_TIMEOUT),
-    [{watchdog, WatchDog}| Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [cinit_plain, cinit_both_verify, cinit_cnocert].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(doc) ->
-    "Want to se what Config contains.";
-init_per_suite(suite) ->
-    [];
-init_per_suite(Config) ->
-    io:format("Config: ~p~n", [Config]),
-
-    %% Check if SSL exists. If this case fails, all other cases are skipped
-    case catch crypto:start() of
-	ok ->
-	    application:start(public_key),
-	    case ssl:start() of
-		ok -> ssl:stop();
-		{error, {already_started, _}} -> ssl:stop();
-		Error -> ?t:fail({failed_starting_ssl,Error})
-	    end,
-	    Config;
-	_Else ->
-	    {skip,"Could not start crypto"}
-    end.
-
-end_per_suite(doc) ->
-    "This test case has no mission other than closing the conf case";
-end_per_suite(suite) ->
-    [];
-end_per_suite(Config) ->
-    crypto:stop(),
-    Config.
-
-cinit_plain(doc) ->
-    "Server closes after accept, Client waits for close. Both have certs "
-	"but both use the defaults for verify and depth, but still tries "
-	"to retreive each others certificates.";
-cinit_plain(suite) ->
-    [];
-cinit_plain(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts, SsslOpts}} = mk_ssl_cert_opts(Config),
-
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     nopeercert,
-	     {recv, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     peercert,
-	     {send, DataSize},
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, 
-			    ?MODULE, Config).
-
-cinit_both_verify(doc) ->
-    "Server closes after accept, Client waits for close. Both have certs "
-	"and both verify each other.";
-cinit_both_verify(suite) ->
-    [];
-cinit_both_verify(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts0, SsslOpts0}} = mk_ssl_cert_opts(Config),
-    ?line CsslOpts = [{verify, 2}, {depth, 2} | CsslOpts0],
-    ?line SsslOpts = [{verify, 2}, {depth, 3} | SsslOpts0],
-
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     peercert,
-	     {recv, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     peercert,
-	     {send, DataSize},
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, 
-			    ?MODULE, Config).
-
-cinit_cnocert(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close.";
-cinit_cnocert(suite) ->
-    [];
-cinit_cnocert(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3457,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {_, SsslOpts0}} = mk_ssl_cert_opts(Config),
-    ?line SsslOpts = [{verify, 0}, {depth, 2} | SsslOpts0],
-
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {connect, {Host, LPort}},
-	     peercert,
-	     {send, DataSize},
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout,
-			    ?MODULE, Config).
-
-
diff --git a/lib/ssl/test/old_ssl_protocol_SUITE.erl b/lib/ssl/test/old_ssl_protocol_SUITE.erl
deleted file mode 100644
index 9b9937c210..0000000000
--- a/lib/ssl/test/old_ssl_protocol_SUITE.erl
+++ /dev/null
@@ -1,185 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2005-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_ssl_protocol_SUITE).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2, 
-	 init_per_testcase/2, end_per_testcase/2, 
-	 sslv2/1, sslv3/1, tlsv1/1, sslv2_sslv3/1,
-	 sslv2_tlsv1/1, sslv3_tlsv1/1, sslv2_sslv3_tlsv1/1]).
-
--import(ssl_test_MACHINE, [mk_ssl_cert_opts/1, test_one_listener/7,
-			   test_server_only/6]).
--include_lib("test_server/include/test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = test_server:timetrap(?DEFAULT_TIMEOUT),
-    [{watchdog, WatchDog}| Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [sslv2, sslv3, tlsv1, sslv2_sslv3, sslv2_tlsv1,
-     sslv3_tlsv1, sslv2_sslv3_tlsv1].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(doc) ->
-    "Want to se what Config contains.";
-init_per_suite(suite) ->
-    [];
-init_per_suite(Config) ->
-    io:format("Config: ~p~n", [Config]),
-
-    %% Check if SSL exists. If this case fails, all other cases are skipped
-    case catch crypto:start() of
-	ok ->
-	    application:start(public_key),
-	    case ssl:start() of
-		ok -> ssl:stop();
-		{error, {already_started, _}} -> ssl:stop();
-		Error -> ?t:fail({failed_starting_ssl,Error})
-	    end,
-	    Config;
-	_Else ->
-	    {skip,"Could not start crypto"}
-    end.
-
-end_per_suite(doc) ->
-    "This test case has no other purpose than closing the conf case.";
-end_per_suite(suite) ->
-    [];
-end_per_suite(Config) ->
-    crypto:stop(),
-    Config.
-
-%%%%%
-
-sslv2(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close. "
-	"Client and server choose SSLv2."; 
-sslv2(suite) ->
-    [];
-sslv2(Config) when list(Config) ->
-    do_run_test(Config, [sslv2]).
-
-sslv3(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close. "
-	"Client and server choose SSLv3."; 
-sslv3(suite) ->
-    [];
-sslv3(Config) when list(Config) ->
-    do_run_test(Config, [sslv3]).
-
-tlsv1(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close. "
-	"Client and server choose TLSv1."; 
-tlsv1(suite) ->
-    [];
-tlsv1(Config) when list(Config) ->
-    do_run_test(Config, [tlsv1]).
-
-sslv2_sslv3(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close. "
-	"Client and server choose between SSLv2 and SSLv3."; 
-sslv2_sslv3(suite) ->
-    [];
-sslv2_sslv3(Config) when list(Config) ->
-    do_run_test(Config, [sslv2, sslv3]).
-
-sslv2_tlsv1(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close. "
-	"Client and server choose between SSLv2 and TLSv1."; 
-sslv2_tlsv1(suite) ->
-    [];
-sslv2_tlsv1(Config) when list(Config) ->
-    do_run_test(Config, [sslv2, tlsv1]).
-
-sslv3_tlsv1(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close. "
-	"Client and server choose between SSLv3 and TLSv1."; 
-sslv3_tlsv1(suite) ->
-    [];
-sslv3_tlsv1(Config) when list(Config) ->
-    do_run_test(Config, [sslv3, tlsv1]).
-
-sslv2_sslv3_tlsv1(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close. "
-	"Client and server choose between SSLv2, SSLv3, and TLSv1."; 
-sslv2_sslv3_tlsv1(suite) ->
-    [];
-sslv2_sslv3_tlsv1(Config) when list(Config) ->
-    do_run_test(Config, [sslv2, sslv3, tlsv1]).
-
-%%%%
-
-do_run_test(Config0, Protocols) ->
-    process_flag(trap_exit, true),
-    LPort = 3456,
-    Timeout = 40000, NConns = 1,
-    DataSize = 10,
-
-    ?line {ok, {_, SsslOpts0}} = mk_ssl_cert_opts(Config0),
-    ?line SsslOpts = [{verify, 0}, {depth, 2} | SsslOpts0],
-
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     connection_info,
-	     {recv, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {connect, {Host, LPort}},
-	     connection_info,
-	     {send, DataSize},
-	     await_close],
-    Config1 = [{env, [{protocol_version, Protocols}]} | Config0],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout,
-			    ?MODULE, Config1).
-
-
diff --git a/lib/ssl/test/old_ssl_verify_SUITE.erl b/lib/ssl/test/old_ssl_verify_SUITE.erl
deleted file mode 100644
index 4c11ea6850..0000000000
--- a/lib/ssl/test/old_ssl_verify_SUITE.erl
+++ /dev/null
@@ -1,153 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 1999-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_ssl_verify_SUITE).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,
-	 end_per_testcase/2,
-	 cinit_both_verify/1,
-	 cinit_cnocert/1
-	 ]).
-
--import(ssl_test_MACHINE, [mk_ssl_cert_opts/1, test_one_listener/7,
-			   test_server_only/6]).
--include_lib("test_server/include/test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = ssl_test_lib:timetrap(?DEFAULT_TIMEOUT),
-    [{watchdog, WatchDog}| Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [cinit_both_verify, cinit_cnocert].
-
-groups() -> 
-    [].
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-init_per_suite(doc) ->
-    "Want to se what Config contains.";
-init_per_suite(suite) ->
-    [];
-init_per_suite(Config) ->
-    io:format("Config: ~p~n", [Config]),
-
-    %% Check if SSL exists. If this case fails, all other cases are skipped
-    case catch crypto:start() of
-	ok ->
-	    application:start(public_key),
-	    case ssl:start() of
-		ok -> ssl:stop();
-		{error, {already_started, _}} -> ssl:stop();
-		Error -> ?t:fail({failed_starting_ssl,Error})
-	    end,
-	    Config;
-	_Else ->
-	    {skip,"Could not start crypto"}
-    end.
-
-end_per_suite(doc) ->
-    "This test case has no mission other than closing the conf case";
-end_per_suite(suite) ->
-    [];
-end_per_suite(Config) ->
-    crypto:stop(),
-    Config.
-
-cinit_both_verify(doc) ->
-    "Server closes after accept, Client waits for close. Both have certs "
-	"and both verify each other.";
-cinit_both_verify(suite) ->
-    [];
-cinit_both_verify(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3456,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {CsslOpts0, SsslOpts0}} = mk_ssl_cert_opts(Config),
-    ?line CsslOpts = [{verify, 2}, {depth, 2} | CsslOpts0],
-    ?line SsslOpts = [{verify, 2}, {depth, 3} | SsslOpts0],
-
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {sslopts, CsslOpts},
-	     {connect, {Host, LPort}},
-	     {send, DataSize},
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, 
-			    ?MODULE, Config).
-
-cinit_cnocert(doc) ->
-    "Client has no cert. Nor the client, nor the server is verifying its "
-	"peer. Server closes, client waits for close.";
-cinit_cnocert(suite) ->
-    [];
-cinit_cnocert(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    DataSize = 1000, LPort = 3457,
-    Timeout = 40000, NConns = 1,
-
-    ?line {ok, {_, SsslOpts0}} = mk_ssl_cert_opts(Config),
-    ?line SsslOpts = [{verify, 0}, {depth, 2} | SsslOpts0],
-
-    ?line {ok, Host} = inet:gethostname(),
-
-    LCmds = [{sockopts, [{backlog, NConns}]},
-	     {sslopts, SsslOpts},
-	     {listen, LPort}, 
-	     wait_sync,
-	     lclose],
-    ACmds = [{timeout, Timeout}, 
-	     accept,
-	     {recv, DataSize},
-	     close],
-    CCmds = [{timeout, Timeout}, 
-	     {connect, {Host, LPort}},
-	     {send, DataSize},
-	     await_close],
-    ?line test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout,
-			    ?MODULE, Config).
-
-
diff --git a/lib/ssl/test/old_transport_accept_SUITE.erl b/lib/ssl/test/old_transport_accept_SUITE.erl
deleted file mode 100644
index 6f0c8e456b..0000000000
--- a/lib/ssl/test/old_transport_accept_SUITE.erl
+++ /dev/null
@@ -1,258 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2007-2011. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(old_transport_accept_SUITE).
--include_lib("common_test/include/ct.hrl").
--include("test_server_line.hrl").
-
-%% Default timetrap timeout (set in init_per_testcase).
--define(default_timeout, ?t:minutes(1)).
--define(application, ssh).
-
--export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2,
-	 init_per_testcase/2,
-	 end_per_testcase/2,
-	 config/1,
-	 echo_once/1,
-	 echo_twice/1,
-	 close_before_ssl_accept/1,
-	 server/5,
-	 tolerant_server/5,
-	 client/5
-	]).
-
-init_per_testcase(_Case, Config) ->
-    WatchDog = ssl_test_lib:timetrap(?default_timeout),
-    [{watchdog, WatchDog}, {protomod, gen_tcp}, {serialize_accept, true}| 
-     Config].
-
-end_per_testcase(_Case, Config) ->
-    WatchDog = ?config(watchdog, Config),
-    test_server:timetrap_cancel(WatchDog).
-
-suite() -> [{ct_hooks,[ts_install_cth]}].
-
-all() -> 
-    [config, echo_once, echo_twice, close_before_ssl_accept].
-
-groups() -> 
-    [].
-
-init_per_suite(Config) ->
-    try crypto:start() of
-	ok ->
-	    Config
-    catch _:_ ->
-	    {skip, "Crypto did not start"}
-    end.
-
-end_per_suite(_Config) ->
-    application:stop(crypto),
-    ok.
-
-init_per_group(_GroupName, Config) ->
-    Config.
-
-end_per_group(_GroupName, Config) ->
-    Config.
-
-
-config(doc) ->
-    "Want to se what Config contains.";
-config(suite) ->
-    [];
-config(Config) ->
-    io:format("Config: ~p~n", [Config]),
-    ok.
-
-echo_once(doc) ->
-    "Client sends 256 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-echo_once(suite) ->
-    [];
-echo_once(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    LPort = 3456,
-    {ok, Host} = inet:gethostname(),
-    {ok, {COpts, SOpts}} = ssl_test_MACHINE:mk_ssl_cert_opts(Config),
-    N = 1,
-    Msg = lists:seq(0, 255),
-    Self = self(),
-    Params = "-pa " ++ filename:dirname(code:which(?MODULE)),
-    Node = start_node(server, Params),
-    CNode = start_node(client, Params),
-    Server = spawn_link(Node, ?MODULE, server, [Self, LPort, SOpts, Msg, N]),
-    Client = spawn_link(Node, ?MODULE, client, [Host, LPort, COpts, Msg, N]),
-    ok = receive
-	     {Server, listening} ->
-		 Client ! {Server, listening},
-		 ok;
-	     E ->
-		 io:format("bad receive (1) ~p\n", [E]),
-		 E
-	 end,
-    receive
-	{Server, done} ->
-	    ok
-    end,
-    test_server:stop_node(Node),
-    test_server:stop_node(CNode).
-
-close_before_ssl_accept(doc) ->
-    "Client sends 256 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-close_before_ssl_accept(suite) ->
-    [];
-close_before_ssl_accept(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    LPort = 3456,
-    {ok, Host} = inet:gethostname(),
-    {ok, {COpts, SOpts}} = ssl_test_MACHINE:mk_ssl_cert_opts(Config),
-    Msg = lists:seq(0, 255),
-    Self = self(),
-    Params = "-pa " ++ filename:dirname(code:which(?MODULE)),
-    Node = start_node(server, Params),
-    CNode = start_node(client, Params),
-    Server = spawn_link(Node, ?MODULE, tolerant_server,
-			[Self, LPort, SOpts, Msg, 2]),
-    Client = spawn_link(Node, ?MODULE, client,
-			[Host, LPort, COpts, Msg, 1]),
-    ok = receive
-	     {Server, listening} ->
-		 {ok, S} = gen_tcp:connect(Host, LPort, []),
-		 gen_tcp:close(S),
-		 Client ! {Server, listening},
-		 ok;
-	     E ->
-		 io:format("bad receive (1) ~p\n", [E]),
-		 E
-	 end,
-    receive
-	{Server, done} ->
-	    ok
-    end,
-    test_server:stop_node(Node),
-    test_server:stop_node(CNode).
-
-client(Host, LPort, COpts, Msg, N) ->
-    ok = receive
-	     {_Server, listening} ->
-		 ok;
-	     E ->
-		 io:format("bad receive (2) ~p\n", [E]),
-		 E
-	 end,
-    Opts = COpts ++ [{packet, raw}, {active, false}],
-    app(),
-    lists:foreach(fun(_) ->
-			  {ok, S} = ssl:connect(Host, LPort, Opts),
-			  ssl:send(S, Msg),
-			  {ok, Msg} = ssl:recv(S, length(Msg)),
-			  ssl:close(S)
-		  end, lists:seq(1, N)).
-
-echo_twice(doc) ->
-    "Two clients sends 256 bytes to server, that receives them, sends them "
-	"back, and closes. Client waits for close. Both have certs.";
-echo_twice(suite) ->
-    [];
-echo_twice(Config) when list(Config) ->
-    process_flag(trap_exit, true),
-    LPort = 3456,
-    {ok, Host} = inet:gethostname(),
-    {ok, {COpts, SOpts}} = ssl_test_MACHINE:mk_ssl_cert_opts(Config),
-    N = 2,
-    Msg = lists:seq(0, 255),
-    Self = self(),
-    Params = "-pa " ++ filename:dirname(code:which(?MODULE)),
-    Node = start_node(server, Params),
-    CNode = start_node(client, Params),
-    Server = spawn_link(Node, ?MODULE, server,
-			[Self, LPort, SOpts, Msg, N]),
-    Client = spawn_link(Node, ?MODULE, client,
-			[Host, LPort, COpts, Msg, N]),
-    ok = receive
-	     {Server, listening} ->
-		 Client ! {Server, listening},
-		 ok;
-	     E ->
-		 io:format("bad receive (3) ~p\n", [E]),
-		 E
-	 end,
-    receive
-	{Server, done} ->
-	    ok
-    end,
-    test_server:stop_node(Node),
-    test_server:stop_node(CNode).
-
-server(Client, Port, SOpts, Msg, N) ->
-    app(),
-    process_flag(trap_exit, true),
-    Opts = SOpts ++ [{packet, raw}, {active, false}],
-    {ok, LSock} = ssl:listen(Port, Opts),
-    Client ! {self(), listening},
-    server_loop(Client, LSock, Msg, N).
-
-server_loop(Client, _, _, 0) ->
-    Client ! {self(), done};
-server_loop(Client, LSock, Msg, N) ->
-    {ok, S} = ssl:transport_accept(LSock),
-    ok = ssl:ssl_accept(S),
-    %% P = ssl:controlling_process(S, Proxy),
-    {ok, Msg} = ssl:recv(S, length(Msg)),
-    ok = ssl:send(S, Msg),
-    ok = ssl:close(S),
-    server_loop(Client, LSock, Msg, N-1).
-
-tolerant_server(Client, Port, SOpts, Msg, N) ->
-    app(),
-    process_flag(trap_exit, true),
-    Opts = SOpts ++ [{packet, raw}, {active, false}],
-    {ok, LSock} = ssl:listen(Port, Opts),
-    Client ! {self(), listening},
-    tolerant_server_loop(Client, LSock, Msg, N).
-
-tolerant_server_loop(Client, _, _, 0) ->
-    Client ! {self(), done};
-tolerant_server_loop(Client, LSock, Msg, N) ->
-    {ok, S} = ssl:transport_accept(LSock),
-    case ssl:ssl_accept(S) of
-	ok ->
-	    %% P = ssl:controlling_process(S, Proxy),
-	    {ok, Msg} = ssl:recv(S, length(Msg)),
-	    ok = ssl:send(S, Msg),
-	    ok = ssl:close(S);
-	E ->
-	    io:format("ssl_accept error: ~p\n", [E])
-    end,
-    tolerant_server_loop(Client, LSock, Msg, N-1).
-
-app() ->
-    crypto:start(),
-    application:start(public_key),
-    ssl:start().
-
-start_node(Kind, Params) ->
-    S = atom_to_list(?MODULE)++"_" ++ atom_to_list(Kind),
-    {ok, Node} = test_server:start_node(list_to_atom(S), slave, [{args, Params}]),
-    Node.
-
diff --git a/lib/ssl/test/ssl.cover b/lib/ssl/test/ssl.cover
index 60774cc0f1..6b13e07a37 100644
--- a/lib/ssl/test/ssl.cover
+++ b/lib/ssl/test/ssl.cover
@@ -1,21 +1,4 @@
 {incl_app,ssl,details}.
 
-{excl_mods, ssl, [ssl_pkix_oid,
-		  'PKIX1Algorithms88', 
-		  'PKIX1Explicit88',
-		  'PKIX1Implicit88',
-		  'PKIXAttributeCertificate',
-		  'SSL-PKIX',
-		  ssl_pem,
-		  ssl_pkix,
-		  ssl_base64,
-		  ssl_broker,
-		  ssl_broker_int,
-		  ssl_broker_sup,
-		  ssl_debug,
-		  ssl_server,		
-		  ssl_prim,
-		  inet_ssl_dist,
-		  'OTP-PKIX'	
-		]}.
+{excl_mods, ssl, [ssl_debug]}.
 
diff --git a/lib/ssl/test/ssl_basic_SUITE.erl b/lib/ssl/test/ssl_basic_SUITE.erl
index 8da1d947d3..d5cd3b3b4b 100644
--- a/lib/ssl/test/ssl_basic_SUITE.erl
+++ b/lib/ssl/test/ssl_basic_SUITE.erl
@@ -28,7 +28,6 @@
 -include_lib("public_key/include/public_key.hrl").
 
 -include("ssl_alert.hrl").
--include("ssl_int.hrl").
 -include("ssl_internal.hrl").
 -include("ssl_record.hrl").
 
@@ -207,7 +206,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}].
 all() -> 
     [app, alerts, connection_info, protocol_versions,
      empty_protocol_versions, controlling_process,
-     controller_dies, client_closes_socket, peercert,
+     controller_dies, client_closes_socket,
      connect_dist, peername, sockname, socket_options,
      invalid_inet_get_option, invalid_inet_get_option_not_list,
      invalid_inet_get_option_improper_list,
@@ -584,50 +583,6 @@ client_closes_socket(Config) when is_list(Config) ->
     ssl_test_lib:check_result(Server, {error,closed}).
 
 %%--------------------------------------------------------------------
-
-peercert(doc) -> 
-    [""];
-
-peercert(suite) -> 
-    [];
-
-peercert(Config) when is_list(Config) -> 
-    ClientOpts = ?config(client_opts, Config),
-    ServerOpts = ?config(server_opts, Config),
-    {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
-    
-    Server = ssl_test_lib:start_server([{node, ClientNode}, {port, 0}, 
-					{from, self()}, 
-			   {mfa, {?MODULE, peercert_result, []}},
-			   {options, ServerOpts}]),
-    Port = ssl_test_lib:inet_port(Server),
-    Client = ssl_test_lib:start_client([{node, ServerNode}, {port, Port}, 
-					{host, Hostname},
-			   {from, self()}, 
-			   {mfa, {?MODULE, peercert_result, []}},
-			   {options, ClientOpts}]),
-    
-    CertFile = proplists:get_value(certfile, ServerOpts),
-    [{'Certificate', BinCert, _}]= ssl_test_lib:pem_to_der(CertFile),
-    ErlCert = public_key:pkix_decode_cert(BinCert, otp),
-       
-    ServerMsg = {{error, no_peercert}, {error, no_peercert}},
-    ClientMsg = {{ok, BinCert}, {ok, ErlCert}},
-    
-    test_server:format("Testcase ~p, Client ~p  Server ~p ~n", 
-		       [self(), Client, Server]),
-    
-    ssl_test_lib:check_result(Server, ServerMsg, Client, ClientMsg),
-    
-    ssl_test_lib:close(Server),
-    ssl_test_lib:close(Client).
-
-peercert_result(Socket) ->
-    Result1 = ssl:peercert(Socket),
-    Result2 = ssl:peercert(Socket, [ssl]), 
-    {Result1, Result2}.
-
-%%--------------------------------------------------------------------
 connect_dist(doc) -> 
     ["Test a simple connect as is used by distribution"];
 
@@ -1528,7 +1483,6 @@ eoptions(Config) when is_list(Config) ->
 	    end,
 
     TestOpts = [{versions, [sslv2, sslv3]}, 
-		{ssl_imp, cool},
 		{verify, 4}, 
 		{verify_fun, function},
 		{fail_if_no_peer_cert, 0}, 
diff --git a/lib/ssl/test/ssl_test_MACHINE.erl b/lib/ssl/test/ssl_test_MACHINE.erl
deleted file mode 100644
index e0ffa15d80..0000000000
--- a/lib/ssl/test/ssl_test_MACHINE.erl
+++ /dev/null
@@ -1,940 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2003-2010. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
-%%
--module(ssl_test_MACHINE).
-
--export([many_conns/0, mk_ssl_cert_opts/1, test_one_listener/7, 
-	 test_server_only/6]).
-
--export([process_init/3, do_start/1]).
-
-
--include("test_server.hrl").
--include("ssl_test_MACHINE.hrl").
-
--define(WAIT_TIMEOUT, 10000).
--define(CLOSE_WAIT, 1000).
-
-%%
-%% many_conns() -> ManyConnections
-%%
-%% Choose a suitable number of "many connections" depending on platform
-%% and current limit for file descriptors.
-%%
-many_conns() ->
-    case os:type() of
-	{unix,_} -> many_conns_1();
-	_ -> 10
-    end.
-
-many_conns_1() ->
-    N0 = os:cmd("ulimit -n"),
-    N1 = lists:reverse(N0),
-    N2 = lists:dropwhile(fun($\r) -> true;
-			    ($\n) -> true;
-			    (_) -> false
-			 end, N1),
-    N = list_to_integer(lists:reverse(N2)),
-    lists:min([(N - 10) div 2, 501]).
-	
-%%
-%% mk_ssl_cert_opts(Config) -> {ok, {COpts, SOpts}}
-%%
-%% 
-mk_ssl_cert_opts(_Config) ->
-    Dir = filename:join([code:lib_dir(ssl), "examples", "certs", "etc"]),
-    COpts = [{ssl_imp, old},
-	     {cacertfile, filename:join([Dir, "client", "cacerts.pem"])}, 
-	     {certfile, filename:join([Dir, "client", "cert.pem"])}, 
-	     {keyfile, filename:join([Dir, "client", "key.pem"])}], 
-    SOpts = [{ssl_imp, old},
-	     {cacertfile, filename:join([Dir, "server", "cacerts.pem"])}, 
-	     {certfile, filename:join([Dir, "server", "cert.pem"])}, 
-	     {keyfile, filename:join([Dir, "server", "key.pem"])}], 
-    {ok, {COpts, SOpts}}.
-
-%%
-%% Cmds:
-%%		{protomod, gen_tcp | ssl}             		default = ssl
-%%		{serialize_accept, true | false}  	default = false
-%%		{timeout, Timeout}
-%%		{sockopts, Opts}
-%%		{sslopts, Opts}
-%%		{protocols, Protocols}  [sslv2|sslv3|tlsv1]
-%%		{listen, Port}
-%%		{lsock, LSock}		listen socket for acceptor
-%%		peercert
-%%		accept
-%%		{connect, {Host, Port}}
-%%		{recv, N}
-%%		{send, N}
-%%		{echo, N}		async echo back
-%%		close			close connection socket
-%%		{close, Time}		wait time and then close socket
-%%		lclose			close listen socket
-%%		await_close		wait for close
-%%		wait_sync		listener's wait for sync from parent
-%%		connection_info		
-%%		{exit, Reason}		exit
-%%
-%%
-%% We cannot have more than `backlog' acceptors at the same time.
-%%
-
-
-%%
-%% test_one_listener(NConns, LCmds, ACmds, CCmds, Timeout, Suite, Config)
-%%
-%% Creates one client and one server node, and runs one listener on
-%% the server node (according to LCmds), and creates NConns acceptors
-%% on the server node, and the same number of connectors on the client
-%% node. The acceptors and and connectors execute according to ACmds
-%% and CCmds, respectively.
-%%
-%% It is a good idea to have the backlog size in LCmds set to
-%% be at least as large as NConns.
-%%
-test_one_listener(NConns, LCmds0, ACmds0, CCmds0, Timeout, Suite, Config) ->
-    ProtoMod = get_protomod(Config), 
-    SerializeAccept = get_serialize_accept(Config), 
-    ?line {ok, {CNode, SNode}} = start_client_server_nodes(Suite),
-    case ProtoMod of
-	ssl -> 
-	    ?line ok = start_ssl([CNode, SNode], Config);
-	gen_tcp ->
-	    ok
-    end, 
-    LCmds = [{protomod, ProtoMod}| LCmds0], 
-    ACmds = [{protomod, ProtoMod}, {serialize_accept, SerializeAccept}| 
-	     ACmds0], 
-    CCmds = [{protomod, ProtoMod}| CCmds0], 
-
-    ?line {ok, Listener} = start_process(SNode, self(), LCmds, listener),
-    ?line {ok, LSock} = wait_lsock(Listener, ?WAIT_TIMEOUT),
-    ?line {ok, Accs0} = start_processes(NConns, SNode, self(), 
-				       [{lsock, LSock}| ACmds], acceptor),
-    Accs = case ProtoMod of 
-	       gen_tcp ->
-		   [Acc1| Accs1] = Accs0,
-		   Acc1 ! {continue_accept, self()},
-		   Accs1;
-	       ssl  ->
-		   Accs0
-	   end,
-    ?line {ok, Conns} = start_processes(NConns, CNode, self(), 
-					CCmds, connector),
-    ?line case wait_ack(Accs, Accs0 ++ Conns, Timeout) of
-	      ok ->
-		  ?line sync([Listener]),
-		  ?line wait_ack([], [Listener], ?WAIT_TIMEOUT);
-	      {error, Reason} ->
-		  ?line stop_node(SNode),
-		  ?line stop_node(CNode),
-		  exit(Reason)
-	  end,
-    ?line stop_node(SNode),
-    ?line stop_node(CNode),
-    ok.
-
-%%
-%% test_server_only(NConns, LCmds, ACmds, Timeout, Suite, Config)
-%%
-%% Creates only one server node, and runs one listener on
-%% the server node (according to LCmds), and creates NConns acceptors
-%% on the server node. The acceptors execute according to ACmds.
-%% There are no connectors.
-%%
-test_server_only(NConns, LCmds0, ACmds0, Timeout, Suite, Config) ->
-    ProtoMod = get_protomod(Config), 
-    ?line {ok, SNode} = start_server_node(Suite),
-    case ProtoMod of
-	ssl -> 
-	    ?line ok = start_ssl([SNode], Config);
-	gen_tcp ->
-	    ok
-    end, 
-    LCmds = [{protomod, ProtoMod}| LCmds0], 
-    ACmds = [{protomod, ProtoMod}| ACmds0], 
-    ?line {ok, Listener} = start_process(SNode, self(), LCmds, listener),
-    ?line {ok, LSock} = wait_lsock(Listener, ?WAIT_TIMEOUT),
-    ?line {ok, Accs0} = start_processes(NConns, SNode, self(), 
-				       [{lsock, LSock}| ACmds], acceptor),
-    Accs = case ProtoMod of 
-	       gen_tcp ->
-		   [Acc1| Accs1] = Accs0,
-		   Acc1 ! {continue_accept, self()},
-		   Accs1;
-	       ssl  ->
-		   Accs0
-	   end,
-    ?line case wait_ack(Accs, Accs0, Timeout) of
-	      ok ->
-		  ?line sync([Listener]),
-		  ?line wait_ack([], [Listener], ?WAIT_TIMEOUT);
-	      {error, Reason} ->
-		  ?line stop_node(SNode),
-		  exit(Reason)
-	  end,
-    ?line stop_node(SNode),
-    ok.
-
-%%
-%% start_client_server_nodes(Suite) -> {ok, {CNode, SNode}}
-%%
-start_client_server_nodes(Suite) ->
-    {ok, CNode} = start_client_node(Suite),
-    {ok, SNode} = start_server_node(Suite),
-    {ok, {CNode, SNode}}.
-
-start_client_node(Suite) ->
-    start_node(lists:concat([Suite, "_client"])).
-
-start_server_node(Suite) ->
-    start_node(lists:concat([Suite, "_server"])).
-
-%%
-%% start_ssl(Nodes, Config)
-%%
-start_ssl(Nodes, Config) -> 
-    Env0 = lists:flatten([Env00 || {env, Env00} <- Config]),
-    Env1 = case os:getenv("SSL_DEBUG") of
-	       false ->
-		   [];
-	       _ ->
-		   Dir = ?config(priv_dir, Config),
-		   [{debug, true}, {debugdir, Dir}]
-	   end,
-    Env = Env0 ++ Env1,
-    lists:foreach(
-      fun(Node) -> rpc:call(Node, ?MODULE, do_start, [Env]) end, Nodes),
-    ok.
-
-do_start(Env) ->
-    application:start(crypto),
-    application:start(public_key),
-    application:load(ssl),
-    lists:foreach(
-      fun({Par, Val}) -> application:set_env(ssl, Par, Val) end, Env),
-    application:start(ssl).
-
-    
-%%
-%% start_node(Name) -> {ok, Node}
-%% start_node(Name, ExtraParams) -> {ok, Node}
-%%
-start_node(Name) ->
-    start_node(Name, []).
-start_node(Name, ExtraParams) ->
-    Params = "-pa " ++ filename:dirname(code:which(?MODULE)) ++ " " ++
-	ExtraParams,
-    test_server:start_node(Name, slave, [{args, Params}]).
-
-stop_node(Node) ->
-    test_server:stop_node(Node).
-
-%%
-%% start_processes(N, Node, Parent, Cmds, Type) -> {ok, Pids}
-%%
-start_processes(M, Node, Parent, Cmds, Type) ->
-    start_processes1(0, M, Node, Parent, Cmds, Type, []).
-start_processes1(M, M, _, _, _, _, Pids) ->
-    {ok, lists:reverse(Pids)};
-start_processes1(N, M, Node, Parent, Cmds, Type, Pids) ->
-    {ok, Pid} = start_process(Node, Parent, Cmds, {Type, N + 1}),
-    start_processes1(N + 1, M, Node, Parent, Cmds, Type, [Pid| Pids]).
-
-%%
-%% start_process(Node, Parent, Cmds, Type) -> {ok, Pid}
-%%
-start_process(Node, Parent, Cmds0, Type) ->
-    Cmds = case os:type() of 
-	       {win32, _} ->
-		   lists:map(fun(close) -> {close, ?CLOSE_WAIT};
-				(Term) -> Term end, Cmds0);
-	       _ ->
-		   Cmds0
-	   end,
-    Pid = spawn_link(Node, ?MODULE, process_init, [Parent, Cmds, Type]),
-    {ok, Pid}.
-
-process_init(Parent, Cmds, Type) ->
-    ?debug("#### ~w start~n", [{Type, self()}]),
-    pre_main_loop(Cmds, #st{parent = Parent, type = Type}).
-
-%%
-%% pre_main_loop
-%%
-pre_main_loop([], St) ->
-    ?debug("#### ~w end~n", [{St#st.type, self()}]),
-    main_loop([], St);
-pre_main_loop(Cmds, St) ->
-    ?debug("#### ~w -> ~w~n", 
-	   [{St#st.type, self(), St#st.sock, St#st.port, 
-	     St#st.peer, St#st.active}, hd(Cmds)]),
-    main_loop(Cmds, St).
-    
-%%
-%% main_loop(Cmds, St)
-%%
-main_loop([{protomod, ProtoMod}| Cmds], St) ->
-    pre_main_loop(Cmds, St#st{protomod = ProtoMod});
-
-main_loop([{serialize_accept, Bool}| Cmds], St) ->
-    pre_main_loop(Cmds, St#st{serialize_accept = Bool});
-
-main_loop([{sockopts, Opts}| Cmds], St) ->
-    pre_main_loop(Cmds, St#st{sockopts = Opts});
-
-main_loop([{sslopts, Opts}| Cmds], St) ->
-    pre_main_loop(Cmds, St#st{sslopts = Opts});
-
-main_loop([{protocols, Protocols}| Cmds], St) ->
-    pre_main_loop(Cmds, St#st{protocols = Protocols});
-
-main_loop([{timeout, T}| Cmds], St) ->
-    pre_main_loop(Cmds, St#st{timeout = T});
-
-main_loop([{lsock, LSock}| Cmds], St) ->
-    pre_main_loop(Cmds, St#st{lsock = LSock});
-
-main_loop([{seed, Data}| Cmds], St) ->
-    case ssl:seed("tjosan") of
-	ok ->
-	    pre_main_loop(Cmds, St);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in seed: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([{listen, Port}| Cmds], St) ->
-    case listen(St, Port) of    
-	{ok, LSock} ->
-	    ack_lsock(St#st.parent, LSock),
-	    NSt = get_active(St#st{port = Port, sock = LSock, lsock = LSock}),
-	    pre_main_loop(Cmds, St);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in listen: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([accept| Cmds], St) ->
-    case St#st.serialize_accept of
-	true ->
-	    Parent = St#st.parent, 
-	    receive 
-		{continue_accept, Parent} ->
-		    ok
-	    end;
-	false ->
-	    ok
-    end,
-    case accept(St) of
-	{ok, Sock, Port, Peer} ->
-	    case St#st.serialize_accept of
-		true ->
-		    St#st.parent ! {one_accept_done, self()};
-		false ->
-		    ok
-	    end,
-	    NSt = get_active(St#st{sock = Sock, port = Port, peer = Peer}),
-	    pre_main_loop(Cmds, NSt);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in accept: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-	
-main_loop([accept_timeout| Cmds], St) ->
-    case accept(St) of
-	{error, timeout} ->
-	    pre_main_loop(Cmds, St);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in accept_timeout: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-	
-
-main_loop([{connect, {Host, Port}}| Cmds], St) ->
-    case connect(St, Host, Port) of
-	{ok, Sock, LPort, Peer} ->
-	    NSt = get_active(St#st{sock = Sock, port = LPort, peer = Peer}),
-	    pre_main_loop(Cmds, NSt);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in connect: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([connection_info| Cmds], St) ->
-    case connection_info(St) of
-	{ok, ProtoInfo} ->
-	    io:fwrite("Got connection_info:~n~p~n", [ProtoInfo]),
-	    pre_main_loop(Cmds, St);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in connection_info: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([peercert| Cmds], St) ->
-    case peercert(St) of
-	{ok, Cert} ->
-	    io:fwrite("Got cert:~n~p~n", [Cert]),
-	    pre_main_loop(Cmds, St);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in peercert: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([nopeercert| Cmds], St) ->
-    case peercert(St) of
-	{error, Reason} ->
-	    io:fwrite("Got no cert as expected. reason:~n~p~n", [Reason]),
-	    pre_main_loop(Cmds, St);
-	{ok, Cert} ->
-	    ?error("#### ~w(~w) in peercert: error: got cert: ~p~n", 
-		   [St#st.type, self(), Cert]),
-	    exit(peercert)
-    end;
-
-main_loop([{recv, N}| Cmds], St) ->
-    recv_loop([{recv, N}| Cmds], fun recv/1, St); % Returns to main_loop/2.
-
-main_loop([{send, N}| Cmds], St) ->
-    Msg = mk_msg(N),
-    case send(St, Msg) of 
-	ok ->
-	    pre_main_loop(Cmds, St);
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in send: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([{echo, N}| Cmds], St) ->
-    recv_loop([{echo, N}| Cmds], fun echo/1, St); % Returns to main_loop/2.
-
-main_loop([{close, WaitTime}| Cmds], St) ->
-    wait(WaitTime),
-    pre_main_loop([close| Cmds], St);
-
-main_loop([close| Cmds], St) ->
-    case close(St) of
-	ok ->
-	    pre_main_loop(Cmds, St#st{sock = nil});
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in close: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([lclose| Cmds], St) ->
-    case lclose(St) of
-	ok ->
-	    pre_main_loop(Cmds, St#st{lsock = nil});
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in lclose: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([await_close| Cmds], St) ->
-    case await_close(St) of
-	ok ->
-	    pre_main_loop(Cmds, St#st{sock = nil});
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in await_close: error: ~w~n", 
-		   [St#st.type, self(), Reason]),
-	    exit(Reason)
-    end;
-
-main_loop([wait_sync| Cmds], St) ->
-    wait_sync(St),
-    pre_main_loop(Cmds, St);
-
-main_loop({exit, Reason}, _St) ->
-    exit(Reason);
-
-main_loop([], _St) ->
-    ok.
-
-%%
-%% recv_loop(Cmds, F, St)
-%%
-%% F = recv/1 | echo/1
-%%
-recv_loop([{_Tag, 0}| Cmds], _, St) ->
-    pre_main_loop(Cmds, St);
-recv_loop([{_Tag, N}| _Cmds], _, St) when N < 0 ->
-    ?error("#### ~w(~w) in recv_loop: error: too much: ~w~n", 
-	   [St#st.type, self(), N]),
-    exit(toomuch);                               % XXX or {error, Reason}?
-recv_loop([{Tag, N}| Cmds], F, St) ->
-    case F(St) of
-	{ok, Len} ->
-	    NSt = St#st{active = new_active(St#st.active)},
-	    if
-		Len == N ->
-		    pre_main_loop(Cmds, NSt);
-		true ->
-		    ?debug("#### ~w -> ~w~n", 
-			   [{NSt#st.type, self(), NSt#st.sock, NSt#st.port, 
-			     NSt#st.peer, NSt#st.active}, {Tag, N - Len}]),
-		    recv_loop([{Tag, N - Len}| Cmds], F, NSt)
-	    end;
-	{error, Reason} ->
-	    ?error("#### ~w(~w) in recv_loop: error: ~w, ~w bytes remain~n", 
-		   [St#st.type, self(), Reason, N]),
-	    exit(Reason)
-    end.
-
-new_active(once) ->
-    false;
-new_active(A) ->
-    A.
-
-get_active(St) ->
-    A = case proplists:get_value(active, St#st.sockopts, undefined) of
-	    undefined ->
-		Mod = case St#st.protomod of
-			  ssl ->
-			      ssl;
-			  gen_tcp ->
-			      inet
-		      end, 
-		{ok, [{active, Ax}]} = Mod:getopts(St#st.sock, [active]),
-		Ax;
-	    Ay ->
-		Ay
-	end,
-    ?debug("#### ~w(~w) get_active: ~p\n", [St#st.type, self(), A]),
-    St#st{active = A}.
-
-
-%%
-%% SOCKET FUNCTIONS
-%%
-
-%%
-%% ssl
-%%
-
-%%
-%% listen(St, LPort) -> {ok, LSock} | {error, Reason}
-%%
-listen(St, LPort) ->
-    case St#st.protomod of
-	ssl ->
-	    ssl:listen(LPort, [{ssl_imp, old} | St#st.sockopts ++ St#st.sslopts]);
-	gen_tcp ->
-	    gen_tcp:listen(LPort, St#st.sockopts)
-    end.
-
-%%
-%% accept(St) -> {ok, Sock} | {error, Reason}
-%%
-accept(St) ->
-    case St#st.protomod of
-	ssl ->
-	    case ssl:transport_accept(St#st.lsock, St#st.timeout) of
-		{ok, Sock} ->
-		    case ssl:ssl_accept(Sock, St#st.timeout) of			
-			ok ->
-			    {ok, Port} = ssl:sockname(Sock),
-			    {ok, Peer} = ssl:peername(Sock),
-			    {ok, Sock, Port, Peer};
-			Other  ->
-			    Other
-		    end;
-		Other  ->
-		    Other
-	    end;
-	gen_tcp ->
-	    case gen_tcp:accept(St#st.lsock, St#st.timeout) of
-		{ok, Sock} ->
-		    {ok, Port} = inet:port(Sock),
-		    {ok, Peer} = inet:peername(Sock),
-		    {ok, Sock, Port, Peer};
-		Other  ->
-		    Other
-	    end
-    end.
-
-%%
-%% connect(St, Host, Port) -> {ok, Sock} | {error, Reason}
-%%
-connect(St, Host, Port) ->
-    
-    case St#st.protomod of
-	ssl ->
-	    case ssl:connect(Host, Port, 
-			     [{ssl_imp, old} | St#st.sockopts ++ St#st.sslopts], 
-			     St#st.timeout) of
-		{ok, Sock} ->
-		    {ok, LPort} = ssl:sockname(Sock),
-		    {ok, Peer} = ssl:peername(Sock),
-		    {ok, Sock, LPort, Peer};
-		Other  ->
-		    Other
-	    end;
-	gen_tcp ->
-	    case gen_tcp:connect(Host, Port, St#st.sockopts, St#st.timeout) of
-		{ok, Sock} ->
-		    {ok, LPort} = inet:port(Sock),
-		    {ok, Peer} = inet:peername(Sock),
-		    {ok, Sock, LPort, Peer};
-		Other  ->
-		    Other
-	    end
-    end.
-
-%%
-%% peercert(St) -> {ok, Cert} | {error, Reason}
-%%
-peercert(St) ->
-    case St#st.protomod of
-	ssl ->
-	    ssl:peercert(St#st.sock, [ssl]);
-	gen_tcp  ->
-	    {ok, <<>>}
-    end.
-
-%%
-%% connection_info(St) -> {ok, ProtoInfo} | {error, Reason}
-%%
-connection_info(St) ->
-    case St#st.protomod of
-	ssl ->
-	    case ssl:connection_info(St#st.sock) of
-		Res = {ok, {Proto, _}} ->
-		    case St#st.protocols of
-			[] ->
-			    Res;
-			Protocols ->
-			    case lists:member(Proto, Protocols) of
-				true ->
-				    Res;
-				false ->
-				    {error, Proto}
-			    end
-		    end;
-		Error ->
-		    Error
-	    end;
-	gen_tcp  ->
-	    {ok, <<>>}
-    end.
-
-%%
-%% close(St) -> ok | {error, Reason}
-%%
-
-close(St) ->
-    Mod = St#st.protomod,
-    case St#st.sock of
-	nil ->
-	    ok;
-	_ ->
-	    Mod:close(St#st.sock)
-    end.
-
-%%
-%% lclose(St) -> ok | {error, Reason}
-%%
-lclose(St) ->
-    Mod = St#st.protomod,
-    case St#st.lsock of
-	nil ->
-	    ok;
-	_ ->
-	    Mod:close(St#st.lsock)
-    end.
-
-%%
-%% recv(St) = {ok, Len} | {error, Reason}
-%%
-recv(St) ->
-    case do_recv(St) of
-	{ok, Msg} ->
-	    {ok, length(Msg)};
-	{error, Reason} ->
-	    {error, Reason}
-    end.
-
-do_recv(St) when St#st.active == false ->
-    %% First check that we do *not* have any ssl/gen_tcp messages in the
-    %% message queue, then call the receive function.
-    Sock = St#st.sock,
-    case St#st.protomod of
-	ssl ->
-	    receive 
-		M = {ssl, Sock, _Msg} ->
-		    {error, {unexpected_messagex, M}};
-		M = {ssl_closed, Sock} ->
-		    {error, {unexpected_message, M}};
-		M = {ssl_error, Sock, _Reason} ->
-		    {error, {unexpected_message, M}}
-	    after 0 ->
-		    ssl:recv(St#st.sock, 0, St#st.timeout)
-	    end;
-	gen_tcp  ->
-	    receive 
-		M = {tcp, Sock, _Msg} ->
-		    {error, {unexpected_message, M}};
-		M = {tcp_closed, Sock} ->
-		    {error, {unexpected_message, M}};
-		M = {tcp_error, Sock, _Reason} ->
-		    {error, {unexpected_message, M}}
-	    after 0 ->
-		    gen_tcp:recv(St#st.sock, 0, St#st.timeout)
-	    end
-    end;
-do_recv(St) ->
-    Sock = St#st.sock,
-    Timeout = St#st.timeout,
-    case St#st.protomod of
-	ssl ->
-	    receive 
-		{ssl, Sock, Msg} ->
-		    {ok, Msg};
-		{ssl_closed, Sock} ->
-		    {error, closed};
-		{ssl_error, Sock, Reason} ->
-		    {error, Reason}
-	    after Timeout ->
-		    {error, timeout}
-	    end;
-	gen_tcp  ->
-	    receive 
-		{tcp, Sock, Msg} ->
-		    {ok, Msg};
-		{tcp_closed, Sock} ->
-		    {error, closed};
-		{tcp_error, Sock, Reason} ->
-		    {error, Reason}
-	    after Timeout ->
-		    {error, timeout}
-	    end
-    end.
-
-%%
-%% echo(St) = {ok, Len} | {error, Reason}
-%%
-echo(St) ->
-    Sock = St#st.sock,
-    case do_recv(St) of
-	{ok, Msg} ->
-	    Mod = St#st.protomod, 
-	    case Mod:send(Sock, Msg) of
-		ok ->
-		    {ok, length(Msg)};
-		{error, Reason} ->
-		    {error, Reason}
-	    end;
-	{error, Reason} ->
-	    {error, Reason}
-    end.
-
-%%
-%% send(St, Msg) -> ok | {error, Reason}
-%%
-send(St, Msg) ->
-    Mod = St#st.protomod,
-    Mod:send(St#st.sock, Msg).
-
-%%
-%% await_close(St) -> ok | {error, Reason}
-%%
-await_close(St) when St#st.active == false ->
-    %% First check that we do *not* have any ssl/gen_tcp messages in the
-    %% message queue, then call the receive function.
-    Sock = St#st.sock,
-    Res = case St#st.protomod of
-	      ssl ->
-		  receive 
-		      M = {ssl, Sock, _Msg0} ->
-			  {error, {unexpected_message, M}};
-		      M = {ssl_closed, Sock} ->
-			  {error, {unexpected_message, M}};
-		      M = {ssl_error, Sock, _Reason} ->
-			  {error, {unexpected_message, M}}
-		  after 0 ->
-			  ok
-		  end;
-	      gen_tcp  ->
-		  receive 
-		      M = {tcp, Sock, _Msg0} ->
-			  {error, {unexpected_message, M}};
-		      M = {tcp_closed, Sock} ->
-			  {error, {unexpected_message, M}};
-		      M = {tcp_error, Sock, _Reason} ->
-			  {error, {unexpected_message, M}}
-		  after 0 ->
-			  ok
-		  end
-	  end,
-    case Res of
-	ok ->
-	    Mod = St#st.protomod, 
-	    case Mod:recv(St#st.sock, 0, St#st.timeout) of
-		{ok, _Msg} ->
-		    {error, toomuch};
-		{error, _} ->
-		    ok
-	    end;
-	_  ->
-	    Res
-    end;
-await_close(St) ->
-    Sock = St#st.sock,
-    Timeout = St#st.timeout,
-    case St#st.protomod of 
-	ssl ->
-	    receive 
-		{ssl, Sock, _Msg} ->
-		    {error, toomuch};
-		{ssl_closed, Sock} ->
-		    ok;
-		{ssl_error, Sock, Reason} ->
-		    {error, Reason}
-	    after Timeout ->
-		    {error, timeout}
-	    end;
-	gen_tcp  ->
-	    receive 
-		{tcp, Sock, _Msg} ->
-		    {error, toomuch};
-		{tcp_closed, Sock} ->
-		    ok;
-		{tcp_error, Sock, Reason} ->
-		    {error, Reason}
-	    after Timeout ->
-		    {error, timeout}
-	    end
-    end.
-
-
-%%
-%% HELP FUNCTIONS
-%%
-
-wait_ack(_, [], _) ->
-    ok;
-wait_ack(AccPids0, Pids, Timeout) ->
-    ?debug("#### CONTROLLER: waiting for ~w~n", [Pids]),
-    receive
-	{one_accept_done, Pid} ->
-	    case lists:delete(Pid, AccPids0) of
-		[] ->
-		    wait_ack([], Pids, Timeout);
-		[AccPid| AccPids1] ->
-		    AccPid ! {continue_accept, self()},
-		    wait_ack(AccPids1, Pids, Timeout)
-	    end;
-	{'EXIT', Pid, normal} ->
-	    wait_ack(AccPids0, lists:delete(Pid, Pids), Timeout);
-	{'EXIT', Pid, Reason} ->
-	    ?error("#### CONTROLLER got abnormal exit: ~w, ~w~n", 
-		   [Pid, Reason]),
-	    {error, Reason}
-    after Timeout ->
-	    ?error("#### CONTROLLER exiting because of timeout = ~w~n", 
-		   [Timeout]),
-	    {error, Timeout}
-    end.
-
-
-%%
-%% ack_lsock(Pid, LSock)
-%%
-ack_lsock(Pid, LSock) ->
-    Pid ! {lsock, self(), LSock}.
-
-wait_lsock(Pid, Timeout) ->
-    receive
-	{lsock, Pid, LSock} ->
-	    {ok, LSock}
-    after Timeout ->
-	    exit(timeout)
-    end.
-
-%%
-%% sync(Pids)
-%%
-sync(Pids) ->
-    lists:foreach(fun (Pid) -> Pid ! {self(), sync} end, Pids).
-
-%%
-%% wait_sync(St)
-%%
-wait_sync(St) ->
-    Pid = St#st.parent, 
-    receive
-	{Pid, sync} ->
-	    ok
-    end.
-
-%% 
-%% wait(Time)
-%%
-wait(Time) ->
-    receive
-    after Time ->
-	    ok
-    end.
-
-%%
-%% mk_msg(Size)
-%%
-mk_msg(Size) ->
-    mk_msg(0, Size, []).
-
-mk_msg(_, 0, Acc) ->
-    Acc;
-mk_msg(Pos, Size, Acc) ->
-    C = (((Pos + Size) rem 256) - 1) band 255,
-    mk_msg(Pos, Size - 1, [C| Acc]).
-
-%%
-%% get_protomod(Config)
-%%
-get_protomod(Config) ->
-    case lists:keysearch(protomod, 1, Config) of
-	{value, {_, ProtoMod}} ->
-	    ProtoMod;
-	false  ->
-	    ssl
-    end.
-
-%%
-%% get_serialize_accept(Config)
-%%
-get_serialize_accept(Config) ->
-    case lists:keysearch(serialize_accept, 1, Config) of
-	{value, {_, Val}} ->
-	    Val;
-	false  ->
-	    false
-    end.
-
diff --git a/lib/ssl/test/ssl_test_MACHINE.hrl b/lib/ssl/test/ssl_test_MACHINE.hrl
deleted file mode 100644
index e78b33f505..0000000000
--- a/lib/ssl/test/ssl_test_MACHINE.hrl
+++ /dev/null
@@ -1,39 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2003-2010. All Rights Reserved.
-%%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% %CopyrightEnd%
-%%
-
--record(st, {protomod = ssl, 
-	     serialize_accept = false,
-	     parent = nil,
-	     type = nil,
-	     active = nil,
-	     port = 0,
-	     peer = nil,
-	     lsock = nil,
-	     sock = nil,
-	     timeout = infinity,
-	     sockopts = [],
-	     sslopts = [],
-	     protocols = []}).
-
-%%-define(debug(X, Y), io:format(X, Y)).
--define(debug(X, Y), ok).
--define(error(X, Y), io:format(X, Y)).
-
--define(DEFAULT_TIMEOUT, 240000).
-