Beispiel #1
0
        public void HandleResponce(IObject obj)
        {
            Log.Debug("Handle RpcResult");

            var message = obj.Cast <TRpcResult>();

            Log.Debug($"Process RpcResult  with request id = '{message.ReqMsgId}'");

            ConfirmationRecieveService.ConfirmRequest(message.ReqMsgId);

            switch (message.Result)
            {
            case TRpcError error:
                HandleRpcError(message.ReqMsgId, error);
                break;

            case TgZipPacked zipPacked:
                var result = ZipPackedHandler.HandleGZipPacked(zipPacked);
                ResponseResultSetter.ReturnResult(message.ReqMsgId, result);
                break;

            default:
                ResponseResultSetter.ReturnResult(message.ReqMsgId, message.Result);
                break;
            }
        }
Beispiel #2
0
        public byte[] HandleResponce(int code, BinaryReader reader)
        {
            Log.Debug("Handle RpcResult");

            var requestId = reader.ReadUInt64();

            Log.Debug($"Process RpcResult  with request id = '{requestId}'");

            ConfirmationRecieveService.ConfirmRequest(requestId);

            var innerCode = reader.ReadUInt32();

            switch (innerCode)
            {
            case 0x2144ca19:
                HandleRpcError(reader, requestId);
                break;

            case 0x3072cfa1:
                HandleZipPacket(reader, requestId);
                break;

            default:
                reader.BaseStream.Position -= 4;
                var bytes = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));

                ResponseResultSetter.ReturnResult(requestId, bytes);
                break;
            }

            return(null);
        }
Beispiel #3
0
        public async Task <(Task, long)> SendWithConfim(IObject obj)
        {
            Log.Debug($"Send with confirm {obj}");

            var mesId = await Send(obj).ConfigureAwait(false);

            var waitTask = ConfirmationRecieveService.WaitForConfirm(mesId);

            return(waitTask, mesId);
        }
Beispiel #4
0
        public void HandleResponce(IObject obj)
        {
            var message = obj.Cast <TBadServerSalt>();

            Log.Info($"Bad server sault detected! message id = {message.BadMsgId} ");

            ClientSettings.Session.Salt = message.NewServerSalt;

            ConfirmationRecieveService.RequestWithException(message.BadMsgId, new BadServerSaltException());
        }
        public async Task <Tuple <Task, long> > Send(IObject obj)
        {
            var preparedData = PrepareToSend(obj, out var mesId);

            await TcpTransport.Send(preparedData).ConfigureAwait(false);

            SessionStore.Save();

            var waitTask = ConfirmationRecieveService.WaitForConfirm(mesId);

            return(Tuple.Create(waitTask, mesId));
        }
Beispiel #6
0
        public Tuple <Task, ulong> Send(TlMethod request)
        {
            var preparedData = PrepareToSend(request, out var mesId);

            TcpTransport.Send(preparedData).Wait();

            SessionStore.Save();

            var waitTask = ConfirmationRecieveService.WaitForConfirm(mesId);

            return(Tuple.Create(waitTask, mesId));
        }
Beispiel #7
0
        public byte[] HandleResponce(int code, BinaryReader reader)
        {
            var badMsgId    = reader.ReadUInt64();
            var badMsgSeqNo = reader.ReadInt32();
            var errorCode   = reader.ReadInt32();
            var newSalt     = reader.ReadUInt64();

            Log.Info($"Bad server sault detected! message id = {badMsgId} ");

            ClientSettings.Session.Salt = newSalt;

            ConfirmationRecieveService.RequestWithException(badMsgId, new BadServerSaltException());

            return(null);
        }