private async Task RequestWithDcMigration(TLMethod request) { if (_sender == null) { throw new InvalidOperationException("Not connected!"); } var completed = false; while (!completed) { try { await _sender.Send(request); await _sender.Receive(request); completed = true; } catch (DataCenterMigrationException e) { if (_session.DataCenter.DataCenterId.HasValue && _session.DataCenter.DataCenterId.Value == e.DC) { throw new Exception($"Telegram server replied requesting a migration to DataCenter {e.DC} when this connection was already using this DataCenter", e); } await ReconnectToDcAsync(e.DC); // prepare the request for another try request.ConfirmReceived = false; } } }
public async Task SendRpcRequest(TLMethod request) { await _sender.Send(request); // error handling order is important await HandleError(request); _session.Save(); // escalate to user request.ThrowIfHasError(); }
public async Task <bool> Connect(bool reconnect = false) { if (_transport == null) { _transport = new TcpTransport(_session.ServerAddress, _session.Port); } if (_session.AuthKey == null || reconnect) { var result = await Authenticator.DoAuthentication(_transport); _session.AuthKey = result.AuthKey; _session.TimeOffset = result.TimeOffset; } _sender = new MtProtoSender(_transport, _session); if (!reconnect) { var request = new InitConnectionRequest(_apiId); await _sender.Send(request); await _sender.Recieve(request); dcOptions = request.ConfigConstructor.dc_options; _session.CurrentDcId = request.ConfigConstructor.this_dc; } return(true); }
private async Task RequestWithDcMigration(TLMethod request) { if (_sender == null) { throw new InvalidOperationException("Not connected!"); } var completed = false; while (!completed) { try { await _sender.Send(request); await _sender.Receive(request); completed = true; } catch (DataCenterMigrationException e) { await ReconnectToDcAsync(e.DC); // prepare the request for another try request.ConfirmReceived = false; } } }
public async Task <bool> Connect(bool reconnect = false) { if (_session.AuthKey == null || reconnect) { var result = await Authenticator.DoAuthentication(_transport); _session.AuthKey = result.AuthKey; _session.TimeOffset = result.TimeOffset; } _sender = new MtProtoSender(_transport, _session); if (!reconnect) { var request = new TL.InvokeWithLayerRequest(config.currentLayer, new TL.InitConnectionRequest(config.apiId, config.DeviceModel, config.SystemVersion, config.AppVersion, config.LangCode, new TL.HelpGetConfigRequest())); await _sender.Send(request); await _sender.Receive(request); var result = (TL.ConfigType)request.Result; dcOptions = result.DcOptions; } return(true); }
public async Task <bool> ConnectAsync(bool reconnect = false) { if (_session.AuthKey == null || reconnect) { var result = await Authenticator.DoAuthentication(_transport); _session.AuthKey = result.AuthKey; _session.TimeOffset = result.TimeOffset; } _sender = new MtProtoSender(_transport, _session); //set-up layer var config = new TLRequestGetConfig(); var request = new TLRequestInitConnection() { api_id = _apiId, app_version = "1.0.0", device_model = "PC", lang_code = "en", query = config, system_version = "Win 10.0" }; var invokewithLayer = new TLRequestInvokeWithLayer() { layer = 57, query = request }; await _sender.Send(invokewithLayer); await _sender.Receive(invokewithLayer); dcOptions = ((TLConfig)invokewithLayer.Response).dc_options.lists; return(true); }
public async Task ConnectAsync(bool reconnect = false, CancellationToken token = default(CancellationToken)) { token.ThrowIfCancellationRequested(); if (session.AuthKey == null || reconnect) { var result = await Authenticator.DoAuthentication(transport, token).ConfigureAwait(false); session.AuthKey = result.AuthKey; session.TimeOffset = result.TimeOffset; } sender = new MtProtoSender(transport, session); //set-up layer var config = new TLRequestGetConfig(); var request = new TLRequestInitConnection() { ApiId = apiId, AppVersion = "1.0.0", DeviceModel = "PC", LangCode = "en", Query = config, SystemVersion = "Win 10.0" }; var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request }; await sender.Send(invokewithLayer, token).ConfigureAwait(false); await sender.Receive(invokewithLayer, token).ConfigureAwait(false); dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList(); }
public async Task <bool> ConnectAsync(bool reconnect = false) { if (_session.AuthKey == null || reconnect) { var result = await Authenticator.DoAuthentication(_transport); _session.AuthKey = result.AuthKey; _session.TimeOffset = result.TimeOffset; } _sender = new MtProtoSender(_transport, _session); //set-up layer var config = new TLRequestGetConfig(); var request = new TLRequestInitConnection() { ApiId = _apiId, AppVersion = "1.0.0", DeviceModel = "PC", LangCode = "en", Query = config, SystemVersion = "Win 10.0" }; var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request }; await _sender.Send(invokewithLayer); await _sender.Receive(invokewithLayer); dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList(); return(true); }
public async Task <bool> IsPhoneRegisteredAsync(string phoneNumber) { if (_sender == null) { throw new InvalidOperationException("Not connected!"); } var authCheckPhoneRequest = new TLRequestCheckPhone() { phone_number = phoneNumber }; await _sender.Send(authCheckPhoneRequest); await _sender.Receive(authCheckPhoneRequest); return(authCheckPhoneRequest.Response.phone_registered); }
public async Task <string> SendCodeRequest(string phoneNumber) { retry: var request = new Auth_SendCodeRequest(phoneNumber, 5, // 5 = app code Values.ApiID, Values.ApiHash, "en"); await _sender.Send(request); await _sender.Recieve(request); var result = (Auth_sentAppCodeConstructor)request.result; if (result == null) { goto retry; // we probs had a phone migrate error! } return(result.phone_code_hash); }
public async Task <TL.ConfigType> getConfig() { var request = new TL.HelpGetConfigRequest(); await _sender.Send(request); await _sender.Receive(request); return((TL.ConfigType)request.Result); }
public async Task <bool> IsPhoneRegisteredAsync(string phoneNumber) { if (String.IsNullOrWhiteSpace(phoneNumber)) { throw new ArgumentNullException(nameof(phoneNumber)); } if (_sender == null) { throw new InvalidOperationException("Not connected!"); } var authCheckPhoneRequest = new TLRequestCheckPhone() { phone_number = phoneNumber }; var completed = false; while (!completed) { try { await _sender.Send(authCheckPhoneRequest); await _sender.Receive(authCheckPhoneRequest); completed = true; } catch (PhoneMigrationException e) { await ReconnectToDcAsync(e.DC); } } return(authCheckPhoneRequest.Response.ToTLCheckedPhone().phone_registered); }
public async Task <bool> IsPhoneRegistered(string phoneNumber) { if (_sender == null) { throw new InvalidOperationException("Not connected!"); } var authCheckPhoneRequest = new AuthCheckPhoneRequest(phoneNumber); await _sender.Send(authCheckPhoneRequest); await _sender.Recieve(authCheckPhoneRequest); return(authCheckPhoneRequest._phoneRegistered); }
public async Task SendRpcRequest(MtProtoRequest request, bool throwOnError = true) { if (isClosed) { throw new ObjectDisposedException("TelegramClient is closed"); } await protoSender.Send(request); // handle errors that can be fixed without user interaction if (request.Error == RpcRequestError.IncorrectServerSalt) { // assuming that salt was already updated by underlying layer Debug.WriteLine("IncorrectServerSalt. Resolving by resending message"); request.ResetError(); await protoSender.Send(request); } if (request.Error == RpcRequestError.MessageSeqNoTooLow) { Debug.WriteLine("MessageSeqNoTooLow. Resoliving by resetting session and resending message"); session.Reset(); request.ResetError(); await protoSender.Send(request); } if (request.Error == RpcRequestError.Unauthorized) { Debug.WriteLine("Invalid authorization"); session.ResetAuth(); OnAuthenticationCanceled(); } session.Save(); // escalate if (throwOnError) { request.ThrowIfHasError(); } }
private async Task <MtProtoSender> CreateProto(Session protoSession) { Debug.WriteLine("Creating new transport.."); if (protoSession.authKey == null) { var authResult = await Authenticator.Authenticate(protoSession.serverAddress, protoSession.port); protoSession.authKey = authResult.authKey; protoSession.timeOffset = authResult.timeOffset; protoSession.salt = authResult.serverSalt; } var proto = new MtProtoSender(protoSession, true); var initRequest = new InitConnectionAndGetConfigRequest(apiLayer, apiId, deviceInfo); await proto.Send(initRequest); return(proto); }
private async Task RequestWithDcMigration(TLMethod request) { var completed = false; while (!completed) { try { await _sender.Send(request); await _sender.Receive(request); completed = true; } catch (DataCenterMigrationException e) { await ReconnectToDcAsync(e.DC); } } }
public async Task <bool> Connect() { if (_session.AuthKey == null) { var result = await Authenticator.DoAuthentication(_transport); _session.AuthKey = result.AuthKey; _session.TimeOffset = result.TimeOffset; } _sender = new MtProtoSender(_transport, _session); var request = new InitConnectionRequest(Values.ApiID); await _sender.Send(request); await _sender.Recieve(request); return(IsUserAuthorized()); }
public async Task <bool> IsPhoneRegistered(string phoneNumber) { if (_sender == null) { throw new InvalidOperationException("Not connected!"); } var authCheckPhoneRequest = new TL.AuthCheckPhoneRequest(phoneNumber); await _sender.Send(authCheckPhoneRequest); await _sender.Receive(authCheckPhoneRequest); var result = (TL.AuthCheckedPhoneType)authCheckPhoneRequest.Result; return(result.PhoneRegistered); }
private async Task ConnectInternalAsync(bool reconnect = false, CancellationToken token = default(CancellationToken)) { token.ThrowIfCancellationRequested(); Session = SessionFactory.TryLoadOrCreateNew(store, sessionUserId); transport = new TcpTransport(Session.DataCenter.Address, Session.DataCenter.Port, this.handler); if (Session.AuthKey == null || reconnect) { var result = await Authenticator.DoAuthentication(transport, token).ConfigureAwait(false); Session.AuthKey = result.AuthKey; Session.TimeOffset = result.TimeOffset; } sender = new MtProtoSender(transport, store, Session); //set-up layer var config = new TLRequestGetConfig(); var request = new TLRequestInitConnection() { ApiId = apiId, AppVersion = "1.0.0", DeviceModel = "PC", LangCode = "en", Query = config, SystemVersion = "Win 10.0", SystemLangCode = "en", LangPack = "" }; var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 108, Query = request }; await sender.Send(invokewithLayer, token).ConfigureAwait(false); await sender.Receive(invokewithLayer, token).ConfigureAwait(false); dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList(); }
public async Task <bool> IsPhoneRegistered(string phoneNumber) { if (_sender == null) { throw new InvalidOperationException("Not connected!"); } bool completed = false; AuthCheckPhoneRequest authCheckPhoneRequest = null; while (!completed) { authCheckPhoneRequest = new AuthCheckPhoneRequest(phoneNumber); try { await _sender.Send(authCheckPhoneRequest); await _sender.Recieve(authCheckPhoneRequest); completed = true; } catch (InvalidOperationException e) { if (e.Message.StartsWith("Your phone number registered to") && e.Data["dcId"] != null) { await ReconnectToDc((int)e.Data["dcId"]); } else { throw; } } } return(authCheckPhoneRequest._phoneRegistered); }
public async Task <Tuple <List <Dialog>, List <Message>, List <Chat>, List <User> > > getDialogs(int offset, int limit) { var request = new TL.ChannelsGetDialogsRequest(offset, limit); await _sender.Send(request); await _sender.Receive(request); if (request.Result is TL.MessagesDialogsType) { var result = (TL.MessagesDialogsType)request.Result; dialogs = result.Dialogs; messages = result.Messages; chats = result.Chats; users = result.Users; } else { var result = (TL.MessagesDialogsSliceType)request.Result; dialogs = result.Dialogs; messages = result.Messages; chats = result.Chats; users = result.Users; } return(new Tuple <List <Dialog>, List <Message>, List <Chat>, List <User> >(dialogs, messages, chats, users)); }