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