void DecompressBuffer(ref byte[] buffer, ref int length) { var source = _bufferPool.AcquireBuffer(); var incompleteLength = _incompleteDecompressionPacket.Length; var sourceLength = incompleteLength + length; if (incompleteLength > 0) { _incompleteDecompressionPacket.Prepend(source, 0); _incompleteDecompressionPacket.Clear(); } Buffer.BlockCopy(buffer, 0, source, incompleteLength, length); int outSize; var processedOffset = 0; var sourceOffset = 0; var offset = 0; while (_decompression.DecompressChunk(ref source, ref sourceOffset, sourceLength, ref buffer, offset, out outSize)) { processedOffset = sourceOffset; offset += outSize; } length = offset; // We've run out of data to parse, or the packet was incomplete. If the packet was incomplete, we should save what's left for the next socket receive event. if (processedOffset >= sourceLength) { _bufferPool.ReleaseBuffer(source); return; } _incompleteDecompressionPacket.Write(source, processedOffset, sourceLength - processedOffset); }
/// <summary> /// /// </summary> /// <param name="byteBuffer"></param> internal static void ReleaseBuffer(byte[] byteBuffer) { Debug.Assert(byteBuffer != null, "SendQueue.ReleaseBuffer(...) - byteBuffer == null error!"); if (byteBuffer.Length == s_CoalesceBufferSize) // 可能修改过m_CoalesceBufferSize如果不同就抛弃它 { s_UnusedBuffers.ReleaseBuffer(byteBuffer); } }
public void ReleaseBufferTest() { string strBufferName = string.Empty; // TODO: 初始化为适当的值 long iInitialCapacity = 0; // TODO: 初始化为适当的值 long iBufferSize = 0; // TODO: 初始化为适当的值 BufferPool target = new BufferPool( strBufferName, iInitialCapacity, iBufferSize ); // TODO: 初始化为适当的值 byte[] byteBuffer = null; // TODO: 初始化为适当的值 target.ReleaseBuffer( byteBuffer ); Assert.Inconclusive( "无法验证不返回值的方法。" ); }
public void ReleaseBufferTest() { string strBufferName = string.Empty; // TODO: 初始化为适当的值 long iInitialCapacity = 0; // TODO: 初始化为适当的值 long iBufferSize = 0; // TODO: 初始化为适当的值 BufferPool target = new BufferPool(strBufferName, iInitialCapacity, iBufferSize); // TODO: 初始化为适当的值 byte[] byteBuffer = null; // TODO: 初始化为适当的值 target.ReleaseBuffer(byteBuffer); Assert.Inconclusive("无法验证不返回值的方法。"); }
/// <summary> /// /// </summary> /// <param name="byteBuffer"></param> internal static void ReleaseBuffer(byte[] byteBuffer) { if (byteBuffer == null) { throw new ArgumentNullException("byteBuffer", "SendQueue.ReleaseBuffer(...) - byteBuffer == null error!"); } if (byteBuffer.Length >= s_BufferSizeMTU) // 可能修改过m_CoalesceBufferSize如果不同就抛弃它 { s_UnusedBuffers.ReleaseBuffer(byteBuffer); } }
private void ResetBuffers() { if (this.buffers.Count > 1) { List <BufferWrapper> bufferWrappers = new List <BufferWrapper>(this.buffers); this.buffers.RemoveRange(1, this.buffers.Count - 1); for (int i = 1; i < bufferWrappers.Count; i++) { this.totalBufferSize -= (int)bufferWrappers[i].Buffer.Length; } for (int j = 1; j < bufferWrappers.Count; j++) { BufferPool.ReleaseBuffer(bufferWrappers[j]); } } }
private void Free() { if (mCompiledBuffer == null) { return; } if ((mState & EPacketState.Buffered) != 0) { mBuffers.ReleaseBuffer(mCompiledBuffer); } mState &= ~(EPacketState.Static | EPacketState.Acquired | EPacketState.Buffered); mCompiledBuffer = null; }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="eventArgs"></param> private void ReceiveFromZoneClusterServer(object sender, ProcessMessageBlockAtClientEventArgs eventArgs) { if (m_NetState == null) { Debug.WriteLine("ZoneExtendData.SocketClient_ProcessReceive(...) - m_NetState == null error!"); return; } // 获取空数据 byte[] l_PacketBuffer = s_ProcessorBuffers.AcquireBuffer(); { Marshal.Copy(eventArgs.MessageBlock.ReadPointer(), l_PacketBuffer, 0, eventArgs.MessageBlock.Length); m_NetState.Send(new BufferPacket(l_PacketBuffer, 0, eventArgs.MessageBlock.Length)); } s_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); // 返回内存池 }
protected override void Dispose(bool disposing) { if (disposing && this.innerStream != null) { if (this.ownStream) { this.innerStream.Close(); } this.innerStream = null; } if (!Environment.HasShutdownStarted) { foreach (BufferWrapper buffer in this.buffers) { BufferPool.ReleaseBuffer(buffer); } this.buffers.Clear(); } base.Dispose(disposing); }
private void Commit(Chunk chunk, int slot) { if (slot < 0 || slot >= active.Length) { throw new ArgumentOutOfRangeException("slot"); } lock (syncRoot) { if (active[slot] != chunk) { throw new ArgumentException(); } bufferPool.ReleaseBuffer(chunk.Buffer); if (pending.Count > 0) { Page page = pending.Dequeue(); active[slot] = new Chunk(this, slot, page.buffer, 0, page.length); callback(active[slot]); } else { active[slot] = null; } --activeCount; if (activeCount == 0) { idle.Set(); } } }
public bool OnReceive(NetState ns) { ByteQueue buffer = ns.Buffer; if (buffer == null || buffer.Length <= 0) { return(true); } lock (buffer) { int length = buffer.Length; while (length > 0) { int packetID = buffer.GetPacketID(); PacketHandler handler = ns.GetHandler(packetID); if (handler == null) { byte[] data = new byte[length]; length = buffer.Dequeue(data, 0, length); new PacketReader(data, length, false).Trace(ns); break; } int packetLength = handler.Length; if (packetLength <= 0) { if (length >= 3) { packetLength = buffer.GetPacketLength(); if (packetLength < 3) { ns.Dispose(); break; } } else { break; } } if (length < packetLength) { break; } byte[] packetBuffer = BufferSize >= packetLength?_buffers.AcquireBuffer() : new byte[packetLength]; packetLength = buffer.Dequeue(packetBuffer, 0, packetLength); PacketReader r = new PacketReader(packetBuffer, packetLength, handler.Length != 0); handler.OnReceive(ns, r); length = buffer.Length; if (BufferSize >= packetLength) { _buffers.ReleaseBuffer(packetBuffer); } } } return(true); }
/// <summary> /// /// </summary> /// <param name="netState"></param> internal static void MessagePump_ProcessReceive(object sender, NetStateEventArgs eventArgs) { LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...){0}", Thread.CurrentThread.Name); if (eventArgs.NetState == null) { Debug.WriteLine("ProcessNet.EventDelegateProcessReceive(...) - netState == null error!"); return; } ReceiveQueue l_ReceiveQueueBuffer = eventArgs.NetState.ReceiveBuffer; if (l_ReceiveQueueBuffer == null) { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - byteQueueBuffer == null error!"); return; } LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...)-Length={0},{1}", l_ReceiveQueueBuffer.Length, Thread.CurrentThread.Name); if (l_ReceiveQueueBuffer.Length < PACKAGE_HEAD) { // 等待数据包的完整 return; } long l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length; // 隔段时间就会有数据过来,所以可以不用锁定的,锁定了也没用,很难保证多线程中处理了所有的数据 while (l_iReceiveBufferLength >= PACKAGE_HEAD) { // ReceiveQueue内部已经有锁定 long l_iPacketSize = l_ReceiveQueueBuffer.GetPacketLength(); if (l_iPacketSize < PACKAGE_HEAD) { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iPacketSize <= 0 error!"); eventArgs.NetState.Dispose(); // 断开 return; } if (l_iReceiveBufferLength < l_iPacketSize) { // 等待数据包的完整 break; } if (l_iPacketSize > BUFFER_SIZE) // 数据包过大 { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iPacketSize > BUFFER_SIZE error!"); eventArgs.NetState.Dispose(); // 断开 return; } // 获取空数据 byte[] l_PacketBuffer = m_ProcessorBuffers.AcquireBuffer(); // ReceiveQueue内部已经有锁定 long l_iReturnPacketSize = l_ReceiveQueueBuffer.Dequeue(ref l_PacketBuffer, 0, l_iPacketSize); // 获取的数据不相同 if (l_iReturnPacketSize != l_iPacketSize) { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iReturnPacketSize != iPacketSize error!"); // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); eventArgs.NetState.Dispose(); // 断开 return; } ////////////////////////////////////////////////////////////////////////// using (StreamWriter streamWriter = new StreamWriter("PreIn_Packets.log", true)) { byte[] byteBuffer = l_PacketBuffer; if (byteBuffer.Length > 0) { streamWriter.WriteLine("客户端: {0} 未经解密过的信息包 长度 = 0x{1:X4} ID = Unknown", eventArgs.NetState, l_iPacketSize); streamWriter.WriteLine("--------------------------------------------------------------------------"); } using (MemoryStream memoryStream = new MemoryStream(byteBuffer)) Utility.FormatBuffer(streamWriter, memoryStream, l_iPacketSize); streamWriter.WriteLine(); streamWriter.WriteLine(); } ////////////////////////////////////////////////////////////////////////// try { // 解密数据包 ROSECrypt.CryptPacket(ref l_PacketBuffer, eventArgs.NetState.EncoderSeed); } catch { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - ROSECrypt.CryptPacket(...) Exception error!"); // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 读取的数据包 PacketReader l_PacketReader = new PacketReader(l_PacketBuffer, l_iPacketSize, PACKAGE_HEAD /*包的长度大小-2个字节、ID大小-2个字节、未用数据大小-2个字节, 6个字节跳过*/); ////////////////////////////////////////////////////////////////////////// using (StreamWriter streamWriter = new StreamWriter("In_Packets.log", true)) { byte[] byteBuffer = l_PacketBuffer; if (byteBuffer.Length > 0) { streamWriter.WriteLine("客户端: {0} 经解密过的信息包 长度 = 0x{1:X4} ID = 0x{2:X4}", eventArgs.NetState, l_iPacketSize, l_PacketReader.GetPacketID()); streamWriter.WriteLine("--------------------------------------------------------------------------"); } using (MemoryStream memoryStream = new MemoryStream(byteBuffer)) Utility.FormatBuffer(streamWriter, memoryStream, l_iPacketSize); streamWriter.WriteLine(); streamWriter.WriteLine(); } ////////////////////////////////////////////////////////////////////////// // 获取数据包命令的ID long l_iPacketID = l_PacketReader.GetPacketID(); LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...)-Packet ID = 0x{0:X4}", l_iPacketID); // 获取处理数据包的实例 PacketHandler l_PacketHandler = PacketHandlers.GetHandler(l_iPacketID); if (l_PacketHandler == null) // 说明还没有解开当前的数据包内容 { l_PacketReader.Trace(eventArgs.NetState); // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); // 获取剩下的数据长度 l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length; continue; } // 当前需处理的数据包的大小 long l_iPacketHandlerLength = l_PacketHandler.Length; if (l_iPacketHandlerLength > l_iReturnPacketSize) // 包需求的数据大小大于得到的数据大小 { // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); eventArgs.NetState.Dispose(); // 断开 return; } PacketProfile l_PacketProfile = PacketProfile.GetIncomingProfile(l_iPacketID); DateTime dateTimeStart = (l_PacketProfile == null ? DateTime.MinValue : DateTime.Now); { l_PacketHandler.OnReceive(eventArgs.NetState, l_PacketReader); } if (l_PacketProfile != null) { l_PacketProfile.Record(l_iPacketHandlerLength, DateTime.Now - dateTimeStart); } // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); // 获取剩下的数据长度 l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length; } }
/// <summary> /// /// </summary> /// <param name="netState"></param> internal void ListenerProcessReceive(object sender, NetStateEventArgs eventArgs) { if (eventArgs.NetState == null) { throw new Exception("Domain.ListenerProcessReceive(...) - netState == null error!"); } if (eventArgs.NetState.ReceiveBuffer == null) { throw new Exception("Domain.ListenerProcessReceive(...) - eventArgs.NetState.ReceiveBuffer == null error!"); } ReceiveQueue receiveQueueBuffer = eventArgs.NetState.ReceiveBuffer; if (receiveQueueBuffer.Length < PACKAGE_HEAD) { // 等待数据包的完整 return; } long iReceiveBufferLength = receiveQueueBuffer.Length; // 隔段时间就会有数据过来,所以可以不用锁定的,锁定了也没用,很难保证多线程中处理了所有的数据 while (iReceiveBufferLength >= PACKAGE_HEAD) { // ReceiveQueue内部已经有锁定 long iPacketSize = receiveQueueBuffer.GetPacketLength(); if (iPacketSize < PACKAGE_HEAD) { LOGs.WriteLine(LogMessageType.MSG_ERROR, "Domain.ListenerProcessReceive(...) - iPacketSize < PACKAGE_HEAD error!"); eventArgs.NetState.Dispose(); // 断开 return; } if (iReceiveBufferLength < iPacketSize) { // 等待数据包的完整 break; } if (iPacketSize > BUFFER_SIZE) // 数据包过大 { LOGs.WriteLine(LogMessageType.MSG_ERROR, "Domain.ListenerProcessReceive(...) - iPacketSize > BUFFER_SIZE error!"); eventArgs.NetState.Dispose(); // 断开 return; } // 获取空数据 byte[] packetBuffer = m_ProcessorBuffers.AcquireBuffer(); // ReceiveQueue内部已经有锁定 long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, 0, iPacketSize); // 获取的数据不相同 if (iReturnPacketSize != iPacketSize) { LOGs.WriteLine(LogMessageType.MSG_ERROR, "Domain.ListenerProcessReceive(...) - iReturnPacketSize != iPacketSize error!"); // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 读取的数据包 PacketReader packetReader = new PacketReader(packetBuffer, iPacketSize, PACKAGE_HEAD /*包的长度大小-2个字节、ID大小-2个字节, 4个字节跳过*/, new EventHandler <PacketIdInfoEventArgs>(this.GetPacketID)); // 获取数据包命令的ID long iPacketID = packetReader.GetPacketID(); // 获取处理数据包的实例 PacketHandler packetHandler = DomainPacketHandlers.GetHandler(iPacketID); if (packetHandler == null) // 说明还没有解开当前的数据包内容 { packetReader.Trace(eventArgs.NetState); // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(packetBuffer); // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; continue; } // 当前需处理的数据包的大小 long iPacketHandlerLength = packetHandler.Length; if (iPacketHandlerLength > iReturnPacketSize) // 包需求的数据大小大于得到的数据大小 { // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 处理数据 packetHandler.OnReceive(eventArgs.NetState, packetReader); // 返回内存池 m_ProcessorBuffers.ReleaseBuffer(packetBuffer); // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; } }
public bool HandleReceive(NetState ns) { ByteQueue buffer = ns.Buffer; if (buffer == null || buffer.Length <= 0) { return(true); } CConsole.DebugLine("{0}: Incoming Data - {1} Bytes", ns, buffer.Length); /* * Packet Analyse/verify && Parsing */ lock ( buffer ) { int length = buffer.Length; // debug Data while (length > 0 && ns.Running) { short packetID = buffer.GetPacketID(); // debug log using (TextWriter writer = File.CreateText(AppDomain.CurrentDomain.BaseDirectory + @"\packet_" + DateTime.Now.UnixTimestamp() + ".log")) { using (MemoryStream ms = new MemoryStream(buffer.ByteBuffer)) Tools.FormatBuffer(writer, ms, (int)ms.Length); } CConsole.DebugLine("{0}: packetID {1}, {2} bytes", ns, packetID, length); PacketHandler handler = PacketHandlers.GetHandler(packetID); if (handler == null) { byte[] data = new byte[length]; length = buffer.Dequeue(data, 0, length); CConsole.ErrorLine("{0}: no Handler found! Data dispose", ns); break; } CConsole.StatusLine("{0}: Handler found ({1} bytes)! Trigger Callback...", ns, handler.Length); byte[] packetBuffer; if (mBufferSize >= handler.Length) { packetBuffer = mBuffers.AcquireBuffer(); } else { packetBuffer = new byte[handler.Length]; } buffer.Dequeue(packetBuffer, 0, handler.Length); PacketReader r = new PacketReader(packetBuffer, handler.Length, 0); handler.OnReceive(ns, r); length = buffer.Length; if (mBufferSize >= handler.Length) { mBuffers.ReleaseBuffer(packetBuffer); } } // end while()*/ } // end Lock() return(true); }
/// <summary> /// /// </summary> /// <param name="netState"></param> internal static void WorldProcessReceive(object sender, NetStateEventArgs eventArgs) { LOGs.WriteLine(LogMessageType.MSG_HACK, "World_ProcessReceive...... 0 = {0}", eventArgs.NetState.ReceiveBuffer.Length); if (eventArgs.NetState == null) { Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - eventArgs.NetState == null error!"); return; } ReceiveQueue receiveQueueBuffer = eventArgs.NetState.ReceiveBuffer; if (receiveQueueBuffer == null) { Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - receiveQueueBuffer == null error!"); return; } WorldExtendData extendData = eventArgs.NetState.GetComponent <WorldExtendData>(WorldExtendData.COMPONENT_ID); if (extendData == null) { Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - extendData == null error!"); return; } if (receiveQueueBuffer.Length < extendData.ProcessReceiveData.Remaining) { // 等待数据包的完整(Remaining 默认的大小为WORLD_HEAD_SIZE) return; } long iReceiveBufferLength = receiveQueueBuffer.Length; // 隔段时间就会有数据过来,所以可以不用锁定的,锁定了也没用,很难保证多线程中处理了所有的数据(指 Length) while (iReceiveBufferLength >= extendData.ProcessReceiveData.Remaining) { if (extendData.ProcessReceiveData.PacketBuffer == null) // 如果空 代表是需要获取新的数据包和包头(Remaining == WORLD_HEAD_SIZE) { // 获取空数据 byte[] packetBuffer = s_ProcessorBuffers.AcquireBuffer(); // 获取数据包头的内容 long iReturnPacketHeadSize = receiveQueueBuffer.Dequeue(ref packetBuffer, 0, WORLD_HEAD_SIZE); // 获取的数据不相同 if (iReturnPacketHeadSize != WORLD_HEAD_SIZE) { Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - iReturnPacketHeadSize != WORLD_HEAD_SIZE error!"); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } IPacketEncoder packetEncoder = eventArgs.NetState.PacketEncoder as IPacketEncoder; if (packetEncoder == null) { Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - packetEncoder == null error!"); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 解密数据包头 long iClientPacketHeader = WORLD_HEAD_SIZE; packetEncoder.DecodeIncomingPacket(eventArgs.NetState, ref packetBuffer, ref iClientPacketHeader); // 给出数据信息头 WOWClientPacketHeader clientPacketHeader = WOWClientPacketHeader.GetClientPacketHeader(packetBuffer); int iRemaining = clientPacketHeader.PacketSize - 4; // -4 是代表剩余的数据包大小(为什么不是减6呢?) if (receiveQueueBuffer.Length < iRemaining) { // 等待数据包的完整 { extendData.ProcessReceiveData.PacketBuffer = packetBuffer; extendData.ProcessReceiveData.Remaining = (uint)iRemaining; return; } } // 获取信息包数据的剩余内容 long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, WORLD_HEAD_SIZE, iRemaining /*获取剩余数据包大小的字节数*/); // 获取的数据不相同 if (iReturnPacketSize != iRemaining) { Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - iReturnPacketSize != iRemaining error!"); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 获取包的全部长度 long iPacketFullLength = iRemaining + WORLD_HEAD_SIZE; // 读取的数据包 PacketReader packetReader = new PacketReader(packetBuffer, iPacketFullLength, WORLD_HEAD_SIZE /*包的ID大小-4个字节、长度大小-2个字节, 6个字节跳过*/); ////////////////////////////////////////////////////////////////////////// // 输出信息包的日志 ////////////////////////////////////////////////////////////////////////// ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID)); ////////////////////////////////////////////////////////////////////////// // 获取处理数据包的实例 PacketHandler packetHandler = ProcessServer.WorldPacketHandlers.GetHandler(clientPacketHeader.PacketID); if (packetHandler == null) // 说明还没有解开当前的数据包内容 { ////////////////////////////////////////////////////////////////////////// // 输出未知信息包的日志 ////////////////////////////////////////////////////////////////////////// ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Unknown_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID)); ////////////////////////////////////////////////////////////////////////// // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; continue; } // 当前需处理的数据包的大小 long iPacketHandlerLength = packetHandler.Length; if (iPacketHandlerLength > iPacketFullLength) // 包需求的数据大小大于得到的数据大小 { // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 处理数据 packetHandler.OnReceive(eventArgs.NetState, packetReader); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; } else //已有数据包头获取剩余数据 { byte[] packetBuffer = extendData.ProcessReceiveData.PacketBuffer; // 获取信息包数据的剩余内容 long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, WORLD_HEAD_SIZE, extendData.ProcessReceiveData.Remaining /*获取剩余数据包大小的字节数*/); // 获取的数据不相同 if (iReturnPacketSize != extendData.ProcessReceiveData.Remaining) { Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - iReturnPacketSize != Remaining error!"); // 恢复原始数据状态 extendData.ProcessReceiveData.PacketBuffer = null; extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE; // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 获取包的全部长度 long iPacketFullLength = extendData.ProcessReceiveData.Remaining + WORLD_HEAD_SIZE; // 读取的数据包 PacketReader packetReader = new PacketReader(extendData.ProcessReceiveData.PacketBuffer, iPacketFullLength, WORLD_HEAD_SIZE /*包的ID大小-4个字节、长度大小-2个字节, 6个字节跳过*/); // 给出数据信息头 WOWClientPacketHeader clientPacketHeader = WOWClientPacketHeader.GetClientPacketHeader(extendData.ProcessReceiveData.PacketBuffer); ////////////////////////////////////////////////////////////////////////// // 输出信息包的日志 ////////////////////////////////////////////////////////////////////////// ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID)); ////////////////////////////////////////////////////////////////////////// // 获取处理数据包的实例 PacketHandler packetHandler = ProcessServer.WorldPacketHandlers.GetHandler(clientPacketHeader.PacketID); if (packetHandler == null) // 说明还没有解开当前的数据包内容 { ////////////////////////////////////////////////////////////////////////// // 输出未知信息包的日志 ////////////////////////////////////////////////////////////////////////// ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Unknown_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID)); ////////////////////////////////////////////////////////////////////////// // 恢复原始数据状态 extendData.ProcessReceiveData.PacketBuffer = null; extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE; // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; continue; } // 当前需处理的数据包的大小 long iPacketHandlerLength = packetHandler.Length; if (iPacketHandlerLength > iPacketFullLength) // 包需求的数据大小大于得到的数据大小 { // 恢复原始数据状态 extendData.ProcessReceiveData.PacketBuffer = null; extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE; // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 处理数据 packetHandler.OnReceive(eventArgs.NetState, packetReader); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(extendData.ProcessReceiveData.PacketBuffer); // 恢复原始数据状态 extendData.ProcessReceiveData.PacketBuffer = null; extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE; // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; } } }
private static IEnumerator <IAsyncResult> AsyncStreamCopyImpl(CrcStream source, CrcStream destination, long numBytes, int bufferSize, AsyncCrcStreamCopy.ComputeAndLogCrcMethod computeCrcMethodForCrcLogging, TimeSpan timeout, AsyncIteratorContext <long> context) { Exception exception; BufferWrapper buffer = null; BufferWrapper bufferWrapper = null; try { Duration startingNow = Duration.StartingNow; IAsyncResult asyncResult = null; IAsyncResult asyncResult1 = null; buffer = BufferPool.GetBuffer(bufferSize); bufferWrapper = BufferPool.GetBuffer(bufferSize); long num = (long)0; long?nullable = null; context.ResultData = (long)0; bool canTimeout = source.CanTimeout; bool flag = destination.CanTimeout; while (true) { int timeoutInMS = AsyncCrcStreamCopy.TimeSpanToTimeoutInMS(startingNow.Remaining(timeout)); if (timeoutInMS == 0) { throw new TimeoutException("The asynchronous stream copy timed out."); } if (canTimeout) { try { source.ReadTimeout = timeoutInMS; } catch (InvalidOperationException invalidOperationException) { canTimeout = false; } } if (flag) { try { destination.WriteTimeout = timeoutInMS; } catch (InvalidOperationException invalidOperationException1) { flag = false; } } if (numBytes > (long)0) { asyncResult = source.BeginRead(buffer.Buffer, 0, (int)Math.Min((long)((int)buffer.Buffer.Length), numBytes), context.GetResumeCallback(), context.GetResumeState("AsyncCrcStreamCopy.source.Read")); } exception = null; if (num > (long)0) { try { asyncResult1 = destination.BeginWrite(bufferWrapper.Buffer, 0, (int)num, nullable, context.GetResumeCallback(), context.GetResumeState("AsyncCrcStreamCopy.dest.Write")); } catch (Exception exception1) { exception = exception1; } if (exception == null) { yield return(asyncResult1); try { destination.EndWrite(asyncResult1); } catch (Exception exception2) { exception = exception2; } } } if (numBytes <= (long)0) { num = (long)0; } else { yield return(asyncResult); num = (long)source.EndRead(out nullable, asyncResult); } if (exception != null) { throw ExceptionCloner.AttemptClone(exception, RethrowableWrapperBehavior.NoWrap); } if (num < (long)0) { break; } numBytes -= num; AsyncIteratorContext <long> resultData = context; resultData.ResultData = resultData.ResultData + num; if (computeCrcMethodForCrcLogging != null) { computeCrcMethodForCrcLogging(buffer.Buffer, 0, (int)num, context.ResultData); } AsyncCrcStreamCopy.Swap <BufferWrapper>(ref buffer, ref bufferWrapper); if (num <= (long)0) { goto Label2; } } throw new TimeoutException("Reading from the stream resulted in a negative number of bytes read. This typically means an HttpWebRequest was aborted."); } finally { if (buffer != null) { BufferPool.ReleaseBuffer(buffer); } if (bufferWrapper != null) { BufferPool.ReleaseBuffer(bufferWrapper); } } Label2: yield break; throw new TimeoutException("The asynchronous stream copy timed out."); throw ExceptionCloner.AttemptClone(exception, RethrowableWrapperBehavior.NoWrap); }
/// <summary> /// /// </summary> /// <param name="netState"></param> internal static void RealmProcessReceive(object sender, NetStateEventArgs eventArgs) { LOGs.WriteLine(LogMessageType.MSG_HACK, "Realm_ProcessReceive......= {0}", eventArgs.NetState.ReceiveBuffer.Length); if (eventArgs.NetState == null) { Debug.WriteLine("ProcessNet.Realm_ProcessReceive(...) - eventArgs.NetState == null error!"); return; } ReceiveQueue receiveQueueBuffer = eventArgs.NetState.ReceiveBuffer; if (receiveQueueBuffer == null) { Debug.WriteLine("ProcessNet.Realm_ProcessReceive(...) - receiveQueueBuffer == null error!"); return; } if (receiveQueueBuffer.Length < REALM_HEAD_SIZE) { // 等待数据包的完整 return; } long iReceiveBufferLength = receiveQueueBuffer.Length; // 隔段时间就会有数据过来,所以可以不用锁定的,锁定了也没用,很难保证多线程中处理了所有的数据 while (iReceiveBufferLength >= REALM_HEAD_SIZE) { // 获取包的 ID long iPacketID = receiveQueueBuffer.GetPacketID(); // 获取包的 命令ID长度 long iPacketLength = receiveQueueBuffer.GetPacketLength(); // 获取包的全部长度 long iPacketFullLength = iPacketLength + REALM_HEAD_SIZE; // 等待数据包的完整 if (iReceiveBufferLength < iPacketFullLength) { break; } if (iPacketLength > BUFFER_SIZE) // 数据包过大 { Debug.WriteLine("ProcessNet.Realm_ProcessReceive(...) - iPacketLength > BUFFER_SIZE error!"); eventArgs.NetState.Dispose(); // 断开 return; } // 获取空数据 byte[] packetBuffer = s_ProcessorBuffers.AcquireBuffer(); // 获取数据内容 long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, 0, iPacketFullLength); // 获取的数据不相同 if (iReturnPacketSize != iPacketFullLength) { Debug.WriteLine("ProcessNet.Realm_ProcessReceive(...) - iReturnPacketSize != iPacketFullLength error!"); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } ////////////////////////////////////////////////////////////////////////// // 输出信息包的日志 ////////////////////////////////////////////////////////////////////////// ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "Realm_In_Packets.log", eventArgs.NetState.ToString(), iPacketID, RealmOpCodeName.GetRealmOpCodeName(iPacketID)); ////////////////////////////////////////////////////////////////////////// // 读取的数据包 PacketReader packetReader = new PacketReader(packetBuffer, iPacketFullLength, REALM_HEAD_SIZE /*包的ID大小-1个字节、长度大小-2个字节, 3个字节跳过*/); // 获取处理数据包的实例 PacketHandler packetHandler = ProcessServer.RealmPacketHandlers.GetHandler(iPacketID); if (packetHandler == null) // 说明还没有解开当前的数据包内容 { ////////////////////////////////////////////////////////////////////////// // 输出信息包的日志 ////////////////////////////////////////////////////////////////////////// ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "Realm_Unknown_Packets.log", eventArgs.NetState.ToString(), iPacketID, RealmOpCodeName.GetRealmOpCodeName(iPacketID)); ////////////////////////////////////////////////////////////////////////// // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; continue; } // 当前需处理的数据包的大小 long iPacketHandlerLength = packetHandler.Length; if (iPacketHandlerLength > iReturnPacketSize) // 包需求的数据大小大于得到的数据大小 { // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); eventArgs.NetState.Dispose(); // 断开 return; } // 处理数据 packetHandler.OnReceive(eventArgs.NetState, packetReader); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(packetBuffer); // 获取剩下的数据长度 iReceiveBufferLength = receiveQueueBuffer.Length; } }
/// <summary> /// /// </summary> /// <param name="netState"></param> internal static void Zone_ProcessReceive(object sender, NetStateEventArgs eventArgs) { LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...) {0}", Thread.CurrentThread.Name); if (eventArgs.NetState == null) { Debug.WriteLine("ProcessNet.EventDelegateProcessReceive(...) - netState == null error!"); return; } ZoneExtendData l_ExtendData = null; if (eventArgs.NetState.ExtendData == null) { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - eventArgs.NetState.ExtendData == null error!"); eventArgs.NetState.Dispose(false); return; } else { l_ExtendData = eventArgs.NetState.ExtendData as ZoneExtendData; if (l_ExtendData == null) { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - l_ExtendData == null error!"); eventArgs.NetState.Dispose(false); return; } } ReceiveQueue l_ReceiveQueueBuffer = eventArgs.NetState.ReceiveBuffer; if (l_ReceiveQueueBuffer == null) { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - byteQueueBuffer == null error!"); return; } LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...) Length = {0},{1}", l_ReceiveQueueBuffer.Length, Thread.CurrentThread.Name); long l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length; // 隔段时间就会有数据过来,所以可以不用锁定的,锁定了也没用,很难保证多线程中处理了所有的数据 while (l_iReceiveBufferLength > 0) { // 获取空数据 byte[] l_PacketBuffer = s_ProcessorBuffers.AcquireBuffer(); // ReceiveQueue内部已经有锁定 long l_iReturnPacketSize = l_ReceiveQueueBuffer.Dequeue(ref l_PacketBuffer, 0, l_iReceiveBufferLength); // 获取的数据不相同 if (l_iReturnPacketSize != l_iReceiveBufferLength) { Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iReturnPacketSize != iPacketSize error!"); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); eventArgs.NetState.Dispose(false); // 断开 return; } // 发送数据 l_ExtendData.SendToZoneClusterServer(l_PacketBuffer, l_iReturnPacketSize); // 返回内存池 s_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer); // 获取剩下的数据长度 l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length; } }
public static void OpCode(Decode state, Client ed) { try { LogConsole.Show(LogType.DEBUG, "OpCode()"); Systems sys = (Systems)state.Packet; sys.PacketInformation = state; ByteQueue queue = ed.queue; int length = queue.Length; LogConsole.Show(LogType.DEBUG, "OpCode() {0}", length); while ((length > 0)) { byte[] buffer; int packetID = queue.GetPacketID(); int packetLength = queue.GetPacketLength(); int packetControlCode = queue.GetPacketControlCode(); LogConsole.Show(LogType.DEBUG, "PacketControl: {0} PacketID: 0x{1:X2} Length: {2}", packetControlCode, packetID, packetLength); LogConsole.HexDump(state.buffer, "", 16); PacketHandler handler = PacketHandlers.GetHandler(packetID); if (handler == null) { byte[] buffer2 = new byte[length]; length = queue.Dequeue(buffer2, 0, length); LogConsole.Show(LogType.DEBUG, "Client: {0}: Unhandled packet 0x{1:X2}", new object[] { state, packetID }); break; } int size = handler.Length; if (length >= 4) { size = packetLength; if (packetLength >= 4) { if (length < size) { break; } if (0x400 >= size) { buffer = m_Buffers.AquireBuffer(); } else { buffer = new byte[size]; } size = queue.Dequeue(buffer, 0, size); ushort packetid = ByteQueue.GetPacketID(buffer); bool flag = IsCrypted(packetid); if (flag) { LogConsole.Show(LogType.DEBUG, "Crypted Packet 0x{0:X4}", new object[] { packetid }); } try { PacketReader2 pr = new PacketReader2(buffer, size); handler.OnReceive(ed, pr); } catch { break; } length = queue.Length; if ((0x400 >= size) && !flag) { m_Buffers.ReleaseBuffer(buffer); break; } } } length = 0; } } catch (Exception) { } }
public bool HandleReceive(ByteQueue ns) { ByteQueue buffer = ns; if (buffer == null || buffer.Length <= 0) { return(true); } lock (buffer) { int length = buffer.Length; if (!ns.Sender.Seeded) { if (buffer.GetPacketID() == 0xEF) { // new packet in client 6.0.5.0 replaces the traditional seed method with a seed packet // 0xEF = 239 = multicast IP, so this should never appear in a normal seed. So this is backwards compatible with older clients. ns.Sender.Seeded = true; } else if (buffer.Length >= 4) { buffer.Dequeue(m_Peek, 0, 4); int seed = (m_Peek[0] << 24) | (m_Peek[1] << 16) | (m_Peek[2] << 8) | m_Peek[3]; if (seed == 0) { Console.WriteLine("Login: {0}: Invalid client detected, disconnecting", ns); ns.Socket.Dispose(); return(false); } ns.Sender.Seed = seed; ns.Sender.Seeded = true; length = buffer.Length; } else { return(true); } } while (length > 0) { int packetID = buffer.GetPacketID(); PacketHandler handler = m_PacketsHander.GetHandler(packetID); if (handler == null) { return(false); } int packetLength = handler.Length; if (packetLength <= 0) { if (length >= 3) { packetLength = buffer.GetPacketLength(); if (packetLength < 3) { break; } } else { break; } } if (length >= packetLength) { byte[] packetBuffer; if (BufferSize >= packetLength) { packetBuffer = m_Buffers.AcquireBuffer(); } else { packetBuffer = new byte[packetLength]; } packetLength = buffer.Dequeue(packetBuffer, 0, packetLength); PacketReader r = new PacketReader(packetBuffer, packetLength, handler.Length != 0); handler.OnReceive(ns, r, ns.Socket); length = buffer.Length; if (BufferSize >= packetLength) { m_Buffers.ReleaseBuffer(packetBuffer); } } else { break; } } } return(true); }