anchor.diff:                      ok ->
                           receive
                               {worker_answer, MsgId, Ans2} ->
  -                              case Msg of
  -                                #logmessage{} -> {ok, Req, State};
  -                                _ -> {reply, {binary, encode_answer(Ans, MsgId, Answer_type, Answer_decoder_name, Ans2)}, Req, State}
  -                              end
  +                                {reply, {binary, encode_answer(Ans, MsgId, Answer_type, Answer_decoder_name, Ans2)}, Req, State}
                           after DispatcherTimeout ->
                               {reply, {binary, encode_answer(dispatcher_timeout, MsgId)}, Req, State}
                           end;
  
positive.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}
  
negative.code:         end,
  
      case DnString =/= undefined orelse UserGID =/= undefined of
          true -> ok;
          false -> throw({no_credentials, MsgId})
      end,
  
      Request = case Msg of
                    CallbackMsg when is_record(CallbackMsg, channelregistration) ->
                        #veil_request{subject = DnString, request =
                        #callback{fuse = FuseID, pid = self(), node = node(), action = channelregistration}, access_token = {UserGID, AccessToken}};
                    CallbackMsg2 when is_record(CallbackMsg2, channelclose) ->
                        #veil_request{subject = DnString, request =
                        #callback{fuse = FuseID, pid = self(), node = node(), action = channelclose}, access_token = {UserGID, AccessToken}};
                    _ ->
                        #veil_request{subject = DnString, request = Msg, fuse_id = FuseID, access_token = {UserGID, AccessToken}}
                end,
  
      case Synch of
  