anchor.diff:                                                  transport_cb = Transport,
                                                   negotiated_version = Version,
                                                   renegotiate_at = RenegotiateAt,
  +                                                key_update_at = ?AES_GCM_MAX,
  +                                                bytes_sent = 0,
                                                   log_level = LogLevel}},
       {next_state, handshake, StateData, [{reply, From, ok}]};
   init(_, _, _) ->
  
positive.code:                                               negotiated_version = Version,
                                                transport_cb = Transport,
                                                renegotiate_at = RenegotiateAt,
                                                log_level = LogLevel},
                               connection_states = ConnectionStates0} = StateData0) ->
      case time_to_renegotiate(Data, ConnectionStates0, RenegotiateAt) of
  	true ->
  	    ssl_connection:internal_renegotiation(Pid, ConnectionStates0),
              {next_state, handshake, StateData0, 
               [{next_event, internal, {application_packets, From, Data}}]};
  
negative.code:               [{next_event, internal,
                 {application_packets,{self(),undefined},erlang:iolist_to_iovec(Data)}}]
        end]};
  connection({call, From}, {key_update}, StateData) ->
      update_cipher_key(From, StateData);
  
  connection(internal, {application_packets, From, Data}, StateData) ->
      send_application_data(Data, From, ?FUNCTION_NAME, StateData);
  connection(internal, {post_handshake_data, From, KeyUpdate}, StateData) ->
      send_post_handshake_data(KeyUpdate, From, ?FUNCTION_NAME, StateData);
  connection(internal, {key_update, From}, StateData) ->
      update_cipher_key(From, StateData);
  %%
  connection(cast, #alert{} = Alert, StateData0) ->
      StateData = send_tls_alert(Alert, StateData0),
  