Merge branch 'ia/ssl/error-msg'

* ia/ssl/error-msg:
  ssl: Further error handling enhancments

8 files changed, 154 insertions, 140 deletions

diff --git a/lib/ssl/src/ssl.erl b/lib/ssl/src/ssl.erl
index 647daeb1ac..0ba59cede2 100644
--- a/lib/ssl/src/ssl.erl
+++ b/lib/ssl/src/ssl.erl
@@ -162,7 +162,7 @@ connect(Host, Port, Options, Timeout) ->
 %% Description: Creates an ssl listen socket.
 %%--------------------------------------------------------------------
 listen(_Port, []) ->
-    {error, enooptions};
+    {error, nooptions};
 listen(Port, Options0) ->
     try
 	{ok, Config} = handle_options(Options0, server),
@@ -380,13 +380,13 @@ getopts(#sslsocket{pid = {ListenSocket,  #config{cb = {Transport,_,_,_}}}},
 	{ok, _} = Result ->
 	    Result;
 	{error, InetError} ->
-	    {error, {eoptions, {socket_options, OptionTags, InetError}}}
+	    {error, {options, {socket_options, OptionTags, InetError}}}
     catch
 	_:_ ->
-	    {error, {eoptions, {socket_options, OptionTags}}}
+	    {error, {options, {socket_options, OptionTags}}}
     end;
 getopts(#sslsocket{}, OptionTags) ->
-    {error, {eoptions, {socket_options, OptionTags}}}.
+    {error, {options, {socket_options, OptionTags}}}.
 
 %%--------------------------------------------------------------------
 -spec setopts(#sslsocket{},  [gen_tcp:option()]) -> ok | {error, reason()}.
@@ -400,7 +400,7 @@ setopts(#sslsocket{pid = Pid}, Options0) when is_pid(Pid), is_list(Options0)  ->
 	    ssl_connection:set_opts(Pid, Options)
     catch
 	_:_ ->
-	    {error, {eoptions, {not_a_proplist, Options0}}}
+	    {error, {options, {not_a_proplist, Options0}}}
     end;
 
 setopts(#sslsocket{pid = {ListenSocket, #config{cb = {Transport,_,_,_}}}}, Options) when is_list(Options) ->
@@ -408,13 +408,13 @@ setopts(#sslsocket{pid = {ListenSocket, #config{cb = {Transport,_,_,_}}}}, Optio
 	ok ->
 	    ok;
 	{error, InetError} ->
-	    {error, {eoptions, {socket_options, Options, InetError}}}
+	    {error, {options, {socket_options, Options, InetError}}}
     catch
 	_:Error ->
-	    {error, {eoptions, {socket_options, Options, Error}}}
+	    {error, {options, {socket_options, Options, Error}}}
     end;
 setopts(#sslsocket{}, Options) ->
-    {error, {eoptions,{not_a_proplist, Options}}}.
+    {error, {options,{not_a_proplist, Options}}}.
 
 %%---------------------------------------------------------------
 -spec shutdown(#sslsocket{}, read | write | read_write) ->  ok | {error, reason()}.
@@ -503,24 +503,26 @@ format_error({error, Reason}) ->
 format_error(Reason) when is_list(Reason) ->
     Reason;
 format_error(closed) ->
-    "The connection is closed";
-format_error({ecacertfile, _}) ->
-    "Own CA certificate file is invalid.";
-format_error({ecertfile, _}) ->
-    "Own certificate file is invalid.";
-format_error({ekeyfile, _}) ->
-    "Own private key file is invalid.";
-format_error({essl, Description}) ->
-    Description;
-format_error({eoptions, Options}) ->
-    lists:flatten(io_lib:format("Error in options list: ~p~n", [Options]));
+    "TLS connection is closed";
+format_error({tls_alert, Description}) ->
+    "TLS Alert: " ++ Description;
+format_error({options,{FileType, File, Reason}}) when FileType == cacertfile;
+						      FileType == certfile;
+						      FileType == keyfile;
+						      FileType == dhfile ->
+    Error = file_error_format(Reason),
+    file_desc(FileType) ++ File ++ ": " ++ Error;
+format_error({options, {socket_options, Option, Error}}) ->
+    lists:flatten(io_lib:format("Invalid transport socket option ~p: ~s", [Option, format_error(Error)]));
+format_error({options, {socket_options, Option}}) ->
+    lists:flatten(io_lib:format("Invalid socket option: ~p", [Option]));
+format_error({options, Options}) ->
+    lists:flatten(io_lib:format("Invalid TLS option: ~p", [Options]));
 
 format_error(Error) ->
-    case (catch inet:format_error(Error)) of
-        "unkknown POSIX" ++ _ ->
-            no_format(Error);
-        {'EXIT', _} ->
-            no_format(Error);
+    case inet:format_error(Error) of
+        "unknown POSIX" ++ _ ->
+            unexpected_format(Error);
         Other ->
             Other
     end.
@@ -541,8 +543,6 @@ random_bytes(N) ->
 	    crypto:rand_bytes(N)
     end.
 
-
-
 %%%--------------------------------------------------------------
 %%% Internal functions
 %%%--------------------------------------------------------------------
@@ -559,11 +559,11 @@ do_connect(Address, Port,
 	    {error, Reason}
     catch
 	exit:{function_clause, _} ->
-	    {error, {eoptions, {cb_info, CbInfo}}};
+	    {error, {options, {cb_info, CbInfo}}};
 	exit:badarg ->
-	    {error, {eoptions, {socket_options, UserOpts}}};
+	    {error, {options, {socket_options, UserOpts}}};
 	exit:{badarg, _} ->
-	    {error, {eoptions, {socket_options, UserOpts}}}
+	    {error, {options, {socket_options, UserOpts}}}
     end.
 
 handle_options(Opts0, _Role) ->
@@ -607,7 +607,7 @@ handle_options(Opts0, _Role) ->
 		{verify_peer, UserFailIfNoPeerCert,
 		 ca_cert_default(verify_peer, UserVerifyFun, CaCerts), UserVerifyFun};
 	    Value ->
-		throw({error, {eoptions, {verify, Value}}})
+		throw({error, {options, {verify, Value}}})
 	end,
 
     CertFile = handle_option(certfile, Opts, <<>>),
@@ -754,9 +754,9 @@ validate_option(ciphers, Value)  when is_list(Value) ->
     try cipher_suites(Version, Value)
     catch
 	exit:_ ->
-	    throw({error, {eoptions, {ciphers, Value}}});
+	    throw({error, {options, {ciphers, Value}}});
 	error:_->
-	    throw({error, {eoptions, {ciphers, Value}}})
+	    throw({error, {options, {ciphers, Value}}})
     end;
 validate_option(reuse_session, Value) when is_function(Value) ->
     Value;
@@ -781,7 +781,7 @@ validate_option(client_preferred_next_protocols = Opt, {Precedence, PreferredPro
   when is_list(PreferredProtocols) ->
     case ssl_record:highest_protocol_version([]) of
 	{3,0} ->
-	    throw({error, {eoptions, {not_supported_in_sslv3, {Opt, Value}}}});
+	    throw({error, {options, {not_supported_in_sslv3, {Opt, Value}}}});
 	_ ->
 	    validate_binary_list(client_preferred_next_protocols, PreferredProtocols),
 	    validate_npn_ordering(Precedence),
@@ -792,7 +792,7 @@ validate_option(client_preferred_next_protocols = Opt, {Precedence, PreferredPro
            byte_size(Default) > 0, byte_size(Default) < 256 ->
     case ssl_record:highest_protocol_version([]) of
 	{3,0} ->
-	    throw({error, {eoptions, {not_supported_in_sslv3, {Opt, Value}}}});
+	    throw({error, {options, {not_supported_in_sslv3, {Opt, Value}}}});
 	_ ->
 	    validate_binary_list(client_preferred_next_protocols, PreferredProtocols),
 	    validate_npn_ordering(Precedence),
@@ -804,7 +804,7 @@ validate_option(client_preferred_next_protocols, undefined) ->
 validate_option(next_protocols_advertised = Opt, Value) when is_list(Value) ->
     case ssl_record:highest_protocol_version([]) of
 	{3,0} ->
-	    throw({error, {eoptions, {not_supported_in_sslv3, {Opt, Value}}}});
+	    throw({error, {options, {not_supported_in_sslv3, {Opt, Value}}}});
 	_ ->
 	    validate_binary_list(next_protocols_advertised, Value),
 	    Value
@@ -813,14 +813,14 @@ validate_option(next_protocols_advertised = Opt, Value) when is_list(Value) ->
 validate_option(next_protocols_advertised, undefined) ->
     undefined;
 validate_option(Opt, Value) ->
-    throw({error, {eoptions, {Opt, Value}}}).
+    throw({error, {options, {Opt, Value}}}).
 
 validate_npn_ordering(client) ->
     ok;
 validate_npn_ordering(server) ->
     ok;
 validate_npn_ordering(Value) ->
-    throw({error, {eoptions, {client_preferred_next_protocols, {invalid_precedence, Value}}}}).
+    throw({error, {options, {client_preferred_next_protocols, {invalid_precedence, Value}}}}).
 
 validate_binary_list(Opt, List) ->
     lists:foreach(
@@ -829,7 +829,7 @@ validate_binary_list(Opt, List) ->
                       byte_size(Bin) < 256 ->
             ok;
            (Bin) ->
-            throw({error, {eoptions, {Opt, {invalid_protocol, Bin}}}})
+            throw({error, {options, {Opt, {invalid_protocol, Bin}}}})
         end, List).
 
 validate_versions([], Versions) ->
@@ -840,23 +840,23 @@ validate_versions([Version | Rest], Versions) when Version == 'tlsv1.2';
                                                    Version == sslv3 ->
     validate_versions(Rest, Versions);					   
 validate_versions([Ver| _], Versions) ->
-    throw({error, {eoptions, {Ver, {versions, Versions}}}}).
+    throw({error, {options, {Ver, {versions, Versions}}}}).
 
 validate_inet_option(mode, Value)
   when Value =/= list, Value =/= binary ->
-    throw({error, {eoptions, {mode,Value}}});
+    throw({error, {options, {mode,Value}}});
 validate_inet_option(packet, Value)
   when not (is_atom(Value) orelse is_integer(Value)) ->
-    throw({error, {eoptions, {packet,Value}}});
+    throw({error, {options, {packet,Value}}});
 validate_inet_option(packet_size, Value)
   when not is_integer(Value) ->
-    throw({error, {eoptions, {packet_size,Value}}});
+    throw({error, {options, {packet_size,Value}}});
 validate_inet_option(header, Value)
   when not is_integer(Value) ->
-    throw({error, {eoptions, {header,Value}}});
+    throw({error, {options, {header,Value}}});
 validate_inet_option(active, Value)
   when Value =/= true, Value =/= false, Value =/= once ->
-    throw({error, {eoptions, {active,Value}}});
+    throw({error, {options, {active,Value}}});
 validate_inet_option(_, _) ->
     ok.
 
@@ -935,8 +935,27 @@ cipher_suites(Version, Ciphers0)  ->
     Ciphers = [ssl_cipher:openssl_suite(C) || C <- string:tokens(Ciphers0, ":")],
     cipher_suites(Version, Ciphers).
 
-no_format(Error) ->    
-    lists:flatten(io_lib:format("No format string for error: \"~p\" available.", [Error])).
+unexpected_format(Error) ->    
+    lists:flatten(io_lib:format("Unexpected error: ~p", [Error])).
+
+file_error_format({error, Error})->
+    case file:format_error(Error) of 
+	"unknown POSIX error" ->
+	    "decoding error";
+	Str ->
+	    Str
+    end;
+file_error_format(_) ->
+    "decoding error".
+    
+file_desc(cacertfile) ->
+    "Invalid CA certificate file ";
+file_desc(certfile) ->
+    "Invalid certificate file ";
+file_desc(keyfile) ->
+    "Invalid key file "; 
+file_desc(dhfile) ->
+    "Invalid DH params file ".
 
 detect(_Pred, []) ->
     undefined;
diff --git a/lib/ssl/src/ssl_alert.erl b/lib/ssl/src/ssl_alert.erl
index f94a1136a0..94e95d3cd3 100644
--- a/lib/ssl/src/ssl_alert.erl
+++ b/lib/ssl/src/ssl_alert.erl
@@ -45,7 +45,7 @@
 reason_code(#alert{description = ?CLOSE_NOTIFY}, _) ->
     closed;
 reason_code(#alert{description = Description}, _) ->
-    {essl, description_txt(Description)}.
+    {tls_alert, description_txt(Description)}.
 
 %%--------------------------------------------------------------------
 -spec alert_txt(#alert{}) -> string().
diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index f51f1c6115..52b765f191 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -1136,9 +1136,8 @@ init_certificates(#ssl_options{cacerts = CaCerts,
 		    end,
 	    {ok, _, _, _, _, _} = ssl_manager:connection_init(Certs, Role)
 	catch
-	    Error:Reason ->
-		handle_file_error(?LINE, Error, Reason, CACertFile, {ecacertfile, Reason},
-				  erlang:get_stacktrace())
+	    _:Reason ->
+		file_error(CACertFile, {cacertfile, Reason})
 	end,
     init_certificates(Cert, CertDbRef, CertDbHandle, FileRefHandle, PemCacheHandle, CacheHandle, CertFile, Role).
 
@@ -1158,9 +1157,8 @@ init_certificates(undefined, CertDbRef, CertDbHandle, FileRefHandle, PemCacheHan
 	[OwnCert] = ssl_certificate:file_to_certificats(CertFile, PemCacheHandle),
 	{ok, CertDbRef, CertDbHandle, FileRefHandle, PemCacheHandle, CacheRef, OwnCert}
     catch
-	Error:Reason ->
-	    handle_file_error(?LINE, Error, Reason, CertFile, {ecertfile, Reason},
-			      erlang:get_stacktrace())
+	_:Reason ->
+	    file_error(CertFile, {certfile, Reason})	    
     end;
 init_certificates(Cert, CertDbRef, CertDbHandle, FileRefHandle, PemCacheHandle, CacheRef, _, _) ->
     {ok, CertDbRef, CertDbHandle, FileRefHandle, PemCacheHandle, CacheRef, Cert}.
@@ -1177,9 +1175,8 @@ init_private_key(DbHandle, undefined, KeyFile, Password, _) ->
 		     ],
 	private_key(public_key:pem_entry_decode(PemEntry, Password))
     catch 
-	Error:Reason ->
-	    handle_file_error(?LINE, Error, Reason, KeyFile, {ekeyfile, Reason},
-			      erlang:get_stacktrace()) 
+	_:Reason ->
+	    file_error(KeyFile, {keyfile, Reason}) 
     end;
 
 %% First two clauses are for backwards compatibility
@@ -1205,18 +1202,14 @@ private_key(#'PrivateKeyInfo'{privateKeyAlgorithm =
 private_key(Key) ->
     Key.
 
--spec(handle_file_error(_,_,_,_,_,_) -> no_return()).
-handle_file_error(Line, Error, {badmatch, Reason}, File, Throw, Stack) ->
-    file_error(Line, Error, Reason, File, Throw, Stack);
-handle_file_error(Line, Error, Reason, File, Throw, Stack) ->
-    file_error(Line, Error, Reason, File, Throw, Stack).
-
--spec(file_error(_,_,_,_,_,_) -> no_return()).
-file_error(Line, Error, Reason, File, Throw, Stack) ->
-    Report = io_lib:format("SSL: ~p: ~p:~p ~s~n  ~p~n",
-			   [Line, Error, Reason, File, Stack]),
-    error_logger:error_report(Report),
-    throw(Throw).
+-spec(file_error(_,_) -> no_return()).
+file_error(File, Throw) ->
+    case Throw of
+	{Opt,{badmatch, {error, {badmatch, Error}}}} ->
+	    throw({options, {Opt, binary_to_list(File), Error}});
+	_ ->
+	    throw(Throw)
+    end.
 
 init_diffie_hellman(_,Params, _,_) when is_binary(Params)->
     public_key:der_decode('DHParameter', Params);
@@ -1234,9 +1227,8 @@ init_diffie_hellman(DbHandle,_, DHParamFile, server) ->
 		?DEFAULT_DIFFIE_HELLMAN_PARAMS
 	end
     catch
-	Error:Reason ->
-	    handle_file_error(?LINE, Error, Reason, 
-			      DHParamFile, {edhfile, Reason},  erlang:get_stacktrace()) 
+	_:Reason ->
+	    file_error(DHParamFile, {dhfile, Reason}) 
     end.
 
 sync_send_all_state_event(FsmPid, Event) ->
@@ -2179,13 +2171,13 @@ get_socket_opts(Transport, Socket, [Tag | Tags], SockOpts, Acc) ->
 	{ok, [Opt]} ->
 	    get_socket_opts(Transport, Socket, Tags, SockOpts, [Opt | Acc]);
 	{error, Error} ->
-	    {error, {eoptions, {socket_option, Tag, Error}}}
+	    {error, {options, {socket_options, Tag, Error}}}
     catch
 	%% So that inet behavior does not crash our process
-	_:Error -> {error, {eoptions, {socket_option, Tag, Error}}}
+	_:Error -> {error, {options, {socket_options, Tag, Error}}}
     end;
 get_socket_opts(_, _,Opts, _,_) ->
-    {error, {eoptions, {socket_options, Opts, function_clause}}}.
+    {error, {options, {socket_options, Opts, function_clause}}}.
 
 set_socket_opts(_,_, [], SockOpts, []) ->
     {ok, SockOpts};
@@ -2195,18 +2187,18 @@ set_socket_opts(Transport, Socket, [], SockOpts, Other) ->
 	ok ->
 	    {ok, SockOpts};
 	{error, InetError} ->
-	    {{error, {eoptions, {socket_option, Other, InetError}}}, SockOpts}
+	    {{error, {options, {socket_options, Other, InetError}}}, SockOpts}
     catch
 	_:Error ->
 	    %% So that inet behavior does not crash our process
-	    {{error, {eoptions, {socket_option, Other, Error}}}, SockOpts}
+	    {{error, {options, {socket_options, Other, Error}}}, SockOpts}
     end;
 
 set_socket_opts(Transport,Socket, [{mode, Mode}| Opts], SockOpts, Other) when Mode == list; Mode == binary ->
     set_socket_opts(Transport, Socket, Opts, 
 		    SockOpts#socket_options{mode = Mode}, Other);
 set_socket_opts(_, _, [{mode, _} = Opt| _], SockOpts, _) ->
-    {{error, {eoptions, {socket_option, Opt}}}, SockOpts};
+    {{error, {options, {socket_options, Opt}}}, SockOpts};
 set_socket_opts(Transport,Socket, [{packet, Packet}| Opts], SockOpts, Other) when Packet == raw;
 									Packet == 0;
 									Packet == 1;
@@ -2225,19 +2217,19 @@ set_socket_opts(Transport,Socket, [{packet, Packet}| Opts], SockOpts, Other) whe
     set_socket_opts(Transport, Socket, Opts, 
 		    SockOpts#socket_options{packet = Packet}, Other);
 set_socket_opts(_, _, [{packet, _} = Opt| _], SockOpts, _) ->
-    {{error, {eoptions, {socket_option, Opt}}}, SockOpts};
+    {{error, {options, {socket_options, Opt}}}, SockOpts};
 set_socket_opts(Transport, Socket, [{header, Header}| Opts], SockOpts, Other) when is_integer(Header) ->
     set_socket_opts(Transport, Socket, Opts, 
 		    SockOpts#socket_options{header = Header}, Other);
 set_socket_opts(_, _, [{header, _} = Opt| _], SockOpts, _) ->
-    {{error,{eoptions, {socket_option, Opt}}}, SockOpts};
+    {{error,{options, {socket_options, Opt}}}, SockOpts};
 set_socket_opts(Transport, Socket, [{active, Active}| Opts], SockOpts, Other) when Active == once;
 										   Active == true;
 										   Active == false ->
     set_socket_opts(Transport, Socket, Opts, 
 		    SockOpts#socket_options{active = Active}, Other);
 set_socket_opts(_, _, [{active, _} = Opt| _], SockOpts, _) ->
-    {{error, {eoptions, {socket_option, Opt}} }, SockOpts};
+    {{error, {options, {socket_options, Opt}} }, SockOpts};
 set_socket_opts(Transport, Socket, [Opt | Opts], SockOpts, Other) ->
     set_socket_opts(Transport, Socket, Opts, SockOpts, [Opt | Other]).
 
diff --git a/lib/ssl/test/ssl_basic_SUITE.erl b/lib/ssl/test/ssl_basic_SUITE.erl
index db203a47c4..b5c6a1da49 100644
--- a/lib/ssl/test/ssl_basic_SUITE.erl
+++ b/lib/ssl/test/ssl_basic_SUITE.erl
@@ -99,10 +99,10 @@ options_tests() ->
      invalid_inet_set_option_not_list,
      invalid_inet_set_option_improper_list,
      dh_params,
-     ecertfile,
-     ecacertfile,
-     ekeyfile,
-     eoptions,
+     invalid_certfile,
+     invalid_cacertfile,
+     invalid_keyfile,
+     invalid_options,
      protocol_versions,
      empty_protocol_versions,
      ipv6,
@@ -822,7 +822,7 @@ invalid_inet_get_option_not_list(Config) when is_list(Config) ->
 
 
 get_invalid_inet_option_not_list(Socket) ->
-    {error, {eoptions, {socket_options, some_invalid_atom_here}}}
+    {error, {options, {socket_options, some_invalid_atom_here}}}
      = ssl:getopts(Socket, some_invalid_atom_here),
      ok.
 
@@ -854,7 +854,7 @@ invalid_inet_get_option_improper_list(Config) when is_list(Config) ->
 
 
 get_invalid_inet_option_improper_list(Socket) ->
-    {error, {eoptions, {socket_options, foo,_}}} = ssl:getopts(Socket, [packet | foo]),
+    {error, {options, {socket_options, foo,_}}} = ssl:getopts(Socket, [packet | foo]),
     ok.
 
 %%--------------------------------------------------------------------
@@ -884,10 +884,10 @@ invalid_inet_set_option(Config) when is_list(Config) ->
     ssl_test_lib:close(Client).
 
 set_invalid_inet_option(Socket) ->
-    {error, {eoptions, {socket_option, {packet, foo}}}} = ssl:setopts(Socket, [{packet, foo}]),
-    {error, {eoptions, {socket_option, {header, foo}}}} = ssl:setopts(Socket, [{header, foo}]),
-    {error, {eoptions, {socket_option, {active, foo}}}} = ssl:setopts(Socket, [{active, foo}]),
-    {error, {eoptions, {socket_option, {mode, foo}}}}   = ssl:setopts(Socket, [{mode, foo}]),
+    {error, {options, {socket_options, {packet, foo}}}} = ssl:setopts(Socket, [{packet, foo}]),
+    {error, {options, {socket_options, {header, foo}}}} = ssl:setopts(Socket, [{header, foo}]),
+    {error, {options, {socket_options, {active, foo}}}} = ssl:setopts(Socket, [{active, foo}]),
+    {error, {options, {socket_options, {mode, foo}}}}   = ssl:setopts(Socket, [{mode, foo}]),
     ok.
 %%--------------------------------------------------------------------
 invalid_inet_set_option_not_list() ->
@@ -917,7 +917,7 @@ invalid_inet_set_option_not_list(Config) when is_list(Config) ->
 
 
 set_invalid_inet_option_not_list(Socket) ->
-    {error, {eoptions, {not_a_proplist, some_invalid_atom_here}}}
+    {error, {options, {not_a_proplist, some_invalid_atom_here}}}
 	= ssl:setopts(Socket, some_invalid_atom_here),
     ok.
 
@@ -948,7 +948,7 @@ invalid_inet_set_option_improper_list(Config) when is_list(Config) ->
     ssl_test_lib:close(Client).
 
 set_invalid_inet_option_improper_list(Socket) ->
-    {error, {eoptions, {not_a_proplist, [{packet, 0} | {foo, 2}]}}} =
+    {error, {options, {not_a_proplist, [{packet, 0} | {foo, 2}]}}} =
 	ssl:setopts(Socket, [{packet, 0} | {foo, 2}]),
     ok.
 
@@ -1286,9 +1286,9 @@ ipv6(Config) when is_list(Config) ->
 
 %%--------------------------------------------------------------------
 
-ekeyfile() ->
+invalid_keyfile() ->
     [{doc,"Test what happens with an invalid key file"}].
-ekeyfile(Config) when is_list(Config) -> 
+invalid_keyfile(Config) when is_list(Config) -> 
     ClientOpts = ?config(client_opts, Config),
     BadOpts = ?config(server_bad_key, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
@@ -1304,16 +1304,17 @@ ekeyfile(Config) when is_list(Config) ->
 	ssl_test_lib:start_client_error([{node, ClientNode}, 
 			    {port, Port}, {host, Hostname},
 			    {from, self()},  {options, ClientOpts}]),
-    
-    ssl_test_lib:check_result(Server, {error, ekeyfile}, Client,  
-			      {error, closed}).
+
+    File = proplists:get_value(keyfile,BadOpts),    
+    ssl_test_lib:check_result(Server, {error,{options, {keyfile, File, {error,enoent}}}}, Client,  
+				       {error, closed}).
 
 %%--------------------------------------------------------------------
 
-ecertfile() ->
+invalid_certfile() ->
     [{doc,"Test what happens with an invalid cert file"}].
 
-ecertfile(Config) when is_list(Config) -> 
+invalid_certfile(Config) when is_list(Config) -> 
     ClientOpts = ?config(client_opts, Config),
     ServerBadOpts = ?config(server_bad_cert, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
@@ -1330,16 +1331,16 @@ ecertfile(Config) when is_list(Config) ->
 					 {port, Port}, {host, Hostname},
 					 {from, self()}, 
 					 {options, ClientOpts}]),
-    
-    ssl_test_lib:check_result(Server, {error, ecertfile}, Client, 
-			      {error, closed}).
+    File = proplists:get_value(certfile, ServerBadOpts),
+    ssl_test_lib:check_result(Server, {error,{options, {certfile, File, {error,enoent}}}}, 
+			      Client, {error, closed}).
     
 
 %%--------------------------------------------------------------------
-ecacertfile() ->
+invalid_cacertfile() ->
     [{doc,"Test what happens with an invalid cacert file"}].
 
-ecacertfile(Config) when is_list(Config) ->
+invalid_cacertfile(Config) when is_list(Config) ->
     ClientOpts    = [{reuseaddr, true}|?config(client_opts, Config)],
     ServerBadOpts = [{reuseaddr, true}|?config(server_bad_ca, Config)],
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
@@ -1357,11 +1358,12 @@ ecacertfile(Config) when is_list(Config) ->
 					 {port, Port0}, {host, Hostname},
 					 {from, self()}, 
 					 {options, ClientOpts}]),
+
+    File0 = proplists:get_value(cacertfile, ServerBadOpts),
     
-    ssl_test_lib:check_result(Server0, {error, ecacertfile},
+    ssl_test_lib:check_result(Server0, {error, {options, {cacertfile, File0,{error,enoent}}}},
 			      Client0, {error, closed}),
     
-    File0 = proplists:get_value(cacertfile, ServerBadOpts),
     File = File0 ++ "do_not_exit.pem",
     ServerBadOpts1 = [{cacertfile, File}|proplists:delete(cacertfile, ServerBadOpts)],
             
@@ -1378,31 +1380,32 @@ ecacertfile(Config) when is_list(Config) ->
 					 {from, self()}, 
 					 {options, ClientOpts}]),
 
-    ssl_test_lib:check_result(Server1, {error, ecacertfile},
+
+    ssl_test_lib:check_result(Server1, {error, {options, {cacertfile, File,{error,enoent}}}},
 			      Client1, {error, closed}),
     ok.
     
     
 
 %%--------------------------------------------------------------------
-eoptions() ->
+invalid_options() ->
     [{doc,"Test what happens when we give invalid options"}].
        
-eoptions(Config) when is_list(Config) -> 
+invalid_options(Config) when is_list(Config) -> 
     ClientOpts = ?config(client_opts, Config),
     ServerOpts = ?config(server_opts, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     
     Check = fun(Client, Server, {versions, [sslv2, sslv3]} = Option) ->
 		    ssl_test_lib:check_result(Server, 
-					      {error, {eoptions, {sslv2, Option}}}, 
+					      {error, {options, {sslv2, Option}}}, 
 					      Client,
-					      {error, {eoptions, {sslv2, Option}}});
+					      {error, {options, {sslv2, Option}}});
 	       (Client, Server, Option) ->
 		    ssl_test_lib:check_result(Server, 
-					      {error, {eoptions, Option}}, 
+					      {error, {options, Option}}, 
 					      Client,
-					      {error, {eoptions, Option}})
+					      {error, {options, Option}})
 	    end,
 
     TestOpts = [{versions, [sslv2, sslv3]}, 
@@ -1593,8 +1596,8 @@ default_reject_anonymous(Config) when is_list(Config) ->
 			    [{ciphers,[Cipher]} |
 			     ClientOpts]}]),
 
-    ssl_test_lib:check_result(Server, {error, {essl, "insufficient security"}},
-			      Client, {error, {essl, "insufficient security"}}).
+    ssl_test_lib:check_result(Server, {error, {tls_alert, "insufficient security"}},
+			      Client, {error, {tls_alert, "insufficient security"}}).
 
 %%--------------------------------------------------------------------
 reuse_session() ->
@@ -3147,7 +3150,7 @@ treashold(N, _) ->
     N + 1.
 
 get_invalid_inet_option(Socket) ->
-    {error, {eoptions, {socket_option, foo, _}}} = ssl:getopts(Socket, [foo]),
+    {error, {options, {socket_options, foo, _}}} = ssl:getopts(Socket, [foo]),
     ok.
 
 shutdown_result(Socket, server) ->
diff --git a/lib/ssl/test/ssl_certificate_verify_SUITE.erl b/lib/ssl/test/ssl_certificate_verify_SUITE.erl
index 86e1d47be7..26938bda50 100644
--- a/lib/ssl/test/ssl_certificate_verify_SUITE.erl
+++ b/lib/ssl/test/ssl_certificate_verify_SUITE.erl
@@ -252,8 +252,8 @@ server_require_peer_cert_fail(Config) when is_list(Config) ->
 					      {from, self()},
 					      {options, [{active, false} | BadClientOpts]}]),
 
-    ssl_test_lib:check_result(Server, {error, {essl, "handshake failure"}},
-			      Client, {error, {essl, "handshake failure"}}).
+    ssl_test_lib:check_result(Server, {error, {tls_alert, "handshake failure"}},
+			      Client, {error, {tls_alert, "handshake failure"}}).
 
 
 %%--------------------------------------------------------------------
@@ -293,14 +293,14 @@ verify_fun_always_run_client(Config) when is_list(Config) ->
 					       [{verify, verify_peer},
 						{verify_fun, FunAndState}
 						| ClientOpts]}]),
-    %% Server error may be {essl,"handshake failure"} or closed depending on timing
+    %% Server error may be {tls_alert,"handshake failure"} or closed depending on timing
     %% this is not a bug it is a circumstance of how tcp works!
     receive
 	{Server, ServerError} ->
 	    ct:print("Server Error ~p~n", [ServerError])
     end,
 
-    ssl_test_lib:check_result(Client, {error, {essl, "handshake failure"}}).
+    ssl_test_lib:check_result(Client, {error, {tls_alert, "handshake failure"}}).
 
 %%--------------------------------------------------------------------
 verify_fun_always_run_server() ->
@@ -342,14 +342,14 @@ verify_fun_always_run_server(Config) when is_list(Config) ->
 					       [{verify, verify_peer}
 						| ClientOpts]}]),
 
-    %% Client error may be {essl, "handshake failure" } or closed depending on timing
+    %% Client error may be {tls_alert, "handshake failure" } or closed depending on timing
     %% this is not a bug it is a circumstance of how tcp works!
     receive
 	{Client, ClientError} ->
 	    ct:print("Client Error ~p~n", [ClientError])
     end,
 
-    ssl_test_lib:check_result(Server, {error, {essl, "handshake failure"}}).
+    ssl_test_lib:check_result(Server, {error, {tls_alert, "handshake failure"}}).
 
 %%--------------------------------------------------------------------
 
@@ -432,8 +432,8 @@ cert_expired(Config) when is_list(Config) ->
 					      {from, self()},
 					      {options, [{verify, verify_peer} | ClientOpts]}]),
 
-    ssl_test_lib:check_result(Server, {error, {essl, "certificate expired"}},
-			      Client, {error, {essl, "certificate expired"}}).
+    ssl_test_lib:check_result(Server, {error, {tls_alert, "certificate expired"}},
+			      Client, {error, {tls_alert, "certificate expired"}}).
 
 two_digits_str(N) when N < 10 ->
     lists:flatten(io_lib:format("0~p", [N]));
@@ -710,8 +710,8 @@ invalid_signature_server(Config) when is_list(Config) ->
 					      {from, self()},
 					      {options, [{verify, verify_peer} | ClientOpts]}]),
 
-    tcp_delivery_workaround(Server, {error, {essl, "bad certificate"}},
-			    Client, {error, {essl, "bad certificate"}}).
+    tcp_delivery_workaround(Server, {error, {tls_alert, "bad certificate"}},
+			    Client, {error, {tls_alert, "bad certificate"}}).
 
 %%--------------------------------------------------------------------
 
@@ -747,8 +747,8 @@ invalid_signature_client(Config) when is_list(Config) ->
 					      {from, self()},
 					      {options, NewClientOpts}]),
 
-    tcp_delivery_workaround(Server, {error, {essl, "bad certificate"}},
-			    Client, {error, {essl, "bad certificate"}}).
+    tcp_delivery_workaround(Server, {error, {tls_alert, "bad certificate"}},
+			    Client, {error, {tls_alert, "bad certificate"}}).
 
 
 %%--------------------------------------------------------------------
@@ -792,7 +792,7 @@ server_verify_no_cacerts(Config) when is_list(Config) ->
 					      {options, [{verify, verify_peer}
 							 | ServerOpts]}]),
 
-    ssl_test_lib:check_result(Server, {error, {eoptions, {cacertfile, ""}}}).
+    ssl_test_lib:check_result(Server, {error, {options, {cacertfile, ""}}}).
 
 
 %%--------------------------------------------------------------------
@@ -829,8 +829,8 @@ unknown_server_ca_fail(Config) when is_list(Config) ->
 						{verify_fun, FunAndState}
 						| ClientOpts]}]),
 
