/// <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; if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= outputInfo.MaxDataSize) { int streamLength = stream.ByteSize; OutputLink nextBuild = LinkNext; stream.PrepLength(sizeof(uint) + sizeof(int) * 2); stream.ByteSize += sizeof(uint) + sizeof(int); if ((Server.GetCommandFlags(ref CommandIndex) & CommandFlags.JsonSerialize) == 0) { sender.Serialize(outputInfo, ref outputParameter); } else { sender.JsonSerialize(ref outputParameter); } int dataLength = stream.ByteSize - streamLength - (sizeof(uint) + sizeof(int)); byte *dataFixed = stream.Data.Byte + streamLength; *(uint *)dataFixed = CommandIndex; *(int *)(dataFixed + sizeof(uint)) = dataLength; outputInfo.CheckMaxDataSize(Math.Max(dataLength + (sizeof(uint) + sizeof(int)), stream.LastPrepSize - streamLength)); ++buildInfo.Count; LinkNext = null; outputParameter = default(outputParameterType); AutoCSer.Threading.RingPool <Output <outputParameterType> > .Default.PushNotNull(this); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
///// <summary> ///// 保持回调序号 ///// </summary> //protected int keepCallbackIdentity; ///// <summary> ///// 保持回调 ///// </summary> //internal bool SetKeepCallback() //{ // int index = (int)(CommandIndex & Server.CommandIndexAnd); // try // { // KeepCallback = new KeepCallback(this, ++keepCallbackIdentity); // return true; // } // catch (Exception error) // { // Socket.Log.add(LogLevel.Error, error); // } // Socket.FreeIndex(index); // return false; //} /// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>下一个命令</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) + sizeof(uint)) { CommandBase nextBuild = LinkNext; int commandIndex = Socket.CommandPool.Push(this); if (commandIndex != 0) { if (KeepCallback.SetCommandIndex(commandIndex)) { stream.Data.Write(CommandInfo.Command, (uint)commandIndex | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData)); ++buildInfo.Count; LinkNext = null; return(nextBuild); } Socket.CommandPool.Cancel(commandIndex); } else { KeepCallback.BuildCancel(); } LinkNext = null; return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>下一个命令</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) + sizeof(uint)) { CommandBase nextBuild = LinkNext; int commandIndex = Socket.CommandPool.Push(this); if (commandIndex != 0) { byte *write = stream.CurrentData; *(int *)write = CommandInfo.Command; *(uint *)(write + sizeof(int)) = (uint)commandIndex | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData); ++buildInfo.Count; LinkNext = null; stream.ByteSize += sizeof(int) + sizeof(uint); return(nextBuild); } LinkNext = null; ReturnType = ReturnType.ClientBuildError; setTask(); 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> /// 创建命令输入数据 /// </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.ByteSize) >= prepLength || (stream.FreeSize >= prepLength && prepLength > buildInfo.SendBufferSize - TcpServer.ClientCommand.Command.StreamStartIndex)) { CommandBase nextBuild = LinkNext; stream.PrepLength(prepLength); byte *write = stream.CurrentData; *(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.Array) Memory.CopyNotNull(dataFixed + data.Start, write + (sizeof(uint) + sizeof(int) * 2), data.Length); } stream.ByteSize += 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="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= CommandInfo.MaxDataSize) { int streamLength = stream.ByteSize; stream.PrepLength(sizeof(uint) + sizeof(int) * 3); CommandBase nextBuild = LinkNext; stream.ByteSize += sizeof(uint) + sizeof(int) * 2; if ((CommandInfo.CommandFlags & CommandFlags.JsonSerialize) == 0) { Socket.Serialize(CommandInfo, ref InputParameter); } else { Socket.JsonSerialize(ref InputParameter); } int dataLength = stream.ByteSize - streamLength - (sizeof(int) * 2 + sizeof(uint)); InputParameter = default(inputParameterType); if (dataLength <= Socket.MaxInputSize) { int commandIndex = Socket.CommandPool.Push(this); if (commandIndex != 0) { if (KeepCallback.SetCommandIndex(commandIndex)) { byte *write = stream.Data.Byte + streamLength; buildInfo.IsVerifyMethod |= CommandInfo.IsVerifyMethod; ++buildInfo.Count; *(int *)write = CommandInfo.Command; *(uint *)(write + sizeof(int)) = (uint)commandIndex | (uint)CommandInfo.CommandFlags; *(int *)(write + (sizeof(uint) + sizeof(int))) = dataLength; CommandInfo.CheckMaxDataSize(Math.Max(dataLength + (sizeof(int) * 2 + sizeof(uint)), stream.LastPrepSize - streamLength)); LinkNext = null; return(nextBuild); } Socket.CommandPool.Cancel(commandIndex); } else { KeepCallback.BuildCancel(); } } else { KeepCallback.BuildCancel(); } stream.ByteSize = streamLength; LinkNext = null; return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>下一个命令</returns> internal unsafe override TcpServer.ClientCommand.CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int)) { *(int *)stream.CurrentData = CommandInfo.Command | (int)(uint)(CommandInfo.CommandFlags | CommandFlags.NullData); stream.ByteSize += sizeof(int); return(LinkNext); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override TcpServer.ClientCommand.CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if (stream.ByteSize == 0 && LinkNext == null) { *(int *)stream.CurrentData = Server.CheckCommandIndex | (int)(uint)TcpServer.CommandFlags.NullData; stream.ByteSize += sizeof(int); } Interlocked.Exchange(ref FreeLock, 1); IsBuildError = true; Socket = null; return(LinkNext); }
/// <summary> /// 创建输出信息 /// </summary> /// <param name="sender">TCP 服务套接字数据发送</param> /// <param name="buildInfo">输出创建参数</param> internal unsafe override OutputLink Build(ServerSocketSenderBase sender, ref SenderBuildInfo buildInfo) { UnmanagedStream stream = sender.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(uint)) { OutputLink nextBuild = LinkNext; stream.Data.Write(CommandIndex); LinkNext = null; ++buildInfo.Count; AutoCSer.Threading.RingPool <ReturnTypeOutput> .Default.PushNotNull(this); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { CommandBase nextBuild = LinkNext; if (buildInfo.Count == 0 && nextBuild == null) { UnmanagedStream stream = Socket.OutputSerializer.Stream; buildInfo.Count = 1; stream.Data.Write(Server.CheckCommandIndex, (uint)CommandFlags.NullData); Socket = null; AutoCSer.Threading.RingPool <CheckCommand> .Default.PushNotNull(this); } else { LinkNext = null; } return(nextBuild); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= CommandInfo.MaxDataSize) { int streamLength = stream.Data.CurrentIndex; stream.PrepSize(sizeof(uint) + sizeof(int) * 3); CommandBase nextBuild = LinkNext; stream.Data.CurrentIndex += sizeof(uint) + sizeof(int) * 2; if ((CommandInfo.CommandFlags & CommandFlags.JsonSerialize) == 0) { Socket.Serialize(CommandInfo, ref InputParameter); } else { Socket.JsonSerialize(ref InputParameter); } int dataLength = stream.Data.CurrentIndex - streamLength - (sizeof(int) * 2 + sizeof(uint)); if (dataLength <= Socket.MaxInputSize) { int commandIndex = Socket.CommandPool.Push(this); if (commandIndex != 0) { byte *write = stream.Data.Byte + streamLength; buildInfo.IsVerifyMethod |= CommandInfo.IsVerifyMethod; ++buildInfo.Count; *(int *)write = CommandInfo.Command; *(uint *)(write + sizeof(int)) = (uint)commandIndex | (uint)CommandInfo.CommandFlags; *(int *)(write + (sizeof(uint) + sizeof(int))) = dataLength; CommandInfo.CheckMaxDataSize(Math.Max(dataLength + (sizeof(int) * 2 + sizeof(uint)), stream.LastPrepSize - streamLength)); LinkNext = null; return(nextBuild); } } stream.Data.CurrentIndex = streamLength; LinkNext = null; ReturnType = ReturnType.ClientBuildError; setTask(); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override TcpServer.ClientCommand.CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; int streamLength = stream.ByteSize; if (streamLength == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= CommandInfo.MaxDataSize) { stream.PrepLength(sizeof(int) * 3); stream.ByteSize += sizeof(int) * 2; if ((CommandInfo.CommandFlags & CommandFlags.JsonSerialize) == 0) { Socket.Serialize(CommandInfo, ref InputParameter); } else { Socket.JsonSerialize(ref InputParameter); } int dataLength = stream.ByteSize - streamLength - sizeof(int) * 2; if (dataLength <= Socket.MaxInputSize) { ulong markData = Socket.Sender.SendMarkData; byte *write = stream.Data.Byte + streamLength; buildInfo.IsVerifyMethod |= CommandInfo.IsVerifyMethod; *(int *)write = CommandInfo.Command | (int)(uint)CommandInfo.CommandFlags; *(int *)(write + sizeof(int)) = dataLength; if (markData != 0) { TcpServer.CommandBase.Mark(write + sizeof(int) * 2, markData, dataLength); } CommandInfo.CheckMaxDataSize(Math.Max(dataLength + sizeof(int) * 2, stream.LastPrepSize - streamLength)); } else { stream.ByteSize = streamLength; OutputParameter.Type = ReturnType.ClientBuildError; IsBuildError = true; setTask(); } return(LinkNext); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) + sizeof(uint)) { CommandBase nextBuild = LinkNext; stream.Data.Write(CommandInfo.Command, (uint)(CommandInfo.CommandFlags | CommandFlags.NullData)); ++buildInfo.Count; Socket = null; LinkNext = null; AutoCSer.Threading.RingPool <SendOnlyCommand> .Default.PushNotNull(this); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) * 3) { CommandBase nextBuild = LinkNext; stream.Data.Write(Server.CancelKeepCommandIndex, cancelCommandIndex, 0); ++buildInfo.Count; Socket = null; LinkNext = null; AutoCSer.Threading.RingPool <CancelKeepCommand> .Default.PushNotNull(this); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { CommandBase nextBuild = LinkNext; if (buildInfo.Count == 0 && nextBuild == null) { UnmanagedStream stream = Socket.OutputSerializer.Stream; buildInfo.Count = 1; byte *write = stream.CurrentData; Socket = null; *(int *)write = Server.CheckCommandIndex; //*(uint*)(write + sizeof(int)) |= (uint)(CommandFlags.NullData | CommandFlags.NullIndex); *(uint *)(write + sizeof(int)) |= (uint)CommandFlags.NullData; stream.ByteSize += sizeof(int) + sizeof(uint); AutoCSer.Threading.RingPool <CheckCommand> .Default.PushNotNull(this); } else { LinkNext = null; } return(nextBuild); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) + sizeof(uint)) { byte * write = stream.CurrentData; CommandBase nextBuild = LinkNext; *(int *)write = CommandInfo.Command; //*(uint*)(write + sizeof(int)) = (CommandIndex & Server.CommandIndexAnd) | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData); *(uint *)(write + sizeof(int)) = (uint)(CommandInfo.CommandFlags | CommandFlags.NullData); ++buildInfo.Count; stream.ByteSize += sizeof(int) + sizeof(uint); Socket = null; LinkNext = null; AutoCSer.Threading.RingPool <SendOnlyCommand> .Default.PushNotNull(this); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>下一个命令</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) + sizeof(uint)) { CommandBase nextBuild = LinkNext; int commandIndex = Socket.CommandPool.Push(this); if (commandIndex != 0) { stream.Data.Write(CommandInfo.Command, (uint)commandIndex | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData)); ++buildInfo.Count; LinkNext = null; return(nextBuild); } LinkNext = null; OutputParameter.Type = ReturnType.ClientBuildError; setTask(); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>是否成功</returns> internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo) { UnmanagedStream stream = Socket.OutputSerializer.Stream; if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) * 3) { CommandBase nextBuild = LinkNext; byte * write = stream.CurrentData; *(int *)write = Server.CancelKeepCommandIndex; *(int *)(write + sizeof(int)) = cancelCommandIndex; *(int *)(write + (sizeof(uint) + sizeof(int))) = 0; stream.ByteSize += sizeof(int) * 3; ++buildInfo.Count; Socket = null; LinkNext = null; AutoCSer.Threading.RingPool <CancelKeepCommand> .Default.PushNotNull(this); return(nextBuild); } buildInfo.isFullSend = 1; return(this); }
/// <summary> /// 创建命令输入数据 /// </summary> /// <param name="buildInfo">TCP 客户端创建命令参数</param> /// <returns>下一个命令</returns> internal virtual CommandBase Build(ref SenderBuildInfo buildInfo) { throw new InvalidOperationException(); }
/// <summary> /// 创建输出信息 /// </summary> /// <param name="sender">TCP 服务套接字数据发送</param> /// <param name="buildInfo">输出创建参数</param> internal abstract outputLinkType Build(ServerSocketSenderBase sender, ref SenderBuildInfo buildInfo);