private void OnData(IAsyncResult result)
{
try
{
_bytesToRead -= _ns.EndRead(result);
if (_bytesToRead > 0)
{
_ns.BeginRead(_buffer, _buffer.Length - _bytesToRead, _bytesToRead, OnData, null);
return;
}
// Combine the buffer for packetId and the data because we encrypt those together, we have to combine and decrypt them together
_buffer = packetId.Concat(_buffer).ToArray();
// Decrypt the buffer to retrieve the actual packetId and the data
if (_crypt != null)
{
_buffer = this._crypt.Decrypt(_buffer).ToArray();
}
var id = BitConverter.ToUInt16(_buffer, 0);
var data = new SerializeReader(new MemoryStream(_buffer.Skip(2).ToArray()));
var hexDump = SerializeWriter.HexDump(_buffer.Skip(2).ToArray());
//Console.WriteLine("{0}", hexDump);
_buffer = new byte[4];
_bytesToRead = _buffer.Length;
_ns.BeginRead(_buffer, 0, 4, OnHeader, null);
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
}
public Packet(GameClient sender, ushort id, byte[] buffer)
{
Sender = sender;
Buffer = buffer;
Id = id;
Reader = new SerializeReader(new MemoryStream(Buffer));
}
public void SetupDicts(Packet p)
{
SerializeReader.FromBinary <Object>(p, out Object obj);
String contents = obj.ToString();
if (contents.StartsWith("TypeConverter"))
{
MatchCollection mc = Regex.Matches(contents, @"0x([A-F0-9]+)[,\s\{]*FullName = ([A-Za-z\._]+), GUID = ([a-z0-9-]+)");
Dictionary <String, bool> loaded = new Dictionary <String, bool>();
foreach (Match m in mc)
{
int categoryId = int.Parse(m.Groups[1].ToString(), System.Globalization.NumberStyles.HexNumber);
String className = m.Groups[2].ToString();
Guid guid = Guid.Parse(m.Groups[3].ToString());
if (classNames.TryGetValue(categoryId, out string dictClassName))
{
if (dictClassName != null && dictClassName != className)
{
Console.WriteLine("Error! Conflicting types going to dictionaries, please remove the static keyword");
}
}
else
{
classNames.Add(categoryId, className);
getGuid.Add(categoryId, guid);
}
}
}
Console.WriteLine("Have {0} types in dict", classNames.Count);
}
public void ProcessTypeConverter(Devcat.Core.Net.Message.Packet p)
{
SerializeReader.FromBinary <Object>(p, out Object obj);
String s1 = obj.ToString();
SetupDicts(s1);
mp.RegisterPrinters(mf, getGuid);
}
private void ProcessClientMessage(Packet packet, RCClient client)
{
Type type = this.MF.GetType(packet);
if (type == typeof(AddProcessMessage))
{
AddProcessMessage addProcessMessage;
SerializeReader.FromBinary <AddProcessMessage>(packet, out addProcessMessage);
client.ProcessMessage(addProcessMessage);
this.CheckAndAddHeroesAdmin(client.ID, client.ClientIP, addProcessMessage.Process);
return;
}
if (type == typeof(ModifyProcessMessage))
{
ModifyProcessMessage modifyProcessMessage;
SerializeReader.FromBinary <ModifyProcessMessage>(packet, out modifyProcessMessage);
client.ProcessMessage(modifyProcessMessage);
this.CheckAndAddHeroesAdmin(client.ID, client.ClientIP, modifyProcessMessage.Process);
return;
}
if (type == typeof(RemoveProcessMessage))
{
RemoveProcessMessage removeProcessMessage;
SerializeReader.FromBinary <RemoveProcessMessage>(packet, out removeProcessMessage);
client.ProcessMessage(removeProcessMessage);
this.CheckAndRemoveHeroesAdmin(client.ID, removeProcessMessage.Name);
return;
}
if (type == typeof(StateChangeProcessMessage))
{
StateChangeProcessMessage stateChangeProcessMessage;
SerializeReader.FromBinary <StateChangeProcessMessage>(packet, out stateChangeProcessMessage);
if (this.serverGroups.ContainsKey(client.ID) && stateChangeProcessMessage.State == RCProcess.ProcessState.On)
{
string processKey = this.GetProcessKey(client.ID, stateChangeProcessMessage.Name);
if (this.serverGroups[client.ID].ContainsKey(processKey))
{
string value = this.serverGroups[client.ID][processKey];
if (this.ServerGroupActivated != null)
{
this.ServerGroupActivated(this, new EventArgs <string>(value));
return;
}
}
}
}
else if (type == typeof(LogProcessMessage))
{
LogProcessMessage logProcessMessage;
SerializeReader.FromBinary <LogProcessMessage>(packet, out logProcessMessage);
RCProcess rcprocess = client[logProcessMessage.Name];
if ((rcprocess.PerformanceString.Length == 0 || !RCProcess.IsStandardOutputLog(logProcessMessage.Message) || !RCProcess.GetOriginalLog(logProcessMessage.Message).StartsWith(rcprocess.PerformanceString)) && this.ProcessLogged != null)
{
this.ProcessLogged(new KeyValuePair <RCClient, RCProcess>(client, rcprocess), new EventArgs <string>(RCProcess.GetOriginalLog(logProcessMessage.Message)));
}
}
}
public GameScoreModel(SerializeReader reader)
{
Token = reader.ReadUnicodeStatic(44);
Score = reader.ReadInt32();
AnswerCorrectly = reader.ReadInt32();
Experience = reader.ReadInt32();
CurrentExperience = reader.ReadInt32();
CurrentLevel = reader.ReadInt32();
}
private static Color DeserializeColor(SerializeReader reader)
{
int r = 0, g = 0, b = 0, a = 0;
if (!reader.InOut(SpecialChars.ObjectStart))
{
throw new InvalidDataException("Ожидалось начало объекта");
}
var colorName = "";
for (var i = 0; i < 4; ++i)
{
if (!reader.InOut(ref colorName))
{
throw new InvalidDataException("Ожидалось имя цветовой компоненты");
}
var colorPart = 0;
if (!reader.InOut(ref colorPart))
{
throw new InvalidDataException("Ожидалось значение цветовой компоненты");
}
switch (colorName)
{
case "r":
r = colorPart;
break;
case "g":
g = colorPart;
break;
case "b":
b = colorPart;
break;
case "a":
a = colorPart;
break;
default:
throw new InvalidDataException("Некорректно задан цвет. Отсутствует одна из компонент");
}
if (i != 3)
{
if (!reader.InOut(SpecialChars.Delimiter))
{
throw new InvalidDataException("Отсутствует разделитель между компонентами цвета");
}
}
}
if (!reader.InOut(SpecialChars.ObjectEnd))
{
throw new InvalidDataException("Не закрыта секция цвета");
}
return(new Color(r, g, b, a));
}
private static ColorDescription DeserializeColorDescription(SerializeReader reader)
{
var comment = "";
var level = 0;
var color = new Color(0, 0, 0);
var param = "";
if (!reader.InOut(SpecialChars.ObjectStart))
{
throw new InvalidDataException("Ожидалось начало секции");
}
for (int i = 0; i < 3; ++i)
{
if (!reader.InOut(ref param))
{
throw new InvalidDataException("Не обнаружено имя параметра");
}
switch (param)
{
case "comment":
if (!reader.InOut(ref comment))
{
throw new InvalidDataException("Невозможно прочитать комментарий");
}
break;
case "level":
if (!reader.InOut(ref level))
{
throw new InvalidDataException("Невозможно прочитать значение уровня цвета");
}
break;
case "color":
color = DeserializeColor(reader);
break;
default:
throw new InvalidDataException("Неожиданное значение в объекте описания цвета");
}
if (i != 2)
{
if (!reader.InOut(SpecialChars.Delimiter))
{
throw new InvalidDataException("Ожидался разделитель");
}
}
}
if (!reader.InOut(SpecialChars.ObjectEnd))
{
throw new InvalidDataException("Ожидался конец объекта");
}
return(new ColorDescription {
Color = color, Comment = comment, Level = level
});
}
/// <summary>
/// 从组资源文件中反序列化ＵＩ窗体
/// 需要外部捕获异常
/// </summary>
/// <param name="packageName">资源包名称</param>
/// <param name="fileName">资源文件名称</param>
/// <returns>序列化窗口，一般情况下不需要处理</returns>
public Window Deserialize(string packageName, string fileName)
{
//XmlSerializeReader reader = new XmlSerializeReader("F:/Test.nui");
NXmlSerializeDataReader reader = new NXmlSerializeDataReader(packageName, fileName);
SerializeReader serializer = new SerializeReader(reader);
Window window = serializer.Deserialize() as Window;
reader.Close();
return(window);
}
private void AddCommandLogging(Packet packet, User user)
{
try
{
StandardInProcessMessage standardInProcessMessage = null;
SerializeReader.FromBinary <StandardInProcessMessage>(packet, out standardInProcessMessage);
if (standardInProcessMessage != null && standardInProcessMessage.Name.CompareTo("HeroesCommandBridge") == 0)
{
Log <ControlServer> .Logger.InfoFormat(standardInProcessMessage.Message + string.Format(" Written By [{0}].", user.AccountId), new object[0]);
}
}
catch (SerializationException)
{
}
catch (Exception ex)
{
Log <ControlServer> .Logger.Error(ex);
}
}
private void OnKeyData(IAsyncResult ar)
{
try
{
_bytesToRead -= _ns.EndRead(ar);
if (_bytesToRead > 0)
{
_ns.BeginRead(_buffer, _buffer.Length - _bytesToRead, _bytesToRead, OnKeyData, null);
return;
}
var reader = new SerializeReader(new MemoryStream(_buffer));
byte[] key = reader.ReadBytes(32);
byte[] iv = reader.ReadBytes(16);
_crypt = new Supercrypt(key, iv);
_buffer = new byte[4];
_bytesToRead = _buffer.Length;
_ns.BeginRead(_buffer, 0, _bytesToRead, OnHeader, null);
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
}
/// <summary>
/// Пытается получить объект указанного типа из указанного десериализатора
/// </summary>
/// <param name="t">Тип объекта, который нужно получить</param>
/// <param name="reader">Десериализатор</param>
/// <param name="settingsForTypeCheck">Если тип объекта -- Settings, то необходимо
/// указать, откуда брать информацию о типах. Значение по-умолчанию null.</param>
/// <returns>
/// Объект указанного типа, если удалось его получить
/// </returns>
/// <exception cref="InvalidDataException">Объект указанного типа получить не
/// удалось в силу различных причин</exception>
private dynamic DeserializeObject(Type t, SerializeReader reader, Settings settingsForTypeCheck = null)
{
if (t == typeof(int))
{
var i = 0;
if (reader.InOut(ref i))
{
return(i);
}
throw new InvalidDataException("Не удалось прочитать число Int32");
}
if (t == typeof(double))
{
var d = 0d;
if (reader.InOut(ref d))
{
return(d);
}
throw new InvalidDataException("Не удалось прочитать число типа Double");
}
if (t == typeof(float))
{
var f = 0f;
if (reader.InOut(ref f))
{
return(f);
}
throw new InvalidDataException("Не удалось прочитать число типа Single");
}
if (t == typeof(string))
{
var s = "";
if (reader.InOut(ref s))
{
return(s);
}
throw new InvalidDataException("Не удалось прочитать строку");
}
if (t == typeof(bool))
{
var b = false;
if (reader.InOut(ref b))
{
return(b);
}
throw new InvalidDataException("Не удалось прочитать значение типа bool");
}
if (t.IsArray)
{
if (!reader.InOut(SpecialChars.ArrayStart))
{
throw new InvalidDataException("Ожидался признак начала массива");
}
var arr = new ArrayList();
while (reader.TestCurrentSpecialChar() != SpecialChars.ArrayEnd)
{
arr.Add(DeserializeObject(t.GetElementType(), reader));
if (!reader.InOut(SpecialChars.Delimiter, false))
{
break;
}
reader.InOut(SpecialChars.Delimiter);
}
if (!reader.InOut(SpecialChars.ArrayEnd))
{
throw new InvalidDataException("Ожидался конец массива либо разделитель");
}
var res = Array.CreateInstance(t.GetElementType(), arr.Count);
arr.CopyTo(res);
return(res);
}
if (t == typeof(Color))
{
return(DeserializeColor(reader));
}
if (t == typeof(ColorDescription))
{
return(DeserializeColorDescription(reader));
}
if (t == typeof(Settings))
{
var settings = new Settings();
if (!reader.InOut(SpecialChars.ObjectStart))
{
throw new InvalidDataException("Ожидался маркер начала объекта");
}
while (reader.TestCurrentSpecialChar() != SpecialChars.ObjectEnd)
{
var name = "";
if (!reader.InOut(ref name))
{
throw new InvalidDataException("Ожидалось имя параметра");
}
var type = typeof(string);
if (settingsForTypeCheck.Exists(name))
{
type = settingsForTypeCheck.GetTypeByName(name);
}
settings[name] = DeserializeObject(type, reader,
(Settings)(type == typeof(Settings) ? settingsForTypeCheck[name] : null));
if (!reader.InOut(SpecialChars.Delimiter, false))
{
break;
}
reader.InOut(SpecialChars.Delimiter);
}
if (!reader.InOut(SpecialChars.ObjectEnd))
{
throw new InvalidDataException("Ожидался маркер конца объекта");
}
return(settings);
}
return(null);
}
/// <summary>
/// Deserialize the content from the network stream into an Message object
/// </summary>
/// <param name="reader"></param>
public void Deserialize(SerializeReader reader)
{
Type = (MessageType)reader.ReadByte();
Text = reader.ReadUnicodePrefixed();
Tick = new DateTime(reader.ReadInt64());
}
public InPacket(Packet packet)
{
Reader = packet.Reader;
}
/// <summary>
/// Read the value in the order of which we serialize it before sending over the networks stream
/// </summary>
/// <param name="reader"the SerializeReader object which we going to read the value></param>
public void Deserialize(SerializeReader reader)
{
X = reader.ReadByte();
Y = reader.ReadByte();
Color = reader.ReadByte();
}
