ssl: Add downgrade handling to connection_env

Remove duplicate handsake history handling form
ssl_config function. Later we might refactor to avoid
duplication in TLS and DTLS code, but handshake history
does not belong in ssl_config function.

3 files changed, 44 insertions, 46 deletions

diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index e048dba38d..f24b4d555a 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -607,11 +607,7 @@ handle_session(#server_hello{cipher_suite = CipherSuite,
 %%--------------------------------------------------------------------
 -spec ssl_config(#ssl_options{}, client | server, #state{}) -> #state{}.
 %%--------------------------------------------------------------------
-ssl_config(Opts, Role, State) ->
-    ssl_config(Opts, Role, State, new).
-
-ssl_config(Opts, Role, #state{static_env = InitStatEnv0,
-                              handshake_env = HsEnv} = State0, Type) ->
+ssl_config(Opts, Role, #state{static_env = InitStatEnv0} = State0) ->
     {ok, #{cert_db_ref := Ref, 
            cert_db_handle := CertDbHandle, 
            fileref_db_handle := FileRefHandle, 
@@ -623,27 +619,19 @@ ssl_config(Opts, Role, #state{static_env = InitStatEnv0,
 	ssl_config:init(Opts, Role), 
     TimeStamp = erlang:monotonic_time(),
     Session = State0#state.session,
-
-    State = State0#state{session = Session#session{own_certificate = OwnCert,
-                                                   time_stamp = TimeStamp},
-                         static_env = InitStatEnv0#static_env{
-                                        file_ref_db = FileRefHandle,
-                                        cert_db_ref = Ref,
-                                        cert_db = CertDbHandle,
-                                        crl_db = CRLDbHandle,
-                                        session_cache = CacheHandle
-                                       },
-                         private_key = Key,
-                         diffie_hellman_params = DHParams,
-                         ssl_options = Opts},
-    case Type of
-        new ->
-            Hist = ssl_handshake:init_handshake_history(),
-            State#state{handshake_env = HsEnv#handshake_env{tls_handshake_history = Hist}};
-        continue ->
-            State
-    end.
-
+    
+    State0#state{session = Session#session{own_certificate = OwnCert,
+                                           time_stamp = TimeStamp},
+                 static_env = InitStatEnv0#static_env{
+                                file_ref_db = FileRefHandle,
+                                cert_db_ref = Ref,
+                                cert_db = CertDbHandle,
+                                crl_db = CRLDbHandle,
+                                session_cache = CacheHandle
+                               },
+                 private_key = Key,
+                 diffie_hellman_params = DHParams,
+                 ssl_options = Opts}.
 
 %%====================================================================
 %% gen_statem general state functions with connection cb argument
@@ -715,7 +703,7 @@ user_hello({call, From}, {handshake_continue, NewOptions, Timeout},
                   ssl_options = Options0} = State0, _Connection) ->
     Timer = start_or_recv_cancel_timer(Timeout, RecvFrom),
     Options = ssl:handle_options(NewOptions, Options0#ssl_options{handshake = full}),
-    State = ssl_config(Options, Role, State0, continue),
+    State = ssl_config(Options, Role, State0),
     {next_state, hello, State#state{start_or_recv_from = From,
                                     timer = Timer}, 
      [{next_event, internal, Hello}]};
@@ -1187,24 +1175,28 @@ handle_common_event(_Type, Msg, StateName, #state{negotiated_version = Version}
 handle_call({application_data, _Data}, _, _, _, _) ->
     %% In renegotiation priorities handshake, send data when handshake is finished
     {keep_state_and_data, [postpone]};
-handle_call({close, _} = Close, From, StateName, State, _Connection) ->
+handle_call({close, _} = Close, From, StateName, #state{connection_env = CEnv} = State, _Connection) ->
     %% Run terminate before returning so that the reuseaddr
     %% inet-option works properly
     Result = terminate(Close, StateName, State),
     {stop_and_reply,
      {shutdown, normal},
-     {reply, From, Result}, State#state{terminated = true}};
+     {reply, From, Result}, State#state{connection_env = CEnv#connection_env{terminated = true}}};
 handle_call({shutdown, read_write = How}, From, StateName,
 	    #state{static_env = #static_env{transport_cb = Transport,
-                                            socket = Socket}} = State, _) ->
+                                            socket = Socket},
+                   connection_env = CEnv} = State, _) ->
     try send_alert(?ALERT_REC(?WARNING, ?CLOSE_NOTIFY),
                    StateName, State) of
         _ -> 
             case Transport:shutdown(Socket, How) of
                 ok ->
