25 files changed, 925 insertions, 552 deletions

diff --git a/lib/ssl/src/dtls_connection.erl b/lib/ssl/src/dtls_connection.erl
index da2e076856..57f8dd86d3 100644
--- a/lib/ssl/src/dtls_connection.erl
+++ b/lib/ssl/src/dtls_connection.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -20,222 +20,514 @@
 
 %% Internal application API
 
-%%====================================================================
+-behaviour(gen_fsm).
+
+-include("dtls_connection.hrl").
+-include("dtls_handshake.hrl").
+-include("ssl_alert.hrl").
+-include("dtls_record.hrl").
+-include("ssl_cipher.hrl").
+-include("ssl_api.hrl").
+-include("ssl_internal.hrl").
+-include("ssl_srp.hrl").
+-include_lib("public_key/include/public_key.hrl"). 
+
 %% Internal application API
-%%====================================================================
 
+%% Setup
+-export([start_fsm/8]).
+
+%% State transition handling	 
+-export([next_record/1, next_state/4%, 
+	 %%next_state_connection/2
+	]).
+
+%% Handshake handling
+-export([%%renegotiate/1, 
+	 send_handshake/2, send_change_cipher/2]).
+
+%% Alert and close handling
+-export([send_alert/2, handle_own_alert/4, %%handle_close_alert/3,
+	 handle_normal_shutdown/3
+	 %%handle_unexpected_message/3,
+	 %%alert_user/5, alert_user/8
+	]).
+
+%% Data handling
+-export([%%write_application_data/3, 
+	 read_application_data/2%%,
+%%	 passive_receive/2,  next_record_if_active/1
+	]).
+
+%% Called by tls_connection_sup
+-export([start_link/7]). 
 
+%% gen_fsm callbacks
+-export([init/1, hello/2, certify/2, cipher/2,
+	 abbreviated/2, connection/2, handle_event/3,
+         handle_sync_event/4, handle_info/3, terminate/3, code_change/4]).
 
