anchor.diff:          Request =
               case PeerType of
                   provider -> decode_providermsg_pb(Data);
  -                user     -> decode_clustermsg_pb(Data)
  +                user -> decode_clustermsg_pb(Data)
               end,
           ?debug("Received request: ~p", [Request]),
   
           handle(Req, Request, State) %% Decode ClusterMsg and handle it
       catch
  -        wrong_message_format                            -> {reply, {binary, encode_answer(wrong_message_format)}, Req, State};
  -        {wrong_internal_message_type, MsgId2}           -> {reply, {binary, encode_answer(wrong_internal_message_type, MsgId2)}, Req, State};
  -        {message_not_supported, MsgId2}                 -> {reply, {binary, encode_answer(message_not_supported, MsgId2)}, Req, State};
  -        {handshake_error, _HError, MsgId2}              -> {reply, {binary, encode_answer(handshake_error, MsgId2)}, Req, State};
  -        {no_credentials, MsgId2}                        -> {reply, {binary, encode_answer(no_credentials, MsgId2)}, Req, State};
  -        {no_user_found_error, _HError, MsgId2}          -> {reply, {binary, encode_answer(no_user_found_error, MsgId2)}, Req, State};
  -        {cert_confirmation_required, UserLogin, MsgId2} -> {reply, {binary, encode_answer(cert_confirmation_required, MsgId2, UserLogin)}, Req, State};
  -        {cert_denied_by_user, MsgId2}                   -> {reply, {binary, encode_answer(cert_denied_by_user, MsgId2)}, Req, State};
  -        {AtomError, MsgId2} when is_atom(AtomError)     -> {reply, {binary, encode_answer(AtomError, MsgId2)}, Req, State};
  +        wrong_message_format -> {reply, {binary, encode_answer(wrong_message_format)}, Req, State};
  +        {wrong_internal_message_type, MsgId2} ->
  +            {reply, {binary, encode_answer(wrong_internal_message_type, MsgId2)}, Req, State};
  +        {message_not_supported, MsgId2} -> {reply, {binary, encode_answer(message_not_supported, MsgId2)}, Req, State};
  +        {handshake_error, _HError, MsgId2} -> {reply, {binary, encode_answer(handshake_error, MsgId2)}, Req, State};
  +        {no_credentials, MsgId2} -> {reply, {binary, encode_answer(no_credentials, MsgId2)}, Req, State};
  +        {no_user_found_error, _HError, MsgId2} ->
  +            {reply, {binary, encode_answer(no_user_found_error, MsgId2)}, Req, State};
  +        {cert_confirmation_required, UserLogin, MsgId2} ->
  +            {reply, {binary, encode_answer(cert_confirmation_required, MsgId2, UserLogin)}, Req, State};
  +        {cert_denied_by_user, MsgId2} -> {reply, {binary, encode_answer(cert_denied_by_user, MsgId2)}, Req, State};
  +        {AtomError, MsgId2} when is_atom(AtomError) -> {reply, {binary, encode_answer(AtomError, MsgId2)}, Req, State};
           _:Reason ->
               ?error_stacktrace("WSHandler failed due to: ~p", [Reason]),
               {reply, {binary, encode_answer(ws_handler_error)}, Req, State}
  
positive.code:         token_hash = TokenHash, global_user_id = GlobalId} = DecodedBytes,
  
      {Decoder, DecodingFun, ModuleNameAtom} = try
        {list_to_existing_atom(Message_decoder_name ++ "_pb"), list_to_existing_atom("decode_" ++ Message_type), list_to_existing_atom(ModuleName)}
      catch
        _:_ -> throw({message_not_supported, MsgId})
      end,
  
      Msg =
          try
  
negative.code:             end;
  
          {error, no_peercert} ->
              {GRUID, Req2} = cowboy_req:header(<<"global-user-id">>, Req),
              {Secret, Req3} = cowboy_req:header(<<"authentication-secret">>, Req2),
  
              case is_binary(GRUID) and is_binary(Secret) of
  