/// <summary>
/// 压缩发送数据
/// </summary>
/// <param name="dataLength"></param>
/// <param name="sendMarkData"></param>
internal unsafe bool CompressSendData(int dataLength, ulong sendMarkData)
{
SubArray <byte> oldSendData = Data;
if (AutoCSer.IO.Compression.DeflateCompressor.Get(Data.Array, Data.Start + (sizeof(uint) + sizeof(int)), dataLength, ref CompressBuffer, ref Data, sizeof(uint) + sizeof(int) * 2, sizeof(uint) + sizeof(int) * 2))
{
int compressionDataSize = Data.Length;
Data.MoveStart(-(sizeof(uint) + sizeof(int) * 2));
fixed(byte *sendDataFixed = Data.GetFixedBuffer(), oldSendDataFixed = oldSendData.GetFixedBuffer())
{
byte *dataStart = sendDataFixed + Data.Start;
*(int *)dataStart = *(int *)(oldSendDataFixed + oldSendData.Start);
*(int *)(dataStart + sizeof(uint)) = -compressionDataSize;
*(int *)(dataStart + (sizeof(uint) + sizeof(int))) = dataLength;
if (sendMarkData != 0)
{
TcpServer.CommandBase.Mark32(dataStart + (sizeof(uint) + sizeof(int) * 2), sendMarkData, (compressionDataSize + 3) & (int.MaxValue - 3));
}
}
return(IsError = true);
}
return(false);
}
/// <summary>
/// 合并数据块集合
/// </summary>
/// <param name="datas">数据块集合</param>
/// <returns>合并后的数据块</returns>
internal unsafe static byte[] BlocksToByte(ref LeftArray <SubArray <byte> > datas)
{
if (datas.Length != 0)
{
int length = 0, count = datas.Length;
SubArray <byte>[] array = datas.Array;
for (int index = 0; index != count; ++index)
{
length += array[index].Length;
}
byte[] data = new byte[length];
fixed(byte *dataFixed = data)
{
byte *currentData = dataFixed;
for (int index = 0; index != count; ++index)
{
SubArray <byte> subArray = array[index];
fixed(byte *subArrayFixed = subArray.GetFixedBuffer())
{
AutoCSer.Memory.Common.CopyNotNull(subArrayFixed + subArray.Start, currentData, subArray.Length);
}
currentData += subArray.Length;
}
}
return(data);
}
return(null);
}
/// <summary>
/// Cookie 解析
/// </summary>
/// <param name="data"></param>
internal unsafe void FromCookie(ref SubArray <byte> data)
{
if (data.Length == 64)
{
fixed(byte *dataFixed = data.GetFixedBuffer())
{
byte *start = dataFixed + data.StartIndex;
bit32 = AutoCSer.Extensions.NumberExtension.ParseHex32(start);
bit0 = AutoCSer.Extensions.NumberExtension.ParseHex32(start + 8);
bit96 = AutoCSer.Extensions.NumberExtension.ParseHex32(start + 16);
bit64 = AutoCSer.Extensions.NumberExtension.ParseHex32(start + 24);
bit160 = AutoCSer.Extensions.NumberExtension.ParseHex32(start + 32);
bit128 = AutoCSer.Extensions.NumberExtension.ParseHex32(start + 40);
bit224 = AutoCSer.Extensions.NumberExtension.ParseHex32(start + 48);
bit192 = AutoCSer.Extensions.NumberExtension.ParseHex32(start + 56);
}
return;
}
Low = 1;
Ticks = 0;
}
internal bool DeSerialize <valueType>(ref SubArray <byte> data, ref valueType value, bool isSimpleSerialize)
where valueType : struct
{
if ((CommandIndex & (uint)CommandFlags.JsonSerialize) == 0)
{
if (isSimpleSerialize)
{
fixed(byte *dataFixed = data.GetFixedBuffer())
{
byte *start = dataFixed + data.Start, end = start + data.Length;
return(SimpleSerialize.TypeDeSerializer <valueType> .DeSerialize(start, ref value, end) == end);
}
}
if (ReceiveDeSerializer == null)
{
ReceiveDeSerializer = AutoCSer.BinaryDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.BinaryDeSerializer();
ReceiveDeSerializer.SetTcpServer(binaryDeSerializeConfig, this);
}
return(ReceiveDeSerializer.DeSerializeTcpServer(ref data, ref value));
//if (ReceiveDeSerializer.DeSerializeTcpServer(ref data, ref value)) return true;
//if (data.Length > 1 << 20) System.IO.File.WriteAllBytes((++testIdentity).ToString() + "." + data.Length.ToString(), data.ToArray());
//return false;
}
if (ReceiveJsonDeSerializer == null)
{
ReceiveJsonDeSerializer = AutoCSer.JsonDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.JsonDeSerializer();
ReceiveJsonDeSerializer.SetTcpServer();
}
return(ReceiveJsonDeSerializer.DeSerializeTcpServer(ref data, ref value));
}
private unsafe void load(ref SubArray <byte> data)
{
if (data.Array != null)
{
if (data.Length != 0)
{
LoadData loadData = new LoadData {
Buffer = loadBuffer
};
fixed(byte *dataFixed = data.GetFixedBuffer())
{
loadData.Set(ref data, dataFixed);
if (Load(ref loadData))
{
return;
}
}
TcpServer.Log.Fatal("缓存数据解析失败", LogLevel.Fatal | LogLevel.AutoCSer);
}
else
{
SlaveServer.Cache = this;
IsLoaded = true;
NextGetter();
}
}
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
byte *read = deSerializer.Read;
int size = *(int *)read;
if (size <= 0)
{
if (size == 0)
{
Buffer.SetNull();
State = (MemberState)(byte)*(int *)(read + sizeof(int));
deSerializer.Read += sizeof(int) * 2;
}
else
{
Buffer.Start = -size;
deSerializer.Read += sizeof(int);
}
}
else if (size == Buffer.Length)
{
if (deSerializer.MoveReadAny(sizeof(int) + size + (-size & 3)))
{
fixed(byte *bufferFixed = Buffer.GetFixedBuffer()) AutoCSer.Memory.Common.CopyNotNull(read + sizeof(int), bufferFixed + Buffer.Start, size);
State = MemberState.Remote;
}
}
else
{
deSerializer.State = BinarySerialize.DeSerializeState.IndexOutOfRange;
}
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="queryData">查询数据</param>
/// <param name="onQuery"></param>
/// <param name="isDeSerializeStream">是否反序列化网络流，否则需要 Copy 数据</param>
internal void Query(ref SubArray <byte> queryData, AutoCSer.Net.TcpServer.ServerCallback <IdentityReturnParameter> onQuery, bool isDeSerializeStream)
{
try
{
queryBuffer.Set(ref queryData);
fixed(byte *dataFixed = queryData.GetFixedBuffer())
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, queryBuffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
parser.SetOnReturn(onQuery, isDeSerializeStream);
onQuery = null;
try
{
dataStructure.Node.Query(ref parser);
}
finally
{
parser.CallOnReturnDistributionMessage();
}
}
}
}
finally
{
if (onQuery != null)
{
onQuery.Callback(new IdentityReturnParameter(ReturnType.DataStructureIdentityError));
}
}
}
/// <summary>
/// 复制内存数据
/// </summary>
/// <param name="source"></param>
/// <param name="destination"></param>
internal static void CopyTo(this SubArray <byte> source, Span <byte> destination)
{
fixed(byte *sourceFixed = source.GetFixedBuffer())
{
CopyTo(new Span <byte>(sourceFixed + source.Start, source.Length), destination);
}
}
internal static void CopyTo(this Span <byte> source, SubArray <byte> destination)
{
fixed(byte *destinationFixed = destination.GetFixedBuffer())
{
CopyTo(source, new Span <byte>(destinationFixed + destination.Start, destination.Length));
}
}
/// <summary>
/// 判断数据是否匹配
/// </summary>
/// <param name="fileStream"></param>
/// <param name="data"></param>
/// <returns></returns>
private bool isData(FileStream fileStream, ref SubArray <byte> data)
{
fileStream.Seek(Index, SeekOrigin.Begin);
SubBuffer.PoolBufferFull buffer = default(SubBuffer.PoolBufferFull);
BlockBase.DefaultBufferPool.Get(ref buffer);
try
{
byte[] bufferArray = buffer.Buffer;
int size = data.Length;
fixed(byte *dataFixed = data.GetFixedBuffer(), bufferFixed = bufferArray)
{
byte *dataStart = dataFixed + data.Start, bufferStart = bufferFixed + buffer.StartIndex;
while (size > BlockBase.CheckSize)
{
if (fileStream.Read(bufferArray, buffer.StartIndex, BlockBase.CheckSize) != BlockBase.CheckSize)
{
return(false);
}
if (!AutoCSer.Memory.Common.EqualNotNull(dataStart, bufferStart, BlockBase.CheckSize))
{
return(false);
}
dataStart += BlockBase.CheckSize;
size -= BlockBase.CheckSize;
}
return(fileStream.Read(bufferArray, buffer.StartIndex, size) == size && AutoCSer.Memory.Common.EqualNotNull(dataStart, bufferStart, size));
}
}
finally { buffer.Free(); }
}
/// <summary>
/// IPv6包
/// </summary>
/// <param name="data">数据</param>
public unsafe Ip6(ref SubArray <byte> data)
{
headerEndIndex = (uint)DefaultHeaderSize;
if (data.Length >= DefaultHeaderSize)
{
fixed(byte *dataFixed = data.GetFixedBuffer())
{
byte *start = dataFixed + data.StartIndex;
int packetSize = (*(start + 4) << 8) + *(start + 5), dataLength = DefaultHeaderSize + packetSize;
if (dataLength <= data.Length)
{
data.Length = dataLength;
byte protocol = *(start + 6);
if (protocol < 64)
{
if ((ExpandProtocol & (1UL << protocol)) == 0)
{
this.data = data;
return;
}
if (packetSize >= 8)
{
do
{
protocol = *(start + headerEndIndex);
headerEndIndex += 8;
if (protocol == (byte)Ip.ProtocolEnum.IPv6FragmentHeader)
{
if (headerEndIndex > dataLength)
{
break;
}
}
else
{
headerEndIndex += (uint)(start + headerEndIndex + 1) << 3;
if (headerEndIndex > dataLength)
{
break;
}
if (protocol >= 64 || (ExpandProtocol & (1UL << protocol)) == 0)
{
this.data = data;
return;
}
}
}while (true);
}
}
else
{
this.data = data;
return;
}
}
}
}
this.data = new SubArray <byte>();
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
int dataSize = (data.Length + 3) & (int.MaxValue), prepLength = dataSize + (sizeof(uint) + sizeof(int) * 2);
if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= prepLength ||
(stream.Data.FreeSize >= prepLength && prepLength > buildInfo.SendBufferSize - TcpServer.ClientCommand.Command.StreamStartIndex))
{
CommandBase nextBuild = LinkNext;
byte * write = stream.GetPrepSizeCurrent(prepLength);
*(int *)write = Server.CustomDataCommandIndex;
*(uint *)(write + sizeof(int)) = (uint)data.Length;
*(int *)(write + (sizeof(uint) + sizeof(int))) = dataSize;
if (data.Length != 0)
{
fixed(byte *dataFixed = data.GetFixedBuffer()) AutoCSer.Memory.Common.CopyNotNull(dataFixed + data.Start, write + (sizeof(uint) + sizeof(int) * 2), data.Length);
}
stream.Data.CurrentIndex += dataSize + (sizeof(uint) + sizeof(int) * 2);
++buildInfo.Count;
data.Array = null;
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <CustomDataCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建输出信息
/// </summary>
/// <param name="sender">TCP 服务套接字数据发送</param>
/// <param name="buildInfo">输出创建参数</param>
internal override OutputLink Build(ServerSocketSenderBase sender, ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = sender.OutputSerializer.Stream;
int dataSize = (Data.Length + (sizeof(int) + 3)) & (int.MaxValue), prepLength = dataSize + (sizeof(uint) + sizeof(int));
if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= prepLength ||
(stream.Data.FreeSize >= prepLength && prepLength > buildInfo.SendBufferSize - TcpServer.ServerOutput.OutputLink.StreamStartIndex))
{
OutputLink nextBuild = LinkNext;
byte * write = stream.GetPrepSizeCurrent(prepLength);
*(uint *)write = ClientCommand.KeepCommand.CustomDataIndex;
*(int *)(write + sizeof(uint)) = dataSize;
*(int *)(write + (sizeof(uint) + sizeof(int))) = Data.Length;
if (Data.Length != 0)
{
fixed(byte *dataFixed = Data.GetFixedBuffer()) AutoCSer.Memory.Common.CopyNotNull(dataFixed + Data.Start, write + (sizeof(uint) + sizeof(int) * 2), Data.Length);
}
stream.Data.CurrentIndex += dataSize + (sizeof(uint) + sizeof(int));
++buildInfo.Count;
LinkNext = null;
Data.Array = null;
AutoCSer.Threading.RingPool <CustomDataOutput> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 根据域名获取IP地址
/// </summary>
/// <param name="domain">域名</param>
/// <returns>IP地址,失败返回null</returns>
internal unsafe static IPAddress[] Get(ref SubArray <byte> domain)
{
try
{
fixed(byte *domainFixed = domain.GetFixedBuffer())
{
byte *domainStart = domainFixed + domain.StartIndex;
AutoCSer.Memory.Common.ToLowerNotNull(domainStart, domainStart + domain.Length);
HashBytes key = domain;
DomainIPAddress value;
Monitor.Enter(domainIpLock);
try
{
value = domainIps.Get(ref key, default(DomainIPAddress));
if (value.Ips != null && value.Timeout < AutoCSer.Threading.SecondTimer.Now)
{
domainIps.Remove(ref key, out value);
value.Ips = null;
}
}
finally { Monitor.Exit(domainIpLock); }
if (value.Ips == null)
{
if (value.Domain == null)
{
value.Domain = MemoryExtensionWebClient.BytesToStringNotEmpty(domainStart, domain.Length);
}
IPAddress ip;
if (IPAddress.TryParse(value.Domain, out ip))
{
value.Timeout = DateTime.MaxValue;
value.Domain = null;
setDomainIp(key.Copy(), ref value);
return(value.Ips = new IPAddress[] { ip });
}
value.Ips = Dns.GetHostEntry(value.Domain).AddressList;
if (value.Ips.Length != 0)
{
value.Timeout = AutoCSer.Threading.SecondTimer.Now.AddTicks(domainIpTimeoutTicks);
setDomainIp(key.Copy(), ref value);
return(value.Ips);
}
}
else
{
return(value.Ips);
}
}
}
catch (Exception error)
{
AutoCSer.LogHelper.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer);
}
return(null);
}
/// <summary>
/// 模拟javascript解码函数unescape
/// </summary>
/// <param name="value">原字符串,长度必须大于 0</param>
public void JavascriptUnescape(SubArray <byte> value)
{
fixed(byte *valueFixed = value.GetFixedBuffer())
{
PrepCharSize(value.Length + 2);
byte *start = valueFixed + value.Start;
Data.JavascriptUnescape(start, start + value.Length);
}
}
/// <summary>
/// 根据域名获取主域名
/// </summary>
/// <param name="domain">域名</param>
/// <returns>主域名</returns>
internal unsafe static SubArray <byte> GetMainDomain(SubArray <byte> domain)
{
fixed(byte *domainFixed = domain.GetFixedBuffer())
{
byte *domainStart = domainFixed + domain.Start;
return(new DomainParser {
data = domain.Array, dataFixed = domainFixed, dataEnd = domainStart + domain.Length
}.GetMainDomain(domainStart));
}
}
/// <summary>
/// 根据URL地址获取主域名
/// </summary>
/// <param name="url">URL地址</param>
/// <returns>主域名</returns>
internal unsafe static SubArray <byte> GetMainDomainByUrl(SubArray <byte> url)
{
fixed(byte *urlFixed = url.GetFixedBuffer())
{
byte *urlStart = urlFixed + url.Start;
return(new DomainParser {
data = url.Array, dataFixed = urlFixed, dataEnd = urlStart + url.Length
}.GetMainDomainByUrl(urlStart));
}
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
UnmanagedStream stream = serializer.Stream;
int valueLength = Data.Length;
byte * data = stream.GetBeforeMove((valueLength + (sizeof(int) + 3)) & (int.MaxValue - 3));
*(int *)data = valueLength;
fixed(byte *dataFixed = Data.GetFixedBuffer()) AutoCSer.Memory.Common.CopyNotNull(dataFixed + Data.Start, data += sizeof(int), valueLength);
Reader.Next();
}
/// <summary>
/// 服务端数据结构定义数据
/// </summary>
/// <param name="buffer">数据缓冲区</param>
internal unsafe DataStructureBuffer(Buffer buffer)
{
Data = buffer.Array;
fixed(byte *dataFixed = Data.GetFixedBuffer())
{
byte *start = dataFixed + Data.Start, read = start + (OperationParameter.Serializer.HeaderSize + IndexIdentity.SerializeSize);
Identity = new IndexIdentity(start + OperationParameter.Serializer.HeaderSize);
CacheName = AutoCSer.BinaryDeSerializer.DeSerializeString(ref read, start + *(int *)start);
Data.MoveStart((int)(read - start));
}
}
internal int SearchLower(ref SubArray <byte> data)
{
if (data.Length != 0)
{
fixed(byte *dataFixed = data.GetFixedBuffer())
{
byte *start = dataFixed + data.Start;
return(SearchLower(start, start + data.Length));
}
}
return(-1);
}
/// <summary>
/// 写入压缩数据
/// </summary>
/// <param name="compressionData"></param>
/// <param name="dataSize"></param>
private void writeCompression(ref SubArray <byte> compressionData, int dataSize)
{
int compressionDataSize = -compressionData.Length;
compressionData.MoveStart(-(sizeof(int) * 2));
fixed(byte *dataFixed = compressionData.GetFixedBuffer())
{
byte *write = dataFixed + compressionData.Start;
*(int *)write = compressionDataSize;
*(int *)(write + sizeof(int)) = dataSize;
}
fileStream.Write(compressionData.Array, compressionData.Start, compressionData.Length);
}
/// <summary>
/// 字节数组比较
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns>是否相等</returns>
public static bool equal(this SubArray <byte> left, ref SubArray <byte> right)
{
switch (left.ReferenceEqual(ref right))
{
case NullableBool.False: return(false);
case NullableBool.True: return(true);
default:
fixed(byte *leftFixed = left.GetFixedBuffer(), rightFixed = right.GetFixedBuffer())
{
return(EqualNotNull(leftFixed + left.Start, rightFixed + right.Start, left.Length));
}
}
}
/// <summary>
/// 替换数据
/// </summary>
/// <param name="array">数组数据</param>
/// <param name="value">新值</param>
/// <param name="isValue">数据匹配器</param>
public static SubArray <ulong> replaceFirst(this SubArray <ulong> array, ulong value, Func <ulong, bool> isValue)
{
if (array.Length != 0)
{
fixed(ulong *valueFixed = array.GetFixedBuffer())
{
ulong *valueIndex = FixedArray.IndexOf(valueFixed + array.Start, array.Length, isValue);
if (valueIndex != null)
{
*valueIndex = value;
}
}
}
return(array);
}
/// <summary>
/// 获取第一个匹配值
/// </summary>
/// <param name="array">数组数据</param>
/// <param name="isValue">数据匹配器</param>
/// <param name="index">起始位置</param>
/// <returns>第一个匹配值,失败为default(ulong)</returns>
public static ulong firstOrDefault(this SubArray <ulong> array, Func <ulong, bool> isValue, int index)
{
if ((uint)index < (uint)array.Length)
{
fixed(ulong *valueFixed = array.GetFixedBuffer())
{
ulong *valueIndex = FixedArray.IndexOf(valueFixed + array.Start + index, array.Length - index, isValue);
if (valueIndex != null)
{
return(*valueIndex);
}
}
}
return(default(ulong));
}
/// <summary>
/// 获取匹配数据位置
/// </summary>
/// <param name="array">数据数组</param>
/// <param name="isValue">数据匹配器</param>
/// <returns>匹配位置,失败为-1</returns>
public static int indexOf(this SubArray <ulong> array, Func <ulong, bool> isValue)
{
if (array.Length != 0)
{
fixed(ulong *valueFixed = array.GetFixedBuffer())
{
ulong *start = valueFixed + array.Start, index = FixedArray.IndexOf(start, array.Length, isValue);
if (index != null)
{
return((int)(index - valueFixed));
}
}
}
return(-1);
}
/// <summary>
/// 写入压缩数据
/// </summary>
/// <param name="compressionData"></param>
/// <param name="bufferStart"></param>
private void writeCompression(ref SubArray <byte> compressionData, byte *bufferStart)
{
int compressionDataSize = -compressionData.Length;
compressionData.MoveStart(-(PacketHeaderSize + sizeof(int)));
fixed(byte *dataFixed = compressionData.GetFixedBuffer())
{
byte *write = dataFixed + compressionData.Start;
*(int *)write = compressionDataSize;
*(ulong *)(write + sizeof(int)) = *(ulong *)bufferStart;
}
dataFileStream.Write(compressionData.Array, compressionData.Start, compressionData.Length);
dataFileLength += compressionData.Length;
setIndex();
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="queryData">查询数据</param>
/// <returns>返回参数</returns>
internal ValueData.Data Query(ref SubArray <byte> queryData)
{
queryBuffer.Set(ref queryData);
fixed(byte *dataFixed = queryData.GetFixedBuffer())
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, queryBuffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
dataStructure.Node.Query(ref parser);
return(parser.ReturnParameter);
}
}
return(new ValueData.Data(ReturnType.DataStructureIdentityError));
}
/// <summary>
/// linuxSLL数据包
/// </summary>
/// <param name="data">数据</param>
public unsafe LinuxSLL(ref SubArray <byte> data)
{
if (data.Length >= HeaderSize)
{
fixed(byte *dataFixed = data.GetFixedBuffer())
{
byte *start = dataFixed + data.StartIndex;
if (data.Length >= ((uint)*(start + 4) << 8) + *(start + 5) + 6)
{
this.data = data;
return;
}
}
}
this.data = new SubArray <byte>();
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public unsafe bool Equals(FileCacheKey other)
{
if (path.Array == null)
{
return(other.path.Array == null);
}
if (other.path.Array != null && ((HashCode ^ other.HashCode) | (pathIdentity ^ other.pathIdentity) | (path.Length ^ other.path.Length)) == 0)
{
if (path.Array == other.path.Array && path.Start == other.path.Start)
return(true);
fixed(byte *dataFixed = path.GetFixedBuffer(), otherDataFixed = other.path.GetFixedBuffer())
{
return(AutoCSer.Memory.Common.EqualNotNull(dataFixed + path.Start, otherDataFixed + other.path.Start, path.Length));
}
}
return(false);
}
/// <summary>
/// 以太网会话点到点协议数据包
/// </summary>
/// <param name="data">数据</param>
public unsafe EthernetSessionP2P(ref SubArray <byte> data)
{
if (data.Length >= HeaderSize)
{
fixed(byte *dataFixed = data.GetFixedBuffer())
{
byte *start = dataFixed + data.StartIndex;
uint packetSize = ((uint)*(start + 4) << 8) + *(start + 5);
if (data.Length >= packetSize)
{
this.data = data;
return;
}
}
}
this.data = new SubArray <byte>();
}
