Exemple #1
0
        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);
        }
Exemple #2
0
    /// <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( "无法验证不返回值的方法。" );
 }
Exemple #4
0
        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("无法验证不返回值的方法。");
        }
Exemple #5
0
        /// <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);
            }
        }
Exemple #6
0
 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]);
         }
     }
 }
Exemple #7
0
        private void Free()
        {
            if (mCompiledBuffer == null)
            {
                return;
            }

            if ((mState & EPacketState.Buffered) != 0)
            {
                mBuffers.ReleaseBuffer(mCompiledBuffer);
            }

            mState &= ~(EPacketState.Static | EPacketState.Acquired | EPacketState.Buffered);

            mCompiledBuffer = null;
        }
Exemple #8
0
        /// <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);   // 返回内存池
        }
Exemple #9
0
 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);
 }
Exemple #10
0
        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();
                }
            }
        }
Exemple #11
0
        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;
            }
        }
Exemple #13
0
        /// <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;
            }
        }
Exemple #14
0
        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;
                }
            }
        }
Exemple #16
0
        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);
        }
Exemple #17
0
        /// <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;
            }
        }
Exemple #18
0
        /// <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);
        }