-    ssl_test_lib:check_result(Server, {error, {essl, "unknown ca"}},
-			      Client, {error, {essl, "unknown ca"}}).
+    ssl_test_lib:check_result(Server, {error, {tls_alert, "unknown ca"}},
+			      Client, {error, {tls_alert, "unknown ca"}}).
 
 %%--------------------------------------------------------------------
 unknown_server_ca_accept_verify_none() ->
diff --git a/lib/ssl/test/ssl_npn_handshake_SUITE.erl b/lib/ssl/test/ssl_npn_handshake_SUITE.erl
index 4e848095a5..862690cd7b 100644
--- a/lib/ssl/test/ssl_npn_handshake_SUITE.erl
+++ b/lib/ssl/test/ssl_npn_handshake_SUITE.erl
@@ -106,15 +106,15 @@ end_per_group(_GroupName, Config) ->
 %%--------------------------------------------------------------------
 
 validate_empty_protocols_are_not_allowed(Config) when is_list(Config) ->
-    {error, {eoptions, {next_protocols_advertised, {invalid_protocol, <<>>}}}}
+    {error, {options, {next_protocols_advertised, {invalid_protocol, <<>>}}}}
 	= (catch ssl:listen(9443,
 			    [{next_protocols_advertised, [<<"foo/1">>, <<"">>]}])),
