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

Adds ConfigureAwait(false) and CancellationToken to all async methods

Browse source
This commit is contained in:
Ruslan Iarmukhamedov 2019-10-25 09:32:04 +06:00
parent e4d0e97571
commit 96f9660b48
6 changed files with 243 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
TLSharp.Core/Auth/Authenticator.cs
View file

@ -1,35 +1,38 @@
using System.Threading.Tasks; using System.Threading;
using System.Threading.Tasks;
using TLSharp.Core.Network; using TLSharp.Core.Network;
namespace TLSharp.Core.Auth namespace TLSharp.Core.Auth
{ {
public static class Authenticator public static class Authenticator
{ {
public static async Task<Step3_Response> DoAuthentication(TcpTransport transport) public static async Task<Step3_Response> DoAuthentication(TcpTransport transport, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
var sender = new MtProtoPlainSender(transport); var sender = new MtProtoPlainSender(transport);
var step1 = new Step1_PQRequest(); var step1 = new Step1_PQRequest();
await sender.Send(step1.ToBytes()); await sender.Send(step1.ToBytes(), token).ConfigureAwait(false);
var step1Response = step1.FromBytes(await sender.Receive()); var step1Response = step1.FromBytes(await sender.Receive(token).ConfigureAwait(false));
var step2 = new Step2_DHExchange(); var step2 = new Step2_DHExchange();
await sender.Send(step2.ToBytes( await sender.Send(step2.ToBytes(
step1Response.Nonce, step1Response.Nonce,
step1Response.ServerNonce, step1Response.ServerNonce,
step1Response.Fingerprints, step1Response.Fingerprints,
step1Response.Pq)); step1Response.Pq), token).ConfigureAwait(false);
var step2Response = step2.FromBytes(await sender.Receive()); var step2Response = step2.FromBytes(await sender.Receive(token).ConfigureAwait(false));
var step3 = new Step3_CompleteDHExchange(); var step3 = new Step3_CompleteDHExchange();
await sender.Send(step3.ToBytes( await sender.Send(step3.ToBytes(
step2Response.Nonce, step2Response.Nonce,
step2Response.ServerNonce, step2Response.ServerNonce,
step2Response.NewNonce, step2Response.NewNonce,
step2Response.EncryptedAnswer)); step2Response.EncryptedAnswer), token).ConfigureAwait(false);
var step3Response = step3.FromBytes(await sender.Receive()); var step3Response = step3.FromBytes(await sender.Receive(token).ConfigureAwait(false));
return step3Response; return step3Response;
} }

33
TLSharp.Core/Network/MtProtoPlainSender.cs
View file

@ -1,24 +1,27 @@
using System; using System;
using System.IO; using System.IO;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace TLSharp.Core.Network namespace TLSharp.Core.Network
{ {
public class MtProtoPlainSender public class MtProtoPlainSender
{ {
private int timeOffset; private int _timeOffset;
private long lastMessageId; private long _lastMessageId;
private Random random; private readonly Random _random;
private TcpTransport _transport; private readonly TcpTransport _transport;
public MtProtoPlainSender(TcpTransport transport) public MtProtoPlainSender(TcpTransport transport)
{ {
_transport = transport; _transport = transport;
random = new Random(); _random = new Random();
} }
public async Task Send(byte[] data) public async Task Send(byte[] data, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
using (var memoryStream = new MemoryStream()) using (var memoryStream = new MemoryStream())
{ {
using (var binaryWriter = new BinaryWriter(memoryStream)) using (var binaryWriter = new BinaryWriter(memoryStream))
@ -30,14 +33,16 @@ namespace TLSharp.Core.Network
byte[] packet = memoryStream.ToArray(); byte[] packet = memoryStream.ToArray();
await _transport.Send(packet); await _transport.Send(packet, token).ConfigureAwait(false);
} }
} }
} }
public async Task<byte[]> Receive() public async Task<byte[]> Receive(CancellationToken token)
{ {
var result = await _transport.Receive(); token.ThrowIfCancellationRequested();
var result = await _transport.Receive(token).ConfigureAwait(false);
using (var memoryStream = new MemoryStream(result.Body)) using (var memoryStream = new MemoryStream(result.Body))
{ {
@ -57,17 +62,17 @@ namespace TLSharp.Core.Network
private long GetNewMessageId() private long GetNewMessageId()
{ {
long time = Convert.ToInt64((DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds); long time = Convert.ToInt64((DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds);
long newMessageId = ((time / 1000 + timeOffset) << 32) | long newMessageId = ((time / 1000 + _timeOffset) << 32) |
((time % 1000) << 22) | ((time % 1000) << 22) |
(random.Next(524288) << 2); // 2^19 (_random.Next(524288) << 2); // 2^19
// [ unix timestamp : 32 bit] [ milliseconds : 10 bit ] [ buffer space : 1 bit ] [ random : 19 bit ] [ msg_id type : 2 bit ] = [ msg_id : 64 bit ] // [ unix timestamp : 32 bit] [ milliseconds : 10 bit ] [ buffer space : 1 bit ] [ random : 19 bit ] [ msg_id type : 2 bit ] = [ msg_id : 64 bit ]
if (lastMessageId >= newMessageId) if (_lastMessageId >= newMessageId)
{ {
newMessageId = lastMessageId + 4; newMessageId = _lastMessageId + 4;
} }
lastMessageId = newMessageId; _lastMessageId = newMessageId;
return newMessageId; return newMessageId;
} }

59
TLSharp.Core/Network/MtProtoSender.cs
View file

@ -1,6 +1,5 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
@ -34,8 +33,10 @@ namespace TLSharp.Core.Network
return confirmed ? _session.Sequence++ * 2 + 1 : _session.Sequence * 2; return confirmed ? _session.Sequence++ * 2 + 1 : _session.Sequence * 2;
} }
public async Task Send(TeleSharp.TL.TLMethod request) public async Task Send(TeleSharp.TL.TLMethod request, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
// TODO: refactor // TODO: refactor
if (needConfirmation.Any()) if (needConfirmation.Any())
{ {
@ -44,7 +45,7 @@ namespace TLSharp.Core.Network
using (var writer = new BinaryWriter(memory)) using (var writer = new BinaryWriter(memory))
{ {
ackRequest.SerializeBody(writer); ackRequest.SerializeBody(writer);
await Send(memory.ToArray(), ackRequest); await Send(memory.ToArray(), ackRequest, token).ConfigureAwait(false);
needConfirmation.Clear(); needConfirmation.Clear();
} }
} }
@ -54,14 +55,16 @@ namespace TLSharp.Core.Network
using (var writer = new BinaryWriter(memory)) using (var writer = new BinaryWriter(memory))
{ {
request.SerializeBody(writer); request.SerializeBody(writer);
await Send(memory.ToArray(), request); await Send(memory.ToArray(), request, token).ConfigureAwait(false);
} }
_session.Save(); _session.Save();
} }
public async Task Send(byte[] packet, TeleSharp.TL.TLMethod request) public async Task Send(byte[] packet, TeleSharp.TL.TLMethod request, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
request.MessageId = _session.GetNewMessageId(); request.MessageId = _session.GetNewMessageId();
byte[] msgKey; byte[] msgKey;
@ -90,7 +93,7 @@ namespace TLSharp.Core.Network
writer.Write(msgKey); writer.Write(msgKey);
writer.Write(ciphertext); writer.Write(ciphertext);
await _transport.Send(ciphertextPacket.GetBuffer()); await _transport.Send(ciphertextPacket.GetBuffer(), token).ConfigureAwait(false);
} }
} }
} }
@ -127,37 +130,43 @@ namespace TLSharp.Core.Network
return new Tuple<byte[], ulong, int>(message, remoteMessageId, remoteSequence); return new Tuple<byte[], ulong, int>(message, remoteMessageId, remoteSequence);
} }
public async Task<byte[]> Receive(TeleSharp.TL.TLMethod request) public async Task<byte[]> Receive(TeleSharp.TL.TLMethod request, CancellationToken token)
{ {
while (!request.ConfirmReceived) while (!request.ConfirmReceived)
{ {
var result = DecodeMessage((await _transport.Receive()).Body); var result = DecodeMessage((await _transport.Receive(token).ConfigureAwait(false)).Body);
using (var messageStream = new MemoryStream(result.Item1, false)) using (var messageStream = new MemoryStream(result.Item1, false))
using (var messageReader = new BinaryReader(messageStream)) using (var messageReader = new BinaryReader(messageStream))
{ {
processMessage(result.Item2, result.Item3, messageReader, request); processMessage(result.Item2, result.Item3, messageReader, request, token);
} }
token.ThrowIfCancellationRequested();
} }
return null; return null;
} }
public async Task SendPingAsync() public async Task SendPingAsync(CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
var pingRequest = new PingRequest(); var pingRequest = new PingRequest();
using (var memory = new MemoryStream()) using (var memory = new MemoryStream())
using (var writer = new BinaryWriter(memory)) using (var writer = new BinaryWriter(memory))
{ {
pingRequest.SerializeBody(writer); pingRequest.SerializeBody(writer);
await Send(memory.ToArray(), pingRequest); await Send(memory.ToArray(), pingRequest, token).ConfigureAwait(false);
} }
await Receive(pingRequest); await Receive(pingRequest, token).ConfigureAwait(false);
} }
private bool processMessage(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request) private bool processMessage(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
// TODO: check salt // TODO: check salt
// TODO: check sessionid // TODO: check sessionid
// TODO: check seqno // TODO: check seqno
@ -171,7 +180,7 @@ namespace TLSharp.Core.Network
{ {
case 0x73f1f8dc: // container case 0x73f1f8dc: // container
//logger.debug("MSG container"); //logger.debug("MSG container");
return HandleContainer(messageId, sequence, messageReader, request); return HandleContainer(messageId, sequence, messageReader, request, token);
case 0x7abe77ec: // ping case 0x7abe77ec: // ping
//logger.debug("MSG ping"); //logger.debug("MSG ping");
return HandlePing(messageId, sequence, messageReader); return HandlePing(messageId, sequence, messageReader);
@ -189,7 +198,7 @@ namespace TLSharp.Core.Network
return HandleMsgsAck(messageId, sequence, messageReader); return HandleMsgsAck(messageId, sequence, messageReader);
case 0xedab447b: // bad_server_salt case 0xedab447b: // bad_server_salt
//logger.debug("MSG bad_server_salt"); //logger.debug("MSG bad_server_salt");
return HandleBadServerSalt(messageId, sequence, messageReader, request); return HandleBadServerSalt(messageId, sequence, messageReader, request, token);
case 0xa7eff811: // bad_msg_notification case 0xa7eff811: // bad_msg_notification
//logger.debug("MSG bad_msg_notification"); //logger.debug("MSG bad_msg_notification");
return HandleBadMsgNotification(messageId, sequence, messageReader); return HandleBadMsgNotification(messageId, sequence, messageReader);
@ -201,7 +210,7 @@ namespace TLSharp.Core.Network
return HandleRpcResult(messageId, sequence, messageReader, request); return HandleRpcResult(messageId, sequence, messageReader, request);
case 0x3072cfa1: // gzip_packed case 0x3072cfa1: // gzip_packed
//logger.debug("MSG gzip_packed"); //logger.debug("MSG gzip_packed");
return HandleGzipPacked(messageId, sequence, messageReader, request); return HandleGzipPacked(messageId, sequence, messageReader, request, token);
case 0xe317af7e: case 0xe317af7e:
case 0xd3f45784: case 0xd3f45784:
case 0x2b2fbd4e: case 0x2b2fbd4e:
@ -233,14 +242,16 @@ namespace TLSharp.Core.Network
*/ */
} }
private bool HandleGzipPacked(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request) private bool HandleGzipPacked(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
uint code = messageReader.ReadUInt32(); uint code = messageReader.ReadUInt32();
byte[] packedData = GZipStream.UncompressBuffer(Serializers.Bytes.read(messageReader)); byte[] packedData = GZipStream.UncompressBuffer(Serializers.Bytes.read(messageReader));
using (MemoryStream packedStream = new MemoryStream(packedData, false)) using (MemoryStream packedStream = new MemoryStream(packedData, false))
using (BinaryReader compressedReader = new BinaryReader(packedStream)) using (BinaryReader compressedReader = new BinaryReader(packedStream))
{ {
processMessage(messageId, sequence, compressedReader, request); processMessage(messageId, sequence, compressedReader, request, token);
} }
return true; return true;
@ -412,8 +423,10 @@ namespace TLSharp.Core.Network
return true; return true;
} }
private bool HandleBadServerSalt(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request) private bool HandleBadServerSalt(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
uint code = messageReader.ReadUInt32(); uint code = messageReader.ReadUInt32();
ulong badMsgId = messageReader.ReadUInt64(); ulong badMsgId = messageReader.ReadUInt64();
int badMsgSeqNo = messageReader.ReadInt32(); int badMsgSeqNo = messageReader.ReadInt32();
@ -425,7 +438,7 @@ namespace TLSharp.Core.Network
_session.Salt = newSalt; _session.Salt = newSalt;
//resend //resend
Send(request); Send(request, token);
/* /*
if(!runningRequests.ContainsKey(badMsgId)) { if(!runningRequests.ContainsKey(badMsgId)) {
logger.debug("bad server salt on unknown message"); logger.debug("bad server salt on unknown message");
@ -491,8 +504,10 @@ namespace TLSharp.Core.Network
return false; return false;
} }
private bool HandleContainer(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request) private bool HandleContainer(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
uint code = messageReader.ReadUInt32(); uint code = messageReader.ReadUInt32();
int size = messageReader.ReadInt32(); int size = messageReader.ReadInt32();
for (int i = 0; i < size; i++) for (int i = 0; i < size; i++)
@ -503,7 +518,7 @@ namespace TLSharp.Core.Network
long beginPosition = messageReader.BaseStream.Position; long beginPosition = messageReader.BaseStream.Position;
try try
{ {
if (!processMessage(innerMessageId, sequence, messageReader, request)) if (!processMessage(innerMessageId, sequence, messageReader, request, token))
{ {
messageReader.BaseStream.Position = beginPosition + innerLength; messageReader.BaseStream.Position = beginPosition + innerLength;
} }

32
TLSharp.Core/Network/TcpTransport.cs
View file

@ -1,6 +1,7 @@
using System; using System;
using System.Net; using System.Net;
using System.Net.Sockets; using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace TLSharp.Core.Network namespace TLSharp.Core.Network
@ -11,7 +12,7 @@ namespace TLSharp.Core.Network
{ {
private readonly TcpClient _tcpClient; private readonly TcpClient _tcpClient;
private readonly NetworkStream _stream; private readonly NetworkStream _stream;
private int sendCounter = 0; private int _sendCounter;
public TcpTransport(string address, int port, TcpClientConnectionHandler handler = null) public TcpTransport(string address, int port, TcpClientConnectionHandler handler = null)
{ {
@ -32,27 +33,29 @@ namespace TLSharp.Core.Network
} }
} }
public async Task Send(byte[] packet) public async Task Send(byte[] packet, CancellationToken token)
{ {
if (!_tcpClient.Connected) if (!_tcpClient.Connected)
throw new InvalidOperationException("Client not connected to server."); throw new InvalidOperationException("Client not connected to server.");
var tcpMessage = new TcpMessage(sendCounter, packet); var tcpMessage = new TcpMessage(_sendCounter, packet);
await _stream.WriteAsync(tcpMessage.Encode(), 0, tcpMessage.Encode().Length); await _stream.WriteAsync(tcpMessage.Encode(), 0, tcpMessage.Encode().Length, token).ConfigureAwait(false);
sendCounter++; _sendCounter++;
} }
public async Task<TcpMessage> Receive() public async Task<TcpMessage> Receive(CancellationToken token)
{ {
var packetLengthBytes = new byte[4]; var packetLengthBytes = new byte[4];
if (await _stream.ReadAsync(packetLengthBytes, 0, 4) != 4) if (await _stream.ReadAsync(packetLengthBytes, 0, 4, token).ConfigureAwait(false) != 4)
throw new InvalidOperationException("Couldn't read the packet length"); throw new InvalidOperationException("Couldn't read the packet length");
int packetLength = BitConverter.ToInt32(packetLengthBytes, 0); int packetLength = BitConverter.ToInt32(packetLengthBytes, 0);
var seqBytes = new byte[4]; var seqBytes = new byte[4];
if (await _stream.ReadAsync(seqBytes, 0, 4) != 4) if (await _stream.ReadAsync(seqBytes, 0, 4, token).ConfigureAwait(false) != 4)
throw new InvalidOperationException("Couldn't read the sequence"); throw new InvalidOperationException("Couldn't read the sequence");
int seq = BitConverter.ToInt32(seqBytes, 0); int seq = BitConverter.ToInt32(seqBytes, 0);
int readBytes = 0; int readBytes = 0;
@ -62,7 +65,7 @@ namespace TLSharp.Core.Network
do do
{ {
var bodyByte = new byte[packetLength - 12]; var bodyByte = new byte[packetLength - 12];
var availableBytes = await _stream.ReadAsync(bodyByte, 0, neededToRead); var availableBytes = await _stream.ReadAsync(bodyByte, 0, neededToRead, token).ConfigureAwait(false);
neededToRead -= availableBytes; neededToRead -= availableBytes;
Buffer.BlockCopy(bodyByte, 0, body, readBytes, availableBytes); Buffer.BlockCopy(bodyByte, 0, body, readBytes, availableBytes);
readBytes += availableBytes; readBytes += availableBytes;
@ -70,8 +73,9 @@ namespace TLSharp.Core.Network
while (readBytes != packetLength - 12); while (readBytes != packetLength - 12);
var crcBytes = new byte[4]; var crcBytes = new byte[4];
if (await _stream.ReadAsync(crcBytes, 0, 4) != 4) if (await _stream.ReadAsync(crcBytes, 0, 4, token).ConfigureAwait(false) != 4)
throw new InvalidOperationException("Couldn't read the crc"); throw new InvalidOperationException("Couldn't read the crc");
int checksum = BitConverter.ToInt32(crcBytes, 0); int checksum = BitConverter.ToInt32(crcBytes, 0);
byte[] rv = new byte[packetLengthBytes.Length + seqBytes.Length + body.Length]; byte[] rv = new byte[packetLengthBytes.Length + seqBytes.Length + body.Length];
@ -91,13 +95,7 @@ namespace TLSharp.Core.Network
return new TcpMessage(seq, body); return new TcpMessage(seq, body);
} }
public bool IsConnected public bool IsConnected => _tcpClient.Connected;
{
get
{
return this._tcpClient.Connected;
}
}
public void Dispose() public void Dispose()

201
TLSharp.Core/TelegramClient.cs
View file

@ -3,6 +3,7 @@ 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;
using System.Threading.Tasks; using System.Threading.Tasks;
using TeleSharp.TL; using TeleSharp.TL;
using TeleSharp.TL.Account; using TeleSharp.TL.Account;
@ -12,7 +13,6 @@ 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.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;
@ -23,16 +23,12 @@ namespace TLSharp.Core
{ {
private MtProtoSender _sender; private MtProtoSender _sender;
private TcpTransport _transport; private TcpTransport _transport;
private string _apiHash = ""; private readonly string _apiHash = "";
private int _apiId = 0; private readonly int _apiId;
private Session _session; private List<TLDcOption> _dcOptions;
private List<TLDcOption> dcOptions; private readonly TcpClientConnectionHandler _handler;
private TcpClientConnectionHandler _handler;
public Session Session public Session Session { get; }
{
get { return _session; }
}
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)
@ -49,20 +45,27 @@ namespace TLSharp.Core
_apiId = apiId; _apiId = apiId;
_handler = handler; _handler = handler;
_session = Session.TryLoadOrCreateNew(store, sessionUserId); Session = Session.TryLoadOrCreateNew(store, sessionUserId);
_transport = new TcpTransport(_session.DataCenter.Address, _session.DataCenter.Port, _handler); _transport = new TcpTransport(Session.DataCenter.Address, Session.DataCenter.Port, _handler);
} }
public async Task ConnectAsync(bool reconnect = false) public async Task ConnectAsync(bool reconnect = false)
{ {
if (_session.AuthKey == null || reconnect) await ConnectAsync(CancellationToken.None, reconnect).ConfigureAwait(false);
}
public async Task ConnectAsync(CancellationToken token, bool reconnect = false)
{
token.ThrowIfCancellationRequested();
if (Session.AuthKey == null || reconnect)
{ {
var result = await Authenticator.DoAuthentication(_transport); var result = await Authenticator.DoAuthentication(_transport, token).ConfigureAwait(false);
_session.AuthKey = result.AuthKey; Session.AuthKey = result.AuthKey;
_session.TimeOffset = result.TimeOffset; Session.TimeOffset = result.TimeOffset;
} }
_sender = new MtProtoSender(_transport, _session); _sender = new MtProtoSender(_transport, Session);
//set-up layer //set-up layer
var config = new TLRequestGetConfig(); var config = new TLRequestGetConfig();
@ -76,41 +79,43 @@ namespace TLSharp.Core
SystemVersion = "Win 10.0" SystemVersion = "Win 10.0"
}; };
var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request }; var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request };
await _sender.Send(invokewithLayer); await _sender.Send(invokewithLayer, token).ConfigureAwait(false);
await _sender.Receive(invokewithLayer); await _sender.Receive(invokewithLayer, token).ConfigureAwait(false);
dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList(); _dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList();
} }
private async Task ReconnectToDcAsync(int dcId) private async Task ReconnectToDcAsync(int dcId, CancellationToken token)
{ {
if (dcOptions == null || !dcOptions.Any()) token.ThrowIfCancellationRequested();
if (_dcOptions == null || !_dcOptions.Any())
throw new InvalidOperationException($"Can't reconnect. Establish initial connection first."); throw new InvalidOperationException($"Can't reconnect. Establish initial connection first.");
TLExportedAuthorization exported = null; TLExportedAuthorization exported = null;
if (_session.TLUser != null) if (Session.TLUser != null)
{ {
TLRequestExportAuthorization exportAuthorization = new TLRequestExportAuthorization() { DcId = dcId }; TLRequestExportAuthorization exportAuthorization = new TLRequestExportAuthorization() { DcId = dcId };
exported = await SendRequestAsync<TLExportedAuthorization>(exportAuthorization); exported = await SendRequestAsync<TLExportedAuthorization>(exportAuthorization, token).ConfigureAwait(false);
} }
var dc = dcOptions.First(d => d.Id == dcId); var dc = _dcOptions.First(d => d.Id == dcId);
var dataCenter = new DataCenter (dcId, dc.IpAddress, dc.Port); var dataCenter = new DataCenter (dcId, dc.IpAddress, dc.Port);
_transport = new TcpTransport(dc.IpAddress, dc.Port, _handler); _transport = new TcpTransport(dc.IpAddress, dc.Port, _handler);
_session.DataCenter = dataCenter; Session.DataCenter = dataCenter;
await ConnectAsync(true); await ConnectAsync(token, true).ConfigureAwait(false);
if (_session.TLUser != null) if (Session.TLUser != null)
{ {
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, token).ConfigureAwait(false);
OnUserAuthenticated(((TLUser)imported.User)); OnUserAuthenticated(((TLUser)imported.User));
} }
} }
private async Task RequestWithDcMigration(TLMethod request) private async Task RequestWithDcMigration(TLMethod request, CancellationToken token)
{ {
if (_sender == null) if (_sender == null)
throw new InvalidOperationException("Not connected!"); throw new InvalidOperationException("Not connected!");
@ -120,19 +125,19 @@ namespace TLSharp.Core
{ {
try try
{ {
await _sender.Send(request); await _sender.Send(request, token).ConfigureAwait(false);
await _sender.Receive(request); await _sender.Receive(request, token).ConfigureAwait(false);
completed = true; completed = true;
} }
catch(DataCenterMigrationException e) catch(DataCenterMigrationException e)
{ {
if (_session.DataCenter.DataCenterId.HasValue && if (Session.DataCenter.DataCenterId.HasValue &&
_session.DataCenter.DataCenterId.Value == e.DC) 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); 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); await ReconnectToDcAsync(e.DC, token).ConfigureAwait(false);
// prepare the request for another try // prepare the request for another try
request.ConfirmReceived = false; request.ConfirmReceived = false;
} }
@ -141,34 +146,49 @@ namespace TLSharp.Core
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)
{
return await IsPhoneRegisteredAsync(phoneNumber, CancellationToken.None).ConfigureAwait(false);
}
public async Task<bool> IsPhoneRegisteredAsync(string phoneNumber, CancellationToken token)
{ {
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, token).ConfigureAwait(false);
return authCheckPhoneRequest.Response.PhoneRegistered; return authCheckPhoneRequest.Response.PhoneRegistered;
} }
public async Task<string> SendCodeRequestAsync(string phoneNumber) public async Task<string> SendCodeRequestAsync(string phoneNumber)
{
return await SendCodeRequestAsync(phoneNumber, CancellationToken.None).ConfigureAwait(false);
}
public async Task<string> SendCodeRequestAsync(string phoneNumber, CancellationToken token)
{ {
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, token).ConfigureAwait(false);
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)
{
return await MakeAuthAsync(phoneNumber, phoneCodeHash, code, CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLUser> MakeAuthAsync(string phoneNumber, string phoneCodeHash, string code, CancellationToken token)
{ {
if (String.IsNullOrWhiteSpace(phoneNumber)) if (String.IsNullOrWhiteSpace(phoneNumber))
throw new ArgumentNullException(nameof(phoneNumber)); throw new ArgumentNullException(nameof(phoneNumber));
@ -181,7 +201,7 @@ namespace TLSharp.Core
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, token).ConfigureAwait(false);
OnUserAuthenticated(((TLUser)request.Response.User)); OnUserAuthenticated(((TLUser)request.Response.User));
@ -189,16 +209,27 @@ namespace TLSharp.Core
} }
public async Task<TLPassword> GetPasswordSetting() public async Task<TLPassword> GetPasswordSetting()
{
return await GetPasswordSetting(CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLPassword> GetPasswordSetting(CancellationToken token)
{ {
var request = new TLRequestGetPassword(); var request = new TLRequestGetPassword();
await RequestWithDcMigration(request); await RequestWithDcMigration(request, token).ConfigureAwait(false);
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)
{ {
return await MakeAuthWithPasswordAsync(password, password_str, CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLUser> MakeAuthWithPasswordAsync(TLPassword password, string password_str, CancellationToken token)
{
token.ThrowIfCancellationRequested();
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);
@ -208,7 +239,7 @@ namespace TLSharp.Core
var request = new TLRequestCheckPassword() { PasswordHash = password_hash }; var request = new TLRequestCheckPassword() { PasswordHash = password_hash };
await RequestWithDcMigration(request); await RequestWithDcMigration(request, token).ConfigureAwait(false);
OnUserAuthenticated(((TLUser)request.Response.User)); OnUserAuthenticated(((TLUser)request.Response.User));
@ -216,18 +247,29 @@ namespace TLSharp.Core
} }
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)
{
return await SignUpAsync(phoneNumber, phoneCodeHash, code, firstName, lastName, CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLUser> SignUpAsync(string phoneNumber, string phoneCodeHash, string code, string firstName, string lastName, CancellationToken token)
{ {
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, token).ConfigureAwait(false);
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); return await SendRequestAsync<T>(methodToExecute, CancellationToken.None).ConfigureAwait(false);
}
public async Task<T> SendRequestAsync<T>(TLMethod methodToExecute, CancellationToken token)
{
await RequestWithDcMigration(methodToExecute, token).ConfigureAwait(false);
var result = methodToExecute.GetType().GetProperty("Response").GetValue(methodToExecute); var result = methodToExecute.GetType().GetProperty("Response").GetValue(methodToExecute);
@ -235,16 +277,26 @@ namespace TLSharp.Core
} }
public async Task<TLContacts> GetContactsAsync() public async Task<TLContacts> GetContactsAsync()
{
return await GetContactsAsync(CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLContacts> GetContactsAsync(CancellationToken token)
{ {
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, token).ConfigureAwait(false);
} }
public async Task<TLAbsUpdates> SendMessageAsync(TLAbsInputPeer peer, string message) public async Task<TLAbsUpdates> SendMessageAsync(TLAbsInputPeer peer, string message)
{
return await SendMessageAsync(peer, message, CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLAbsUpdates> SendMessageAsync(TLAbsInputPeer peer, string message, CancellationToken token)
{ {
if (!IsUserAuthorized()) if (!IsUserAuthorized())
throw new InvalidOperationException("Authorize user first!"); throw new InvalidOperationException("Authorize user first!");
@ -255,20 +307,30 @@ namespace TLSharp.Core
Peer = peer, Peer = peer,
Message = message, Message = message,
RandomId = Helpers.GenerateRandomLong() RandomId = Helpers.GenerateRandomLong()
}); }, token).ConfigureAwait(false);
} }
public async Task<Boolean> SendTypingAsync(TLAbsInputPeer peer) public async Task<Boolean> SendTypingAsync(TLAbsInputPeer peer)
{
return await SendTypingAsync(peer, CancellationToken.None).ConfigureAwait(false);
}
public async Task<Boolean> SendTypingAsync(TLAbsInputPeer peer, CancellationToken token)
{ {
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, token).ConfigureAwait(false);
} }
public async Task<TLAbsDialogs> GetUserDialogsAsync(int offsetDate = 0, int offsetId = 0, TLAbsInputPeer offsetPeer = null, int limit = 100) public async Task<TLAbsDialogs> GetUserDialogsAsync(int offsetDate = 0, int offsetId = 0, TLAbsInputPeer offsetPeer = null, int limit = 100)
{
return await GetUserDialogsAsync(CancellationToken.None, offsetDate, offsetId, offsetPeer, limit).ConfigureAwait(false);
}
public async Task<TLAbsDialogs> GetUserDialogsAsync(CancellationToken token, int offsetDate = 0, int offsetId = 0, TLAbsInputPeer offsetPeer = null, int limit = 100)
{ {
if (!IsUserAuthorized()) if (!IsUserAuthorized())
throw new InvalidOperationException("Authorize user first!"); throw new InvalidOperationException("Authorize user first!");
@ -283,10 +345,15 @@ namespace TLSharp.Core
OffsetPeer = offsetPeer, OffsetPeer = offsetPeer,
Limit = limit Limit = limit
}; };
return await SendRequestAsync<TLAbsDialogs>(req); return await SendRequestAsync<TLAbsDialogs>(req, token).ConfigureAwait(false);
} }
public async Task<TLAbsUpdates> SendUploadedPhoto(TLAbsInputPeer peer, TLAbsInputFile file, string caption) public async Task<TLAbsUpdates> SendUploadedPhoto(TLAbsInputPeer peer, TLAbsInputFile file, string caption)
{
return await SendUploadedPhoto(peer, file, caption, CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLAbsUpdates> SendUploadedPhoto(TLAbsInputPeer peer, TLAbsInputFile file, string caption, CancellationToken token)
{ {
return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia() return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{ {
@ -295,11 +362,15 @@ namespace TLSharp.Core
ClearDraft = false, ClearDraft = false,
Media = new TLInputMediaUploadedPhoto() { File = file, Caption = caption }, Media = new TLInputMediaUploadedPhoto() { File = file, Caption = caption },
Peer = peer Peer = peer
}); }, token).ConfigureAwait(false);
} }
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 SendUploadedDocument(peer, file, caption, mimeType, attributes, CancellationToken.None).ConfigureAwait(false);
}
public async Task<TLAbsUpdates> SendUploadedDocument(TLAbsInputPeer peer, TLAbsInputFile file, string caption, string mimeType, TLVector<TLAbsDocumentAttribute> attributes, CancellationToken token)
{ {
return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia() return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{ {
@ -314,10 +385,15 @@ namespace TLSharp.Core
Attributes = attributes Attributes = attributes
}, },
Peer = peer Peer = peer
}); }, token).ConfigureAwait(false);
} }
public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, int offset = 0) public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, int offset = 0)
{
return await GetFile(location, filePartSize, CancellationToken.None, offset).ConfigureAwait(false);
}
public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, CancellationToken token, int offset = 0)
{ {
TLFile result = null; TLFile result = null;
result = await SendRequestAsync<TLFile>(new TLRequestGetFile() result = await SendRequestAsync<TLFile>(new TLRequestGetFile()
@ -325,16 +401,16 @@ namespace TLSharp.Core
Location = location, Location = location,
Limit = filePartSize, Limit = filePartSize,
Offset = offset Offset = offset
}); }, token).ConfigureAwait(false);
return result; return result;
} }
public async Task SendPingAsync() public async Task SendPingAsync(CancellationToken token)
{ {
await _sender.SendPingAsync(); await _sender.SendPingAsync(token).ConfigureAwait(false);
} }
public async Task<TLAbsMessages> GetHistoryAsync(TLAbsInputPeer peer, int offsetId = 0, int offsetDate = 0, int addOffset = 0, int limit = 100, int maxId = 0, int minId = 0) public async Task<TLAbsMessages> GetHistoryAsync(TLAbsInputPeer peer, CancellationToken token, int offsetId = 0, int offsetDate = 0, int addOffset = 0, int limit = 100, int maxId = 0, int minId = 0)
{ {
if (!IsUserAuthorized()) if (!IsUserAuthorized())
throw new InvalidOperationException("Authorize user first!"); throw new InvalidOperationException("Authorize user first!");
@ -349,7 +425,7 @@ namespace TLSharp.Core
MaxId = maxId, MaxId = maxId,
MinId = minId MinId = minId
}; };
return await SendRequestAsync<TLAbsMessages>(req); return await SendRequestAsync<TLAbsMessages>(req, token).ConfigureAwait(false);
} }
/// <summary> /// <summary>
@ -359,6 +435,11 @@ namespace TLSharp.Core
/// <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)
{
return await SearchUserAsync(q, CancellationToken.None, limit).ConfigureAwait(false);
}
public async Task<TLFound> SearchUserAsync(string q, CancellationToken token, int limit = 10)
{ {
var r = new TeleSharp.TL.Contacts.TLRequestSearch var r = new TeleSharp.TL.Contacts.TLRequestSearch
{ {
@ -366,15 +447,15 @@ namespace TLSharp.Core
Limit = limit Limit = limit
}; };
return await SendRequestAsync<TLFound>(r); return await SendRequestAsync<TLFound>(r, token).ConfigureAwait(false);
} }
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

33
TLSharp.Core/Utils/UploadHelper.cs
View file

@ -1,9 +1,9 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq;
using System.Security.Cryptography; using System.Security.Cryptography;
using System.Text; using System.Text;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using TeleSharp.TL; using TeleSharp.TL;
using TeleSharp.TL.Upload; using TeleSharp.TL.Upload;
@ -30,9 +30,14 @@ namespace TLSharp.Core.Utils
} }
public static async Task<TLAbsInputFile> UploadFile(this TelegramClient client, string name, StreamReader reader) public static async Task<TLAbsInputFile> UploadFile(this TelegramClient client, string name, StreamReader reader)
{
return await UploadFile(client, name, reader, CancellationToken.None).ConfigureAwait(false);
}
public static async Task<TLAbsInputFile> UploadFile(this TelegramClient client, string name, StreamReader reader, CancellationToken token)
{ {
const long tenMb = 10 * 1024 * 1024; const long tenMb = 10 * 1024 * 1024;
return await UploadFile(name, reader, client, reader.BaseStream.Length >= tenMb); return await UploadFile(name, reader, client, reader.BaseStream.Length >= tenMb, token).ConfigureAwait(false);
} }
private static byte[] GetFile(StreamReader reader) private static byte[] GetFile(StreamReader reader)
@ -77,8 +82,10 @@ namespace TLSharp.Core.Utils
} }
private static async Task<TLAbsInputFile> UploadFile(string name, StreamReader reader, private static async Task<TLAbsInputFile> UploadFile(string name, StreamReader reader,
TelegramClient client, bool isBigFileUpload) TelegramClient client, bool isBigFileUpload, CancellationToken token)
{ {
token.ThrowIfCancellationRequested();
var file = GetFile(reader); var file = GetFile(reader);
var fileParts = GetFileParts(file); var fileParts = GetFileParts(file);
@ -97,7 +104,7 @@ namespace TLSharp.Core.Utils
FilePart = partNumber, FilePart = partNumber,
Bytes = part, Bytes = part,
FileTotalParts = partsCount FileTotalParts = partsCount
}); }, token).ConfigureAwait(false);
} }
else else
{ {
@ -106,7 +113,7 @@ namespace TLSharp.Core.Utils
FileId = file_id, FileId = file_id,
FilePart = partNumber, FilePart = partNumber,
Bytes = part Bytes = part
}); }, token).ConfigureAwait(false);
} }
partNumber++; partNumber++;
} }
@ -120,16 +127,14 @@ namespace TLSharp.Core.Utils
Parts = partsCount Parts = partsCount
}; };
} }
else
return new TLInputFile
{ {
return new TLInputFile Id = file_id,
{ Name = name,
Id = file_id, Parts = partsCount,
Name = name, Md5Checksum = GetFileHash(file)
Parts = partsCount, };
Md5Checksum = GetFileHash(file)
};
}
} }
} }
} }