public virtual void Receive(byte[] data, int offset, int count)
{
lock (m_recvLocker)
{
m_buffer.Add(data, offset, count);
while (m_buffer.BytesAvailable > 0)
{
if (m_currentMessage == null)
{
m_currentMessage = new MessagePart();
}
// if message is complete
if (m_currentMessage.Build(m_buffer))
{
var messageDataReader = new BigEndianReader(m_currentMessage.Data);
NetworkMessage message = MessageBuilder.BuildMessage((uint)m_currentMessage.MessageId.Value, messageDataReader);
LastActivity = DateTime.Now;
OnMessageReceived(message);
m_currentMessage = null;
}
}
}
}
protected override void ReceiveEvent_Completed(object sender, SocketAsyncEventArgs e)
{
if (!IsConnected())
{
return;
}
_reader.Add(e.Buffer, e.Offset, e.BytesTransferred);
while (_reader.BytesAvailable > 0)
{
if (_currentMessage == null)
{
_currentMessage = new MessagePart();
}
if (_currentMessage.Build(_reader))
{
var messageDataReader = new CustomDataReader(_currentMessage.Data);
var message = MessageReceiver.BuildMessage((uint)_currentMessage.MessageId, messageDataReader);
if (message == null)
{
return;
}
_dispatcher.Dispatch(message);
_currentMessage = null;
}
else
{
break;
}
}
base.ReceiveEvent_Completed(sender, e);
}
public virtual void Receive(byte[] data, int offset, int count)
{
lock (_recvLocker)
{
buffer.Add(data, offset, count);
while (buffer.BytesAvailable > 0)
{
if (_currentMessage == null)
{
_currentMessage = new MessagePart();
}
// if message is complete
if (!_currentMessage.Build(buffer))
{
continue;
}
var messageDataReader = new BigEndianReader(_currentMessage.Data);
if (_currentMessage.MessageId != null)
{
//Logger.Default.Log(string.Format("Parsing Message[{0}] => {1}",_currentMessage.MessageId, BitConverter.ToString(buffer.Data).Replace("-","")));
var message =
MessageBuilder.BuildMessage((ushort)_currentMessage.MessageId.Value, messageDataReader);
LastActivity = DateTime.Now;
OnMessageReceived(message);
}
_currentMessage = null;
}
buffer = new BigEndianReader();
}
}
public virtual void Receive(byte[] data, int offset, int count)
{
lock (_recvLocker)
{
buffer.Add(data, offset, count);
while (buffer.BytesAvailable > 0)
{
if (_currentMessage == null)
{
_currentMessage = new MessagePart();
}
// if message is complete
if (!_currentMessage.Build(buffer))
{
continue;
}
var messageDataReader = new BigEndianReader(_currentMessage.Data);
if (_currentMessage.MessageId != null)
{
var message =
MessageBuilder.BuildMessage((ushort)_currentMessage.MessageId.Value, messageDataReader);
LastActivity = DateTime.Now;
OnMessageReceived(message);
}
_currentMessage = null;
}
buffer = new BigEndianReader();
}
}
public void ParseBuffer(byte[] data)
{
m_Reader.Add(data, 0, data.Length);
if (m_Reader.BytesAvailable <= 0)
{
return;
}
while (m_Reader.BytesAvailable != 0)
{
if (Build())
{
if ((account.IsMITM) && (!ForbiddenHeaders.Contains((int)m_ProtocolID)))
{
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(m_Data);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)m_ProtocolID);
account.SocketManager.SendToDofusClient(pack.Writer.Content);
account.Log(new BotTextInformation("SND (-> Dof) " + m_ProtocolID), 0);
}
}
//using (
// StreamWriter fileWriter =
// new StreamWriter(
// Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) +
// @"\BlueSheep\Packets.txt", true))
// fileWriter.WriteLine("[" + DateTime.Now.ToShortTimeString() + "] Paquet reçu : " + m_ProtocolID);
Treatment.Treatment treatment = new Treatment.Treatment(account);
if (m_ProtocolID == 6372)
{
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(m_Data);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack(6372);
account.SocketManager.Send(pack.Writer.Content);
}
}
if (m_ProtocolID != null)
{
treatment.Treat(m_ProtocolID.Value, m_Data);
}
m_Header = null;
m_Length = null;
m_Data = null;
m_LenghtType = null;
m_ProtocolID = null;
}
else
{
break;
}
}
}
public void ParseBuffer(byte[] data)
{
m_Reader.Add(data, 0, data.Length);
if (m_Reader.BytesAvailable <= 0)
{
return;
}
while (m_Reader.BytesAvailable != 0)
{
if (Build())
{
if ((account.IsMITM) && (!ForbiddenHeaders.Contains((int)m_ProtocolID)))
{
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(m_Data);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)m_ProtocolID);
account.SocketManager.SendToDofusClient(pack.Writer.Content);
account.Log(new BotTextInformation("SND (-> Dof) " + m_ProtocolID), 0);
}
}
Treatment.Treatment treatment = new Treatment.Treatment(account);
if (m_ProtocolID == 6372)
{
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(m_Data);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack(6372);
account.SocketManager.Send(pack.Writer.Content);
}
}
if (m_ProtocolID != null)
{
treatment.Treat(m_ProtocolID.Value, m_Data);
}
m_Header = null;
m_Length = null;
m_Data = null;
m_LenghtType = null;
m_ProtocolID = null;
}
else
{
break;
}
}
}
public virtual void Receive(byte[] data, int offset, int count)
{
try
{
lock (_lockObject)
{
_buffer.Add(data, offset, count);
BuildMessage();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public virtual void Receive(byte[] data, int offset, int count)
{
try
{
lock (m_lock)
{
m_buffer.Add(data, offset, count);
BuildMessage();
}
}
catch (Exception ex)
{
Log(LogLevel.Fatal, "Cannot process receive " + ex);
}
}
/// <summary>
/// thx to Hitman for this implementation ;)
/// </summary>
/// <param name="stream"></param>
private async void OnReceive(MemoryStream stream)
{
if (_reader is null)
{
_reader = new BigEndianReader();
}
if (stream.Length > 0)
{
_reader.Add(stream.ToArray(), 0, (int)stream.Length);
}
byte[] full_data = _reader.Data;
while (_position < full_data.Length && full_data.Length - _position >= 2)
{
long start_pos = _position;
_current_header = (ushort)((full_data[_position] * 256) + full_data[_position + 1]);
_position += sizeof(ushort);
_instance_id = (uint)((full_data[_position] * 256 * 256 * 256) + (full_data[_position + 1] * 256 * 256) + (full_data[_position + 2] * 256) + full_data[_position + 3]);
_position += sizeof(uint);
if (full_data.Length - _position < _static_header)
{
break;
}
switch (_static_header)
{
case 0: _length = 0; break;
case 1: _length = full_data[_position]; break;
case 2: _length = (ushort)((full_data[_position] * 256) + full_data[_position + 1]); break;
case 3: _length = (full_data[_position] * 256 * 256) + (full_data[_position + 1] * 256) + full_data[_position + 2]; break;
}
_position += _static_header;
long _current_data_len = full_data.Length - _position;
if (_current_data_len >= _length)
{
NetworkElement _element = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Messages, x => x.protocolID == _message_id];
_data = new byte[_current_data_len];
byte[] packet_data = new byte[(int)(_position - start_pos) + _length.Value];
Array.Copy(full_data, start_pos, packet_data, 0, packet_data.Length);
Array.Copy(full_data, _position, _data, 0, _length.Value);
if (_element != null)
{
logger.Info($"[{_tag}] {_element.BasicString}");
_data_buffer_reader = new MessageDataBufferReader(_element);
using (BigEndianReader big_data_reader = new BigEndianReader(_data))
{
await _handler.Handle(this, _element, _data_buffer_reader.Parse(big_data_reader));
}
}
_position += _length.Value;
if (_current_data_len == _length)
{
_clear();
_reader.Dispose();
_reader = new BigEndianReader();
_position = 0;
break;
}
_clear();
}
else
{
_position = start_pos;
break;
}
}
}
internal void ProcessReceive(byte[] data, int offset, int count)
{
m_buffer.Add(data, offset, count);
Receive();
}
/// <summary>
/// thx to Hitman for this implementation made by ToOnS
/// </summary>
/// <param name="stream"></param>
protected virtual void OnReceive(MemoryStream stream)
{
if (_reader is null)
{
_reader = new BigEndianReader();
}
if (stream.Length > 0)
{
_reader.Add(stream.ToArray(), 0, (int)stream.Length);
}
byte[] full_data = _reader.Data;
while (_position < full_data.Length && full_data.Length - _position >= 2)
{
long start_pos = _position;
_current_header = (ushort)((full_data[_position] * 256) + full_data[_position + 1]);
_position += sizeof(ushort);
if (_tag == ProxyTagEnum.Client)
{
_instance_id = (uint)((full_data[_position] * 256 * 256 * 256) + (full_data[_position + 1] * 256 * 256) + (full_data[_position + 2] * 256) + full_data[_position + 3]);
_position += sizeof(uint);
}
if (full_data.Length - _position < _static_header)
{
break;
}
switch (_static_header)
{
case 0: _length = 0; break;
case 1: _length = full_data[_position]; break;
case 2: _length = (ushort)((full_data[_position] * 256) + full_data[_position + 1]); break;
case 3: _length = (full_data[_position] * 256 * 256) + (full_data[_position + 1] * 256) + full_data[_position + 2]; break;
}
_position += _static_header;
long _current_data_len = full_data.Length - _position;
if (_current_data_len >= _length)
{
NetworkElement _element = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Messages, x => x.protocolID == _message_id];
_data = new byte[_current_data_len];
if (_tag == ProxyTagEnum.Client)
{
// rmv element from not game socket
if (_instance_id > _proxy.GLOBAL_INSTANCE_ID * 2)
{
_element = null;
}
else
{
_proxy.LAST_CLIENT_INSTANCE_ID = _instance_id.Value;
_proxy.MESSAGE_RECEIVED_FROM_LAST = 0;
}
}
else
{
if (_message_id == StaticValues.RAW_DATA_MSG_RCV_ID) // rdm
{
_element = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Messages, x => x.name == "RawDataMessage"];
}
_proxy.MESSAGE_RECEIVED_FROM_LAST++;
}
byte[] packet_data = new byte[(int)(_position - start_pos) + _length.Value];
Array.Copy(full_data, start_pos, packet_data, 0, packet_data.Length);
Array.Copy(full_data, _position, _data, 0, _length.Value);
if (_element != null)
{
logger.Info($"[{_tag}] {_element.BasicString} n°{_proxy.GLOBAL_INSTANCE_ID}");
_data_buffer_reader = new MessageDataBufferReader(_element);
using (BigEndianReader big_data_reader = new BigEndianReader(_data))
{
if (_handler.Handle(this, _element, _data_buffer_reader.Parse(big_data_reader)).Result)
{
_client_sender.Handle(_remote, packet_data);
}
}
}
else
{
_client_sender.Handle(_remote, packet_data);
}
_position += _length.Value;
if (_current_data_len == _length)
{
_clear();
_reader.Dispose();
_reader = new BigEndianReader();
_position = 0;
break;
}
_clear();
}
else
{
_position = start_pos;
break;
}
}
}