-                    {next_state, StateName, State#state{terminated = true}, [{reply, From, ok}]};
+                    {next_state, StateName, State#state{connection_env = 
+                                                            CEnv#connection_env{terminated = true}},
+                     [{reply, From, ok}]};
                 Error ->
-                    {stop_and_reply, {shutdown, normal}, {reply, From, Error}, State#state{terminated = true}}
+                    {stop_and_reply, {shutdown, normal}, {reply, From, Error}, 
+                     State#state{connection_env = CEnv#connection_env{terminated = true}}}
             end
     catch
         throw:Return ->
@@ -1353,7 +1345,7 @@ handle_info(Msg, StateName, #state{static_env = #static_env{socket = Socket, err
 %%====================================================================
 %% general gen_statem callbacks
 %%====================================================================
-terminate(_, _, #state{terminated = true}) ->
+terminate(_, _, #state{connection_env = #connection_env{terminated = true}}) ->
     %% Happens when user closes the connection using ssl:close/1
     %% we want to guarantee that Transport:close has been called
     %% when ssl:close/1 returns unless it is a downgrade where
diff --git a/lib/ssl/src/ssl_connection.hrl b/lib/ssl/src/ssl_connection.hrl
index f182783f54..9d535cb1f2 100644
--- a/lib/ssl/src/ssl_connection.hrl
+++ b/lib/ssl/src/ssl_connection.hrl
@@ -70,7 +70,8 @@
 
 -record(connection_env, { 
                           user_application      :: {Monitor::reference(), User::pid()},
-                                                   
+                          downgrade,
+                          terminated = false                          ::boolean() | closed                           
                         }).
 
 -record(state, {
@@ -90,9 +91,7 @@
                 ssl_options           :: #ssl_options{},
                 socket_options        :: #socket_options{},
                 session               :: #session{} | secret_printout(),
-                terminated = false                          ::boolean() | closed,
                 negotiated_version    :: ssl_record:ssl_version() | 'undefined',
-                downgrade,
                 
                 %% Used only in HS
                 client_certificate_requested = false :: boolean(),
diff --git a/lib/ssl/src/tls_connection.erl b/lib/ssl/src/tls_connection.erl
index 7c901c882b..2e9ae97da0 100644
--- a/lib/ssl/src/tls_connection.erl
+++ b/lib/ssl/src/tls_connection.erl
@@ -619,13 +619,16 @@ connection({call, From}, {user_renegotiate, WriteState},
      [{next_event,{call, From}, renegotiate}]};
 connection({call, From}, 
            {close, {Pid, _Timeout}}, 
-           #state{terminated = closed} = State) ->
-    {next_state, downgrade, State#state{terminated = true, downgrade = {Pid, From}}, 
+           #state{connection_env = #connection_env{terminated = closed} =CEnv} = State) ->
+    {next_state, downgrade, State#state{connection_env = 
+                                            CEnv#connection_env{terminated = true, 
+                                                                downgrade = {Pid, From}}}, 
      [{next_event, internal, ?ALERT_REC(?WARNING, ?CLOSE_NOTIFY)}]};
 connection({call, From}, 
            {close,{Pid, Timeout}},
            #state{connection_states = ConnectionStates,
-                  protocol_specific = #{sender := Sender}
+                  protocol_specific = #{sender := Sender},
+                  connection_env = CEnv
                  } = State0) ->
     case tls_sender:downgrade(Sender, Timeout) of
         {ok, Write} ->
@@ -636,8 +639,10 @@ connection({call, From},
             State = send_alert(?ALERT_REC(?WARNING, ?CLOSE_NOTIFY), 
                                State0#state{connection_states =
                                                 ConnectionStates#{current_write => Write}}),
-            {next_state, downgrade, State#state{downgrade = {Pid, From},
-                                                terminated = true}, [{timeout, Timeout, downgrade}]};
+            {next_state, downgrade, State#state{connection_env = 
+                                                    CEnv#connection_env{downgrade = {Pid, From},
+                                                                        terminated = true}}, 
+             [{timeout, Timeout, downgrade}]};
         {error, timeout} ->
             {stop_and_reply, {shutdown, downgrade_fail}, [{reply, From, {error, timeout}}]}
     end;
@@ -715,15 +720,16 @@ connection(Type, Event, State) ->
 downgrade(internal, #alert{description = ?CLOSE_NOTIFY},
 	  #state{static_env = #static_env{transport_cb = Transport,
                                           socket = Socket},
-		 downgrade = {Pid, From}} = State) ->
+		 connection_env = #connection_env{downgrade = {Pid, From}}} = State) ->
     tls_socket:setopts(Transport, Socket, [{active, false}, {packet, 0}, {mode, binary}]),
     Transport:controlling_process(Socket, Pid),
     {stop_and_reply, {shutdown, downgrade},[{reply, From, {ok, Socket}}], State};
-downgrade(timeout, downgrade, #state{downgrade = {_, From}} = State) ->
+downgrade(timeout, downgrade, #state{ connection_env = #connection_env{downgrade = {_, From}}} = State) ->
     {stop_and_reply, {shutdown, normal},[{reply, From, {error, timeout}}], State};
 downgrade(info, {CloseTag, Socket},
           #state{static_env = #static_env{socket = Socket, 
-                                          close_tag = CloseTag}, downgrade = {_, From}} =
+                                          close_tag = CloseTag},
+                 connection_env = #connection_env{downgrade = {_, From}}} =
               State) ->
     {stop_and_reply, {shutdown, normal},[{reply, From, {error, CloseTag}}], State};
 downgrade(info, Info, State) ->
@@ -924,12 +930,13 @@ handle_alerts([], Result) ->
 handle_alerts(_, {stop, _, _} = Stop) ->
     Stop;
 handle_alerts([#alert{level = ?WARNING, description = ?CLOSE_NOTIFY} | _Alerts], 
-              {next_state, connection = StateName, #state{user_data_buffer = Buffer,
+              {next_state, connection = StateName, #state{connection_env = CEnv, 
                                                           socket_options = #socket_options{active = false},
+                                                          user_data_buffer = Buffer,
                                                           protocol_buffers = #protocol_buffers{tls_cipher_texts = CTs}} = 
                    State}) when (Buffer =/= <<>>) orelse
                                 (CTs =/= []) -> 
-    {next_state, StateName, State#state{terminated = true}};
+    {next_state, StateName, State#state{connection_env = CEnv#connection_env{terminated = true}}};
 handle_alerts([Alert | Alerts], {next_state, StateName, State}) ->
      handle_alerts(Alerts, ssl_connection:handle_alert(Alert, StateName, State));
 handle_alerts([Alert | Alerts], {next_state, StateName, State, _Actions}) ->