-%% %%====================================================================
-%% %% State functions
-%% %%====================================================================
-
-%% -spec hello(start | #hello_request{} | #client_hello{} | #server_hello{} | term(),
-%% 	    #state{}) -> gen_fsm_state_return().
-%% %%--------------------------------------------------------------------
-%% hello(start, #state{host = Host, port = Port, role = client,
-%% 			      ssl_options = SslOpts,
-%% 			      session = #session{own_certificate = Cert} = Session0,
-%% 			      session_cache = Cache, session_cache_cb = CacheCb,
-%% 			      connection_states = ConnectionStates0,
-%% 			      renegotiation = {Renegotiation, _},
-%% 			      client_cookie = Cookie} = State0) ->
-%%     Hello = dtls_handshake:client_hello(Host, Port, Cookie, ConnectionStates0, SslOpts,
-%% 				       Cache, CacheCb, Renegotiation, Cert),
-
-%%     Version = Hello#client_hello.client_version,
-%%     State1 = State0#state{negotiated_version = Version, %% Requested version
-%% 			  session =
-%% 			      Session0#session{session_id = Hello#client_hello.session_id},
-%% 			  dtls_handshake_history = ssl_handshake:init_handshake_history()},
-
-%%     State2 = send_flight(Hello, waiting, State1),
-
-%%     {Record, State} = next_record(State2),
-%%     next_state(hello, hello, Record, State);
-
-%% hello(start, #state{role = server} = State0) ->
-%%     {Record, State} = next_record(State0),
-%%     next_state(hello, hello, Record, State);
-
-%% hello(#hello_request{}, #state{role = client} = State0) ->
-%%     {Record, State} = next_record(State0),
-%%     next_state(hello, hello, Record, State);
-
-%% hello(#server_hello{cipher_suite = CipherSuite,
-%% 		    compression_method = Compression} = Hello,
-%%       #state{session = #session{session_id = OldId},
-%% 	     connection_states = ConnectionStates0,
-%% 	     role = client,
-%% 	     negotiated_version = ReqVersion,
-%% 	     renegotiation = {Renegotiation, _},
-%% 	     ssl_options = SslOptions} = State1) ->
-%%     State0 = flight_done(State1),
-%%     case ssl_handshake:hello(Hello, SslOptions, ConnectionStates0, Renegotiation) of
-%% 	#alert{} = Alert ->
-%% 	    handle_own_alert(Alert, ReqVersion, hello, State0);
-%% 	{Version, NewId, ConnectionStates, NextProtocol} ->
-%% 	    {KeyAlgorithm, _, _, _} =
-%% 		ssl_cipher:suite_definition(CipherSuite),
-
-%% 	    PremasterSecret = make_premaster_secret(ReqVersion, KeyAlgorithm),
-
-%% 	    NewNextProtocol = case NextProtocol of
-%% 				  undefined ->
-%% 				      State0#state.next_protocol;
-%% 				  _ ->
-%% 				      NextProtocol
-%% 			      end,
-
-%% 	    State = State0#state{key_algorithm = KeyAlgorithm,
-%% 				 hashsign_algorithm = default_hashsign(Version, KeyAlgorithm),
-%% 				 negotiated_version = Version,
-%% 				 connection_states = ConnectionStates,
-%% 				 premaster_secret = PremasterSecret,
-%% 				 expecting_next_protocol_negotiation = NextProtocol =/= undefined,
-%% 				 next_protocol = NewNextProtocol},
-
-%% 	    case ssl_session:is_new(OldId, NewId) of
-%% 		true ->
-%% 		    handle_new_session(NewId, CipherSuite, Compression,
-%% 				       State#state{connection_states = ConnectionStates});
-%% 		false ->
-%% 		    handle_resumed_session(NewId, State#state{connection_states = ConnectionStates})
-%% 	    end
-%%     end;
-
-%% hello(#hello_verify_request{cookie = Cookie},
-%%       #state{host = Host, port = Port,
-%% 	     session = #session{own_certificate = Cert},
-%% 	     session_cache = Cache, session_cache_cb = CacheCb,
-%% 	     ssl_options = SslOpts,
-%% 	     connection_states = ConnectionStates0,
-%% 	     renegotiation = {Renegotiation, _}} = State0) ->
-%%     Hello = ssl_handshake:client_hello(Host, Port, Cookie, ConnectionStates0, SslOpts,
-%% 				       Cache, CacheCb, Renegotiation, Cert),
-%%     State1 = State0#state{
-%% 	       tls_handshake_history = ssl_handshake:init_handshake_history(),
-%% 	       client_cookie = Cookie},
-%%     State2 = send_flight(Hello, waiting, State1),
-
-%%     {Record, State} = next_record(State2),
-%%     next_state(hello, hello, Record, State);
-
-
-%% %%--------------------------------------------------------------------
-%% -spec abbreviated(#hello_request{} | #finished{} | term(),
-%% 		  #state{}) -> gen_fsm_state_return().
-%% %%--------------------------------------------------------------------
-
-%% abbreviated(timeout, State) ->
-%%     { next_state, abbreviated, State, hibernate };
-
-%% abbreviated(Msg, State) ->
-%%     handle_unexpected_message(Msg, abbreviated, State).
-
-%% %%--------------------------------------------------------------------
-%% -spec certify(#hello_request{} | #certificate{} |  #server_key_exchange{} |
-%% 	      #certificate_request{} | #server_hello_done{} | #client_key_exchange{} | term(),
-%% 	      #state{}) -> gen_fsm_state_return().
-%% %%--------------------------------------------------------------------
-
-
-%% certify(timeout, State) ->
-%%     { next_state, certify, State, hibernate };
-
-%% certify(Msg, State) ->
-%%     handle_unexpected_message(Msg, certify, State).
-
-
-%% %%--------------------------------------------------------------------
-%% -spec cipher(#hello_request{} | #certificate_verify{} | #finished{} | term(),
-%% 	     #state{}) -> gen_fsm_state_return().
-%% %%--------------------------------------------------------------------
-
-%% cipher(timeout, State) ->
-%%     { next_state, cipher, State, hibernate };
-
-%% cipher(Msg, State) ->
-%%     handle_unexpected_message(Msg, cipher, State).
-
-%% %%--------------------------------------------------------------------
-%% -spec connection(#hello_request{} | #client_hello{} | term(),
-%% 		 #state{}) -> gen_fsm_state_return().
-%% %%--------------------------------------------------------------------
-
-%% connection(timeout, State) ->
-%%     {next_state, connection, State, hibernate};
-
-%% connection(Msg, State) ->
-%%     handle_unexpected_message(Msg, connection, State).
-
-%% %%--------------------------------------------------------------------
-%% %%% Internal functions
-%% %%--------------------------------------------------------------------
-%% handle_unexpected_message(Msg, Info, #state{negotiated_version = Version} = State) ->
-%%     Alert =  ?ALERT_REC(?FATAL,?UNEXPECTED_MESSAGE),
-%%     handle_own_alert(Alert, Version, {Info, Msg}, State).
-
-%% send_flight(HandshakeRec, FlightState, State) ->
-%%     send_flight(FlightState, buffer_flight(HandshakeRec, State)).
-
-%% send_flight(FlightState, State = #state{negotiated_version = Version,
-%% 					flight_buffer = Buffer}) ->
-
-%%     State1 = do_send_flight(queue:to_list(Buffer), [], State),
-%%     finish_send_flight(Version, FlightState, State1).
-
-%% resend_flight(State = #state{negotiated_version = Version,
-%% 			     flight_state = FlightState,
-%% 			     flight_buffer = Buffer})
-%%   when FlightState == finished; FlightState == waiting ->
-%%     State1 = do_send_flight(queue:to_list(Buffer), [], State),
-%%     finish_send_flight(Version, FlightState, State1);
-
-%% resend_flight(State) ->
-%%     State.
-
-%% flight_done(State) ->
-%%     cancel_dtls_retransmit_timer(State#state{flight_state = done,
-%% 					     flight_buffer = undefined}).
-
-%% do_send_flight([], BinMsgs, State = #state{transport_cb = Transport, socket = Socket}) ->
-%%     Transport:send(Socket, lists:reverse(BinMsgs)),
-%%     State;
-%% do_send_flight([{Epoch, MsgSeq, HandshakeRec}|T], BinMsgs0,
-%% 	       State = #state{negotiated_version = Version,
-%% 			      connection_states = ConnectionStates0}) ->
-%%     CS0 = ssl_record:connection_state_by_epoch(ConnectionStates0, Epoch, write),
-%%     {BinMsgs, CS1} = encode_handshake_rec(HandshakeRec, Version, MsgSeq, BinMsgs0, CS0),
-%%     ConnectionStates1 = ssl_record:set_connection_state_by_epoch(ConnectionStates0, CS1, write),
-%%     do_send_flight(T, BinMsgs, State#state{connection_states = ConnectionStates1}).
-
-%% cancel_dtls_retransmit_timer(State = #state{dtls_retransmit_timer = TimerRef}) ->
-%%     cancel_timer(TimerRef),
-%%     State#state{dtls_retransmit_timer = undefined}.
-
-%% rearm_dtls_retransmit_timer(State = #state{dtls_retransmit_timer = undefined}) ->
-%%     TimerRef = erlang:start_timer(1000, self(), dtls_retransmit),
-%%     State#state{dtls_retransmit_timer = TimerRef};
-%% rearm_dtls_retransmit_timer(State) ->
-%%     State.
-
-%% finish_send_flight({254, _}, waiting, State) ->
-%%     TimerRef = erlang:start_timer(1000, self(), dtls_retransmit),
-%%     State#state{
-%%       dtls_retransmit_timer = TimerRef,
-%%       last_retransmit = timestamp(),
-%%       flight_state = waiting};
-
-%% finish_send_flight(_, FlightState, State) ->
-%%     State#state{flight_state = FlightState}.
-
-%% timestamp() ->
-%%     {Mega, Sec, Micro} = erlang:now(),
-%%     Mega * 1000000 * 1000 + Sec * 1000 + (Micro div 1000).
-
-%% encode_handshake_rec(HandshakeRec, Version, MsgSeq, BinMsgs0, CS0) ->
-%%     {_, Fragments} = ssl_handshake:encode_handshake(HandshakeRec, Version, MsgSeq, 1400),
-%%     lists:foldl(fun(F, {Bin, C0}) ->
-%% 			{B, C1} = ssl_record:encode_handshake(F, Version, C0),
-%% 		{[B|Bin], C1} end, {BinMsgs0, CS0}, Fragments).
+%%====================================================================
+%% Internal application API
+%%====================================================================	     
+start_fsm(Role, Host, Port, Socket, {#ssl_options{erl_dist = false},_} = Opts,
+	  User, {CbModule, _,_, _} = CbInfo, 
+	  Timeout) -> 
+    try 
+	{ok, Pid} = dtls_connection_sup:start_child([Role, Host, Port, Socket, 
+						     Opts, User, CbInfo]), 
+	{ok, SslSocket} = ssl_connection:socket_control(?MODULE, Socket, Pid, CbModule),
+	ok = ssl_connection:handshake(SslSocket, Timeout),
+	{ok, SslSocket} 
+    catch
+	error:{badmatch, {error, _} = Error} ->
+	    Error
+    end;
+
+start_fsm(Role, Host, Port, Socket, {#ssl_options{erl_dist = true},_} = Opts,
+	  User, {CbModule, _,_, _} = CbInfo, 
+	  Timeout) -> 
+    try 
+	{ok, Pid} = dtls_connection_sup:start_child_dist([Role, Host, Port, Socket, 
+							  Opts, User, CbInfo]), 
+	{ok, SslSocket} = ssl_connection:socket_control(?MODULE, Socket, Pid, CbModule),
+	ok = ssl_connection:handshake(SslSocket, Timeout),
+	{ok, SslSocket} 
+    catch
+	error:{badmatch, {error, _} = Error} ->
+	    Error
+    end.
+
+send_handshake(Handshake, #state{negotiated_version = Version,
+				 tls_handshake_history = Hist0,
+				 connection_states = ConnectionStates0} = State0) ->
+    {BinHandshake, ConnectionStates, Hist} =
+	encode_handshake(Handshake, Version, ConnectionStates0, Hist0),
+    send_flight(BinHandshake, State0#state{connection_states = ConnectionStates,
+					   tls_handshake_history = Hist
+					  }).
+
+send_alert(Alert, #state{negotiated_version = Version,
+			 socket = Socket,
+			 transport_cb = Transport,
+			 connection_states = ConnectionStates0} = State0) ->
+    {BinMsg, ConnectionStates} =
+	ssl_alert:encode(Alert, Version, ConnectionStates0),
+    Transport:send(Socket, BinMsg),
+    State0#state{connection_states = ConnectionStates}.
+
+send_change_cipher(Msg, #state{connection_states = ConnectionStates0,
+			       socket = Socket,
+			       negotiated_version = Version,
+			       transport_cb = Transport} = State0) ->
+    {BinChangeCipher, ConnectionStates} =
+	encode_change_cipher(Msg, Version, ConnectionStates0),
+    Transport:send(Socket, BinChangeCipher),
+    State0#state{connection_states = ConnectionStates}.
+
+%%====================================================================
+%% tls_connection_sup API
+%%====================================================================
+
+%%--------------------------------------------------------------------
+-spec start_link(atom(), host(), inet:port_number(), port(), list(), pid(), tuple()) ->
+    {ok, pid()} | ignore |  {error, reason()}.
+%%
+%% Description: Creates a gen_fsm process which calls Module:init/1 to
+%% initialize. To ensure a synchronized start-up procedure, this function
+%% does not return until Module:init/1 has returned.  
+%%--------------------------------------------------------------------
+start_link(Role, Host, Port, Socket, Options, User, CbInfo) ->
+    {ok, proc_lib:spawn_link(?MODULE, init, [[Role, Host, Port, Socket, Options, User, CbInfo]])}.
+
+init([Role, Host, Port, Socket, {SSLOpts0, _} = Options,  User, CbInfo]) ->
+    process_flag(trap_exit, true),
+    State0 =  initial_state(Role, Host, Port, Socket, Options, User, CbInfo),
+    Handshake = ssl_handshake:init_handshake_history(),
+    TimeStamp = calendar:datetime_to_gregorian_seconds({date(), time()}),
+    try ssl_config:init(SSLOpts0, Role) of
+	{ok, Ref, CertDbHandle, FileRefHandle, CacheHandle, OwnCert, Key, DHParams} ->
+	    Session = State0#state.session,
+	    State = State0#state{
+		      tls_handshake_history = Handshake,
+		      session = Session#session{own_certificate = OwnCert,
+						time_stamp = TimeStamp},
+		      file_ref_db = FileRefHandle,
+		      cert_db_ref = Ref,
+		      cert_db = CertDbHandle,
+		      session_cache = CacheHandle,
+		      private_key = Key,
+		      diffie_hellman_params = DHParams},
+	    gen_fsm:enter_loop(?MODULE, [], hello, State, get_timeout(State))
+    catch
+	throw:Error ->
+	    gen_fsm:enter_loop(?MODULE, [], error, {Error,State0}, get_timeout(State0))
+    end.
+
+%%--------------------------------------------------------------------
+%% Description:There should be one instance of this function for each
+%% possible state name. Whenever a gen_fsm receives an event sent
+%% using gen_fsm:send_event/2, the instance of this function with the
+%% same name as the current state name StateName is called to handle
+%% the event. It is also called if a timeout occurs.
+%%
+hello(start, #state{host = Host, port = Port, role = client,
+		    ssl_options = SslOpts,
+		    session = #session{own_certificate = Cert} = Session0,
+		    session_cache = Cache, session_cache_cb = CacheCb,
+		    transport_cb = Transport, socket = Socket,
+		    connection_states = ConnectionStates0,
+		    renegotiation = {Renegotiation, _}} = State0) ->
+    Hello = dtls_handshake:client_hello(Host, Port, ConnectionStates0, SslOpts,
+					Cache, CacheCb, Renegotiation, Cert),
+    
+    Version = Hello#client_hello.client_version,
+    Handshake0 = ssl_handshake:init_handshake_history(),
+    {BinMsg, ConnectionStates, Handshake} =
+        encode_handshake(Hello, Version, ConnectionStates0, Handshake0),
+    Transport:send(Socket, BinMsg),
+    State1 = State0#state{connection_states = ConnectionStates,
+			  negotiated_version = Version, %% Requested version
+			  session =
+			      Session0#session{session_id = Hello#client_hello.session_id},
+			  tls_handshake_history = Handshake},
+    {Record, State} = next_record(State1),
+    next_state(hello, hello, Record, State);
+
+hello(Hello = #client_hello{client_version = ClientVersion,
+			    extensions = #hello_extensions{hash_signs = HashSigns}},
+      State = #state{connection_states = ConnectionStates0,
+		     port = Port, session = #session{own_certificate = Cert} = Session0,
+		     renegotiation = {Renegotiation, _},
+		     session_cache = Cache,
+		     session_cache_cb = CacheCb,
+		     ssl_options = SslOpts}) ->
+    HashSign = ssl_handshake:select_hashsign(HashSigns, Cert),
+    case dtls_handshake:hello(Hello, SslOpts, {Port, Session0, Cache, CacheCb,
+					      ConnectionStates0, Cert}, Renegotiation) of
+        {Version, {Type, Session},
+	 ConnectionStates,
+	 #hello_extensions{ec_point_formats = EcPointFormats,
+			   elliptic_curves = EllipticCurves} = ServerHelloExt} ->
+            ssl_connection:hello({common_client_hello, Type, ServerHelloExt, HashSign},
+				 State#state{connection_states  = ConnectionStates,
+					     negotiated_version = Version,
+					     session = Session,
+					     client_ecc = {EllipticCurves, EcPointFormats}}, ?MODULE);
+        #alert{} = Alert ->
+            handle_own_alert(Alert, ClientVersion, hello, State)
+    end;
+hello(Hello,
+      #state{connection_states = ConnectionStates0,
+	     negotiated_version = ReqVersion,
+	     role = client,
+	     renegotiation = {Renegotiation, _},
+	     ssl_options = SslOptions} = State) ->
+    case dtls_handshake:hello(Hello, SslOptions, ConnectionStates0, Renegotiation) of
+	#alert{} = Alert ->
+	    handle_own_alert(Alert, ReqVersion, hello, State);
+	{Version, NewId, ConnectionStates, NextProtocol} ->
+	    ssl_connection:handle_session(Hello, 
+					  Version, NewId, ConnectionStates, NextProtocol, State)
+    end;
+
+hello(Msg, State) ->
+    ssl_connection:hello(Msg, State, ?MODULE).
+
+abbreviated(Msg, State) ->
+    ssl_connection:abbreviated(Msg, State, ?MODULE).
+
+certify(Msg, State) ->
+    ssl_connection:certify(Msg, State, ?MODULE).
+
+cipher(Msg, State) ->
+     ssl_connection:cipher(Msg, State, ?MODULE).
+
+connection(#hello_request{}, #state{host = Host, port = Port,
+				    session = #session{own_certificate = Cert} = Session0,
+				    session_cache = Cache, session_cache_cb = CacheCb,
+				    ssl_options = SslOpts,
+				    connection_states = ConnectionStates0,
+				    renegotiation = {Renegotiation, _}} = State0) ->
+    Hello = dtls_handshake:client_hello(Host, Port, ConnectionStates0, SslOpts,
+					Cache, CacheCb, Renegotiation, Cert),
+    %% TODO DTLS version State1 = send_handshake(Hello, State0),
+    State1 = State0,
+    {Record, State} =
+	next_record(
+	  State1#state{session = Session0#session{session_id
+						  = Hello#client_hello.session_id}}),
+    next_state(connection, hello, Record, State);
+
+connection(#client_hello{} = Hello, #state{role = server, allow_renegotiate = true} = State) ->
+    %% Mitigate Computational DoS attack
+    %% http://www.educatedguesswork.org/2011/10/ssltls_and_computational_dos.html
+    %% http://www.thc.org/thc-ssl-dos/ Rather than disabling client
+    %% initiated renegotiation we will disallow many client initiated
+    %% renegotiations immediately after each other.
+    erlang:send_after(?WAIT_TO_ALLOW_RENEGOTIATION, self(), allow_renegotiate),
+    hello(Hello, State#state{allow_renegotiate = false});
+
+connection(#client_hello{}, #state{role = server, allow_renegotiate = false} = State0) ->
+    Alert = ?ALERT_REC(?WARNING, ?NO_RENEGOTIATION),
+    State = send_alert(Alert, State0),
+    next_state_connection(connection, State);
+  
+connection(Msg, State) ->
+     ssl_connection:connection(Msg, State, tls_connection).
+
+%%--------------------------------------------------------------------
+%% Description: Whenever a gen_fsm receives an event sent using
+%% gen_fsm:send_all_state_event/2, this function is called to handle
+%% the event. Not currently used!
+%%--------------------------------------------------------------------
+handle_event(_Event, StateName, State) ->
+    {next_state, StateName, State, get_timeout(State)}.
+
+%%--------------------------------------------------------------------
+%% Description: Whenever a gen_fsm receives an event sent using
+%% gen_fsm:sync_send_all_state_event/2,3, this function is called to handle
+%% the event.
+%%--------------------------------------------------------------------
+handle_sync_event(Event, From, StateName, State) ->
+    ssl_connection:handle_sync_event(Event, From, StateName, State).
+
+%%--------------------------------------------------------------------
+%% Description: This function is called by a gen_fsm when it receives any
+%% other message than a synchronous or asynchronous event
+%% (or a system message).
+%%--------------------------------------------------------------------
+
+%% raw data from socket, unpack records
+handle_info({Protocol, _, Data}, StateName,
+            #state{data_tag = Protocol} = State0) ->
+    %% Simplify for now to avoid dialzer warnings before implementation is  compleate
+    %% case next_tls_record(Data, State0) of
+    %% 	{Record, State} ->
+    %% 	    next_state(StateName, StateName, Record, State);
+    %% 	#alert{} = Alert ->
+    %% 	    handle_normal_shutdown(Alert, StateName, State0), 
+    %% 	    {stop, {shutdown, own_alert}, State0}
+    %% end;
+    {Record, State} = next_tls_record(Data, State0), 
+    next_state(StateName, StateName, Record, State);
+
+handle_info({CloseTag, Socket}, StateName,
+            #state{socket = Socket, close_tag = CloseTag,
+		   negotiated_version = _Version} = State) ->
+    handle_normal_shutdown(?ALERT_REC(?FATAL, ?CLOSE_NOTIFY), StateName, State),
+    {stop, {shutdown, transport_closed}, State};
+
+handle_info(Msg, StateName, State) ->
+    ssl_connection:handle_info(Msg, StateName, State).
+
+%%--------------------------------------------------------------------
+%% Description:This function is called by a gen_fsm when it is about
+%% to terminate. It should be the opposite of Module:init/1 and do any
+%% necessary cleaning up. When it returns, the gen_fsm terminates with
+%% Reason. The return value is ignored.
+%%--------------------------------------------------------------------
+terminate(Reason, StateName, State) ->
+    ssl_connection:terminate(Reason, StateName, State).
+
+%%--------------------------------------------------------------------
+%% code_change(OldVsn, StateName, State, Extra) -> {ok, StateName, NewState}
+%% Description: Convert process state when code is changed
+%%--------------------------------------------------------------------
+code_change(_OldVsn, StateName, State, _Extra) ->
+    {ok, StateName, State}.
+
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+encode_handshake(Handshake, Version, ConnectionStates0, Hist0) ->
+    Seq = sequence(ConnectionStates0),
+    {EncHandshake, FragmentedHandshake} = dtls_handshake:encode_handshake(Handshake, Version,
+								      Seq),
+    Hist = ssl_handshake:update_handshake_history(Hist0, EncHandshake),
+    {Encoded, ConnectionStates} =
+        dtls_record:encode_handshake(FragmentedHandshake, 
+				     Version, ConnectionStates0),
+    {Encoded, ConnectionStates, Hist}.
+
+next_record(#state{%%flight = #flight{state = finished}, 
+		   protocol_buffers =
+		       #protocol_buffers{dtls_packets = [], dtls_cipher_texts = [CT | Rest]}
+		   = Buffers,
+		   connection_states = ConnStates0} = State) ->
+    case dtls_record:decode_cipher_text(CT, ConnStates0) of
+	{Plain, ConnStates} ->		      
+	    {Plain, State#state{protocol_buffers =
+				    Buffers#protocol_buffers{dtls_cipher_texts = Rest},
+				connection_states = ConnStates}};
+	#alert{} = Alert ->
+	    {Alert, State}
+    end;
+next_record(#state{socket = Socket,
+		   transport_cb = Transport} = State) -> %% when FlightState =/= finished
+    ssl_socket:setopts(Transport, Socket, [{active,once}]),
+    {no_record, State};
+
+
+next_record(State) ->
+    {no_record, State}.
+
+next_state(Current,_, #alert{} = Alert, #state{negotiated_version = Version} = State) ->
+    handle_own_alert(Alert, Version, Current, State);
+
+next_state(_,Next, no_record, State) ->
+    {next_state, Next, State, get_timeout(State)};
+
+%% next_state(_,Next, #ssl_tls{type = ?ALERT, fragment = EncAlerts}, State) ->
+%%     Alerts = decode_alerts(EncAlerts),
+%%     handle_alerts(Alerts,  {next_state, Next, State, get_timeout(State)});
+
+next_state(Current, Next, #ssl_tls{type = ?HANDSHAKE, fragment = Data},
+	   State0 = #state{protocol_buffers =
+			       #protocol_buffers{dtls_handshake_buffer = Buf0} = Buffers,
+			   negotiated_version = Version}) ->
+    Handle = 
+   	fun({#hello_request{} = Packet, _}, {next_state, connection = SName, State}) ->
+   		%% This message should not be included in handshake
+   		%% message hashes. Starts new handshake (renegotiation)
+		Hs0 = ssl_handshake:init_handshake_history(),
+		?MODULE:SName(Packet, State#state{tls_handshake_history=Hs0,
+   						  renegotiation = {true, peer}});
+   	   ({#hello_request{} = Packet, _}, {next_state, SName, State}) ->
+   		%% This message should not be included in handshake
+   		%% message hashes. Already in negotiation so it will be ignored!
+   		?MODULE:SName(Packet, State);
+	   ({#client_hello{} = Packet, Raw}, {next_state, connection = SName, State}) ->
+		Version = Packet#client_hello.client_version,
+		Hs0 = ssl_handshake:init_handshake_history(),
+		Hs1 = ssl_handshake:update_handshake_history(Hs0, Raw),
+		?MODULE:SName(Packet, State#state{tls_handshake_history=Hs1,
+   						  renegotiation = {true, peer}});
+	   ({Packet, Raw}, {next_state, SName, State = #state{tls_handshake_history=Hs0}}) ->
+		Hs1 = ssl_handshake:update_handshake_history(Hs0, Raw),
+		?MODULE:SName(Packet, State#state{tls_handshake_history=Hs1});
+   	   (_, StopState) -> StopState
+   	end,
+    try
+	{Packets, Buf} = tls_handshake:get_tls_handshake(Version,Data,Buf0),
+	State = State0#state{protocol_buffers =
+				 Buffers#protocol_buffers{dtls_packets = Packets,
+							  dtls_handshake_buffer = Buf}},
+	handle_dtls_handshake(Handle, Next, State)
+    catch throw:#alert{} = Alert ->
+	    handle_own_alert(Alert, Version, Current, State0)
+    end;
+
+next_state(_, StateName, #ssl_tls{type = ?APPLICATION_DATA, fragment = Data}, State0) ->
+    %% Simplify for now to avoid dialzer warnings before implementation is  compleate
+    %% case read_application_data(Data, State0) of
+    %% 	Stop = {stop,_,_} ->
+    %% 	    Stop;
+    %% 	{Record, State} ->
+    %% 	    next_state(StateName, StateName, Record, State)
+    %% end;
+    {Record, State} = read_application_data(Data, State0),
+    next_state(StateName, StateName, Record, State);
+	
+next_state(Current, Next, #ssl_tls{type = ?CHANGE_CIPHER_SPEC, fragment = <<1>>} = 
+ 	   _ChangeCipher, 
+ 	   #state{connection_states = ConnectionStates0} = State0) ->
+    ConnectionStates1 =
+	ssl_record:activate_pending_connection_state(ConnectionStates0, read),
+    {Record, State} = next_record(State0#state{connection_states = ConnectionStates1}),
+    next_state(Current, Next, Record, State);
+next_state(Current, Next, #ssl_tls{type = _Unknown}, State0) ->
+    %% Ignore unknown type 
+    {Record, State} = next_record(State0),
+    next_state(Current, Next, Record, State).
+
+handle_dtls_handshake(Handle, StateName,
+		     #state{protocol_buffers =
+				#protocol_buffers{dtls_packets = [Packet]} = Buffers} = State) ->
+    FsmReturn = {next_state, StateName, State#state{protocol_buffers =
+							Buffers#protocol_buffers{dtls_packets = []}}},
+    Handle(Packet, FsmReturn);
+
+handle_dtls_handshake(Handle, StateName,
+		     #state{protocol_buffers =
+				#protocol_buffers{dtls_packets = [Packet | Packets]} = Buffers} =
+			 State0) ->
+    FsmReturn = {next_state, StateName, State0#state{protocol_buffers =
+							 Buffers#protocol_buffers{dtls_packets =
+										      Packets}}},
+    case Handle(Packet, FsmReturn) of
+	{next_state, NextStateName, State, _Timeout} ->
+	    handle_dtls_handshake(Handle, NextStateName, State);
+	{stop, _,_} = Stop ->
+	    Stop
+    end.
+
+
+send_flight(Fragments, #state{transport_cb = Transport, socket = Socket,
+			      protocol_buffers = _PBuffers} = State) ->
+    Transport:send(Socket, Fragments),
+    %% Start retransmission
+    %% State#state{protocol_buffers = 
+    %% 		    (PBuffers#protocol_buffers){ #flight{state = waiting}}}}.
+    State.
+
+handle_own_alert(_,_,_, State) -> %% Place holder
+    {stop, {shutdown, own_alert}, State}.
+
+handle_normal_shutdown(_, _, _State) -> %% Place holder
+    ok.
+
+encode_change_cipher(#change_cipher_spec{}, Version, ConnectionStates) -> 
+    dtls_record:encode_change_cipher_spec(Version, ConnectionStates).
+
+initial_state(Role, Host, Port, Socket, {SSLOptions, SocketOptions}, User,
+	      {CbModule, DataTag, CloseTag, ErrorTag}) ->
+    ConnectionStates = ssl_record:init_connection_states(Role),
+    
+    SessionCacheCb = case application:get_env(ssl, session_cb) of
+			 {ok, Cb} when is_atom(Cb) ->
+			    Cb;
+			 _  ->
+			     ssl_session_cache
+		     end,
+    
+    Monitor = erlang:monitor(process, User),
+
+    #state{socket_options = SocketOptions,
+	   %% We do not want to save the password in the state so that
+	   %% could be written in the clear into error logs.
+	   ssl_options = SSLOptions#ssl_options{password = undefined},	   
+	   session = #session{is_resumable = new},
+	   transport_cb = CbModule,
+	   data_tag = DataTag,
+	   close_tag = CloseTag,
+	   error_tag = ErrorTag,
+	   role = Role,
+	   host = Host,
+	   port = Port,
+	   socket = Socket,
+	   connection_states = ConnectionStates,
+	   protocol_buffers = #protocol_buffers{},
+	   user_application = {Monitor, User},
+	   user_data_buffer = <<>>,
+	   session_cache_cb = SessionCacheCb,
+	   renegotiation = {false, first},
+	   start_or_recv_from = undefined,
+	   send_queue = queue:new(),
+	   protocol_cb = ?MODULE
+	  }.
+read_application_data(_,State) ->
+    {#ssl_tls{fragment = <<"place holder">>}, State}.
+	
+next_tls_record(_, State) ->
+    {#ssl_tls{fragment = <<"place holder">>}, State}.
+
+get_timeout(_) -> %% Place holder
+    infinity.
+
+next_state_connection(_, State) -> %% Place holder
+    {next_state, connection, State, get_timeout(State)}.
+
+sequence(_) -> 
+    %%TODO real imp
+    1.
diff --git a/lib/ssl/src/dtls_connection.hrl b/lib/ssl/src/dtls_connection.hrl
index b8dff479d5..08707dc8de 100644
--- a/lib/ssl/src/dtls_connection.hrl
+++ b/lib/ssl/src/dtls_connection.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -28,24 +28,19 @@
 -include("ssl_connection.hrl").
 
 -record(protocol_buffers, {
-	  dtls_packets = []      ::[binary()],  % Not yet handled decode ssl/tls packets.
-          dtls_record_buffer     :: binary(),   % Buffer of incomplete records
-          dtls_handshake_buffer  :: binary(),   % Buffer of incomplete handshakes
-	  dtls_cipher_texts      :: [binary()],
-	  dtls_cipher_texts_next :: [binary()]  % Received for Epoch not yet active
+	  dtls_packets = [],              %%::[binary()],  % Not yet handled decode ssl/tls packets.
+          dtls_record_buffer = <<>>,      %%:: binary(),   % Buffer of incomplete records
+          dtls_handshake_buffer = <<>>,   %%:: binary(),   % Buffer of incomplete handshakes
+	  dtls_cipher_texts = [],         %%:: [binary()],
+	  dtls_cipher_texts_next          %%:: [binary()]  % Received for Epoch not yet active
 	 }).
 
 -record(flight, {
 	  last_retransmit,
 	  last_read_seq,
 	  msl_timer,
-	  flight_state,
-	  flight_buffer,        % buffer of not yet ACKed TLS records
-	 }).
-
--record(message_sequences, {
-	  read = 0,
-	  write = 0
+	  state,
+	  buffer        % buffer of not yet ACKed TLS records
 	 }).
 
 -endif. % -ifdef(dtls_connection).
diff --git a/lib/ssl/src/dtls_connection_sup.erl b/lib/ssl/src/dtls_connection_sup.erl
index 9fe545be18..0b4711cfb4 100644
--- a/lib/ssl/src/dtls_connection_sup.erl
+++ b/lib/ssl/src/dtls_connection_sup.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2007-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2014. 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
@@ -26,8 +26,8 @@
 -behaviour(supervisor).
 
 %% API
--export([start_link/0]).
--export([start_child/1]).
+-export([start_link/0, start_link_dist/0]).
+-export([start_child/1, start_child_dist/1]).
 
 %% Supervisor callback
 -export([init/1]).
@@ -38,8 +38,14 @@
 start_link() ->
     supervisor:start_link({local, ?MODULE}, ?MODULE, []).
 
+start_link_dist() ->
+    supervisor:start_link({local, dtls_connection_sup_dist}, ?MODULE, []).
+
 start_child(Args) ->
     supervisor:start_child(?MODULE, Args).
+        
+start_child_dist(Args) ->
+    supervisor:start_child(dtls_connection_sup_dist, Args).
     
 %%%=========================================================================
 %%%  Supervisor callback
diff --git a/lib/ssl/src/dtls_handshake.erl b/lib/ssl/src/dtls_handshake.erl
index 5db2434753..31d525b295 100644
--- a/lib/ssl/src/dtls_handshake.erl
+++ b/lib/ssl/src/dtls_handshake.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -20,11 +20,15 @@
 -include("dtls_handshake.hrl").
 -include("dtls_record.hrl").
 -include("ssl_internal.hrl").
+-include("ssl_alert.hrl").
 
--export([client_hello/8, client_hello/9, hello/3,
+-export([client_hello/8, client_hello/9, hello/4,
 	 get_dtls_handshake/2,
-	 dtls_handshake_new_flight/1, dtls_handshake_new_epoch/1,
-	 encode_handshake/4]).
+	 %%dtls_handshake_new_flight/1, dtls_handshake_new_epoch/1,
+	 encode_handshake/3]).
+
+-type dtls_handshake() :: #client_hello{} | #hello_verify_request{} | 
+			  ssl_handshake:ssl_handshake().
 
 %%====================================================================
 %% Internal application API
@@ -54,12 +58,12 @@ client_hello(Host, Port, Cookie, ConnectionStates,
 			  ciphers = UserSuites
 			 } = SslOpts,
 	     Cache, CacheCb, Renegotiation, OwnCert) ->
-    Version = dtls_record:highest_protocol_version(Versions),
+    Version =  dtls_record:highest_protocol_version(Versions),
     Pending = ssl_record:pending_connection_state(ConnectionStates, read),
     SecParams = Pending#connection_state.security_parameters,
     CipherSuites = ssl_handshake:available_suites(UserSuites, Version),
 
-    Extensions = ssl_handshake:client_hello_extensions(Host, Version, CipherSuites,
+    Extensions = ssl_handshake:client_hello_extensions(Host, dtls_v1:corresponding_tls_version(Version), CipherSuites,
 						SslOpts, ConnectionStates, Renegotiation),
 
     Id = ssl_session:client_id({Host, Port, SslOpts}, Cache, CacheCb, OwnCert),
@@ -73,163 +77,197 @@ client_hello(Host, Port, Cookie, ConnectionStates,
 		  extensions = Extensions
 		 }.
 
-hello(Address, Port,
-      #ssl_tls{epoch = _Epoch, record_seq = _Seq,
-	       version = Version} = Record) ->
-    {[{Hello, _}], _, _} =
-	get_dtls_handshake(Record,
-			   dtls_handshake_new_flight(undefined)),
-    #client_hello{client_version = {Major, Minor},
-		  random = Random,
-		  session_id = SessionId,
-		  cipher_suites = CipherSuites,
-		  compression_methods = CompressionMethods} = Hello,
-    CookieData = [address_to_bin(Address, Port),
-		  <<?BYTE(Major), ?BYTE(Minor)>>,
-		  Random, SessionId, CipherSuites, CompressionMethods],
-    Cookie = crypto:hmac(sha, <<"secret">>, CookieData),
-
-    case Hello of
-	#client_hello{cookie = Cookie} ->
-	    accept;
-	_ ->
-	    %% generate HelloVerifyRequest
-	    HelloVerifyRequest = encode_handshake(#hello_verify_request{protocol_version = Version,
-									  cookie = Cookie},
-						    Version, 0, 1400),
-	    {reply, HelloVerifyRequest}
-    end.
+hello(#server_hello{server_version = Version, random = Random,
+		    cipher_suite = CipherSuite,
+		    compression_method = Compression,
+		    session_id = SessionId, extensions = HelloExt},
+      #ssl_options{versions = SupportedVersions} = SslOpt,
+      ConnectionStates0, Renegotiation) ->
+    case dtls_record:is_acceptable_version(Version, SupportedVersions) of
+	true ->
+	    handle_server_hello_extensions(Version, SessionId, Random, CipherSuite,
+					   Compression, HelloExt, SslOpt, ConnectionStates0, Renegotiation);
+	false ->
+	    ?ALERT_REC(?FATAL, ?PROTOCOL_VERSION)
+    end;
 
-%%--------------------------------------------------------------------
-encode_handshake(Package, Version, MsgSeq, Mss) ->
-    {MsgType, Bin} = enc_hs(Package, Version),
+hello(#client_hello{client_version = ClientVersion}, _Options, {_,_,_,_,ConnectionStates,_}, _Renegotiation) ->      
+    %% Return correct typ to make dialyzer happy until we have time to make the real imp.
+    {ClientVersion, {new, #session{}}, ConnectionStates, #hello_extensions{}}.
+
+%% hello(Address, Port,
+%%       #ssl_tls{epoch = _Epoch, sequence_number = _Seq,
+%% 	       version = Version} = Record) ->
+%%     case get_dtls_handshake(Record,
+%% 				dtls_handshake_new_flight(undefined)) of
+%% 	{[Hello | _], _} ->
+%% 	    hello(Address, Port, Version, Hello);
+%% 	{retransmit, HandshakeState} ->
+%% 	    {retransmit, HandshakeState}
+%%     end.
+					     
+%% hello(Address, Port, Version, Hello) ->
+%%     #client_hello{client_version = {Major, Minor},
+%% 		  random = Random,
+%% 		  session_id = SessionId,
+%% 		  cipher_suites = CipherSuites,
+%% 		  compression_methods = CompressionMethods} = Hello,
+%%     CookieData = [address_to_bin(Address, Port),
+%% 		  <<?BYTE(Major), ?BYTE(Minor)>>,
+%% 		  Random, SessionId, CipherSuites, CompressionMethods],
+%%     Cookie = crypto:hmac(sha, <<"secret">>, CookieData),
+
+%%     case Hello of
+%% 	#client_hello{cookie = Cookie} ->
+%% 	    accept;
+%% 	_ ->
+%% 	    %% generate HelloVerifyRequest
+%% 	    HelloVerifyRequest = enc_hs(#hello_verify_request{protocol_version = Version,
+%% 									  cookie = Cookie},
+%% 						    Version, 0, 1400),
+%% 	    {reply, HelloVerifyRequest}
+%%     end.
+
+%% %%--------------------------------------------------------------------
+encode_handshake(Handshake, Version, MsgSeq) ->
+    {MsgType, Bin} = enc_handshake(Handshake, Version),
     Len = byte_size(Bin),
-    HsHistory = [MsgType, ?uint24(Len), ?uint16(MsgSeq), ?uint24(0), ?uint24(Len), Bin],
-    BinMsg = dtls_split_handshake(Mss, MsgType, Len, MsgSeq, Bin, 0, []),
-    {HsHistory, BinMsg}.
+    EncHandshake = [MsgType, ?uint24(Len), ?uint16(MsgSeq), ?uint24(0), ?uint24(Len), Bin],
+    FragmentedHandshake = dtls_fragment(erlang:iolist_size(EncHandshake), MsgType, Len, MsgSeq, Bin, 0, []),
+    {EncHandshake, FragmentedHandshake}.
 
-%--------------------------------------------------------------------
+%%--------------------------------------------------------------------
 -spec get_dtls_handshake(#ssl_tls{}, #dtls_hs_state{} | binary()) ->
-     {[dtls_handshake()], #dtls_hs_state{}} | {retransmit, #dtls_hs_state{}}.
-%
-% Description: Given a DTLS state and new data from ssl_record, collects
-% and returns it as a list of handshake messages, also returns a new
-% DTLS state
-%--------------------------------------------------------------------
-% get_dtls_handshake(Record, <<>>) ->
-%     get_dtls_handshake_aux(Record, dtls_hs_state_init());
+				{[dtls_handshake()], #dtls_hs_state{}} | {retransmit, #dtls_hs_state{}}.
+%%
+%% Description: Given a DTLS state and new data from ssl_record, collects
+%% and returns it as a list of handshake messages, also returns a new
+%% DTLS state
+%%--------------------------------------------------------------------
+get_dtls_handshake(Record, <<>>) ->
+    get_dtls_handshake_aux(Record, #dtls_hs_state{}); %% Init handshake state!?
 get_dtls_handshake(Record, HsState) ->
     get_dtls_handshake_aux(Record, HsState).
 
-%--------------------------------------------------------------------
--spec dtls_handshake_new_epoch(#dtls_hs_state{}) -> #dtls_hs_state{}.
-%
-% Description: Reset the DTLS decoder state for a new Epoch
-%--------------------------------------------------------------------
-% dtls_handshake_new_epoch(<<>>) ->
-%     dtls_hs_state_init();
-dtls_handshake_new_epoch(HsState) ->
-    HsState#dtls_hs_state{highest_record_seq = 0,
-			  starting_read_seq = HsState#dtls_hs_state.current_read_seq,
-			  fragments = gb_trees:empty(), completed = []}.
-
-%--------------------------------------------------------------------
--spec dtls_handshake_new_flight(integer() | undefined) -> #dtls_hs_state{}.
-%
-% Description: Init the DTLS decoder state for a new Flight
-dtls_handshake_new_flight(ExpectedReadReq) ->
-    #dtls_hs_state{current_read_seq = ExpectedReadReq,
-		   highest_record_seq = 0,
-		   starting_read_seq = 0,
-		   fragments = gb_trees:empty(), completed = []}.
+%% %%--------------------------------------------------------------------
+%% -spec dtls_handshake_new_epoch(#dtls_hs_state{}) -> #dtls_hs_state{}.
+%% %%
+%% %% Description: Reset the DTLS decoder state for a new Epoch
+%% %%--------------------------------------------------------------------
+%% dtls_handshake_new_epoch(<<>>) ->
+%%     dtls_hs_state_init();
+%% dtls_handshake_new_epoch(HsState) ->
+%%     HsState#dtls_hs_state{highest_record_seq = 0,
+%%   			  starting_read_seq = HsState#dtls_hs_state.current_read_seq,
+%%   			  fragments = gb_trees:empty(), completed = []}.
+
+%% %--------------------------------------------------------------------
+%% -spec dtls_handshake_new_flight(integer() | undefined) -> #dtls_hs_state{}.
+%% %
+%% % Description: Init the DTLS decoder state for a new Flight
+%% dtls_handshake_new_flight(ExpectedReadReq) ->
+%%     #dtls_hs_state{current_read_seq = ExpectedReadReq,
+%% 		   highest_record_seq = 0,
+%% 		   starting_read_seq = 0,
+%% 		   fragments = gb_trees:empty(), completed = []}.
 
 %%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
+handle_server_hello_extensions(Version, SessionId, Random, CipherSuite,
+			       Compression, HelloExt, SslOpt, ConnectionStates0, Renegotiation) ->
+    case ssl_handshake:handle_server_hello_extensions(dtls_record, Random, CipherSuite,
+						      Compression, HelloExt, Version,
+						      SslOpt, ConnectionStates0, Renegotiation) of
+	#alert{} = Alert ->
+	    Alert;
+	{ConnectionStates, Protocol} ->
+	    {Version, SessionId, ConnectionStates, Protocol}
+    end.
 
-dtls_split_handshake(Mss, MsgType, Len, MsgSeq, Bin, Offset, Acc)
+dtls_fragment(Mss, MsgType, Len, MsgSeq, Bin, Offset, Acc)
   when byte_size(Bin) + 12 < Mss ->
     FragmentLen = byte_size(Bin),
     BinMsg = [MsgType, ?uint24(Len), ?uint16(MsgSeq), ?uint24(Offset), ?uint24(FragmentLen), Bin],
     lists:reverse([BinMsg|Acc]);
-dtls_split_handshake(Mss, MsgType, Len, MsgSeq, Bin, Offset, Acc) ->
+dtls_fragment(Mss, MsgType, Len, MsgSeq, Bin, Offset, Acc) ->
     FragmentLen = Mss - 12,
     <<Fragment:FragmentLen/bytes, Rest/binary>> = Bin,
     BinMsg = [MsgType, ?uint24(Len), ?uint16(MsgSeq), ?uint24(Offset), ?uint24(FragmentLen), Fragment],
-    dtls_split_handshake(Mss, MsgType, Len, MsgSeq, Rest, Offset + FragmentLen, [BinMsg|Acc]).
+    dtls_fragment(Mss, MsgType, Len, MsgSeq, Rest, Offset + FragmentLen, [BinMsg|Acc]).
 
 get_dtls_handshake_aux(#ssl_tls{version = Version,
-				record_seq = SeqNo,
-				fragment = Data}, HsState) ->
+ 				sequence_number = SeqNo,
+ 				fragment = Data}, HsState) ->
     get_dtls_handshake_aux(Version, SeqNo, Data, HsState).
 
 get_dtls_handshake_aux(Version, SeqNo,
-		       <<?BYTE(Type), ?UINT24(Length),
-			 ?UINT16(MessageSeq),
-			 ?UINT24(FragmentOffset), ?UINT24(FragmentLength),
-			 Body:FragmentLength/binary, Rest/binary>>,
-		       HsState0) ->
+ 		       <<?BYTE(Type), ?UINT24(Length),
+ 			 ?UINT16(MessageSeq),
+ 			 ?UINT24(FragmentOffset), ?UINT24(FragmentLength),
+ 			 Body:FragmentLength/binary, Rest/binary>>,
+ 		       HsState0) ->
     case reassemble_dtls_fragment(SeqNo, Type, Length, MessageSeq,
-				 FragmentOffset, FragmentLength,
-				 Body, HsState0) of
-	{retransmit, HsState1} ->
-	    case Rest of
-		<<>> ->
-		    {retransmit, HsState1};
-		_ ->
-		    get_dtls_handshake_aux(Version, SeqNo, Rest, HsState1)
-	    end;
-	{HsState1, HighestSeqNo, MsgBody} ->
-	    HsState2 = dec_dtls_fragment(Version, HighestSeqNo, Type, Length, MessageSeq, MsgBody, HsState1),
-	    HsState3 = process_dtls_fragments(Version, HsState2),
-	    get_dtls_handshake_aux(Version, SeqNo, Rest, HsState3);
-	HsState2 ->
-	    HsState3 = process_dtls_fragments(Version, HsState2),
-	    get_dtls_handshake_aux(Version, SeqNo, Rest, HsState3)
-    end;
+				  FragmentOffset, FragmentLength,
+				  Body, HsState0) of
+ 	{retransmit, HsState1} ->
+ 	    case Rest of
+ 		<<>> ->
+ 		    {retransmit, HsState1};
+ 		_ ->
+ 		    get_dtls_handshake_aux(Version, SeqNo, Rest, HsState1)
+ 	    end;
+ 	{HsState1, HighestSeqNo, MsgBody} ->
+ 	    HsState2 = dec_dtls_fragment(Version, HighestSeqNo, Type, Length, MessageSeq, MsgBody, HsState1),
+ 	    HsState3 = process_dtls_fragments(Version, HsState2),
+ 	    get_dtls_handshake_aux(Version, SeqNo, Rest, HsState3);
+ 	HsState2 ->
+ 	    HsState3 = process_dtls_fragments(Version, HsState2),
+ 	    get_dtls_handshake_aux(Version, SeqNo, Rest, HsState3)
+     end;
 
 get_dtls_handshake_aux(_Version, _SeqNo, <<>>, HsState) ->
-    {lists:reverse(HsState#dtls_hs_state.completed),
-     HsState#dtls_hs_state{completed = []}}.
+     {lists:reverse(HsState#dtls_hs_state.completed),
+      HsState#dtls_hs_state{completed = []}}.
 
 dec_dtls_fragment(Version, SeqNo, Type, Length, MessageSeq, MsgBody,
-		  HsState = #dtls_hs_state{highest_record_seq = HighestSeqNo, completed = Acc}) ->
+ 		  HsState = #dtls_hs_state{highest_record_seq = HighestSeqNo, completed = Acc}) ->
     Raw = <<?BYTE(Type), ?UINT24(Length), ?UINT16(MessageSeq), ?UINT24(0), ?UINT24(Length), MsgBody/binary>>,
     H = decode_handshake(Version, Type, MsgBody),
     HsState#dtls_hs_state{completed = [{H,Raw}|Acc], highest_record_seq = erlang:max(HighestSeqNo, SeqNo)}.
 
 process_dtls_fragments(Version,
-		       HsState0 = #dtls_hs_state{current_read_seq = CurrentReadSeq,
-						 fragments = Fragments0}) ->
+ 		       HsState0 = #dtls_hs_state{current_read_seq = CurrentReadSeq,
+ 						 fragments = Fragments0}) ->
     case gb_trees:is_empty(Fragments0) of
-	true ->
-	    HsState0;
-	_ ->
-	    case gb_trees:smallest(Fragments0) of
-		{CurrentReadSeq, {SeqNo, Type, Length, CurrentReadSeq, {Length, [{0, Length}], MsgBody}}} ->
-		    HsState1 = dtls_hs_state_process_seq(HsState0),
-		    HsState2 = dec_dtls_fragment(Version, SeqNo, Type, Length, CurrentReadSeq, MsgBody, HsState1),
-		    process_dtls_fragments(Version, HsState2);
-		_ ->
-		    HsState0
-	    end
-    end.
+ 	true ->
+ 	    HsState0;
+ 	_ ->
+ 	    case gb_trees:smallest(Fragments0) of
+ 		{CurrentReadSeq, {SeqNo, Type, Length, CurrentReadSeq, {Length, [{0, Length}], MsgBody}}} ->
+ 		    HsState1 = dtls_hs_state_process_seq(HsState0),
+ 		    HsState2 = dec_dtls_fragment(Version, SeqNo, Type, Length, CurrentReadSeq, MsgBody, HsState1),
+ 		    process_dtls_fragments(Version, HsState2);
+ 		_ ->
+ 		    HsState0
+ 	    end
+     end.
 
 dtls_hs_state_process_seq(HsState0 = #dtls_hs_state{current_read_seq = CurrentReadSeq,
-						    fragments = Fragments0}) ->
+ 						    fragments = Fragments0}) ->
     Fragments1 = gb_trees:delete_any(CurrentReadSeq, Fragments0),
     HsState0#dtls_hs_state{current_read_seq = CurrentReadSeq + 1,
-			   fragments = Fragments1}.
+ 			   fragments = Fragments1}.
 
 dtls_hs_state_add_fragment(MessageSeq, Fragment, HsState0 = #dtls_hs_state{fragments = Fragments0}) ->
     Fragments1 = gb_trees:enter(MessageSeq, Fragment, Fragments0),
     HsState0#dtls_hs_state{fragments = Fragments1}.
 
 reassemble_dtls_fragment(SeqNo, Type, Length, MessageSeq, 0, Length,
-			 Body, HsState0 = #dtls_hs_state{current_read_seq = undefined})
+ 			 Body, HsState0 = #dtls_hs_state{current_read_seq = undefined})
   when Type == ?CLIENT_HELLO;
        Type == ?SERVER_HELLO;
-       Type == ?HELLO_VERIFY_REQUEST ->
+        Type == ?HELLO_VERIFY_REQUEST ->
     %% First message, should be client hello
     %% return the current message and set the next expected Sequence
     %%
@@ -245,8 +283,8 @@ reassemble_dtls_fragment(_SeqNo, _Type, Length, _MessageSeq, _, Length,
     HsState;
 
 reassemble_dtls_fragment(SeqNo, _Type, Length, MessageSeq, 0, Length,
-			 Body, HsState0 =
-			     #dtls_hs_state{starting_read_seq = StartingReadSeq})
+ 			 Body, HsState0 =
+ 			     #dtls_hs_state{starting_read_seq = StartingReadSeq})
   when MessageSeq < StartingReadSeq ->
     %% this has to be the start of a new flight, let it through
     %%
@@ -257,69 +295,69 @@ reassemble_dtls_fragment(SeqNo, _Type, Length, MessageSeq, 0, Length,
     {HsState, SeqNo, Body};
 
 reassemble_dtls_fragment(_SeqNo, _Type, Length, MessageSeq, 0, Length,
-			 _Body, HsState =
-			     #dtls_hs_state{current_read_seq = CurrentReadSeq})
+ 			 _Body, HsState =
+ 			     #dtls_hs_state{current_read_seq = CurrentReadSeq})
   when MessageSeq < CurrentReadSeq ->
     {retransmit, HsState};
 
 reassemble_dtls_fragment(_SeqNo, _Type, Length, MessageSeq, 0, Length,
-			 _Body, HsState = #dtls_hs_state{current_read_seq = CurrentReadSeq})
+ 			 _Body, HsState = #dtls_hs_state{current_read_seq = CurrentReadSeq})
   when MessageSeq < CurrentReadSeq ->
     HsState;
 
 reassemble_dtls_fragment(SeqNo, _Type, Length, MessageSeq, 0, Length,
-			 Body, HsState0 = #dtls_hs_state{current_read_seq = MessageSeq}) ->
+ 			 Body, HsState0 = #dtls_hs_state{current_read_seq = MessageSeq}) ->
     %% Message fully contained and it's the current seq
     HsState1 = dtls_hs_state_process_seq(HsState0),
     {HsState1, SeqNo, Body};
 
 reassemble_dtls_fragment(SeqNo, Type, Length, MessageSeq, 0, Length,
-			 Body, HsState) ->
+ 			 Body, HsState) ->
     %% Message fully contained and it's the NOT the current seq -> buffer
     Fragment = {SeqNo, Type, Length, MessageSeq,
-		dtls_fragment_init(Length, 0, Length, Body)},
+ 		dtls_fragment_init(Length, 0, Length, Body)},
     dtls_hs_state_add_fragment(MessageSeq, Fragment, HsState);
 
 reassemble_dtls_fragment(_SeqNo, _Type, Length, MessageSeq, FragmentOffset, FragmentLength,
-			 _Body,
-			 HsState = #dtls_hs_state{current_read_seq = CurrentReadSeq})
+ 			 _Body,
+ 			 HsState = #dtls_hs_state{current_read_seq = CurrentReadSeq})
   when FragmentOffset + FragmentLength == Length andalso MessageSeq == (CurrentReadSeq - 1) ->
     {retransmit, HsState};
 
 reassemble_dtls_fragment(_SeqNo, _Type, _Length, MessageSeq, _FragmentOffset, _FragmentLength,
-			 _Body,
-			 HsState = #dtls_hs_state{current_read_seq = CurrentReadSeq})
+ 			 _Body,
+ 			 HsState = #dtls_hs_state{current_read_seq = CurrentReadSeq})
   when MessageSeq < CurrentReadSeq ->
     HsState;
 
 reassemble_dtls_fragment(SeqNo, Type, Length, MessageSeq,
-			 FragmentOffset, FragmentLength,
-			 Body,
-			 HsState = #dtls_hs_state{fragments = Fragments0}) ->
+ 			 FragmentOffset, FragmentLength,
+ 			 Body,
+ 			 HsState = #dtls_hs_state{fragments = Fragments0}) ->
     case gb_trees:lookup(MessageSeq, Fragments0) of
-	{value, Fragment} ->
-	    dtls_fragment_reassemble(SeqNo, Type, Length, MessageSeq,
-				     FragmentOffset, FragmentLength,
-				     Body, Fragment, HsState);
-	none ->
-	    dtls_fragment_start(SeqNo, Type, Length, MessageSeq,
-				FragmentOffset, FragmentLength,
-				Body, HsState)
+ 	{value, Fragment} ->
+ 	    dtls_fragment_reassemble(SeqNo, Type, Length, MessageSeq,
+ 				     FragmentOffset, FragmentLength,
+ 				     Body, Fragment, HsState);
+ 	none ->
+ 	    dtls_fragment_start(SeqNo, Type, Length, MessageSeq,
+ 				FragmentOffset, FragmentLength,
+ 				Body, HsState)
     end.
 
 dtls_fragment_start(SeqNo, Type, Length, MessageSeq,
-				FragmentOffset, FragmentLength,
-				Body, HsState = #dtls_hs_state{fragments = Fragments0}) ->
+		    FragmentOffset, FragmentLength,
+		    Body, HsState = #dtls_hs_state{fragments = Fragments0}) ->
     Fragment = {SeqNo, Type, Length, MessageSeq,
-		dtls_fragment_init(Length, FragmentOffset, FragmentLength, Body)},
-    Fragments1 = gb_trees:insert(MessageSeq, Fragment, Fragments0),
+ 		dtls_fragment_init(Length, FragmentOffset, FragmentLength, Body)},
+     Fragments1 = gb_trees:insert(MessageSeq, Fragment, Fragments0),
     HsState#dtls_hs_state{fragments = Fragments1}.
 
 dtls_fragment_reassemble(SeqNo, Type, Length, MessageSeq,
 			 FragmentOffset, FragmentLength,
-			 Body,
-			 {LastSeqNo, Type, Length, MessageSeq, FragBuffer0},
-			 HsState = #dtls_hs_state{fragments = Fragments0}) ->
+ 			 Body,
+ 			 {LastSeqNo, Type, Length, MessageSeq, FragBuffer0},
+ 			 HsState = #dtls_hs_state{fragments = Fragments0}) ->
     FragBuffer1 = dtls_fragment_add(FragBuffer0, FragmentOffset, FragmentLength, Body),
     Fragment = {erlang:max(SeqNo, LastSeqNo), Type, Length, MessageSeq, FragBuffer1},
     Fragments1 = gb_trees:enter(MessageSeq, Fragment, Fragments0),
@@ -328,8 +366,8 @@ dtls_fragment_reassemble(SeqNo, Type, Length, MessageSeq,
 %% Type, Length or Seq mismatch, drop everything...
 %% Note: the RFC is not clear on how to handle this...
 dtls_fragment_reassemble(_SeqNo, _Type, _Length, MessageSeq,
-			 _FragmentOffset, _FragmentLength, _Body, _Fragment,
-			 HsState = #dtls_hs_state{fragments = Fragments0}) ->
+ 			 _FragmentOffset, _FragmentLength, _Body, _Fragment,
+ 			 HsState = #dtls_hs_state{fragments = Fragments0}) ->
     Fragments1 = gb_trees:delete_any(MessageSeq, Fragments0),
     HsState#dtls_hs_state{fragments = Fragments1}.
 
@@ -360,7 +398,7 @@ merge_fragment_list(Rest = [{HStart, _HEnd}|_], Frag = {_FStart, FEnd}, Acc)
     lists:reverse(Acc) ++ [Frag|Rest];
 
 merge_fragment_list([{HStart, HEnd}|Rest], _Frag = {FStart, FEnd}, Acc)
-  when
+   when
       FStart =< HEnd orelse FEnd >= HStart ->
     Start = erlang:min(HStart, FStart),
     End = erlang:max(HEnd, FEnd),
@@ -370,20 +408,20 @@ merge_fragment_list([{HStart, HEnd}|Rest], _Frag = {FStart, FEnd}, Acc)
 add_fragment(List, {FragmentOffset, FragmentLength}) ->
     merge_fragment_list(List, {FragmentOffset, FragmentOffset + FragmentLength}, []).
 
-enc_hs(#hello_verify_request{protocol_version = {Major, Minor},
-			     cookie = Cookie}, _Version) ->
-    CookieLength = byte_size(Cookie),
+enc_handshake(#hello_verify_request{protocol_version = {Major, Minor},
+ 				       cookie = Cookie}, _Version) ->
+     CookieLength = byte_size(Cookie),
     {?HELLO_VERIFY_REQUEST, <<?BYTE(Major), ?BYTE(Minor),
-			      ?BYTE(CookieLength),
-			      Cookie/binary>>};
-
-enc_hs(#client_hello{client_version = {Major, Minor},
-		     random = Random,
-		     session_id = SessionID,
-		     cookie = Cookie,
-		     cipher_suites = CipherSuites,
-		     compression_methods = CompMethods,
-		     extensions = HelloExtensions}, Version) ->
+ 			      ?BYTE(CookieLength),
+ 			      Cookie/binary>>};
+
+enc_handshake(#client_hello{client_version = {Major, Minor},
+			       random = Random,
+			       session_id = SessionID,
+			       cookie = Cookie,
+			       cipher_suites = CipherSuites,
+			       compression_methods = CompMethods,
+			       extensions = HelloExtensions}, Version) ->
     SIDLength = byte_size(SessionID),
     BinCookie = enc_client_hello_cookie(Version, Cookie),
     BinCompMethods = list_to_binary(CompMethods),
@@ -391,13 +429,13 @@ enc_hs(#client_hello{client_version = {Major, Minor},
     BinCipherSuites = list_to_binary(CipherSuites),
     CsLength = byte_size(BinCipherSuites),
     ExtensionsBin = ssl_handshake:encode_hello_extensions(HelloExtensions),
-
+    
     {?CLIENT_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
-		      ?BYTE(SIDLength), SessionID/binary,
-		      BinCookie/binary,
-				?UINT16(CsLength), BinCipherSuites/binary,
-		      ?BYTE(CmLength), BinCompMethods/binary, ExtensionsBin/binary>>};
-enc_hs(HandshakeMsg, Version) ->
+ 		      ?BYTE(SIDLength), SessionID/binary,
+ 		      BinCookie/binary,
+		      ?UINT16(CsLength), BinCipherSuites/binary,
+ 		      ?BYTE(CmLength), BinCompMethods/binary, ExtensionsBin/binary>>};
+enc_handshake(HandshakeMsg, Version) ->
     ssl_handshake:encode_handshake(HandshakeMsg, Version).
 
 enc_client_hello_cookie(_, <<>>) ->
@@ -407,26 +445,26 @@ enc_client_hello_cookie(_, Cookie) ->
     <<?BYTE(CookieLength), Cookie/binary>>.
 
 decode_handshake(_Version, ?CLIENT_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
-		       ?BYTE(SID_length), Session_ID:SID_length/binary,
-		       ?BYTE(Cookie_length), Cookie:Cookie_length/binary,
-		       ?UINT16(Cs_length), CipherSuites:Cs_length/binary,
-		       ?BYTE(Cm_length), Comp_methods:Cm_length/binary,
-		       Extensions/binary>>) ->
-
+					    ?BYTE(SID_length), Session_ID:SID_length/binary,
+					    ?BYTE(Cookie_length), Cookie:Cookie_length/binary,
+					    ?UINT16(Cs_length), CipherSuites:Cs_length/binary,
+					    ?BYTE(Cm_length), Comp_methods:Cm_length/binary,
+					    Extensions/binary>>) ->
+    
     DecodedExtensions = ssl_handshake:decode_hello_extensions(Extensions),
-
+    
     #client_hello{
        client_version = {Major,Minor},
        random = Random,
-       session_id = Session_ID,
+        session_id = Session_ID,
        cookie = Cookie,
        cipher_suites = ssl_handshake:decode_suites('2_bytes', CipherSuites),
        compression_methods = Comp_methods,
        extensions = DecodedExtensions
-      };
+       };
 
 decode_handshake(_Version, ?HELLO_VERIFY_REQUEST, <<?BYTE(Major), ?BYTE(Minor),
-					  ?BYTE(CookieLength), Cookie:CookieLength/binary>>) ->
+						    ?BYTE(CookieLength), Cookie:CookieLength/binary>>) ->
 
     #hello_verify_request{
        protocol_version = {Major,Minor},
@@ -434,7 +472,7 @@ decode_handshake(_Version, ?HELLO_VERIFY_REQUEST, <<?BYTE(Major), ?BYTE(Minor),
 decode_handshake(Version, Tag, Msg) ->
     ssl_handshake:decode_handshake(Version, Tag, Msg).
 
-address_to_bin({A,B,C,D}, Port) ->
-    <<0:80,16#ffff:16,A,B,C,D,Port:16>>;
-address_to_bin({A,B,C,D,E,F,G,H}, Port) ->
-    <<A:16,B:16,C:16,D:16,E:16,F:16,G:16,H:16,Port:16>>.
+%% address_to_bin({A,B,C,D}, Port) ->
+%%     <<0:80,16#ffff:16,A,B,C,D,Port:16>>;
+%% address_to_bin({A,B,C,D,E,F,G,H}, Port) ->
+%%     <<A:16,B:16,C:16,D:16,E:16,F:16,G:16,H:16,Port:16>>.
diff --git a/lib/ssl/src/dtls_handshake.hrl b/lib/ssl/src/dtls_handshake.hrl
index 5bdf45f627..3b57575b6d 100644
--- a/lib/ssl/src/dtls_handshake.hrl
+++ b/lib/ssl/src/dtls_handshake.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -53,6 +53,4 @@
 	 completed
 	}).
 
--type dtls_handshake() :: #client_hello{} | #hello_verify_request{} | ssl_handshake().
-
 -endif. % -ifdef(dtls_handshake).
diff --git a/lib/ssl/src/dtls_record.erl b/lib/ssl/src/dtls_record.erl
index b0a7976864..a7bbb6bc40 100644
--- a/lib/ssl/src/dtls_record.erl
+++ b/lib/ssl/src/dtls_record.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -35,7 +35,7 @@
 -export([decode_cipher_text/2]).
 
 %% Encoding
--export([encode_plain_text/4]).
+-export([encode_plain_text/4, encode_handshake/3, encode_change_cipher_spec/2]).
 
 %% Protocol version handling
 -export([protocol_version/1, lowest_protocol_version/2,
@@ -46,6 +46,11 @@
 -export([init_connection_state_seq/2, current_connection_state_epoch/2,
 	 set_connection_state_by_epoch/3, connection_state_by_epoch/3]).
 
+-export_type([dtls_version/0, dtls_atom_version/0]).
+
+-type dtls_version()       :: ssl_record:ssl_version().
+-type dtls_atom_version()  :: dtlsv1 | 'dtlsv1.2'.
+
 -compile(inline).
 
 %%====================================================================
@@ -70,7 +75,7 @@ get_dtls_records_aux(<<?BYTE(?APPLICATION_DATA),?BYTE(MajVer),?BYTE(MinVer),
 		     Acc) ->
     get_dtls_records_aux(Rest, [#ssl_tls{type = ?APPLICATION_DATA,
 					 version = {MajVer, MinVer},
-					 epoch = Epoch, record_seq = SequenceNumber,
+					 epoch = Epoch, sequence_number = SequenceNumber,
 					 fragment = Data} | Acc]);
 get_dtls_records_aux(<<?BYTE(?HANDSHAKE),?BYTE(MajVer),?BYTE(MinVer),
 		       ?UINT16(Epoch), ?UINT48(SequenceNumber),
@@ -78,7 +83,7 @@ get_dtls_records_aux(<<?BYTE(?HANDSHAKE),?BYTE(MajVer),?BYTE(MinVer),
 		       Data:Length/binary, Rest/binary>>, Acc) when MajVer >= 128 ->
     get_dtls_records_aux(Rest, [#ssl_tls{type = ?HANDSHAKE,
 					 version = {MajVer, MinVer},
-					 epoch = Epoch, record_seq = SequenceNumber,
+					 epoch = Epoch, sequence_number = SequenceNumber,
 					 fragment = Data} | Acc]);
 get_dtls_records_aux(<<?BYTE(?ALERT),?BYTE(MajVer),?BYTE(MinVer),
 		       ?UINT16(Epoch), ?UINT48(SequenceNumber),
@@ -86,7 +91,7 @@ get_dtls_records_aux(<<?BYTE(?ALERT),?BYTE(MajVer),?BYTE(MinVer),
 		       Rest/binary>>, Acc) ->
     get_dtls_records_aux(Rest, [#ssl_tls{type = ?ALERT,
 					 version = {MajVer, MinVer},
-					 epoch = Epoch, record_seq = SequenceNumber,
+					 epoch = Epoch, sequence_number = SequenceNumber,
 					 fragment = Data} | Acc]);
 get_dtls_records_aux(<<?BYTE(?CHANGE_CIPHER_SPEC),?BYTE(MajVer),?BYTE(MinVer),
 		       ?UINT16(Epoch), ?UINT48(SequenceNumber),
@@ -94,7 +99,7 @@ get_dtls_records_aux(<<?BYTE(?CHANGE_CIPHER_SPEC),?BYTE(MajVer),?BYTE(MinVer),
 		     Acc) ->
     get_dtls_records_aux(Rest, [#ssl_tls{type = ?CHANGE_CIPHER_SPEC,
 					 version = {MajVer, MinVer},
-					 epoch = Epoch, record_seq = SequenceNumber,
+					 epoch = Epoch, sequence_number = SequenceNumber,
 					 fragment = Data} | Acc]);
 
 get_dtls_records_aux(<<0:1, _CT:7, ?BYTE(_MajVer), ?BYTE(_MinVer),
@@ -125,14 +130,15 @@ encode_plain_text(Type, Version, Data,
     {Comp, CompS1} = ssl_record:compress(CompAlg, Data, CompS0),
     WriteState1 = WriteState0#connection_state{compression_state = CompS1},
     MacHash = calc_mac_hash(WriteState1, Type, Version, Epoch, Seq, Comp),
-    {CipherFragment, WriteState} = ssl_record:cipher(Version, Comp, WriteState1, MacHash),
+    {CipherFragment, WriteState} = ssl_record:cipher(dtls_v1:corresponding_tls_version(Version), 
+						     Comp, WriteState1, MacHash),
     CipherText = encode_tls_cipher_text(Type, Version, Epoch, Seq, CipherFragment),
     {CipherText, ConnectionStates#connection_states{current_write =
 							WriteState#connection_state{sequence_number = Seq +1}}}.
 
 decode_cipher_text(#ssl_tls{type = Type, version = Version,
 			    epoch = Epoch,
-			    record_seq = Seq,
+			    sequence_number = Seq,
 			    fragment = CipherFragment} = CipherText,
 		   #connection_states{current_read =
 					  #connection_state{compression_state = CompressionS0,
@@ -141,7 +147,7 @@ decode_cipher_text(#ssl_tls{type = Type, version = Version,
     CompressAlg = SecParams#security_parameters.compression_algorithm,
     {PlainFragment, Mac, ReadState1} = ssl_record:decipher(dtls_v1:corresponding_tls_version(Version),
 							   CipherFragment, ReadState0),
-    MacHash = calc_mac_hash(Type, Version, Epoch, Seq, PlainFragment, ReadState1),
+    MacHash = calc_mac_hash(ReadState1, Type, Version, Epoch, Seq, PlainFragment),
     case ssl_record:is_correct_mac(Mac, MacHash) of
 	true ->
 	    {Plain, CompressionS1} = ssl_record:uncompress(CompressAlg,
@@ -153,10 +159,27 @@ decode_cipher_text(#ssl_tls{type = Type, version = Version,
 	false ->
 	    ?ALERT_REC(?FATAL, ?BAD_RECORD_MAC)
     end.
+%%--------------------------------------------------------------------
+-spec encode_handshake(iolist(), dtls_version(), #connection_states{}) ->
+			      {iolist(), #connection_states{}}.
+%%
+%% Description: Encodes a handshake message to send on the ssl-socket.
+%%--------------------------------------------------------------------
+encode_handshake(Frag, Version, ConnectionStates) ->
+    encode_plain_text(?HANDSHAKE, Version, Frag, ConnectionStates).
+
+%%--------------------------------------------------------------------
+-spec encode_change_cipher_spec(dtls_version(), #connection_states{}) ->
+				       {iolist(), #connection_states{}}.
+%%
+%% Description: Encodes a change_cipher_spec-message to send on the ssl socket.
+%%--------------------------------------------------------------------
+encode_change_cipher_spec(Version, ConnectionStates) ->
+    encode_plain_text(?CHANGE_CIPHER_SPEC, Version, <<1:8>>, ConnectionStates).
 
 %%--------------------------------------------------------------------
--spec protocol_version(tls_atom_version() | tls_version()) ->
-			      tls_version() | tls_atom_version().
+-spec protocol_version(dtls_atom_version() | dtls_version()) ->
+			      dtls_version() | dtls_atom_version().
 %%
 %% Description: Creates a protocol version record from a version atom
 %% or vice versa.
@@ -170,7 +193,7 @@ protocol_version({254, 253}) ->
 protocol_version({254, 255}) ->
     dtlsv1.
 %%--------------------------------------------------------------------
--spec lowest_protocol_version(tls_version(), tls_version()) -> tls_version().
+-spec lowest_protocol_version(dtls_version(), dtls_version()) -> dtls_version().
 %%
 %% Description: Lowes protocol version of two given versions
 %%--------------------------------------------------------------------
@@ -183,7 +206,7 @@ lowest_protocol_version(Version = {M,_}, {N, _}) when M > N ->
 lowest_protocol_version(_,Version) ->
     Version.
 %%--------------------------------------------------------------------
--spec highest_protocol_version([tls_version()]) -> tls_version().
+-spec highest_protocol_version([dtls_version()]) -> dtls_version().
 %%
 %% Description: Highest protocol version present in a list
 %%--------------------------------------------------------------------
@@ -203,7 +226,7 @@ highest_protocol_version(_, [Version | Rest]) ->
 
 
 %%--------------------------------------------------------------------
--spec supported_protocol_versions() -> [tls_version()].
+-spec supported_protocol_versions() -> [dtls_version()].
 %%
 %% Description: Protocol versions supported
 %%--------------------------------------------------------------------
@@ -234,7 +257,7 @@ supported_connection_protocol_versions([]) ->
     ?ALL_DATAGRAM_SUPPORTED_VERSIONS.
 
 %%--------------------------------------------------------------------
--spec is_acceptable_version(tls_version(), Supported :: [tls_version()]) -> boolean().
+-spec is_acceptable_version(dtls_version(), Supported :: [dtls_version()]) -> boolean().
 %%
 %% Description: ssl version 2 is not acceptable security risks are too big.
 %%
@@ -244,7 +267,7 @@ is_acceptable_version(Version, Versions) ->
 
 
 %%--------------------------------------------------------------------
--spec init_connection_state_seq(tls_version(), #connection_states{}) ->
+-spec init_connection_state_seq(dtls_version(), #connection_states{}) ->
 				       #connection_state{}.
 %%
 %% Description: Copy the read sequence number to the write sequence number
@@ -343,5 +366,5 @@ calc_mac_hash(#connection_state{mac_secret = MacSecret,
 	     Length, Fragment).
 
 mac_hash(Version, MacAlg, MacSecret, SeqNo, Type, Length, Fragment) ->
-    dtls_v1:mac_hash(MacAlg, MacSecret, SeqNo, Type, Version,
+    dtls_v1:mac_hash(Version, MacAlg, MacSecret, SeqNo, Type,
 		     Length, Fragment).
diff --git a/lib/ssl/src/dtls_record.hrl b/lib/ssl/src/dtls_record.hrl
index e935d84bdf..edb77fb2b1 100644
--- a/lib/ssl/src/dtls_record.hrl
+++ b/lib/ssl/src/dtls_record.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -28,16 +28,15 @@
 
 -include("ssl_record.hrl"). %% Common TLS and DTLS records and Constantes
 
-%% Used to handle tls_plain_text, tls_compressed and tls_cipher_text
+%% Used to handle dtls_plain_text, dtls_compressed and dtls_cipher_text
 
 -record(ssl_tls, {   
 	  type,
 	  version,
-	  record_seq,      % used in plain_text
-	  epoch,           % used in plain_text  
-	  message_seq, 
-	  fragment_offset,
-	  fragment_length,
+	  epoch,           
+	  sequence_number,      
+	  offset,
+	  length,
 	  fragment
 	 }).
 
diff --git a/lib/ssl/src/dtls_v1.erl b/lib/ssl/src/dtls_v1.erl
index 6e41641483..5a7ab32887 100644
--- a/lib/ssl/src/dtls_v1.erl
+++ b/lib/ssl/src/dtls_v1.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -22,7 +22,7 @@
 
 -export([suites/1, mac_hash/7, ecc_curves/1, corresponding_tls_version/1]).
 
--spec suites(Minor:: 253|255) -> [cipher_suite()].
+-spec suites(Minor:: 253|255) -> [ssl_cipher:cipher_suite()].
 
 suites(Minor) ->
    tls_v1:suites(corresponding_minor_tls_version(Minor)).
diff --git a/lib/ssl/src/ssl.erl b/lib/ssl/src/ssl.erl
index 9e098e12c4..a88bf45293 100644
--- a/lib/ssl/src/ssl.erl
+++ b/lib/ssl/src/ssl.erl
@@ -276,7 +276,7 @@ controlling_process(#sslsocket{pid = {Listen,
     Transport:controlling_process(Listen, NewOwner).
 
 %%--------------------------------------------------------------------
--spec connection_info(#sslsocket{}) -> 	{ok, {tls_atom_version(), erl_cipher_suite()}} |
+-spec connection_info(#sslsocket{}) -> 	{ok, {tls_record:tls_atom_version(), ssl_cipher:erl_cipher_suite()}} |
 					{error, reason()}.
 %%
 %% Description: Returns ssl protocol and cipher used for the connection
@@ -312,7 +312,7 @@ peercert(#sslsocket{pid = {Listen, _}}) when is_port(Listen) ->
     {error, enotconn}.
 
 %%--------------------------------------------------------------------
--spec suite_definition(cipher_suite()) -> erl_cipher_suite().
+-spec suite_definition(ssl_cipher:cipher_suite()) -> ssl_cipher:erl_cipher_suite().
 %%
 %% Description: Return erlang cipher suite definition.
 %%--------------------------------------------------------------------
@@ -330,8 +330,8 @@ negotiated_next_protocol(#sslsocket{pid = Pid}) ->
     ssl_connection:negotiated_next_protocol(Pid).
 
 %%--------------------------------------------------------------------
--spec cipher_suites() -> [erl_cipher_suite()].
--spec cipher_suites(erlang | openssl | all) -> [erl_cipher_suite()] | [string()].
+-spec cipher_suites() -> [ssl_cipher:erl_cipher_suite()].
+-spec cipher_suites(erlang | openssl | all) -> [ssl_cipher:erl_cipher_suite()] | [string()].
 			   
 %% Description: Returns all supported cipher suites.
 %%--------------------------------------------------------------------
@@ -437,8 +437,8 @@ session_info(#sslsocket{pid = {Listen,_}}) when is_port(Listen) ->
     {error, enotconn}.
 
 %%---------------------------------------------------------------
--spec versions() -> [{ssl_app, string()} | {supported, [tls_atom_version()]} |
-		     {available, [tls_atom_version()]}].
+-spec versions() -> [{ssl_app, string()} | {supported, [tls_record:tls_atom_version()]} |
+		     {available, [tls_record:tls_atom_version()]}].
 %%
 %% Description: Returns a list of relevant versions.
 %%--------------------------------------------------------------------
@@ -558,6 +558,8 @@ handle_options(Opts0, _Role) ->
     Opts = proplists:expand([{binary, [{mode, binary}]},
 			     {list, [{mode, list}]}], Opts0),
     assert_proplist(Opts),
+    RecordCb = record_cb(Opts),
+
     ReuseSessionFun = fun(_, _, _, _) -> true end,
 
     DefaultVerifyNoneFun =
@@ -600,12 +602,14 @@ handle_options(Opts0, _Role) ->
 	end,
 
     CertFile = handle_option(certfile, Opts, <<>>),
-
+    
+    RecordCb = record_cb(Opts),
+    
     Versions = case handle_option(versions, Opts, []) of
 		   [] ->
-		       tls_record:supported_protocol_versions();
+		       RecordCb:supported_protocol_versions();
 		   Vsns  ->
-		       [tls_record:protocol_version(Vsn) || Vsn <- Vsns]
+		       [RecordCb:protocol_version(Vsn) || Vsn <- Vsns]
 	       end,
 
     SSLOptions = #ssl_options{
@@ -1035,6 +1039,13 @@ connection_cb(dtls) ->
 connection_cb(Opts) ->
    connection_cb(proplists:get_value(protocol, Opts, tls)).
 
+record_cb(tls) ->
+    tls_record;
+record_cb(dtls) ->
+    dtls_record;
+record_cb(Opts) ->
+   record_cb(proplists:get_value(protocol, Opts, tls)).
+
 connection_sup(tls_connection) ->
     tls_connection_sup;
 connection_sup(dtls_connection) ->
diff --git a/lib/ssl/src/ssl_alert.erl b/lib/ssl/src/ssl_alert.erl
index 8b393468ea..db1535b5ec 100644
--- a/lib/ssl/src/ssl_alert.erl
+++ b/lib/ssl/src/ssl_alert.erl
@@ -38,7 +38,7 @@
 %%====================================================================
 
 %%--------------------------------------------------------------------
--spec encode(#alert{}, tls_version(), #connection_states{}) -> 
+-spec encode(#alert{}, ssl_record:ssl_version(), #connection_states{}) -> 
 		    {iolist(), #connection_states{}}.
 %%
 %% Description: 
diff --git a/lib/ssl/src/ssl_api.hrl b/lib/ssl/src/ssl_api.hrl
index 607991750f..22185ff60a 100644
--- a/lib/ssl/src/ssl_api.hrl
+++ b/lib/ssl/src/ssl_api.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -24,8 +24,6 @@
 
 %% Visible in API
 -export_type([connect_option/0, listen_option/0, ssl_option/0, transport_option/0,
-	      erl_cipher_suite/0, %% From ssl_cipher.hrl
-	      tls_atom_version/0, %% From ssl_internal.hrl
 	      prf_random/0, sslsocket/0]).
 
 
@@ -39,23 +37,24 @@
 -type listen_option()            :: socket_listen_option() | ssl_option() | transport_option().
 -type socket_listen_option()     :: gen_tcp:listen_option().
 
--type ssl_option()    :: {verify, verify_type()} |
-			{verify_fun, {fun(), InitialUserState::term()}} |
-                        {fail_if_no_peer_cert, boolean()} | {depth, integer()} |
-                        {cert, Der::binary()} | {certfile, path()} | {key, Der::binary()} |
-                        {keyfile, path()} | {password, string()} | {cacerts, [Der::binary()]} |
-                        {cacertfile, path()} | {dh, Der::binary()} | {dhfile, path()} |
-                        {user_lookup_fun, {fun(), InitialUserState::term()}} |
-                        {psk_identity, string()} |
-                        {srp_identity, {string(), string()}} |
-                        {ciphers, ciphers()} | {ssl_imp, ssl_imp()} | {reuse_sessions, boolean()} |
-                        {reuse_session, fun()} | {hibernate_after, integer()|undefined} |
-                        {next_protocols_advertised, list(binary())} |
-                        {client_preferred_next_protocols, binary(), client | server, list(binary())}.
+-type ssl_option()    :: {versions, ssl_record:ssl_atom_version()} |
+			 {verify, verify_type()} |
+			 {verify_fun, {fun(), InitialUserState::term()}} |
+                         {fail_if_no_peer_cert, boolean()} | {depth, integer()} |
+                         {cert, Der::binary()} | {certfile, path()} | {key, Der::binary()} |
+                         {keyfile, path()} | {password, string()} | {cacerts, [Der::binary()]} |
+                         {cacertfile, path()} | {dh, Der::binary()} | {dhfile, path()} |
+                         {user_lookup_fun, {fun(), InitialUserState::term()}} |
+                         {psk_identity, string()} |
+                         {srp_identity, {string(), string()}} |
+                         {ciphers, ciphers()} | {ssl_imp, ssl_imp()} | {reuse_sessions, boolean()} |
+                         {reuse_session, fun()} | {hibernate_after, integer()|undefined} |
+                         {next_protocols_advertised, list(binary())} |
+                         {client_preferred_next_protocols, binary(), client | server, list(binary())}.
 
 -type verify_type()  :: verify_none | verify_peer.
 -type path()         :: string().
--type ciphers()      :: [erl_cipher_suite()] |
+-type ciphers()      :: [ssl_cipher:erl_cipher_suite()] |
 			string(). % (according to old API)
 -type ssl_imp()      :: new | old.
 
diff --git a/lib/ssl/src/ssl_cipher.erl b/lib/ssl/src/ssl_cipher.erl
index b2077c662a..78a328ace8 100644
--- a/lib/ssl/src/ssl_cipher.erl
+++ b/lib/ssl/src/ssl_cipher.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2007-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2014. 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
@@ -38,6 +38,21 @@
 	 openssl_suite/1, openssl_suite_name/1, filter/2, filter_suites/1,
 	 hash_algorithm/1, sign_algorithm/1, is_acceptable_hash/2]).
 
+-export_type([cipher_suite/0,
+	      erl_cipher_suite/0, openssl_cipher_suite/0,
+	      key_algo/0]).
+
+-type cipher()            :: null |rc4_128 | idea_cbc | des40_cbc | des_cbc | '3des_ede_cbc' 
+			   | aes_128_cbc |  aes_256_cbc.
+-type hash()              :: null | sha | md5 | sha224 | sha256 | sha384 | sha512.
+-type key_algo()          :: null | rsa | dhe_rsa | dhe_dss | ecdhe_ecdsa| ecdh_ecdsa | ecdh_rsa| srp_rsa| srp_dss | psk | dhe_psk | rsa_psk | dh_anon | ecdh_anon | srp_anon.
+-type erl_cipher_suite()  :: {key_algo(), cipher(), hash()}.
+-type int_cipher_suite()  :: {key_algo(), cipher(), hash(), hash() | default_prf}.
+-type cipher_suite()      :: binary().
+-type cipher_enum()        :: integer().
+-type openssl_cipher_suite()  :: string().
+
+
 -compile(inline).
 
 %%--------------------------------------------------------------------
@@ -51,7 +66,7 @@ security_parameters(?TLS_NULL_WITH_NULL_NULL = CipherSuite, SecParams) ->
     security_parameters(undefined, CipherSuite, SecParams).
 
 %%--------------------------------------------------------------------
--spec security_parameters(tls_version() | undefined, cipher_suite(), #security_parameters{}) ->
+-spec security_parameters(ssl_record:ssl_version() | undefined, cipher_suite(), #security_parameters{}) ->
 				 #security_parameters{}.
 %%
 %% Description: Returns a security parameters record where the
@@ -72,7 +87,7 @@ security_parameters(Version, CipherSuite, SecParams) ->
       hash_size = hash_size(Hash)}.
 
 %%--------------------------------------------------------------------
--spec cipher(cipher_enum(), #cipher_state{}, binary(), iolist(), tls_version()) ->
+-spec cipher(cipher_enum(), #cipher_state{}, binary(), iodata(), ssl_record:ssl_version()) ->
 		    {binary(), #cipher_state{}}. 
 %%
 %% Description: Encrypts the data and the MAC using chipher described
@@ -127,7 +142,7 @@ block_cipher(Fun, BlockSz, #cipher_state{key=Key, iv=IV} = CS0,
     {T, CS0#cipher_state{iv=NextIV}}.
 
 %%--------------------------------------------------------------------
--spec decipher(cipher_enum(), integer(), #cipher_state{}, binary(), tls_version()) ->
+-spec decipher(cipher_enum(), integer(), #cipher_state{}, binary(), ssl_record:ssl_version()) ->
 		      {binary(), binary(), #cipher_state{}} | #alert{}.
 %%
 %% Description: Decrypts the data and the MAC using cipher described
@@ -200,7 +215,7 @@ block_decipher(Fun, #cipher_state{key=Key, iv=IV} = CipherState0,
 	    ?ALERT_REC(?FATAL, ?BAD_RECORD_MAC)
     end.
 %%--------------------------------------------------------------------
--spec suites(tls_version()) -> [cipher_suite()].
+-spec suites(ssl_record:ssl_version()) -> [cipher_suite()].
 %%
 %% Description: Returns a list of supported cipher suites.
 %%--------------------------------------------------------------------
@@ -229,7 +244,7 @@ anonymous_suites() ->
      ?TLS_ECDH_anon_WITH_AES_256_CBC_SHA].
 
 %%--------------------------------------------------------------------
--spec psk_suites(tls_version() | integer()) -> [cipher_suite()].
+-spec psk_suites(ssl_record:ssl_version() | integer()) -> [cipher_suite()].
 %%
 %% Description: Returns a list of the PSK cipher suites, only supported
 %% if explicitly set by user.
diff --git a/lib/ssl/src/ssl_cipher.hrl b/lib/ssl/src/ssl_cipher.hrl
index 62a5269def..3ce9c19aa9 100644
--- a/lib/ssl/src/ssl_cipher.hrl
+++ b/lib/ssl/src/ssl_cipher.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2007-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2014. 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
@@ -26,16 +26,6 @@
 -ifndef(ssl_cipher).
 -define(ssl_cipher, true).
 
--type cipher()            :: null |rc4_128 | idea_cbc | des40_cbc | des_cbc | '3des_ede_cbc' 
-			   | aes_128_cbc |  aes_256_cbc.
--type hash()              :: null | sha | md5 | sha224 | sha256 | sha384 | sha512.
--type key_algo()          :: null | rsa | dhe_rsa | dhe_dss | ecdhe_ecdsa| ecdh_ecdsa | ecdh_rsa| srp_rsa| srp_dss | psk | dhe_psk | rsa_psk | dh_anon | ecdh_anon | srp_anon.
--type erl_cipher_suite()  :: {key_algo(), cipher(), hash()}.
--type int_cipher_suite()  :: {key_algo(), cipher(), hash(), hash() | default_prf}.
--type cipher_suite()      :: binary().
--type cipher_enum()        :: integer().
--type openssl_cipher_suite()  :: string().
-
 %%% SSL cipher protocol  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 -define(CHANGE_CIPHER_SPEC_PROTO, 1).           % _PROTO to not clash with 
 						% SSL record protocol
diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index e283e6079e..ed9e4d344f 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -52,6 +52,7 @@
 %% SSL all state functions 
 -export([handle_sync_event/4, handle_info/3, terminate/3]).
 
+
 %%====================================================================
 %% Internal application API
 %%====================================================================	     
diff --git a/lib/ssl/src/ssl_connection.hrl b/lib/ssl/src/ssl_connection.hrl
index 341a4217e4..b01c6cb1b3 100644
--- a/lib/ssl/src/ssl_connection.hrl
+++ b/lib/ssl/src/ssl_connection.hrl
@@ -48,17 +48,17 @@
           socket_options        :: #socket_options{},
           connection_states     :: #connection_states{},
 	  protocol_buffers      :: term(), %% #protocol_buffers{} from tls_record.hrl or dtls_recor.hrl
-          tls_handshake_history ::tls_handshake_history(),
+          tls_handshake_history :: ssl_handshake:ssl_handshake_history(),
 	  cert_db               :: reference(),
           session               :: #session{},
 	  session_cache         :: db_handle(),
 	  session_cache_cb      :: atom(),
-          negotiated_version    :: tls_version(),
+          negotiated_version    :: ssl_record:ssl_version(),
           client_certificate_requested = false :: boolean(),
-	  key_algorithm         :: key_algo(),
+	  key_algorithm         :: ssl_cipher:key_algo(),
 	  hashsign_algorithm = {undefined, undefined},
 	  cert_hashsign_algorithm,
-          public_key_info      ::public_key_info(),
+          public_key_info      ::ssl_handshake:public_key_info(),
           private_key          ::public_key:private_key(),
 	  diffie_hellman_params, % PKIX: #'DHParameter'{} relevant for server side
 	  diffie_hellman_keys, % {PublicKey, PrivateKey}
diff --git a/lib/ssl/src/ssl_handshake.erl b/lib/ssl/src/ssl_handshake.erl
index 74ca7ca699..1108edcf48 100644
--- a/lib/ssl/src/ssl_handshake.erl
+++ b/lib/ssl/src/ssl_handshake.erl
@@ -31,6 +31,18 @@
 -include("ssl_srp.hrl").
 -include_lib("public_key/include/public_key.hrl").
 
+-export_type([ssl_handshake/0, ssl_handshake_history/0,
+	      public_key_info/0, oid/0]).
+
+-type oid()               :: tuple().
+-type public_key_params() :: #'Dss-Parms'{} |  {namedCurve, oid()} | #'ECParameters'{} | term().
+-type public_key_info()   :: {oid(), #'RSAPublicKey'{} | integer() | #'ECPoint'{}, public_key_params()}.
+-type ssl_handshake_history() :: {[binary()], [binary()]}.
+
+-type ssl_handshake() :: #server_hello{} | #server_hello_done{} | #certificate{} | #certificate_request{} |
+			 #client_key_exchange{} | #finished{} | #certificate_verify{} |
+			 #hello_request{} | #next_protocol{}.
+
 %% Handshake messages
 -export([hello_request/0, server_hello/4, server_hello_done/0,
 	 certificate/4, certificate_request/4, key_exchange/3,
@@ -80,7 +92,7 @@ hello_request() ->
     #hello_request{}.
 
 %%--------------------------------------------------------------------
--spec server_hello(#session{}, tls_version(), #connection_states{},
+-spec server_hello(#session{}, ssl_record:ssl_version(), #connection_states{},
 		   #hello_extensions{}) -> #server_hello{}.
 %%
 %% Description: Creates a server hello message.
@@ -164,8 +176,8 @@ next_protocol(SelectedProtocol) ->
 
 %%--------------------------------------------------------------------
 -spec client_certificate_verify(undefined | der_cert(), binary(),
-				tls_version(), term(), public_key:private_key(),
-				tls_handshake_history()) ->
+				ssl_record:ssl_version(), term(), public_key:private_key(),
+				ssl_handshake_history()) ->
     #certificate_verify{} | ignore | #alert{}.
 %%
 %% Description: Creates a certificate_verify message, called by the client.
@@ -188,7 +200,7 @@ client_certificate_verify(OwnCert, MasterSecret, Version,
     end.
 
 %%--------------------------------------------------------------------
--spec certificate_request(erl_cipher_suite(), db_handle(), certdb_ref(), tls_version()) ->
+-spec certificate_request(ssl_cipher:erl_cipher_suite(), db_handle(), certdb_ref(), ssl_record:ssl_version()) ->
     #certificate_request{}.
 %%
 %% Description: Creates a certificate_request message, called by the server.
@@ -203,7 +215,7 @@ certificate_request(CipherSuite, CertDbHandle, CertDbRef, Version) ->
 		    certificate_authorities = Authorities
 		   }.
 %%--------------------------------------------------------------------
--spec key_exchange(client | server, tls_version(),
+-spec key_exchange(client | server, ssl_record:ssl_version(),
 		   {premaster_secret, binary(), public_key_info()} |
 		   {dh, binary()} |
 		   {dh, {binary(), binary()}, #'DHParameter'{}, {HashAlgo::atom(), SignAlgo::atom()},
@@ -304,7 +316,7 @@ key_exchange(server, Version, {srp, {PublicKey, _},
 			    ClientRandom, ServerRandom, PrivateKey).
 
 %%--------------------------------------------------------------------
--spec finished(tls_version(), client | server, integer(), binary(), tls_handshake_history()) ->
+-spec finished(ssl_record:ssl_version(), client | server, integer(), binary(), ssl_handshake_history()) ->
     #finished{}.
 %%
 %% Description: Creates a handshake finished message
@@ -331,8 +343,8 @@ verify_server_key(#server_key_params{params_bin = EncParams,
     verify_signature(Version, Hash, HashSign, Signature, PubKeyInfo).
 
 %%--------------------------------------------------------------------
--spec certificate_verify(binary(), public_key_info(), tls_version(), term(),
-			 binary(), tls_handshake_history()) -> valid | #alert{}.
+-spec certificate_verify(binary(), public_key_info(), ssl_record:ssl_version(), term(),
+			 binary(), ssl_handshake_history()) -> valid | #alert{}.
 %%
 %% Description: Checks that the certificate_verify message is valid.
 %%--------------------------------------------------------------------
@@ -346,7 +358,7 @@ certificate_verify(Signature, PublicKeyInfo, Version,
 	    ?ALERT_REC(?FATAL, ?BAD_CERTIFICATE)
     end.
 %%--------------------------------------------------------------------
--spec verify_signature(tls_version(), binary(), {term(), term()}, binary(),
+-spec verify_signature(ssl_record:ssl_version(), binary(), {term(), term()}, binary(),
 				   public_key_info()) -> true | false.
 %%
 %% Description: Checks that a public_key signature is valid.
@@ -426,8 +438,8 @@ certify(#certificate{asn1_certificates = ASN1Certs}, CertDbHandle, CertDbRef,
     end.
 
 %%--------------------------------------------------------------------
--spec verify_connection(tls_version(), #finished{}, client | server, integer(), binary(),
-			tls_handshake_history()) -> verified | #alert{}.
+-spec verify_connection(ssl_record:ssl_version(), #finished{}, client | server, integer(), binary(),
+			ssl_handshake_history()) -> verified | #alert{}.
 %%
 %% Description: Checks the ssl handshake finished message to verify
 %%              the connection.
@@ -443,7 +455,7 @@ verify_connection(Version, #finished{verify_data = Data},
     end.
 
 %%--------------------------------------------------------------------
--spec init_handshake_history() -> tls_handshake_history().
+-spec init_handshake_history() -> ssl_handshake_history().
 
 %%
 %% Description: Initialize the empty handshake history buffer.
@@ -452,8 +464,8 @@ init_handshake_history() ->
     {[], []}.
 
 %%--------------------------------------------------------------------
--spec update_handshake_history(tls_handshake_history(), Data ::term()) ->
-				      tls_handshake_history().
+-spec update_handshake_history(ssl_handshake:ssl_handshake_history(), Data ::term()) ->
+				      ssl_handshake:ssl_handshake_history().
 %%
 %% Description: Update the handshake history buffer with Data.
 %%--------------------------------------------------------------------
@@ -567,7 +579,7 @@ server_key_exchange_hash(md5sha, Value) ->
 server_key_exchange_hash(Hash, Value) ->
     crypto:hash(Hash, Value).
 %%--------------------------------------------------------------------
--spec prf(tls_version(), binary(), binary(), [binary()], non_neg_integer()) ->
+-spec prf(ssl_record:ssl_version(), binary(), binary(), [binary()], non_neg_integer()) ->
 		 {ok, binary()} | {error, undefined}.
 %%
 %% Description: use the TLS PRF to generate key material
@@ -611,7 +623,7 @@ select_hashsign(#hash_sign_algos{hash_sign_algos = HashSigns}, Cert) ->
 	    HashSign
     end.
 %%--------------------------------------------------------------------
--spec select_cert_hashsign(#hash_sign_algos{}| undefined, oid(), tls_version() | {undefined, undefined}) ->
+-spec select_cert_hashsign(#hash_sign_algos{}| undefined, oid(), ssl_record:ssl_version() | {undefined, undefined}) ->
 				  {atom(), atom()}.
 
 %%
@@ -631,7 +643,7 @@ select_cert_hashsign(undefined, ?'id-dsa', _) ->
     {sha, dsa}.
 
 %%--------------------------------------------------------------------
--spec master_secret(atom(), tls_version(), #session{} | binary(), #connection_states{},
+-spec master_secret(atom(), ssl_record:ssl_version(), #session{} | binary(), #connection_states{},
 		   client | server) -> {binary(), #connection_states{}} | #alert{}.
 %%
 %% Description: Sets or calculates the master secret and calculate keys,
@@ -816,7 +828,7 @@ enc_server_key_exchange(Version, Params, {HashAlgo, SignAlgo},
     end.
 
 %%--------------------------------------------------------------------
--spec decode_client_key(binary(), key_algo(), tls_version()) ->
+-spec decode_client_key(binary(), ssl_cipher:key_algo(), ssl_record:ssl_version()) ->
 			    #encrypted_premaster_secret{}
 			    | #client_diffie_hellman_public{}
 			    | #client_ec_diffie_hellman_public{}
@@ -831,7 +843,7 @@ decode_client_key(ClientKey, Type, Version) ->
     dec_client_key(ClientKey, key_exchange_alg(Type), Version).
 
 %%--------------------------------------------------------------------
--spec decode_server_key(binary(), key_algo(), tls_version()) ->
+-spec decode_server_key(binary(), ssl_cipher:key_algo(), ssl_record:ssl_version()) ->
 			       #server_key_params{}.
 %%
 %% Description: Decode server_key data and return appropriate type
diff --git a/lib/ssl/src/ssl_handshake.hrl b/lib/ssl/src/ssl_handshake.hrl
index 75160526b9..80284faef0 100644
--- a/lib/ssl/src/ssl_handshake.hrl
+++ b/lib/ssl/src/ssl_handshake.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2007-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2014. 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
@@ -352,18 +352,4 @@
           hostname = undefined
         }).
 
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% Dialyzer types
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
--type oid()               :: tuple().
--type public_key_params() :: #'Dss-Parms'{} |  {namedCurve, oid()} | #'ECParameters'{} | term().
--type public_key_info()   :: {oid(), #'RSAPublicKey'{} | integer() | #'ECPoint'{}, public_key_params()}.
--type tls_handshake_history() :: {[binary()], [binary()]}.
-
--type ssl_handshake() :: #server_hello{} | #server_hello_done{} | #certificate{} | #certificate_request{} |
-			 #client_key_exchange{} | #finished{} | #certificate_verify{} |
-			 #hello_request{} | #next_protocol{}.
-
-
 -endif. % -ifdef(ssl_handshake).
diff --git a/lib/ssl/src/ssl_internal.hrl b/lib/ssl/src/ssl_internal.hrl
index 64b89e9f95..cec5d8fbb1 100644
--- a/lib/ssl/src/ssl_internal.hrl
+++ b/lib/ssl/src/ssl_internal.hrl
@@ -30,8 +30,6 @@
 -type from()              :: term().
 -type host()		  :: inet:ip_address() | inet:hostname().
 -type session_id()        :: 0 | binary().
--type tls_version()       :: {integer(), integer()}.
--type tls_atom_version()  :: sslv3 | tlsv1 | 'tlsv1.1' | 'tlsv1.2'.
 -type certdb_ref()        :: reference().
 -type db_handle()         :: term().
 -type der_cert()          :: binary().
@@ -73,7 +71,7 @@
 
 -record(ssl_options, {
 	  protocol    :: tls | dtls,
-	  versions    :: ['tlsv1.2' | 'tlsv1.1' | tlsv1 | sslv3] | ['dtlsv1.2' | dtlsv1],
+	  versions    :: [ssl_record:ssl_version()], %% ssl_record:atom_version() in API
 	  verify      :: verify_none | verify_peer,
 	  verify_fun,  %%:: fun(CertVerifyErrors::term()) -> boolean(),
 	  fail_if_no_peer_cert ::  boolean(),
diff --git a/lib/ssl/src/ssl_record.erl b/lib/ssl/src/ssl_record.erl
index 018c8befe0..b0e9943e6d 100644
--- a/lib/ssl/src/ssl_record.erl
+++ b/lib/ssl/src/ssl_record.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -50,6 +50,11 @@
 %% Payload encryption/decryption
 -export([cipher/4, decipher/3, is_correct_mac/2]).
 
+-export_type([ssl_version/0, ssl_atom_version/0]).
+
+-type ssl_version()       :: {integer(), integer()}.
+-type ssl_atom_version() :: tls_record:tls_atom_version().
+
 %%====================================================================
 %% Internal application API
 %%====================================================================
@@ -299,7 +304,7 @@ set_pending_cipher_state(#connection_states{pending_read = Read,
 
 
 %%--------------------------------------------------------------------
--spec encode_handshake(iolist(), tls_version(), #connection_states{}) ->
+-spec encode_handshake(iolist(), ssl_version(), #connection_states{}) ->
 			      {iolist(), #connection_states{}}.
 %%
 %% Description: Encodes a handshake message to send on the ssl-socket.
@@ -308,7 +313,7 @@ encode_handshake(Frag, Version, ConnectionStates) ->
     encode_plain_text(?HANDSHAKE, Version, Frag, ConnectionStates).
 
 %%--------------------------------------------------------------------
--spec encode_alert_record(#alert{}, tls_version(), #connection_states{}) ->
+-spec encode_alert_record(#alert{}, ssl_version(), #connection_states{}) ->
 				 {iolist(), #connection_states{}}.
 %%
 %% Description: Encodes an alert message to send on the ssl-socket.
@@ -319,7 +324,7 @@ encode_alert_record(#alert{level = Level, description = Description},
 		      ConnectionStates).
 
 %%--------------------------------------------------------------------
--spec encode_change_cipher_spec(tls_version(), #connection_states{}) ->
+-spec encode_change_cipher_spec(ssl_version(), #connection_states{}) ->
 				       {iolist(), #connection_states{}}.
 %%
 %% Description: Encodes a change_cipher_spec-message to send on the ssl socket.
@@ -328,7 +333,7 @@ encode_change_cipher_spec(Version, ConnectionStates) ->
     encode_plain_text(?CHANGE_CIPHER_SPEC, Version, <<1:8>>, ConnectionStates).
 
 %%--------------------------------------------------------------------
--spec encode_data(binary(), tls_version(), #connection_states{}) ->
+-spec encode_data(binary(), ssl_version(), #connection_states{}) ->
 			 {iolist(), #connection_states{}}.
 %%
 %% Description: Encodes data to send on the ssl-socket.
@@ -356,7 +361,7 @@ compressions() ->
     [?byte(?NULL)].
 
 %%--------------------------------------------------------------------
--spec cipher(tls_version(), iolist(), #connection_state{}, MacHash::binary()) ->
+-spec cipher(ssl_version(), iodata(), #connection_state{}, MacHash::binary()) ->
 		    {CipherFragment::binary(), #connection_state{}}.
 %%
 %% Description: Payload encryption
@@ -372,7 +377,7 @@ cipher(Version, Fragment,
 	ssl_cipher:cipher(BulkCipherAlgo, CipherS0, MacHash, Fragment, Version),
     {CipherFragment,  WriteState0#connection_state{cipher_state = CipherS1}}.
 %%--------------------------------------------------------------------
--spec decipher(tls_version(), binary(), #connection_state{}) -> {binary(), binary(), #connection_state{}}.
+-spec decipher(ssl_version(), binary(), #connection_state{}) -> {binary(), binary(), #connection_state{}}.
 %%
 %% Description: Payload decryption
 %%--------------------------------------------------------------------
diff --git a/lib/ssl/src/ssl_record.hrl b/lib/ssl/src/ssl_record.hrl
index c17fa53a62..87ed233c0a 100644
--- a/lib/ssl/src/ssl_record.hrl
+++ b/lib/ssl/src/ssl_record.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2007-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2014. 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
@@ -20,7 +20,7 @@
 %%
 %%----------------------------------------------------------------------
 %% Purpose: Record and constant defenitions for the SSL-record protocol
-%% see RFC 2246
+% see RFC 2246
 %%----------------------------------------------------------------------
 
 -ifndef(ssl_record).
diff --git a/lib/ssl/src/ssl_v3.erl b/lib/ssl/src/ssl_v3.erl
index d477b3df81..68f7f5dee2 100644
--- a/lib/ssl/src/ssl_v3.erl
+++ b/lib/ssl/src/ssl_v3.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2007-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2014. 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
@@ -130,7 +130,7 @@ setup_keys(MasterSecret, ServerRandom, ClientRandom, HS, KML, _EKML, IVS) ->
     {ClientWriteMacSecret, ServerWriteMacSecret, ClientWriteKey,
      ServerWriteKey, ClientIV, ServerIV}.
 
--spec suites() -> [cipher_suite()].
+-spec suites() -> [ssl_cipher:cipher_suite()].
 
 suites() ->
     [
diff --git a/lib/ssl/src/tls_handshake.erl b/lib/ssl/src/tls_handshake.erl
index 01abefca46..183cabcfcd 100644
--- a/lib/ssl/src/tls_handshake.erl
+++ b/lib/ssl/src/tls_handshake.erl
@@ -33,6 +33,8 @@
 -export([client_hello/8, hello/4,
 	 get_tls_handshake/3, encode_handshake/2, decode_handshake/3]).
 
+-type tls_handshake() :: #client_hello{} | ssl_handshake:ssl_handshake().
+
 %%====================================================================
 %% Internal application API
 %%====================================================================
@@ -71,11 +73,11 @@ client_hello(Host, Port, ConnectionStates,
 	    #connection_states{} | {inet:port_number(), #session{}, db_handle(),
 				    atom(), #connection_states{}, binary() | undefined},
 	    boolean()) ->
-			  {tls_version(), session_id(), #connection_states{}, binary() | undefined}|
-			  {tls_version(), {resumed | new, #session{}}, #connection_states{},
-			   [binary()] | undefined,
-			  [oid()] | undefined, [oid()] | undefined} |
-			  #alert{}.
+		   {tls_record:tls_version(), session_id(), #connection_states{}, binary() | undefined}|
+		   {tls_record:tls_version(), {resumed | new, #session{}}, #connection_states{},
+		    [binary()] | undefined,
+		    [ssl_handshake:oid()] | undefined, [ssl_handshake:oid()] | undefined} |
+		   #alert{}.
 %%
 %% Description: Handles a recieved hello message
 %%--------------------------------------------------------------------
@@ -122,7 +124,7 @@ hello(#client_hello{client_version = ClientVersion,
     end.
 
 %%--------------------------------------------------------------------
--spec encode_handshake(tls_handshake(), tls_version()) -> iolist().
+-spec encode_handshake(tls_handshake(), tls_record:tls_version()) -> iolist().
 %%     
 %% Description: Encode a handshake packet
 %%--------------------------------------------------------------------x
@@ -132,7 +134,7 @@ encode_handshake(Package, Version) ->
     [MsgType, ?uint24(Len), Bin].
 
 %%--------------------------------------------------------------------
--spec get_tls_handshake(tls_version(), binary(), binary() | iolist()) ->
+-spec get_tls_handshake(tls_record:tls_version(), binary(), binary() | iolist()) ->
      {[tls_handshake()], binary()}.
 %%
 %% Description: Given buffered and new data from ssl_record, collects
diff --git a/lib/ssl/src/tls_handshake.hrl b/lib/ssl/src/tls_handshake.hrl
index dbe930cb90..1646e5b6f2 100644
--- a/lib/ssl/src/tls_handshake.hrl
+++ b/lib/ssl/src/tls_handshake.hrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2013-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2013-2014. 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
@@ -37,6 +37,4 @@
 	  extensions
 	 }).
 
--type tls_handshake() :: #client_hello{} | ssl_handshake().
-
 -endif. % -ifdef(tls_handshake).
diff --git a/lib/ssl/src/tls_record.erl b/lib/ssl/src/tls_record.erl
index 8c0c4f3c91..4da08e9c51 100644
--- a/lib/ssl/src/tls_record.erl
+++ b/lib/ssl/src/tls_record.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2007-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2014. 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
@@ -44,6 +44,11 @@
 	 highest_protocol_version/1, supported_protocol_versions/0,
 	 is_acceptable_version/1, is_acceptable_version/2]).
 
+-export_type([tls_version/0, tls_atom_version/0]).
+
+-type tls_version()       :: ssl_record:ssl_version().
+-type tls_atom_version()  :: sslv3 | tlsv1 | 'tlsv1.1' | 'tlsv1.2'.
+
 -compile(inline).
 
 %%====================================================================
diff --git a/lib/ssl/src/tls_v1.erl b/lib/ssl/src/tls_v1.erl
index 7b1f53b969..067417d163 100644
--- a/lib/ssl/src/tls_v1.erl
+++ b/lib/ssl/src/tls_v1.erl
@@ -166,7 +166,7 @@ setup_keys(Version, PrfAlgo, MasterSecret, ServerRandom, ClientRandom, HashSize,
     {ClientWriteMacSecret, ServerWriteMacSecret, ClientWriteKey,
      ServerWriteKey, ClientIV, ServerIV}.
 
--spec mac_hash(integer(), binary(), integer(), integer(), tls_version(),
+-spec mac_hash(integer(), binary(), integer(), integer(), tls_record:tls_version(),
 	       integer(), binary()) -> binary().
 
 mac_hash(Method, Mac_write_secret, Seq_num, Type, {Major, Minor},
@@ -181,7 +181,7 @@ mac_hash(Method, Mac_write_secret, Seq_num, Type, {Major, Minor},
 		     Fragment]),
     Mac.
 
--spec suites(1|2|3) -> [cipher_suite()].
+-spec suites(1|2|3) -> [ssl_cipher:cipher_suite()].
 
 suites(Minor) when Minor == 1; Minor == 2->
     case sufficent_ec_support() of