-    {error, {eoptions, {client_preferred_next_protocols, {invalid_protocol, <<>>}}}}
+    {error, {options, {client_preferred_next_protocols, {invalid_protocol, <<>>}}}}
 	= (catch ssl:connect({127,0,0,1}, 9443,
 			     [{client_preferred_next_protocols,
 			       {client, [<<"foo/1">>, <<"">>], <<"foox/1">>}}], infinity)),
     Option = {client_preferred_next_protocols, {invalid_protocol, <<"">>}},
-    {error, {eoptions, Option}} = (catch ssl:connect({127,0,0,1}, 9443, [Option], infinity)).
+    {error, {options, Option}} = (catch ssl:connect({127,0,0,1}, 9443, [Option], infinity)).
 
 %--------------------------------------------------------------------------------
 
@@ -126,12 +126,12 @@ validate_empty_advertisement_list_is_allowed(Config) when is_list(Config) ->
 
 validate_advertisement_must_be_a_binary_list(Config) when is_list(Config) ->
     Option = {next_protocols_advertised, blah},
-    {error, {eoptions, Option}} = (catch ssl:listen(9443, [Option])).
+    {error, {options, Option}} = (catch ssl:listen(9443, [Option])).
 %--------------------------------------------------------------------------------
 
 validate_client_protocols_must_be_a_tuple(Config) when is_list(Config)  ->
     Option = {client_preferred_next_protocols, [<<"foo/1">>]},
