Merge branch 'dev' into major

* dev:
  Use erlang:send_after instead of timer:send_after
  Handle inet:getopts/2 and inet:setopts/2 crashes

3 files changed, 99 insertions, 34 deletions

diff --git a/lib/ssl/src/ssl.erl b/lib/ssl/src/ssl.erl
index a5e8e7e5c2..a0aedbbbee 100644
--- a/lib/ssl/src/ssl.erl
+++ b/lib/ssl/src/ssl.erl
@@ -112,7 +112,7 @@ connect(Socket, SslOptions) when is_port(Socket) ->
 connect(Socket, SslOptions0, Timeout) when is_port(Socket) ->
     EmulatedOptions = emulated_options(),
     {ok, InetValues} = inet:getopts(Socket, EmulatedOptions),
-    inet:setopts(Socket, internal_inet_values()), 
+    ok = inet:setopts(Socket, internal_inet_values()),
     try handle_options(SslOptions0 ++ InetValues, client) of
 	{ok, #config{cb=CbInfo, ssl=SslOptions, emulated=EmOpts}} ->
 	    case inet:peername(Socket) of
@@ -238,7 +238,7 @@ ssl_accept(#sslsocket{} = Socket, Timeout)  ->
 ssl_accept(Socket, SslOptions, Timeout) when is_port(Socket) -> 
     EmulatedOptions = emulated_options(),
     {ok, InetValues} = inet:getopts(Socket, EmulatedOptions),
-    inet:setopts(Socket, internal_inet_values()), 
+    ok = inet:setopts(Socket, internal_inet_values()),
     try handle_options(SslOptions ++ InetValues, server) of
 	{ok, #config{cb=CbInfo,ssl=SslOpts, emulated=EmOpts}} ->
 	    {ok, Port} = inet:port(Socket),
@@ -406,25 +406,51 @@ cipher_suites(openssl) ->
 %% 
 %% Description: Gets options
 %%--------------------------------------------------------------------
-getopts(#sslsocket{fd = new_ssl, pid = Pid}, OptTags) when is_pid(Pid) ->
-    ssl_connection:get_opts(Pid, OptTags);
-getopts(#sslsocket{fd = new_ssl, pid = {ListenSocket, _}}, OptTags) ->
-    inet:getopts(ListenSocket, OptTags);
-getopts(#sslsocket{} = Socket, Options) ->
+getopts(#sslsocket{fd = new_ssl, pid = Pid}, OptionTags) when is_pid(Pid), is_list(OptionTags) ->
+    ssl_connection:get_opts(Pid, OptionTags);
+getopts(#sslsocket{fd = new_ssl, pid = {ListenSocket, _}}, OptionTags) when is_list(OptionTags) ->
+    try inet:getopts(ListenSocket, OptionTags) of
+	{ok, _} = Result ->
+	    Result;
+	{error, InetError} ->
+	    {error, {eoptions, {inet_options, OptionTags, InetError}}}
+    catch
+	_:_ ->
+	    {error, {eoptions, {inet_options, OptionTags}}}
+    end;
+getopts(#sslsocket{fd = new_ssl}, OptionTags) ->
+    {error, {eoptions, {inet_options, OptionTags}}};
+getopts(#sslsocket{} = Socket, OptionTags) ->
     ensure_old_ssl_started(),
-    ssl_broker:getopts(Socket, Options).
+    ssl_broker:getopts(Socket, OptionTags).
 
 %%--------------------------------------------------------------------
 -spec setopts(#sslsocket{},  [proplists:property()]) -> ok | {error, reason()}.
 %% 
 %% Description: Sets options
 %%--------------------------------------------------------------------
-setopts(#sslsocket{fd = new_ssl, pid = Pid}, Opts0) when is_pid(Pid) ->
-    Opts = proplists:expand([{binary, [{mode, binary}]},
-			     {list, [{mode, list}]}], Opts0),
-    ssl_connection:set_opts(Pid, Opts);
-setopts(#sslsocket{fd = new_ssl, pid = {ListenSocket, _}}, OptTags) ->
-    inet:setopts(ListenSocket, OptTags);
+setopts(#sslsocket{fd = new_ssl, pid = Pid}, Options0) when is_pid(Pid), is_list(Options0)  ->
+    try proplists:expand([{binary, [{mode, binary}]},
+			  {list, [{mode, list}]}], Options0) of
+	Options ->
+	    ssl_connection:set_opts(Pid, Options)
+    catch
+	_:_ ->
+	    {error, {eoptions, {not_a_proplist, Options0}}}
+    end;
+
+setopts(#sslsocket{fd = new_ssl, pid = {ListenSocket, _}}, Options) when is_list(Options) ->
+    try inet:setopts(ListenSocket, Options) of
+	ok ->
+	    ok;
+	{error, InetError} ->
+	    {error, {eoptions, {inet_options, Options, InetError}}}
+    catch
+	_:Error ->
+	    {error, {eoptions, {inet_options, Options, Error}}}
+    end;
+setopts(#sslsocket{fd = new_ssl}, Options) ->
+    {error, {eoptions,{not_a_proplist, Options}}};
 setopts(#sslsocket{} = Socket, Options) ->
     ensure_old_ssl_started(),
     ssl_broker:setopts(Socket, Options).
diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index 2c452837f8..5550897a06 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -859,23 +859,23 @@ handle_sync_event({set_opts, Opts0}, _From, StateName,
 		  #state{socket_options = Opts1, 
 			 socket = Socket,
 			 user_data_buffer = Buffer} = State0) ->
-    Opts   = set_socket_opts(Socket, Opts0, Opts1, []),
+    {Reply, Opts} = set_socket_opts(Socket, Opts0, Opts1, []),
     State1 = State0#state{socket_options = Opts},
     if 
 	Opts#socket_options.active =:= false ->
-	    {reply, ok, StateName, State1, get_timeout(State1)};
+	    {reply, Reply, StateName, State1, get_timeout(State1)};
 	Buffer =:= <<>>, Opts1#socket_options.active =:= false ->
             %% Need data, set active once
 	    {Record, State2} = next_record_if_active(State1),
 	    case next_state(StateName, Record, State2) of
 		{next_state, StateName, State, Timeout} ->
-		    {reply, ok, StateName, State, Timeout};
+		    {reply, Reply, StateName, State, Timeout};
 		{stop, Reason, State} ->
 		    {stop, Reason, State}
 	    end;
 	Buffer =:= <<>> ->
             %% Active once already set 
-	    {reply, ok, StateName, State1, get_timeout(State1)};
+	    {reply, Reply, StateName, State1, get_timeout(State1)};
 	true ->
 	    case application_data(<<>>, State1) of
 		Stop = {stop,_,_} ->
@@ -883,7 +883,7 @@ handle_sync_event({set_opts, Opts0}, _From, StateName,
 		{Record, State2} ->
 		    case next_state(StateName, Record, State2) of
 			{next_state, StateName, State, Timeout} ->
-			    {reply, ok, StateName, State, Timeout};
+			    {reply, Reply, StateName, State, Timeout};
 			{stop, Reason, State} ->
 			    {stop, Reason, State}
 		    end
@@ -2040,31 +2040,67 @@ get_socket_opts(Socket, [active | Tags], SockOpts, Acc) ->
     get_socket_opts(Socket, Tags, SockOpts, 
 		    [{active, SockOpts#socket_options.active} | Acc]);
 get_socket_opts(Socket, [Tag | Tags], SockOpts, Acc) ->
-    case inet:getopts(Socket, [Tag]) of
+    try inet:getopts(Socket, [Tag]) of
 	{ok, [Opt]} ->
 	    get_socket_opts(Socket, Tags, SockOpts, [Opt | Acc]);
 	{error, Error} ->
-	    {error, Error}
-    end.
+	    {error, {eoptions, {inet_option, Tag, Error}}}
+    catch
+	%% So that inet behavior does not crash our process
+	_:Error -> {error, {eoptions, {inet_option, Tag, Error}}}
+    end;
+get_socket_opts(_,Opts, _,_) ->
+    {error, {eoptions, {inet_option, Opts, function_clause}}}.
 
 set_socket_opts(_, [], SockOpts, []) ->
-    SockOpts;
+    {ok, SockOpts};
 set_socket_opts(Socket, [], SockOpts, Other) ->
     %% Set non emulated options 
-    inet:setopts(Socket, Other),
-    SockOpts;
-set_socket_opts(Socket, [{mode, Mode}| Opts], SockOpts, Other) ->
+    try inet:setopts(Socket, Other) of
+	ok ->
+	    {ok, SockOpts};
+	{error, InetError} ->
+	    {{error, {eoptions, {inet_options, Other, InetError}}}, SockOpts}
+    catch
+	_:Error ->
+	    %% So that inet behavior does not crash our process
+	    {{error, {eoptions, {inet_options, Other, Error}}}, SockOpts}
+    end;
+
+set_socket_opts(Socket, [{mode, Mode}| Opts], SockOpts, Other) when Mode == list; Mode == binary ->
     set_socket_opts(Socket, Opts, 
 		    SockOpts#socket_options{mode = Mode}, Other);
-set_socket_opts(Socket, [{packet, Packet}| Opts], SockOpts, Other) ->
+set_socket_opts(_, [{mode, _} = Opt| _], SockOpts, _) ->
+    {{error, {eoptions, {inet_opt, Opt}}}, SockOpts};
+set_socket_opts(Socket, [{packet, Packet}| Opts], SockOpts, Other) when Packet == raw;
+									Packet == 0;
+									Packet == 1;
+									Packet == 2;
+									Packet == 4;
+									Packet == asn1;
+									Packet == cdr;
+									Packet == sunrm;
+									Packet == fcgi;
+									Packet == tpkt;
+									Packet == line;
+									Packet == http;
+									Packet == http_bin ->
     set_socket_opts(Socket, Opts, 
 		    SockOpts#socket_options{packet = Packet}, Other);
-set_socket_opts(Socket, [{header, Header}| Opts], SockOpts, Other) ->
+set_socket_opts(_, [{packet, _} = Opt| _], SockOpts, _) ->
+    {{error, {eoptions, {inet_opt, Opt}}}, SockOpts};
+set_socket_opts(Socket, [{header, Header}| Opts], SockOpts, Other) when is_integer(Header) ->
     set_socket_opts(Socket, Opts, 
 		    SockOpts#socket_options{header = Header}, Other);
-set_socket_opts(Socket, [{active, Active}| Opts], SockOpts, Other) ->
+set_socket_opts(_, [{header, _} = Opt| _], SockOpts, _) ->
+    {{error,{eoptions, {inet_opt, Opt}}}, SockOpts};
+set_socket_opts(Socket, [{active, Active}| Opts], SockOpts, Other) when Active == once;
+									Active == true;
+									Active == false ->
     set_socket_opts(Socket, Opts, 
 		    SockOpts#socket_options{active = Active}, Other);
+set_socket_opts(_, [{active, _} = Opt| _], SockOpts, _) ->
+    {{error, {eoptions, {inet_opt, Opt}} }, SockOpts};
 set_socket_opts(Socket, [Opt | Opts], SockOpts, Other) ->
     set_socket_opts(Socket, Opts, SockOpts, [Opt | Other]).
 
diff --git a/lib/ssl/src/ssl_manager.erl b/lib/ssl/src/ssl_manager.erl
index 541ca1e918..371bfafae0 100644
--- a/lib/ssl/src/ssl_manager.erl
+++ b/lib/ssl/src/ssl_manager.erl
@@ -50,7 +50,8 @@
 	  session_cache_cb,
 	  session_lifetime,
 	  certificate_db,
-	  session_validation_timer
+	  session_validation_timer,
+	  last_delay_timer %% Keep for testing purposes
 	 }).
 
 -define('24H_in_msec', 8640000).
@@ -273,15 +274,17 @@ handle_cast({invalidate_session, Host, Port,
 	    #state{session_cache = Cache,
 		   session_cache_cb = CacheCb} = State) ->
     CacheCb:update(Cache, {{Host, Port}, ID}, Session#session{is_resumable = false}),
-    timer:send_after(delay_time(), self(), {delayed_clean_session, {{Host, Port}, ID}}),
-    {noreply, State};
+    TRef =
+	erlang:send_after(delay_time(), self(), {delayed_clean_session, {{Host, Port}, ID}}),
+    {noreply, State#state{last_delay_timer = TRef}};
 
 handle_cast({invalidate_session, Port, #session{session_id = ID} = Session},
 	    #state{session_cache = Cache,
 		   session_cache_cb = CacheCb} = State) ->
     CacheCb:update(Cache, {Port, ID}, Session#session{is_resumable = false}),
-    timer:send_after(delay_time(), self(), {delayed_clean_session, {Port, ID}}),
-    {noreply, State};
+    TRef =
+	erlang:send_after(delay_time(), self(), {delayed_clean_session, {Port, ID}}),
+    {noreply, State#state{last_delay_timer = TRef}};
 
 handle_cast({recache_pem, File, LastWrite, Pid, From},
 	    #state{certificate_db = [_, FileToRefDb, _]} = State0) ->