public static string decodeWithAES(byte[] AESKey, byte[] ticket)
{
using (AesManaged _AesManaged = new AesManaged())
{
_AesManaged.Key = AESKey;
_AesManaged.Padding = PaddingMode.None;
_AesManaged.Mode = CipherMode.CBC;
byte[] cipherText = new byte[16 + ticket.Length];
BigEndianWriter writer = new BigEndianWriter(cipherText);
writer.WriteBytes(AESKey, 0, 16);
writer.WriteBytes(ticket);
ICryptoTransform decryptor = _AesManaged.CreateDecryptor(_AesManaged.Key, _AesManaged.IV);
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
return(srDecrypt.ReadToEnd());
}
}
}
}
}
public void Save(string uri)
{
using (var writer = new BigEndianWriter(new StreamWriter(uri).BaseStream))
{
var indexTable = new BigEndianWriter();
writer.Seek(4, SeekOrigin.Begin);
int i = 0;
foreach (var index in indexes)
{
indexTable.WriteInt(index.Key);
indexTable.WriteBoolean(unDiacriticalIndex.ContainsKey(index.Key));
indexTable.WriteInt((int)writer.Position);
writer.WriteUTF(index.Value);
if (unDiacriticalIndex.ContainsKey(index.Key))
{
indexTable.WriteInt((int)writer.Position);
writer.WriteUTF(testUndial[index.Key]);
}
i++;
}
var indexLen = (int)indexTable.Data.Length;
var indexTextTable = new BigEndianWriter();
foreach (var index in textIndexes)
{
indexTextTable.WriteUTF(index.Key);
indexTextTable.WriteInt((int)writer.Position);
writer.WriteUTF(index.Value);
i++;
}
var indexTextSortTable = new BigEndianWriter();
foreach (var index in _textSortIndex)
{
indexTextSortTable.WriteInt((int)index.Key);
i++;
}
var indexPos = (int)writer.Position;
/* write index at end */
var indexData = indexTable.Data;
writer.WriteInt(indexLen);
writer.WriteBytes(indexData);
writer.WriteInt((int)indexTextTable.Data.Length);
writer.WriteBytes(indexTextTable.Data);
writer.WriteInt((int)indexTextSortTable.Data.Length);
writer.WriteBytes(indexTextSortTable.Data);
/* write index pos at begin */
writer.Seek(0, SeekOrigin.Begin);
writer.WriteInt(indexPos);
}
}
public static void SerializeState(AuthClient client, byte step, bool display, int countryId, bool connectedToServer)
{
BigEndianWriter packet = new BigEndianWriter();
packet.WriteByte(step); //Step
packet.WriteBoolean(display); //Display serveur
if (display)
{
packet.WriteInt(countryId); //0 FR
packet.WriteBoolean(connectedToServer); //Connecté au serveur
if (connectedToServer)
{
BigEndianWriter server = new BigEndianWriter();
server.WriteInt(0); //Id account
server.WriteUTF("Clemon"); //Pseudo
server.WriteInt(1); //Nombre de serveur
for (int i = 0; i < 1; i++)
{
server.WriteInt(1); //ID serveur
server.WriteInt(0); //Droit du serveur
}
packet.WriteInt(server.Data.Length);
packet.WriteBytes(server.Data);
}
}
client.Send(MessageConstant.S_STATE_CONNECTION, packet);
}
private void _parse_super(BigEndianWriter writer)
{
if (_network_base.super_serialize)
{
writer.WriteBytes(new MessageDataBufferWriter(_super).Parse(_network_content));
}
}
public void Pack(BigEndianWriter header)
{
var data = new BigEndianWriter();
Serialize(data);
var size = data.Data.Length;
var compute = ComputeTypeLen(size);
short val = (short)((MessageId << 2) | compute);
header.WriteShort(val);
switch (compute)
{
case 1:
header.WriteByte((byte)size);
break;
case 2:
header.WriteUShort((ushort)size);
break;
case 3:
header.WriteByte((byte)((size >> 0x10) & 0xff));
header.WriteUShort((ushort)(size & 0xffff));
break;
}
header.WriteBytes(data.Data);
data.Dispose();
}
private void BuildPacket(BigEndianWriter writer)
{
byte[] data = writer.Data;
writer.Clear();
int messageLenghtType = ComputeTypeLen(data.Length);
short header = ComputeStaticHeader((int)MessageId, messageLenghtType);
writer.WriteShort(header);
switch (messageLenghtType)
{
case 1:
writer.WriteByte((byte)data.Length);
break;
case 2:
writer.WriteShort((short)data.Length);
break;
case 3:
writer.WriteByte((byte)(data.Length >> 16 & 255));
writer.WriteShort((short)(data.Length & 65535));
break;
}
writer.WriteBytes(data);
}
public void Save(string uri)
{
using (var writer = new BigEndianWriter(new StreamWriter(uri).BaseStream))
{
var indexTable = new BigEndianWriter();
writer.Seek(4, SeekOrigin.Begin);
foreach (var index in indexes)
{
indexTable.WriteInt(index.Key);
indexTable.WriteInt((int)writer.Position);
writer.WriteUTF(index.Value);
}
var indexLen = (int)indexTable.Position;
foreach (var index in textIndexes)
{
indexTable.WriteUTF(index.Key);
indexTable.WriteInt((int)writer.Position);
writer.WriteUTF(index.Value);
}
var indexPos = (int)writer.Position;
/* write index at end */
var indexData = indexTable.Data;
writer.WriteInt(indexLen);
writer.WriteBytes(indexData);
/* write index pos at begin */
writer.Seek(0, SeekOrigin.Begin);
writer.WriteInt(indexPos);
}
}
public static void SerializeCrypt(AuthClient client)
{
BigEndianWriter packet = new BigEndianWriter();
packet.WriteULong(0x8000000000000000);
packet.WriteBytes(CryptoManager.RsaPublicKey.ToArray());
client.Send(MessageConstant.S_CRYPT, packet);
}
public static void Serialize(AuthClient client)
{
byte i = 0;
BigEndianWriter packet = new BigEndianWriter();
BigEndianWriter part2 = new BigEndianWriter();
packet.WriteInt(World.Servers.Count);
part2.WriteInt(World.Servers.Count);
foreach (Models.Server server in World.Servers)
{
packet.WriteInt(server.ID);
packet.WriteUTF(server.Name);
packet.WriteInt((int)server.Community);
packet.WriteUTF(server.Ip);
packet.WriteInt(server.Ports.Count);
foreach (int port in server.Ports)
{
packet.WriteInt(port);
}
packet.WriteByte(i);
part2.WriteInt(server.ID);
BigEndianWriter version = new BigEndianWriter();
version.WriteByte((byte)Config.VERSION[0]);
version.WriteUShort((ushort)Config.VERSION[1]);
version.WriteByte((byte)Config.VERSION[2]);
version.WriteString((string)Config.VERSION[3]);
part2.WriteInt(version.Data.Length);
part2.WriteBytes(version.Data);
BigEndianWriter propertys = new BigEndianWriter();
propertys.WriteInt(server.Propertys.Count);
foreach (KeyValuePair <PropertyID, string> prop in server.Propertys)
{
propertys.WriteShort((short)prop.Key);
propertys.WriteUTF(prop.Value);
}
part2.WriteInt(propertys.Data.Length);
part2.WriteBytes(propertys.Data);
part2.WriteBoolean(server.Locked);
i++;
}
packet.WriteBytes(part2.Data);
client.Send(MessageConstant.S_LIST_SERVER, packet);
}
public void SaveAs(string destination, bool overwrite = true)
{
while (this.m_linksToSave.Count > 0)
{
D2pFile link = this.m_linksToSave.Dequeue();
link.Save();
}
Stream stream;
if (!File.Exists(destination))
{
stream = File.Create(destination);
}
else
{
if (!overwrite)
{
throw new InvalidOperationException("Cannot perform SaveAs : file already exist, notify overwrite parameter to true");
}
stream = File.OpenWrite(destination);
}
using (BigEndianWriter writer = new BigEndianWriter(stream))
{
writer.WriteByte(2);
writer.WriteByte(1);
D2pEntry[] entries = this.GetEntriesOfInstanceOnly();
int offset = 2;
D2pEntry[] array = entries;
for (int i = 0; i < array.Length; i++)
{
D2pEntry entry = array[i];
byte[] data = this.ReadFile(entry);
entry.Index = (int)writer.Position - offset;
writer.WriteBytes(data);
}
int entriesDefOffset = (int)writer.Position;
array = entries;
for (int i = 0; i < array.Length; i++)
{
D2pEntry entry = array[i];
entry.WriteEntryDefinition(writer);
}
int propertiesOffset = (int)writer.Position;
foreach (D2pProperty property in this.m_properties)
{
property.WriteProperty(writer);
}
this.IndexTable.OffsetBase = offset;
this.IndexTable.EntriesCount = entries.Length;
this.IndexTable.EntriesDefinitionOffset = entriesDefOffset;
this.IndexTable.PropertiesCount = this.m_properties.Count;
this.IndexTable.PropertiesOffset = propertiesOffset;
this.IndexTable.Size = this.IndexTable.EntriesDefinitionOffset - this.IndexTable.OffsetBase;
this.IndexTable.WriteTable(writer);
}
}
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 Send(NetworkElement message, ProtocolJsonContent content, bool clientSide)
{
if (message is null)
{
return;
}
using (BigEndianWriter writer = new BigEndianWriter())
{
byte[] data = ProtocolTreatmentExtension.FromContent(content, message);
int cmpLen = _cmpLen(data.Length);
writer.WriteShort((short)((message.protocolID << 2) | cmpLen));
if (clientSide)
{
writer.WriteUnsignedInt(GetCustomInstanceId());
}
switch (cmpLen)
{
case 0:
break;
case 1:
writer.WriteByte((byte)data.Length);
break;
case 2:
writer.WriteShort((short)data.Length);
break;
case 3:
writer.WriteByte((byte)((data.Length >> 16) & 255));
writer.WriteShort((short)(data.Length & 65535));
break;
}
writer.WriteBytes(data);
Send(writer.Data);
OnCustomMessageSent?.Invoke(message, content);
StartupConfiguration configuration = Configurations.ConfigurationManager.Instance.Startup;
if (configuration.show_fake_message)
{
logger.Info($"fake message sent to {remoteIp} |{message.BasicString()}]");
if (configuration.show_fake_message_content)
{
logger.Info($"{content}");
}
}
}
}
public byte[] hash_function(byte[] packet)
{
/* Hello Mr.Fourbasse :hap: */
if (_hashKey == null)
{
return(packet);
}
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(packet);
BigEndianWriter writer2 = new BigEndianWriter();
writer2.WriteBytes(hash(packet));
using (RijndaelManaged myRijndael = new RijndaelManaged())
{
myRijndael.GenerateIV();
// Encrypt the string to an array of bytes.
byte[] encrypted = EncryptStringToBytes(writer2.Content.ToString(), _hashKey, myRijndael.IV);
}
writer.WriteBytes(writer2.Content);
return(writer.Content);
}
}
public byte[] hash_function(byte[] packet)
{
//object _loc5_ = null;
//byte[] _loc6_ = null;
if (this._hashKey == null)
{
return(packet);
}
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(packet);
BigEndianWriter writer2 = new BigEndianWriter();
writer2.WriteBytes(this.hash(packet));
using (RijndaelManaged myRijndael = new RijndaelManaged())
{
myRijndael.GenerateIV();
// Encrypt the string to an array of bytes.
byte[] encrypted = EncryptStringToBytes(writer2.Content.ToString(), this._hashKey, myRijndael.IV);
}
writer.WriteBytes(writer2.Content);
return(writer.Content);
}
}
public void Send(int processId, NetworkElementField message, ProtocolJsonContent content, bool clientSide)
{
if (message is null)
{
return;
}
using (BigEndianWriter writer = new BigEndianWriter())
{
byte[] data = message.ToByte(content);
int cmpLen = _cmpLen(data.Length);
writer.WriteShort((short)((message.protocolID << 2) | cmpLen));
ProxyManager.Instance[processId].FAKE_MESSAGE_SENT++;
if (clientSide)
{
writer.WriteUnsignedInt(ProxyManager.Instance[processId].FAKE_MSG_INSTANCE_ID);
}
switch (cmpLen)
{
case 0:
break;
case 1:
writer.WriteByte((byte)data.Length);
break;
case 2:
writer.WriteShort((short)data.Length);
break;
case 3:
writer.WriteByte((byte)((data.Length >> 16) & 255));
writer.WriteShort((short)(data.Length & 65535));
break;
}
writer.WriteBytes(data);
Send(writer.Data);
if (ConfigurationManager.Instance.Startup.show_fake_message_sent)
{
Console.WriteLine($"Fake Message sent to ({RemoteIP}) : (n°{ProxyManager.Instance[processId].FAKE_MSG_INSTANCE_ID}) [{message.name} ({message.protocolID})]");
if (ConfigurationManager.Instance.Startup.show_message_content)
{
Console.WriteLine($"{content}");
}
}
}
}
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 static byte[] FromContent(ProtocolJsonContent content, NetworkElement field)
{
if (content is null)
{
return(new byte[0]);
}
if (field is null)
{
throw new Exception("field cannot be null");
}
try
{
using (BigEndianWriter writer = new BigEndianWriter())
{
if (field.super_serialize)
{
NetworkElement super = ProtocolManager.Instance.Protocol[ProtocolKeyEnum.MessagesAndTypes, x => x.name == field.super];
byte[] super_data = FromContent(content, super);
writer.WriteBytes(super_data);
}
IEnumerable <ClassField> boolWrapper = field.fields.Where(x => x.use_boolean_byte_wrapper).OrderBy(x => x.boolean_byte_wrapper_position);
IEnumerable <ClassField> vars = field.fields.Where(x => !boolWrapper.Contains(x)).OrderBy(x => x.position);
if (boolWrapper.Count() > 0)
{
byte[] flags = new byte[boolWrapper.LastOrDefault().position.Value + 1];
foreach (ClassField _bool in boolWrapper)
{
flags[_bool.position.Value] = BooleanByteWrapper.SetFlag(flags[_bool.position.Value], (byte)((_bool.boolean_byte_wrapper_position.Value - 1) % 8), content[_bool.name]);
}
}
foreach (ClassField _var in vars)
{
Parse(_var, content[_var.name], writer);
}
return(writer.Data);
}
}
catch (Exception e)
{
logger.Error(e);
return(new byte[0]);
}
}
public void Send(Buffer message)
{
BigEndianWriter writer = new BigEndianWriter();
byte typeLen;//get the size of the size
if (message.Data.Length > 65535)
{
typeLen = 3;
}
else if (message.Data.Length > 255)
{
typeLen = 2;
}
else if (message.Data.Length > 0)
{
typeLen = 1;
}
else
{
typeLen = 0;
}
writer.WriteShort((short)(message.MessageId << 2 | typeLen)); //write id and size of size
switch (typeLen) //write the size
{
case 0:
break;
case 1:
writer.WriteByte((byte)message.Data.Length);
break;
case 2:
writer.WriteShort((short)message.Data.Length);
break;
case 3:
writer.WriteByte((byte)(message.Data.Length >> 16 & 255));
writer.WriteShort((short)(message.Data.Length & 65535));
break;
}
writer.WriteBytes(message.Data);//write the packet after write the header
Send(writer.Data);
}
private void _parse_var_element(ClassField field, dynamic value, BigEndianWriter writer)
{
if (_is_primitive(field))
{
string write_method = field.write_method.Replace("write", "Write");
_write_value(write_method, value, writer);
}
else
{
bool is_null = value is null;
if (field.write_false_if_null_method != null &&
field.write_false_if_null_method != "" &&
is_null)
{
string check_null_method = field.write_false_if_null_method.Replace("write", "Write");
_write_value(check_null_method, 0, writer);
return;
}
if (is_null)
{
throw new ArgumentNullException(nameof(value));
}
NetworkElement var_type = null;
if (field.prefixed_by_type_id)
{
string write_type_id_method = field.write_type_id_method.Replace("write", "Write");
_write_value(write_type_id_method, value["protocol_id"], writer);
var_type = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Types, x => x.protocolID == value["protocol_id"]];
}
else
{
var_type = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Types, x => x.name == field.type];
}
MessageDataBufferWriter _writer = new MessageDataBufferWriter(var_type);
writer.WriteBytes(_writer.Parse(value));
}
}
public static void ReadD2PFiles()
{
var protocol = new PakProtocol();
protocol.Load(string.Format(@"{0}\app\content\maps\maps0.d2p", _clientPath));
protocol.Load(string.Format(@"{0}\app\content\gfx\world\gfx0.d2p", _clientPath));
foreach (var item in protocol.GetIndexes())
{
foreach (var pair in item.Value)
{
var reader = pair.Value.Item3;
reader.Seek(pair.Value.Item1, SeekOrigin.Begin);
if (pair.Key.EndsWith(".dlm")) // map
{
var map = new Map();
map.FromRaw(new BigEndianReader(Program.Uncompress(reader.ReadBytes(pair.Value.Item2))));
var render = new MapRenderer();
render.Render(map);
Program._accessor.Database.Update(Program.GenerateMapRecord(map));
}
else // gfx
{
var filePath = string.Format("./gfx/{0}", pair.Key);
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
using (var stream = File.Create(filePath))
{
var writer = new BigEndianWriter(stream);
writer.WriteBytes(reader.ReadBytes(pair.Value.Item2));
}
}
}
}
}
public void Read(IDataReader reader, bool isClient)
{
var writer = new BigEndianWriter();
Lenght = reader.ReadShort();
writer.WriteShort(Lenght);
if (isClient)
{
writer.WriteByte(reader.ReadByte());
}
Id = reader.ReadShort();
writer.WriteShort(Id);
if (Id != 1036)
{
Datas = reader.ReadBytes(Lenght - (isClient ? 5 : 4));
writer.WriteBytes(Datas);
CompleteDatas = writer.Data;
}
}
private void InternalSave(Stream stream)
{
var writer = new BigEndianWriter(stream);
// header
writer.WriteByte(2);
writer.WriteByte(1);
D2pEntry[] entries = GetEntriesOfInstanceOnly();
// avoid the header
int offset = 2;
foreach (D2pEntry entry in entries)
{
byte[] data = ReadFile(entry);
entry.Index = (int)writer.Position - offset;
writer.WriteBytes(data);
}
var entriesDefOffset = (int)writer.Position;
foreach (D2pEntry entry in entries)
{
entry.WriteEntryDefinition(writer);
}
var propertiesOffset = (int)writer.Position;
foreach (D2pProperty property in m_properties)
{
property.WriteProperty(writer);
}
IndexTable.OffsetBase = offset;
IndexTable.EntriesCount = entries.Length;
IndexTable.EntriesDefinitionOffset = entriesDefOffset;
IndexTable.PropertiesCount = m_properties.Count;
IndexTable.PropertiesOffset = propertiesOffset;
IndexTable.Size = IndexTable.EntriesDefinitionOffset - IndexTable.OffsetBase;
IndexTable.WriteTable(writer);
}
/// <summary>
/// ONLY CLIENT SIDE !!!
/// </summary>
/// <param name="instanceId"></param>
/// <returns></returns>
public byte[] ReWriteInstanceId(uint instanceId)
{
using (BigEndianReader reader = new BigEndianReader(FullPacket))
{
using (BigEndianWriter writer = new BigEndianWriter())
{
// header
writer.WriteShort(reader.ReadShort());
// instance id
writer.WriteUnsignedInt(instanceId);
// skip
reader.ReadUnsignedInt();
// len + data
writer.WriteBytes(reader.ReadBytes((int)reader.BytesAvailable));
return(writer.Data);
}
}
}
private void _parse_bool(BigEndianWriter writer)
{
IEnumerable <ClassField> bools = _network_base.fields.Where(x => x.use_boolean_byte_wrapper).OrderBy(x => x.boolean_byte_wrapper_position);
if (bools.Count() == 0)
{
return;
}
byte[] flags = new byte[bools.LastOrDefault().position.Value + 1];
foreach (ClassField _bool in bools)
{
flags[_bool.position.Value] = BooleanByteWrapper.SetFlag(flags[_bool.position.Value],
(byte)((_bool.boolean_byte_wrapper_position.Value - 1) % 8),
_network_content[_bool.name]);
}
writer.WriteBytes(flags);
}
public static void _writeElement(ClassField field, dynamic value, ref BigEndianWriter writer)
{
if (IsPrimitiv(field.type))
{
string write_method = field.write_method.Replace("write", "Write");
_writeMethod(write_method, value, ref writer);
}
else
{
NetworkElement var_type = null;
bool is_null = value is null;
if (is_null && field.write_false_if_null_method != null && field.write_false_if_null_method != "")
{
string check_null_method = field.write_false_if_null_method.Replace("write", "Write");
_writeMethod(check_null_method, 0, ref writer);
return;
}
if (is_null)
{
throw new Exception($"{var_type.name} cannot be null");
}
if (!field.prefixed_by_type_id)
{
var_type = ProtocolManager.Instance.Protocol[ProtocolKeyEnum.Types, x => x.name == field.type];
}
else
{
string write_type_id_method = field.write_type_id_method.Replace("write", "Write");
_writeMethod(write_type_id_method, value["protocol_id"], ref writer);
var_type = ProtocolManager.Instance.Protocol[ProtocolKeyEnum.Types, x => x.protocolID == value["protocol_id"]];
}
writer.WriteBytes(FromContent(value as ProtocolJsonContent, var_type));
}
}
public void ToSwl()
{
var writer = new BigEndianWriter();
writer.WriteByte(76); //Header
writer.WriteByte(Version);
writer.WriteUInt(FrameRate);
writer.WriteInt(Classes.Count);
foreach (var classe in Classes)
{
writer.WriteUTF(classe);
}
writer.WriteBytes(SwfData);
var swlName = FilePath.Replace(".swf", ".swl");
var file = File.Create(swlName);
file.Write(writer.Data, 0, writer.Data.Length);
file.Dispose();
writer.Dispose();
}
public BigEndianWriter Build(ushort messageId, uint?instanceId, byte[] data)
{
BigEndianWriter writer = new BigEndianWriter();
MessageId = messageId;
InstanceId = instanceId;
Data = data;
Length = data.Length;
writer.WriteShort(Header.Value);
if (ClientSide && instanceId != null)
{
writer.WriteUnsignedInt(InstanceId.Value);
}
switch (LengthBytesCount)
{
case 1:
writer.WriteByte((byte)Length);
break;
case 2:
writer.WriteShort((short)Length);
break;
case 3:
writer.WriteByte((byte)((Length >> 16) & 255));
writer.WriteShort((short)(Length & 65535));
break;
}
writer.WriteBytes(Data);
return(writer);
}
public void Send(MessagePart part, NetworkDestinationEnum destination)
{
++this.Instance;
BigEndianWriter bigEndianWriter1 = new BigEndianWriter();
byte num1 = part.Data.Length <= (int)ushort.MaxValue ? (part.Data.Length <= (int)byte.MaxValue ? ((uint)part.Data.Length <= 0U ? (byte)0 : (byte)1) : (byte)2) : (byte)3;
BigEndianWriter bigEndianWriter2 = bigEndianWriter1;
int? nullable1 = part.MessageId;
int? nullable2 = nullable1.HasValue ? new int?(nullable1.GetValueOrDefault() << 2) : new int?();
int num2 = (int)num1;
int? nullable3;
if (!nullable2.HasValue)
{
nullable1 = new int?();
nullable3 = nullable1;
}
else
{
nullable3 = new int?(nullable2.GetValueOrDefault() | num2);
}
nullable1 = nullable3;
int num3 = (int)(short)nullable1.Value;
bigEndianWriter2.WriteShort((short)num3);
if (destination == NetworkDestinationEnum.Server)
{
bigEndianWriter1.WriteUInt(this.Instance);
}
switch (num1)
{
case 1:
bigEndianWriter1.WriteByte((byte)part.Data.Length);
break;
case 2:
bigEndianWriter1.WriteShort((short)part.Data.Length);
break;
case 3:
bigEndianWriter1.WriteByte((byte)(part.Data.Length >> 16 & (int)byte.MaxValue));
bigEndianWriter1.WriteShort((short)(part.Data.Length & (int)ushort.MaxValue));
break;
}
bigEndianWriter1.WriteBytes(part.Data);
if (bigEndianWriter1.Data == null)
{
return;
}
try
{
switch (destination)
{
case NetworkDestinationEnum.Client:
this.Client.Send(bigEndianWriter1.Data);
break;
case NetworkDestinationEnum.Server:
this.Server.Send(bigEndianWriter1.Data);
break;
}
}
catch
{
}
}
public void Save(string uri)
{
using (var contentWriter = new BigEndianWriter(new StreamWriter(uri).BaseStream))
{
var headerWriter = new BigEndianWriter();
contentWriter.Seek(4, SeekOrigin.Begin);
// first table = index table
foreach (var index in m_entries.Where(x => x.Value.Text != null))
{
headerWriter.WriteInt(index.Key);
headerWriter.WriteBoolean(index.Value.UseUndiactricalText);
headerWriter.WriteInt((int)contentWriter.Position);
contentWriter.WriteUTF(index.Value.Text);
if (index.Value.UseUndiactricalText)
{
headerWriter.WriteInt((int)contentWriter.Position);
contentWriter.WriteUTF(index.Value.UnDiactricialText);
}
}
var indexLen = (int)headerWriter.Position;
// second table = text index table
headerWriter.WriteInt(0); // placeholder for text index table len
foreach (var index in m_textEntries.Where(x => x.Value.Text != null))
{
headerWriter.WriteUTF(index.Key);
headerWriter.WriteInt((int)contentWriter.Position);
contentWriter.WriteUTF(index.Value.Text);
}
var textIndexLen = headerWriter.Position - indexLen - 4;
var searchTablePos = headerWriter.Position;
headerWriter.Seek(indexLen);
headerWriter.WriteInt((int)textIndexLen); // write table len
headerWriter.Seek((int)searchTablePos);
// third table = search index table
headerWriter.WriteInt(0); // placeholder for table len
var sortedEntries = m_entries.Values.OrderBy(x => x.Text);
foreach (var entry in sortedEntries)
{
headerWriter.WriteInt(entry.Key);
}
var searchTableLen = headerWriter.Position - searchTablePos - 4;
headerWriter.Seek((int)searchTablePos);
headerWriter.WriteInt((int)searchTableLen); // write table len
var indexPos = (int)contentWriter.Position;
/* write index at end */
byte[] indexData = headerWriter.Data;
contentWriter.WriteInt(indexLen);
contentWriter.WriteBytes(indexData);
/* write index pos at begin */
contentWriter.Seek(0, SeekOrigin.Begin);
contentWriter.WriteInt(indexPos);
}
}
protected virtual void ReceiveEvent_Completed(object sender, SocketAsyncEventArgs e)
{
do
{
if (!IsConnected())
{
break;
}
var reader = new BigEndianReader(buffer.SubArray(0, ReceiveEvent.BytesTransferred));
while (reader.BytesAvailable > 0)
{
var msg = new NetworkMessage();
msg.Read(reader, !IsServer);
if (!IsGame)
{
if (IsServer)
{
if (msg.Id == 1036)
{
List <ServerType> servers = new List <ServerType>();
var q = reader.ReadInt();
for (int i = 0; i < q; i++)
{
var serv = new ServerType();
serv.Ports = new List <int>();
serv.Id = reader.ReadInt();
serv.Name = reader.ReadUTF();
serv.Commu = reader.ReadInt();
reader.ReadUTF();
serv.Ip = "127.0.0.1";
var countPort = reader.ReadInt();
for (int z = 0; z < countPort; z++)
{
serv.Ports.Add(reader.ReadInt());
}
serv.Position = reader.ReadByte();
servers.Add(serv);
}
var writer = new BigEndianWriter();
writer.WriteUShort(1036);
writer.WriteInt(servers.Count);
foreach (var item in servers)
{
writer.WriteInt(item.Id);
writer.WriteUTF(item.Name);
writer.WriteInt(item.Commu);
writer.WriteUTF(item.Ip);
writer.WriteInt(item.Ports.Count);
foreach (var port in item.Ports)
{
writer.WriteInt(port);
}
writer.WriteByte(item.Position);
}
var bytes = reader.ReadBytes((int)reader.BytesAvailable);
writer.WriteBytes(bytes);
var writer2 = new BigEndianWriter();
writer2.WriteUShort((ushort)(writer.Data.Length + 2));
writer2.WriteBytes(writer.Data);
Program.ServerLogin.SendToClient(writer2.Data);
LogManager.GetLoggerClass().Server(string.Format("Id [{0}] | Data : {1}", msg.Id, writer2.Data.GetDatas(Program.Hexa)));
}
else
{
Program.ServerLogin.SendToClient(msg.CompleteDatas);
LogManager.GetLoggerClass().Server(string.Format("Id [{0}] | Data : {1}", msg.Id, msg.Datas.GetDatas(Program.Hexa)));
}
}
else
{
Program.ServerLogin.SendToServer(msg.CompleteDatas);
LogManager.GetLoggerClass().Client(string.Format("Id [{0}] | Data : {1}", msg.Id, msg.Datas.GetDatas(Program.Hexa)));
}
}
else
{
if (IsServer)
{
Program.ServerGame.SendToClient(msg.CompleteDatas);
LogManager.GetLoggerClass().Server(string.Format("Id [{0}] | Data : {1}", msg.Id, msg.Datas.GetDatas(Program.Hexa)));
}
else
{
Program.ServerGame.SendToServer(msg.CompleteDatas);
LogManager.GetLoggerClass().Client(string.Format("Id [{0}] | Data : {1}", msg.Id, msg.Datas.GetDatas(Program.Hexa)));
}
}
}
} while (!Socket.ReceiveAsync(ReceiveEvent));
}
