sochix/TLSharp
1
0
Fork 0
mirror of https://github.com/sochix/TLSharp.git synced 2025-12-06 08:02:00 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added connection checks

Browse source 
Added connection checks, in order to see if the user is connected to the internet or not
This commit is contained in:
ferferga 2018-03-02 16:34:56 +01:00 committed by GitHub
parent c1ce5e25ba
commit e9957bcc1c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 357 additions and 347 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

704
TLSharp.Core/TelegramClient.cs
View file

@ -1,88 +1,98 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Security.Cryptography; using System.Security.Cryptography;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
using TeleSharp.TL; using TeleSharp.TL;
using TeleSharp.TL.Account; using TeleSharp.TL.Account;
using TeleSharp.TL.Auth; using TeleSharp.TL.Auth;
using TeleSharp.TL.Contacts; using TeleSharp.TL.Contacts;
using TeleSharp.TL.Help; using TeleSharp.TL.Help;
using TeleSharp.TL.Messages; using TeleSharp.TL.Messages;
using TeleSharp.TL.Upload; using TeleSharp.TL.Upload;
using TLSharp.Core.Auth; using TLSharp.Core.Auth;
using TLSharp.Core.MTProto.Crypto; using TLSharp.Core.MTProto.Crypto;
using TLSharp.Core.Network; using TLSharp.Core.Network;
using TLSharp.Core.Utils; using TLSharp.Core.Utils;
using TLAuthorization = TeleSharp.TL.Auth.TLAuthorization; using TLAuthorization = TeleSharp.TL.Auth.TLAuthorization;
namespace TLSharp.Core namespace TLSharp.Core
{ {
public class TelegramClient : IDisposable public class TelegramClient : IDisposable
{ {
private MtProtoSender _sender; private MtProtoSender _sender;
private AuthKey _key; private AuthKey _key;
private TcpTransport _transport; private TcpTransport _transport;
private string _apiHash = ""; private string _apiHash = "";
private int _apiId = 0; private int _apiId = 0;
private Session _session; private Session _session;
private List<TLDcOption> dcOptions; private List<TLDcOption> dcOptions;
private TcpClientConnectionHandler _handler; private TcpClientConnectionHandler _handler;
public TelegramClient(int apiId, string apiHash, public TelegramClient(int apiId, string apiHash, ISessionStore store = null, string sessionUserId = "session", TcpClientConnectionHandler handler = null)
ISessionStore store = null, string sessionUserId = "session", TcpClientConnectionHandler handler = null) {
{ try
if (apiId == default(int)) {
throw new MissingApiConfigurationException("API_ID"); if (apiId == default(int))
if (string.IsNullOrEmpty(apiHash)) throw new MissingApiConfigurationException("API_ID");
throw new MissingApiConfigurationException("API_HASH"); if (string.IsNullOrEmpty(apiHash))
throw new MissingApiConfigurationException("API_HASH");
if (store == null)
store = new FileSessionStore(); if (store == null)
store = new FileSessionStore();
TLContext.Init();
_apiHash = apiHash; TLContext.Init();
_apiId = apiId; _apiHash = apiHash;
_handler = handler; _apiId = apiId;
_handler = handler;
_session = Session.TryLoadOrCreateNew(store, sessionUserId);
_transport = new TcpTransport(_session.ServerAddress, _session.Port, _handler); _session = Session.TryLoadOrCreateNew(store, sessionUserId);
} _transport = new TcpTransport(_session.ServerAddress, _session.Port, _handler);
}
public async Task ConnectAsync(bool reconnect = false) catch
{ {
if (_session.AuthKey == null || reconnect) throw new Exception("Not connected to the internet");
{ }
var result = await Authenticator.DoAuthentication(_transport); }
_session.AuthKey = result.AuthKey; public async Task<bool> ConnectAsync(bool reconnect = false)
_session.TimeOffset = result.TimeOffset; {
} try
{
_sender = new MtProtoSender(_transport, _session); if (_session.AuthKey == null || reconnect)
{
//set-up layer var result = await Authenticator.DoAuthentication(_transport);
var config = new TLRequestGetConfig(); _session.AuthKey = result.AuthKey;
var request = new TLRequestInitConnection() _session.TimeOffset = result.TimeOffset;
{ }
ApiId = _apiId, _sender = new MtProtoSender(_transport, _session);
AppVersion = "1.0.0",
DeviceModel = "PC", //set-up layer
LangCode = "en", var config = new TLRequestGetConfig();
Query = config, var request = new TLRequestInitConnection()
SystemVersion = "Win 10.0" {
}; ApiId = _apiId,
var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request }; AppVersion = "1.0.0",
await _sender.Send(invokewithLayer); DeviceModel = "PC",
await _sender.Receive(invokewithLayer); LangCode = "en",
Query = config,
dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList(); SystemVersion = "Win 10.0"
} };
var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request };
private async Task ReconnectToDcAsync(int dcId) await _sender.Send(invokewithLayer);
{ await _sender.Receive(invokewithLayer);
if (dcOptions == null || !dcOptions.Any()) dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList();
throw new InvalidOperationException($"Can't reconnect. Establish initial connection first."); }
catch
{
return false;
}
return true;
}
private async Task ReconnectToDcAsync(int dcId)
{
if (dcOptions == null || !dcOptions.Any())
throw new InvalidOperationException($"Can't reconnect. Establish initial connection first.");
TLExportedAuthorization exported = null; TLExportedAuthorization exported = null;
if (_session.TLUser != null) if (_session.TLUser != null)
@ -90,13 +100,13 @@ namespace TLSharp.Core
TLRequestExportAuthorization exportAuthorization = new TLRequestExportAuthorization() { DcId = dcId }; TLRequestExportAuthorization exportAuthorization = new TLRequestExportAuthorization() { DcId = dcId };
exported = await SendRequestAsync<TLExportedAuthorization>(exportAuthorization); exported = await SendRequestAsync<TLExportedAuthorization>(exportAuthorization);
} }
var dc = dcOptions.First(d => d.Id == dcId); var dc = dcOptions.First(d => d.Id == dcId);
_transport = new TcpTransport(dc.IpAddress, dc.Port, _handler); _transport = new TcpTransport(dc.IpAddress, dc.Port, _handler);
_session.ServerAddress = dc.IpAddress; _session.ServerAddress = dc.IpAddress;
_session.Port = dc.Port; _session.Port = dc.Port;
await ConnectAsync(true); await ConnectAsync(true);
if (_session.TLUser != null) if (_session.TLUser != null)
@ -104,214 +114,214 @@ namespace TLSharp.Core
TLRequestImportAuthorization importAuthorization = new TLRequestImportAuthorization() { Id = exported.Id, Bytes = exported.Bytes }; TLRequestImportAuthorization importAuthorization = new TLRequestImportAuthorization() { Id = exported.Id, Bytes = exported.Bytes };
var imported = await SendRequestAsync<TLAuthorization>(importAuthorization); var imported = await SendRequestAsync<TLAuthorization>(importAuthorization);
OnUserAuthenticated(((TLUser)imported.User)); OnUserAuthenticated(((TLUser)imported.User));
} }
} }
private async Task RequestWithDcMigration(TLMethod request) private async Task RequestWithDcMigration(TLMethod request)
{ {
if (_sender == null) if (_sender == null)
throw new InvalidOperationException("Not connected!"); throw new InvalidOperationException("Not connected!");
var completed = false; var completed = false;
while(!completed) while(!completed)
{ {
try try
{ {
await _sender.Send(request); await _sender.Send(request);
await _sender.Receive(request); await _sender.Receive(request);
completed = true; completed = true;
} }
catch(DataCenterMigrationException e) catch(DataCenterMigrationException e)
{ {
await ReconnectToDcAsync(e.DC); await ReconnectToDcAsync(e.DC);
// prepare the request for another try // prepare the request for another try
request.ConfirmReceived = false; request.ConfirmReceived = false;
} }
} }
} }
public bool IsUserAuthorized() public bool IsUserAuthorized()
{ {
return _session.TLUser != null; return _session.TLUser != null;
} }
public async Task<bool> IsPhoneRegisteredAsync(string phoneNumber) public async Task<bool> IsPhoneRegisteredAsync(string phoneNumber)
{ {
if (String.IsNullOrWhiteSpace(phoneNumber)) if (String.IsNullOrWhiteSpace(phoneNumber))
throw new ArgumentNullException(nameof(phoneNumber)); throw new ArgumentNullException(nameof(phoneNumber));
var authCheckPhoneRequest = new TLRequestCheckPhone() { PhoneNumber = phoneNumber }; var authCheckPhoneRequest = new TLRequestCheckPhone() { PhoneNumber = phoneNumber };
await RequestWithDcMigration(authCheckPhoneRequest); await RequestWithDcMigration(authCheckPhoneRequest);
return authCheckPhoneRequest.Response.PhoneRegistered; return authCheckPhoneRequest.Response.PhoneRegistered;
} }
public async Task<string> SendCodeRequestAsync(string phoneNumber) public async Task<string> SendCodeRequestAsync(string phoneNumber)
{ {
if (String.IsNullOrWhiteSpace(phoneNumber)) if (String.IsNullOrWhiteSpace(phoneNumber))
throw new ArgumentNullException(nameof(phoneNumber)); throw new ArgumentNullException(nameof(phoneNumber));
var request = new TLRequestSendCode() { PhoneNumber = phoneNumber, ApiId = _apiId, ApiHash = _apiHash }; var request = new TLRequestSendCode() { PhoneNumber = phoneNumber, ApiId = _apiId, ApiHash = _apiHash };
await RequestWithDcMigration(request); await RequestWithDcMigration(request);
return request.Response.PhoneCodeHash; return request.Response.PhoneCodeHash;
} }
public async Task<TLUser> MakeAuthAsync(string phoneNumber, string phoneCodeHash, string code) public async Task<TLUser> MakeAuthAsync(string phoneNumber, string phoneCodeHash, string code)
{ {
if (String.IsNullOrWhiteSpace(phoneNumber)) if (String.IsNullOrWhiteSpace(phoneNumber))
throw new ArgumentNullException(nameof(phoneNumber)); throw new ArgumentNullException(nameof(phoneNumber));
if (String.IsNullOrWhiteSpace(phoneCodeHash)) if (String.IsNullOrWhiteSpace(phoneCodeHash))
throw new ArgumentNullException(nameof(phoneCodeHash)); throw new ArgumentNullException(nameof(phoneCodeHash));
if (String.IsNullOrWhiteSpace(code)) if (String.IsNullOrWhiteSpace(code))
throw new ArgumentNullException(nameof(code)); throw new ArgumentNullException(nameof(code));
var request = new TLRequestSignIn() { PhoneNumber = phoneNumber, PhoneCodeHash = phoneCodeHash, PhoneCode = code }; var request = new TLRequestSignIn() { PhoneNumber = phoneNumber, PhoneCodeHash = phoneCodeHash, PhoneCode = code };
await RequestWithDcMigration(request); await RequestWithDcMigration(request);
OnUserAuthenticated(((TLUser)request.Response.User)); OnUserAuthenticated(((TLUser)request.Response.User));
return ((TLUser)request.Response.User); return ((TLUser)request.Response.User);
} }
public async Task<TLPassword> GetPasswordSetting() public async Task<TLPassword> GetPasswordSetting()
{ {
var request = new TLRequestGetPassword(); var request = new TLRequestGetPassword();
await RequestWithDcMigration(request); await RequestWithDcMigration(request);
return ((TLPassword)request.Response); return ((TLPassword)request.Response);
} }
public async Task<TLUser> MakeAuthWithPasswordAsync(TLPassword password, string password_str) public async Task<TLUser> MakeAuthWithPasswordAsync(TLPassword password, string password_str)
{ {
byte[] password_Bytes = Encoding.UTF8.GetBytes(password_str); byte[] password_Bytes = Encoding.UTF8.GetBytes(password_str);
IEnumerable<byte> rv = password.CurrentSalt.Concat(password_Bytes).Concat(password.CurrentSalt); IEnumerable<byte> rv = password.CurrentSalt.Concat(password_Bytes).Concat(password.CurrentSalt);
SHA256Managed hashstring = new SHA256Managed(); SHA256Managed hashstring = new SHA256Managed();
var password_hash = hashstring.ComputeHash(rv.ToArray()); var password_hash = hashstring.ComputeHash(rv.ToArray());
var request = new TLRequestCheckPassword() { PasswordHash = password_hash }; var request = new TLRequestCheckPassword() { PasswordHash = password_hash };
await RequestWithDcMigration(request); await RequestWithDcMigration(request);
OnUserAuthenticated(((TLUser)request.Response.User)); OnUserAuthenticated(((TLUser)request.Response.User));
return ((TLUser)request.Response.User); return ((TLUser)request.Response.User);
} }
public async Task<TLUser> SignUpAsync(string phoneNumber, string phoneCodeHash, string code, string firstName, string lastName) public async Task<TLUser> SignUpAsync(string phoneNumber, string phoneCodeHash, string code, string firstName, string lastName)
{ {
var request = new TLRequestSignUp() { PhoneNumber = phoneNumber, PhoneCode = code, PhoneCodeHash = phoneCodeHash, FirstName = firstName, LastName = lastName }; var request = new TLRequestSignUp() { PhoneNumber = phoneNumber, PhoneCode = code, PhoneCodeHash = phoneCodeHash, FirstName = firstName, LastName = lastName };
await RequestWithDcMigration(request); await RequestWithDcMigration(request);
OnUserAuthenticated(((TLUser)request.Response.User)); OnUserAuthenticated(((TLUser)request.Response.User));
return ((TLUser)request.Response.User); return ((TLUser)request.Response.User);
} }
public async Task<T> SendRequestAsync<T>(TLMethod methodToExecute) public async Task<T> SendRequestAsync<T>(TLMethod methodToExecute)
{ {
await RequestWithDcMigration(methodToExecute); await RequestWithDcMigration(methodToExecute);
var result = methodToExecute.GetType().GetProperty("Response").GetValue(methodToExecute); var result = methodToExecute.GetType().GetProperty("Response").GetValue(methodToExecute);
return (T)result; return (T)result;
} }
public async Task<TLContacts> GetContactsAsync() public async Task<TLContacts> GetContactsAsync()
{ {
if (!IsUserAuthorized()) if (!IsUserAuthorized())
throw new InvalidOperationException("Authorize user first!"); throw new InvalidOperationException("Authorize user first!");
var req = new TLRequestGetContacts() { Hash = "" }; var req = new TLRequestGetContacts() { Hash = "" };
return await SendRequestAsync<TLContacts>(req); return await SendRequestAsync<TLContacts>(req);
} }
public async Task<TLAbsUpdates> SendMessageAsync(TLAbsInputPeer peer, string message) public async Task<TLAbsUpdates> SendMessageAsync(TLAbsInputPeer peer, string message)
{ {
if (!IsUserAuthorized()) if (!IsUserAuthorized())
throw new InvalidOperationException("Authorize user first!"); throw new InvalidOperationException("Authorize user first!");
return await SendRequestAsync<TLAbsUpdates>( return await SendRequestAsync<TLAbsUpdates>(
new TLRequestSendMessage() new TLRequestSendMessage()
{ {
Peer = peer, Peer = peer,
Message = message, Message = message,
RandomId = Helpers.GenerateRandomLong() RandomId = Helpers.GenerateRandomLong()
}); });
} }
public async Task<Boolean> SendTypingAsync(TLAbsInputPeer peer) public async Task<Boolean> SendTypingAsync(TLAbsInputPeer peer)
{ {
var req = new TLRequestSetTyping() var req = new TLRequestSetTyping()
{ {
Action = new TLSendMessageTypingAction(), Action = new TLSendMessageTypingAction(),
Peer = peer Peer = peer
}; };
return await SendRequestAsync<Boolean>(req); return await SendRequestAsync<Boolean>(req);
} }
public async Task<TLAbsDialogs> GetUserDialogsAsync() public async Task<TLAbsDialogs> GetUserDialogsAsync()
{ {
var peer = new TLInputPeerSelf(); var peer = new TLInputPeerSelf();
return await SendRequestAsync<TLAbsDialogs>( return await SendRequestAsync<TLAbsDialogs>(
new TLRequestGetDialogs() { OffsetDate = 0, OffsetPeer = peer, Limit = 100 }); new TLRequestGetDialogs() { OffsetDate = 0, OffsetPeer = peer, Limit = 100 });
} }
public async Task<TLAbsUpdates> SendUploadedPhoto(TLAbsInputPeer peer, TLAbsInputFile file, string caption) public async Task<TLAbsUpdates> SendUploadedPhoto(TLAbsInputPeer peer, TLAbsInputFile file, string caption)
{ {
return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia() return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{ {
RandomId = Helpers.GenerateRandomLong(), RandomId = Helpers.GenerateRandomLong(),
Background = false, Background = false,
ClearDraft = false, ClearDraft = false,
Media = new TLInputMediaUploadedPhoto() { File = file, Caption = caption }, Media = new TLInputMediaUploadedPhoto() { File = file, Caption = caption },
Peer = peer Peer = peer
}); });
} }
public async Task<TLAbsUpdates> SendUploadedDocument( public async Task<TLAbsUpdates> SendUploadedDocument(
TLAbsInputPeer peer, TLAbsInputFile file, string caption, string mimeType, TLVector<TLAbsDocumentAttribute> attributes) TLAbsInputPeer peer, TLAbsInputFile file, string caption, string mimeType, TLVector<TLAbsDocumentAttribute> attributes)
{ {
return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia() return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{ {
RandomId = Helpers.GenerateRandomLong(), RandomId = Helpers.GenerateRandomLong(),
Background = false, Background = false,
ClearDraft = false, ClearDraft = false,
Media = new TLInputMediaUploadedDocument() Media = new TLInputMediaUploadedDocument()
{ {
File = file, File = file,
Caption = caption, Caption = caption,
MimeType = mimeType, MimeType = mimeType,
Attributes = attributes Attributes = attributes
}, },
Peer = peer Peer = peer
}); });
} }
public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, int offset = 0) public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, int offset = 0)
{ {
TLFile result = null; TLFile result = null;
result = await SendRequestAsync<TLFile>(new TLRequestGetFile() result = await SendRequestAsync<TLFile>(new TLRequestGetFile()
{ {
Location = location, Location = location,
Limit = filePartSize, Limit = filePartSize,
Offset = offset Offset = offset
}); });
return result; return result;
} }
public async Task SendPingAsync() public async Task SendPingAsync()
{ {
await _sender.SendPingAsync(); await _sender.SendPingAsync();
} }
public async Task<TLAbsMessages> GetHistoryAsync(TLAbsInputPeer peer, int offset, int max_id, int limit) public async Task<TLAbsMessages> GetHistoryAsync(TLAbsInputPeer peer, int offset, int max_id, int limit)
@ -327,31 +337,31 @@ namespace TLSharp.Core
Limit = limit Limit = limit
}; };
return await SendRequestAsync<TLAbsMessages>(req); return await SendRequestAsync<TLAbsMessages>(req);
} }
/// <summary> /// <summary>
/// Serch user or chat. API: contacts.search#11f812d8 q:string limit:int = contacts.Found; /// Serch user or chat. API: contacts.search#11f812d8 q:string limit:int = contacts.Found;
/// </summary> /// </summary>
/// <param name="q">User or chat name</param> /// <param name="q">User or chat name</param>
/// <param name="limit">Max result count</param> /// <param name="limit">Max result count</param>
/// <returns></returns> /// <returns></returns>
public async Task<TLFound> SearchUserAsync(string q, int limit = 10) public async Task<TLFound> SearchUserAsync(string q, int limit = 10)
{ {
var r = new TeleSharp.TL.Contacts.TLRequestSearch var r = new TeleSharp.TL.Contacts.TLRequestSearch
{ {
Q = q, Q = q,
Limit = limit Limit = limit
}; };
return await SendRequestAsync<TLFound>(r); return await SendRequestAsync<TLFound>(r);
} }
private void OnUserAuthenticated(TLUser TLUser) private void OnUserAuthenticated(TLUser TLUser)
{ {
_session.TLUser = TLUser; _session.TLUser = TLUser;
_session.SessionExpires = int.MaxValue; _session.SessionExpires = int.MaxValue;
_session.Save(); _session.Save();
} }
public bool IsConnected public bool IsConnected
@ -364,32 +374,32 @@ namespace TLSharp.Core
} }
} }
public void Dispose() public void Dispose()
{ {
if (_transport != null) if (_transport != null)
{ {
_transport.Dispose(); _transport.Dispose();
_transport = null; _transport = null;
} }
} }
} }
public class MissingApiConfigurationException : Exception public class MissingApiConfigurationException : Exception
{ {
public const string InfoUrl = "https://github.com/sochix/TLSharp#quick-configuration"; public const string InfoUrl = "https://github.com/sochix/TLSharp#quick-configuration";
internal MissingApiConfigurationException(string invalidParamName) : internal MissingApiConfigurationException(string invalidParamName) :
base($"Your {invalidParamName} setting is missing. Adjust the configuration first, see {InfoUrl}") base($"Your {invalidParamName} setting is missing. Adjust the configuration first, see {InfoUrl}")
{ {
} }
} }
public class InvalidPhoneCodeException : Exception public class InvalidPhoneCodeException : Exception
{ {
internal InvalidPhoneCodeException(string msg) : base(msg) { } internal InvalidPhoneCodeException(string msg) : base(msg) { }
} }
public class CloudPasswordNeededException : Exception public class CloudPasswordNeededException : Exception
{ {
internal CloudPasswordNeededException(string msg) : base(msg) { } internal CloudPasswordNeededException(string msg) : base(msg) { }
} }
} }