-    {error, {eoptions, Option}} = (catch ssl:connect({127,0,0,1}, 9443, [Option])).
+    {error, {options, Option}} = (catch ssl:connect({127,0,0,1}, 9443, [Option])).
 
 %--------------------------------------------------------------------------------
 
@@ -220,7 +220,7 @@ npn_not_supported_client(Config) when is_list(Config) ->
 			    {from, self()},  {options, ClientOpts}]),
     
     ssl_test_lib:check_result(Client, {error, 
-				       {eoptions, 
+				       {options, 
 					{not_supported_in_sslv3, PrefProtocols}}}).
 
 %--------------------------------------------------------------------------------
@@ -229,7 +229,7 @@ npn_not_supported_server(Config) when is_list(Config)->
     AdvProtocols = {next_protocols_advertised, [<<"spdy/2">>, <<"http/1.1">>, <<"http/1.0">>]},
     ServerOpts = [AdvProtocols] ++  ServerOpts0,
   
-    {error, {eoptions, {not_supported_in_sslv3, AdvProtocols}}} = ssl:listen(0, ServerOpts).
+    {error, {options, {not_supported_in_sslv3, AdvProtocols}}} = ssl:listen(0, ServerOpts).
 
 %%--------------------------------------------------------------------
 %% Internal functions ------------------------------------------------
diff --git a/lib/ssl/test/ssl_test_lib.erl b/lib/ssl/test/ssl_test_lib.erl
index 8d96a70a6e..d58541df52 100644
--- a/lib/ssl/test/ssl_test_lib.erl
+++ b/lib/ssl/test/ssl_test_lib.erl
@@ -206,7 +206,7 @@ close(Pid) ->
 
 check_result(Server, {error, SReason} = ServerMsg, Client,  {error, closed} = ClientMsg) -> 
     receive 
-	{Server, {error, {SReason, _}}} -> 
+	{Server, {error, SReason}} -> 
 	    receive 
 		{Client, ClientMsg} ->
 		    ok;
diff --git a/lib/ssl/test/ssl_to_openssl_SUITE.erl b/lib/ssl/test/ssl_to_openssl_SUITE.erl
index 7c0c00bf36..4f53132d5d 100644
--- a/lib/ssl/test/ssl_to_openssl_SUITE.erl
+++ b/lib/ssl/test/ssl_to_openssl_SUITE.erl
@@ -902,7 +902,7 @@ ssl2_erlang_server_openssl_client(Config) when is_list(Config) ->
 	    ok
 
     end,
-    ssl_test_lib:check_result(Server, {error, {essl, "protocol version"}}),
+    ssl_test_lib:check_result(Server, {error, {tls_alert, "protocol version"}}),
     process_flag(trap_exit, false).
 
 %%--------------------------------------------------------------------