anchor.diff:  handle_call({recv, N, Timeout}, RecvFrom, StateName, State, _) ->
       %% Doing renegotiate wait with handling request until renegotiate is
       %% finished. 
  -    {next_state, StateName, State#state{bytes_to_read = N, start_or_recv_from = RecvFrom}, 
  +    {next_state, StateName, State#state{bytes_to_read = N, start_or_recv_from = RecvFrom},
        [{next_event, internal, {recv, RecvFrom}} , {{timeout, recv}, Timeout, timeout}]};
   handle_call({new_user, User}, From, StateName, 
               State = #state{connection_env = #connection_env{user_application = {OldMon, _}} = CEnv}, _) ->
  
positive.code: handle_common_event({timeout, recv}, timeout, StateName, #state{start_or_recv_from = RecvFrom} = State, _) ->
      {next_state, StateName, State#state{start_or_recv_from = undefined,
                                          bytes_to_read = undefined}, [{reply, RecvFrom, {error, timeout}}]};
  handle_common_event(Type, Msg, StateName, #state{connection_env =
                                                        #connection_env{negotiated_version = Version}} = State, 
  		    _) ->
      Alert =  ?ALERT_REC(?FATAL,?UNEXPECTED_MESSAGE, {unexpected_msg, {Type,Msg}}),
      handle_own_alert(Alert, Version, StateName, State).
  
negative.code:     Connection:next_event(connection, Record, State);
  connection(info, Msg, State, _) ->
      handle_info(Msg, ?FUNCTION_NAME, State);
  connection(internal, {recv, RecvFrom}, #state{start_or_recv_from = RecvFrom} = State, Connection) ->
      passive_receive(State, ?FUNCTION_NAME, Connection, []);
  connection(Type, Msg, State, Connection) ->
      handle_common_event(Type, Msg, ?FUNCTION_NAME, State, Connection).
  
  