private async Task <object> ProcessAck(IMTSession session, InnerMessage message)
{
var result = await Task.FromResult <object>(null);
var ack = session.Services.Serialization().Deserialize(message.Content) as MTMsgsAck;
var pendings = (await session.GetPending());
var prev = pendings.Count();
foreach (var msg_id in ack.MsgIds)
{
session.Ack(msg_id);
}
//session.AddMessage(new MTRpcResult
//{
// ReqMsgId = (long)message.inner_msg_id,
// Result = new MTGzipPacked
// {
// PackedData = Utils.compress( new TLInputPeerEmpty { }.ToByteArray())
// }
//}, false, true);
//(session as MTSession).GetMessageBox().Clear();
this.logger.LogInformation(
$"{prev - pendings.Count() } messages acknowledged");
return(result);
}
private async Task <object> ProcessHttpWait(IMTSession session, InnerMessage message)
{
var result = await Task.FromResult <object>(null);
var _req = session.Services.Serialization().Deserialize(message.Content) as MTHttpWait;
if (_req != null)
{
this.max_delay = _req.MaxDelay;
this.max_wait = _req.MaxWait;
this.wait_after = _req.WaitAfter;
message.max_wait = _req.MaxWait;
message.max_delay = _req.MaxDelay;
message.wait_after = _req.WaitAfter;
}
var _ret = new TLInputPeerEmpty
{
};
if (_ret as MTObject != null)
{
result = new MTRpcResult
{
ReqMsgId = (long)message.msg_id,
Result = new MTGzipPacked
{
PackedData = Utils.compress(BitConverter.GetBytes(0x997275b5))
}
};
//session.AddMessage(result as MTObject, true, true);
}
return(result);
}
private async Task <object> ProcessContainer(IMTSession session, InnerMessage message, CancellationToken cancellationToken)
{
var result = await Task.FromResult <object>(null);
using (var stream = new MemoryStream(message.Content))
using (var reader = new BinaryReader(stream))
{
this.logger.LogInformation("Container...");
var type = reader.ReadUInt32();
var count = reader.ReadInt32();
for (var i = 0; i < count; i++)
{
var _message_id = reader.ReadUInt64();
var _seq_no = reader.ReadInt32();
var _len = reader.ReadInt32();
var _content = reader.ReadBytes(_len);
var _resp = await this.ProcessProtoMessage(session, message.DoClone(_content, m =>
{
m.msg_id = _message_id;
m.seq_no = _seq_no;
}), cancellationToken);
}
}
return(result);
}
private async Task <object> ProcessInvokeAftert(IMTSession session, InnerMessage message, CancellationToken cancellationToken)
{
var result = await Task.FromResult <object>(null);
var _req = session.Services.Serialization().Deserialize(message.Content) as TLInvokeAfterMsg;
if (_req != null)
{
await ProcessProtoMessage(session, message.DoClone(_req.Query.ToByteArray(), cfg =>
{
}), cancellationToken);
}
return(result);
}
private async Task <object> ProcessInitInvokeWithLayer(IMTSession session, InnerMessage message, CancellationToken cancellationToken)
{
var result = await Task.FromResult <object>(null);
using (var stream = new MemoryStream(message.Content))
using (var reader = new BinaryReader(stream))
{
var type = reader.ReadUInt32();
var layer = reader.ReadInt32();
var inner_message = reader.ReadAllBytes();
this.logger.LogInformation("WithLayer...");
result = await this.ProcessProtoMessage(session, message.DoClone(inner_message), cancellationToken);
}
return(result);
}
private async Task <object> ProcessMessage(IMTSession session, InnerMessage message, CancellationToken cancellationToken)
{
object result = null;
ulong type = 0;
try
{
type = BitConverter.ToUInt32(message.Content, 0);
var req = message.Content.ToMTObject(); // session.Services.Serialization().Deserialize(message.Content);
{
this.logger.LogInformation(req.GetType().Name);
var envelop = MessageContext.Create(req);
envelop.container_seq_no(message.container_seq_no);
envelop.container_msg_id(message.container_msg_id);
envelop.AuthKey(message.AuthKey);
envelop.msg_id(message.msg_id);
envelop.seq_no(message.seq_no);
var _ret = await serviceProvider.Bus().Send(envelop, cancellationToken: cancellationToken) as MTObject;
if (_ret as MTObject != null)
{
result = new MTRpcResult
{
ReqMsgId = (long)message.msg_id,
Result = new MTGzipPacked
{
PackedData = Utils.compress(_ret.ToByteArray())
}
};
session.AddMessage(result as MTObject, true, true);
}
}
}
catch (Exception err)
{
if (err is InvalidDataException)
{
this.logger.LogWarning(
$"Invalid or Not Supported Constructor: '{type.ToString("X4")}'");
}
else
{
this.logger.LogError($"An error occured while trying to process this message: {err}");
}
}
return(result);
}
private async Task <object> ProcessAuthSendCode(IMTSession session, InnerMessage message)
{
var result = await Task.FromResult <object>(null);
using (var stream = new MemoryStream(message.Content))
using (var reader = new BinaryReader(stream))
{
var o = session.Services.Serialization().Deserialize(message.Content) as MTObject;
//o.ToByteArray();
//var type = reader.ReadUInt32();
//var flags = reader.ReadUInt32();
//var phone = StringSerializer.Deserialize(reader);
///
/// auth.sentCode#5e002502 flags:# type:auth.SentCodeType phone_code_hash:string next_type:flags.1?auth.CodeType timeout:flags.2?int = auth.SentCode;
///
this.logger.LogInformation("************************SendCode");
var hash = new byte[8];
new Random().NextBytes(hash);
var code = "1234";
//this.SentCode = true;
var sent_code = new TLSentCode()
{
Flags = 4,
PhoneCodeHash = "phonehash",
Type = new TLSentCodeTypeSms
{
Length = 4,
},
Timeout = 40000
};
var ss = sent_code.ToByteArray();
result = new MTRpcResult
{
ReqMsgId = (long)message.msg_id,
Result = new MTGzipPacked
{
PackedData = Utils.compress(sent_code.ToByteArray())
}
};
session.AddMessage(result as MTObject, false, true);
}
return(result);
}
public InnerMessage DoClone(byte[] content = null, Action <InnerMessage> update = null)
{
var result = new InnerMessage
{
container_seq_no = this.container_seq_no,
sever_salt = this.sever_salt,
msg_id = this.msg_id,
seq_no = this.seq_no,
container_msg_id = this.container_msg_id,
session_id = this.session_id,
AuthKey = this.AuthKey,
//Responses = this.Responses ?? new List<object>(),
Content = content ?? this.Content
};
update?.Invoke(result);
return(result);
}
private async Task <object> ProcessInitConnection(IMTSession session, InnerMessage message, CancellationToken cancellationToken)
{
var result = await Task.FromResult <object>(null);
using (var stream = new MemoryStream(message.Content))
using (var reader = new BinaryReader(stream))
{
var type = reader.ReadUInt32();
var appId = reader.ReadUInt32();
var device_info = StringSerializer.Deserialize(reader);
var os_info = StringSerializer.Deserialize(reader);
var app_version = StringSerializer.Deserialize(reader);
var system_language = StringSerializer.Deserialize(reader);
var system_language_pack = StringSerializer.Deserialize(reader);
var lang_code = StringSerializer.Deserialize(reader);
var remain = reader.ReadAllBytes();
this.logger.LogInformation("Init...");
result = await this.ProcessProtoMessage(session, message.DoClone(remain), cancellationToken);
}
return(result);
}
private async Task HandleEncryptedRequest(HttpContext context, ulong auth_key, BinaryReader reader)
{
var message_key = reader.ReadBytes(128 / 8);
var session = this.sessionManager.GetSession(auth_key);
if (session != null)
{
var message = session.Decrypt(message_key, reader.ReadAllBytes());
using (var s = new MemoryStream(message))
using (var r = new BinaryReader(s))
{
var sever_salt = r.ReadUInt64();
var session_id = r.ReadUInt64();
var msg_id = r.ReadUInt64();
var seq_no = r.ReadInt32();
var len = r.ReadInt32();
var inner_message = new InnerMessage
{
container_msg_id = msg_id,
container_seq_no = seq_no,
session_id = session_id,
sever_salt = sever_salt,
AuthKey = auth_key,
Content = r.ReadAllBytes(),
};
await session.KeepAlive(session_id);
//session.op
await this.ProcessProtoMessage(session, inner_message, context.RequestAborted);
/// Http Wait
///
await Task.Delay(this.max_delay ?? 100);
var pendings = (await session.GetPending()).ToArray();
if (pendings.Length == 0)
{
await Task.Delay(this.max_wait ?? 2500);
var wait = this.max_wait ?? 2500;
this.logger.LogDebug($"Http Wait ({wait}).....");
for (int i = 0; i < wait; i = i + 100)
{
try
{
await Task.Delay(100, context.RequestAborted);
pendings = (await session.GetPending()).ToArray();
}
catch { }
if (pendings.Length > 0)
{
break;
}
if (context.RequestAborted.IsCancellationRequested)
{
break;
}
}
}
var response = await this.GenerateResponse(session);
session.TryCreateResponseMessage(response.Item2, inner_message.sever_salt, inner_message.session_id, out var _encr, out var msgkey, true);
using (var memory = new MemoryStream())
using (var w = new BinaryWriter(memory))
{
w.Write(session.AuthId());
w.Write(msgkey);
w.Write(_encr);
w.Flush();
w.Close();
context.Response.Body.Write(memory.ToArray(), 0, memory.ToArray().Length);
this.logger.LogInformation($"Response Sent: Count:'{response.Item1}', Length:'{response.Item2.Length}'");
}
};
}
else
{
throw new Exception(
$"Session Not Found. AuthKeyId:{auth_key}");
}
}
private async Task <object> ProcessProtoMessage(IMTSession session, InnerMessage message, CancellationToken cancellationToken)
{
var type = BitConverter.ToUInt32(message.Content, 0);
var result = await Task.FromResult <object>(null);
try
{
switch (type)
{
case 0xcb9f372d:
{
// Invoke after Message
await this.ProcessInvokeAftert(session, message, cancellationToken);
}
break;
case 0x73f1f8dc:
// container
await this.ProcessContainer(session, message, cancellationToken);
break;
case 0xc7481da6:
// init connection
result = await this.ProcessInitConnection(session, message, cancellationToken);
break;
case 0xda9b0d0d:
result = await this.ProcessInitInvokeWithLayer(session, message, cancellationToken);
break;
case 0x86aef0ec:
result = await this.ProcessAuthSendCode(session, message);
break;
case 0x62d6b459:
result = await this.ProcessAck(session, message);
break;
case 0x9299359f:
/// Http Wait
///
{
await this.ProcessHttpWait(session, message);
}
break;
default:
await this.ProcessMessage(session, message, cancellationToken);
break;
}
}
catch (Exception err)
{
this.logger.LogError(
$"===============================================>Unknown Request: '{type.ToString("X4")}'");
}
return(result);
}
