private static T[] InternalToArray <T>(PacketReader reader, PacketConverter converter)
{
var readerList = reader.GetList();
var count = readerList.Count;
if (count < 1)
{
return(new T[0]);
}
try
{
var result = new T[count];
var generic = (PacketConverter <T>)converter;
for (var i = 0; i < count; i++)
{
result[i] = generic.GetValue(readerList[i].block);
}
return(result);
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
private static Info GetInfoFromType(Type type)
{
var info = new Info()
{
Type = type
};
if (IsBasicTypeOrEnum(info, type))
{
return(info);
}
var generic = type.IsGenericType;
var genericArguments = generic ? type.GetGenericArguments() : null;
var genericDefinition = generic ? type.GetGenericTypeDefinition() : null;
#region dictionary, map...
if (genericDefinition == typeof(KeyValuePair <,>))
{
throw PacketException.InvalidType(type);
}
if (Convert.ToFSharpMapFunc(type, genericArguments, out var dictionaryFunc, out var dictionaryExtendFunc))
{
info.To = InfoFlags.Dictionary;
info.ToDictionary = dictionaryFunc;
info.ToDictionaryExtend = dictionaryExtendFunc;
}
internal void ToDictionary <TK, TV>(PacketConverter indexConverter, PacketConverter elementConverter, DictionaryAbstract <TK, TV> dictionary)
{
if (this.Length == 0)
{
return;
}
var indexGeneric = (PacketConverter <TK>)indexConverter;
var elementGeneric = (PacketConverter <TV>)elementConverter;
var vernier = (Vernier)this;
try
{
while (vernier.Any)
{
vernier.FlushExcept(indexGeneric.Length);
var key = indexGeneric.GetValue(vernier.Buffer, vernier.Offset, vernier.Length);
vernier.FlushExcept(elementGeneric.Length);
var value = elementGeneric.GetValue(vernier.Buffer, vernier.Offset, vernier.Length);
dictionary.Add(key, value);
}
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
private static IPAddress ToValue(byte[] buffer, int offset, int length)
{
if (length == 0)
return null;
if (buffer == null || offset < 0 || length < 1 || buffer.Length - offset < length)
throw PacketException.Overflow();
var result = new byte[length];
Unsafe.Copy(ref result[0], in buffer[offset], length);
internal object ThrowOrNull()
{
if (this.valueType)
{
throw PacketException.Overflow();
}
return(null);
}
internal static unsafe T ToValue(byte[] buffer, int offset, int length)
{
if (buffer == null || offset < 0 || length < sizeof(T) || buffer.Length - offset < length)
{
throw PacketException.Overflow();
}
return(UnsafeToValue(ref buffer[offset]));
}
private static GetInfo InternalGetGetInfo(Type type)
{
if (type == typeof(object))
{
goto fail;
}
var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
if (properties.Length == 0)
{
goto fail;
}
var propertyList = new List <KeyValuePair <string, Type> >();
var methodInfos = new List <MethodInfo>();
for (var i = 0; i < properties.Length; i++)
{
var item = properties[i];
var getter = item.GetGetMethod();
if (getter == null)
{
continue;
}
var parameters = getter.GetParameters();
// Length != 0 -> indexer
if (parameters == null || parameters.Length != 0)
{
continue;
}
propertyList.Add(new KeyValuePair <string, Type>(item.Name, item.PropertyType));
methodInfos.Add(getter);
}
var expressionList = new List <Expression>();
var parameter = Expression.Parameter(typeof(object), "parameter");
var objectArray = Expression.Parameter(typeof(object[]), "array");
var value = Expression.Variable(type, "value");
expressionList.Add(Expression.Assign(value, Expression.Convert(parameter, type)));
for (var i = 0; i < propertyList.Count; i++)
{
var arrayAccess = Expression.ArrayAccess(objectArray, Expression.Constant(i));
var result = Expression.Call(value, methodInfos[i]);
var convert = Expression.Convert(result, typeof(object));
var assign = Expression.Assign(arrayAccess, convert);
expressionList.Add(assign);
}
var block = Expression.Block(new[] { value }, expressionList);
var expression = Expression.Lambda <Action <object, object[]> >(block, parameter, objectArray);
return(new GetInfo(propertyList.ToArray(), expression.Compile()));
fail:
throw PacketException.InvalidType(type);
}
internal static T GetValueChecked <T>(this PacketConverter <T> converter, byte[] buffer, int offset, int length, bool check = false)
{
try
{
if (check && converter.Length > length)
{
throw PacketException.Overflow();
}
return(converter.GetValue(buffer, offset, length));
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
public static Model[] ToValue(byte[] buffer, int offset, int length)
{
if (length == 0)
{
return(s_empty_array);
}
if (buffer == null || (uint)length > (uint)buffer.Length || (length % sizeof(Model)) != 0)
{
throw PacketException.Overflow();
}
var dst = new Model[length / sizeof(Model)];
Buffer.BlockCopy(buffer, offset, dst, 0, length);
return(dst);
}
public static byte[] ToValue(byte[] buffer, int offset, int length)
{
if (length == 0)
{
return(Extension.s_empty_bytes);
}
if (buffer == null || (uint)length > (uint)buffer.Length)
{
throw PacketException.Overflow();
}
var dst = new byte[length];
Buffer.BlockCopy(buffer, offset, dst, 0, length);
return(dst);
}
internal void FlushExcept(int define)
{
if (define > 0)
{
this.Offset += this.Length;
if ((uint)(this.Limits - this.Offset) < (uint)define)
{
throw PacketException.Overflow();
}
this.Length = define;
}
else
{
this.Flush();
}
}
IEnumerator IEnumerable.GetEnumerator()
{
var define = this.converter.Length;
if (define < 1)
{
return(Enumerator(this.reader.GetList(), this.converter));
}
var block = this.reader.block;
var quotient = Math.DivRem(block.Length, define, out var remainder);
if (remainder != 0)
{
throw PacketException.Overflow();
}
return(Enumerator(block.Buffer, block.Offset, quotient, define, this.converter));
}
private static SetInfo InternalGetSetInfo(Type type)
{
if (type.IsAbstract || type.IsInterface)
{
goto fail;
}
var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
if (properties.Length == 0)
{
goto fail;
}
return(InternalGetSetInfoAnonymousType(type, properties) ?? InternalGetSetInfoProperties(type, properties));
fail:
throw PacketException.InvalidType(type);
}
internal void Flush()
{
this.Offset += this.Length;
if ((uint)(this.Limits - this.Offset) < sizeof(int))
{
goto fail;
}
var length = UnmanagedValueConverter <int> .UnsafeToValue(ref this.Buffer[this.Offset]);
this.Offset += sizeof(int);
if ((uint)(this.Limits - this.Offset) < (uint)length)
{
goto fail;
}
this.Length = length;
return;
fail:
throw PacketException.Overflow();
}
internal static byte[] GetBytesChecked <T>(this PacketConverter <T> converter, T value)
{
try
{
var buffer = converter.GetBytes(value);
if (buffer == null)
{
buffer = Empty.Array <byte>();
}
var define = converter.Length;
if (define > 0 && define != buffer.Length)
{
throw PacketException.ConversionMismatch(define);
}
return(buffer);
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
internal T[] ToArray <T>(PacketConverter converter)
{
if (this.Length < 1)
{
return(new T[0]);
}
if (typeof(T) == typeof(byte))
{
return((T[])(object)UnmanagedArrayConverter <byte> .ToValue(this.Buffer, this.Offset, this.Length));
}
else if (typeof(T) == typeof(sbyte))
{
return((T[])(object)UnmanagedArrayConverter <sbyte> .ToValue(this.Buffer, this.Offset, this.Length));
}
var define = converter.Length;
var quotient = Math.DivRem(this.Length, define, out var remainder);
if (remainder != 0)
{
throw PacketException.Overflow();
}
try
{
var target = new T[quotient];
var generic = (PacketConverter <T>)converter;
for (var i = 0; i < quotient; i++)
{
target[i] = generic.GetValue(this.Buffer, this.Offset + i * define, define);
}
return(target);
}
catch (Exception ex) when(PacketException.ReThrowFilter(ex))
{
throw PacketException.ConversionError(ex);
}
}
internal static PacketConverter GetConverter(ConverterDictionary converters, Type type, bool nothrow)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if ((converters != null && converters.TryGetValue(type, out var converter)) || Extension.Converters.TryGetValue(type, out converter))
{
return(converter);
}
var info = GetInfo(type);
if ((converter = info.Converter) != null)
{
return(converter);
}
if (nothrow == true)
{
return(null);
}
throw PacketException.InvalidType(type);
}
//User buffer to push data
void ProcessPacket()
{
if (m_SocketInputStream == null)
{
return;
}
int nProcessPacketCount = m_nEachFrame_ProcessPacket_Count;
Int32 packetSize;
Int16 messageid;
Ipacket pPacket = null;
while (m_bCanProcessPacket && (nProcessPacketCount--) > 0)
{
Array.Clear(m_HeadbyteData, 0, PACKET_HEADER_SIZE);
if (!m_SocketInputStream.Peek(m_HeadbyteData, PACKET_HEADER_SIZE))
{
break;
}
packetSize = BitConverter.ToInt32(m_HeadbyteData, 0);
packetSize = System.Net.IPAddress.NetworkToHostOrder(packetSize);
messageid = BitConverter.ToInt16(m_HeadbyteData, sizeof(UInt32));
messageid = System.Net.IPAddress.NetworkToHostOrder(messageid);
if (packetSize <= 0 || messageid <= 0)
{
LogModule.ErrorLog("ProcessPacket packetSize: " + packetSize + " messageid : " + messageid + " HeadDate: " + LogModule.ByteToString(m_HeadbyteData, 0, PACKET_HEADER_SIZE));
}
if (m_SocketInputStream.Length() < packetSize)
{
break;
}
try
{
if (m_MaxRevOnePacketbyteCount < packetSize)
{
m_MaxRevOnePacketbyte = new byte[packetSize];
m_MaxRevOnePacketbyteCount = packetSize;
}
Array.Clear(m_MaxRevOnePacketbyte, 0, m_MaxRevOnePacketbyteCount);
bool bRet = m_SocketInputStream.Skip(PACKET_HEADER_SIZE);
if (bRet == false)
{
string errorLog = string.Format("Can not Create Packet MessageID({0},packetSize{1})", messageid, packetSize);
throw PacketException.PacketReadError(errorLog);
}
m_SocketInputStream.Read(m_MaxRevOnePacketbyte, (uint)(packetSize - PACKET_HEADER_SIZE));
if (IsCryptoPacket((UInt16)messageid))
{
XorCrypto.XorDecrypt(m_MaxRevOnePacketbyte, (uint)(packetSize - PACKET_HEADER_SIZE));
}
pPacket = m_PacketFactoryManager.GetPacketHandler((MessageID)messageid);
if (pPacket == null)
{
string errorLog = string.Format("Can not Create Packet MessageID({0},buff{1})", messageid, LogModule.ByteToString(m_MaxRevOnePacketbyte, 0, m_MaxRevOnePacketbyteCount));
throw PacketException.PacketCreateError(errorLog);
}
PacketDistributed realPacket = PacketDistributed.CreatePacket((MessageID)messageid);
if (realPacket == null)
{
string errorLog = string.Format("Can not Create Inner Packet Data MessageID({0},buff{1})", messageid, LogModule.ByteToString(m_MaxRevOnePacketbyte, 0, m_MaxRevOnePacketbyteCount));
throw PacketException.PacketCreateError(errorLog);
}
PacketDistributed instancePacket = realPacket.ParseFrom(m_MaxRevOnePacketbyte, packetSize - PACKET_HEADER_SIZE);
if (instancePacket == null)
{
string errorLog = string.Format("Can not Merged Inner Packet Data MessageID({0},buff{1})", messageid, LogModule.ByteToString(m_MaxRevOnePacketbyte, 0, m_MaxRevOnePacketbyteCount));
throw PacketException.PacketCreateError(errorLog);
}
//Profiler.BeginSample((MessageID)messageid+"");
uint result = pPacket.Execute(instancePacket);
if (pPacket.GetType().Name != "GC_RET_PINGHandler" &&
pPacket.GetType().Name != "GC_CONNECTED_HEARTBEATHandler" &&
pPacket.GetType().Name != "GC_MOVEHandler")
{
LogModule.WarningLog("Packet :" + pPacket.GetType().Name);
}
//Profiler.EndSample();
if ((PACKET_EXE)result != PACKET_EXE.PACKET_EXE_NOTREMOVE)
{
m_PacketFactoryManager.RemovePacket(pPacket);
}
else if ((PACKET_EXE)result == PACKET_EXE.PACKET_EXE_ERROR)
{
string errorLog = string.Format("Execute Packet error!!! MessageID({0},buff{1})", messageid, LogModule.ByteToString(m_MaxRevOnePacketbyte, 0, m_MaxRevOnePacketbyteCount));
throw PacketException.PacketExecuteError(errorLog);
}
}
catch (PacketException ex)
{
LogModule.ErrorLog(ex.ToString());
}
catch (System.Exception ex)
{
LogModule.ErrorLog(ex.ToString());
}
}
if (nProcessPacketCount >= 0)
{
m_nEachFrame_ProcessPacket_Count = EACHFRAME_PROCESSPACKET_COUNT;
}
else
{
m_nEachFrame_ProcessPacket_Count += 4;
}
}
private void HanderPacketException(PacketException ex)
{
Logs.Error("接收错误 " + ex.Code + "-" + ex.Data);
}
