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:     ?debug("Handshake request: ~p", [HReq]),
      NewFuseId = genFuseId(HReq),
      UID = case DnString =:= undefined of %% Fetch user's ID
          false ->
              case user_logic:get_user({dn, DnString}) of
                  {ok, #veil_document{uuid = UID1}} ->
                      UID1;
                  {error, Error} ->
                      case user_logic:get_user({unverified_dn, DnString}) of
                          {ok, #veil_document{uuid = UID1, record = #user{login = Login}} = UserDoc} ->
                              case CertConfirmation of
                                  #handshakerequest_certconfirmation{login = Login, result = Result} ->
                                      % Remove the DN from unverified DNs as it has been confirmed or declined
                                      {ok, UserDoc2} = user_logic:update_unverified_dn_list(UserDoc, user_logic:get_unverified_dn_list(UserDoc) -- [DnString]),
                                      case Result of
                                          false ->
                                              ?alert("Private key owner denied having added a certificate with DN: ~p (added by ~p)", [DnString, Login]),
                                              throw({cert_denied_by_user, MsgId});
                                          true ->
                                              {ok, _} = user_logic:update_dn_list(UserDoc2, user_logic:get_dn_list(UserDoc2) ++ [DnString]),
                                              ?debug("User ~p confirmed a certificate with DN: ~p", [Login, DnString]),
                                              UID1
                                      end;
                                  _ ->
                                      ?debug("Handshake request is missing confirmation of certificate with DN: ~p. Denying connection.", [DnString]),
                                      throw({cert_confirmation_required, Login, MsgId})
                              end;
                          {error, _} ->
                              ?error("VeilClient handshake failed. User (DN: ~p) data is not available due to DAO error: ~p", [DnString, Error]),
                              throw({no_user_found_error, Error, MsgId})
                      end
              end;
  
          true ->
              case user_logic:get_user({global_id, vcn_utils:ensure_list(GRUID)}) of
                  {ok, #veil_document{uuid = UID1}} ->
                      UID1;
                  {error, Error} ->
                      ?error("VeilClient handshake failed. User (GRUID: ~p) data is not available due to DAO error: ~p", [GRUID, Error]),
                      throw({no_user_found_error, Error, MsgId})
              end
      end,
  
      %% Env Vars list. Entry format: {Name :: atom(), value :: string()}
      EnvVars = [{list_to_atom(string:to_lower(Name)), Value} || #handshakerequest_envvariable{name = Name, value = Value} <- Vars],
  