anchor.diff:              end;
   
           {error, no_peercert} ->
  -            {GRUID, Req2}  = cowboy_req:header(<<"global-user-id">>, Req),
  +            {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
  
positive.code:             %% Session data found, and its user ID matches -> send OK status and update current connection state
              ?debug("User ~p assigned FUSE ID ~p to the connection (PID: ~p)", [UserKey, NewFuseId, self()]),
              {reply, {binary, encode_answer(ok, MsgId, Answer_type, Answer_decoder_name, #atom{value = ?VOK})}, Req,
                          State#handler_state{fuse_id = NewFuseId, connection_id = ConnID, access_token = vcn_utils:ensure_binary(AccessToken), user_global_id = vcn_utils:ensure_binary(UserGID)}};
  
          {ok, #veil_document{record = #fuse_session{uid = OtherUID}}} ->
              %% Current user does not match session owner
  
negative.code:         Request =
              case PeerType of
                  provider -> decode_providermsg_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};
          _:Reason ->
              ?error_stacktrace("WSHandler failed due to: ~p", [Reason]),
              {reply, {binary, encode_answer(ws_handler_error)}, Req, State}
  