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)); }