Compile() публичный Метод

public Compile ( bool compress, int &length ) : byte[]
compress bool
length int
Результат byte[]
Пример #1
0
        public static Packet Compress(Packet p)
        {
            int length;
            byte[] source = p.Compile(false, out length);

            if (length > 100 && length < 60000)
            {
                byte[] dest = new byte[(int)(length * 1.001) + 10];
                int destSize = dest.Length;

                ZLibError error = Compression.Pack(dest, ref destSize, source, length, ZLibQuality.Default);

                if (error != ZLibError.Okay)
                {
                    Console.WriteLine("WARNING: Unable to compress admin packet, zlib error: {0}", error);
                    return p;
                }
                else
                {
                    return new AdminCompressedPacket(dest, destSize, length);
                }
            }
            else
            {
                return p;
            }
        }
Пример #2
0
        public static Packet Compress( Packet p )
        {
            byte[] source = p.Compile( false );

            if ( source.Length > 100 && source.Length < 60000 )
            {
                byte[] dest = new byte[(int)(source.Length*1.001)+1];
                int destSize = dest.Length;

                ZLibError error = ZLib.compress2( dest, ref destSize, source, source.Length, ZLibCompressionLevel.Z_BEST_COMPRESSION );// best compression (slowest)

                if ( error != ZLibError.Z_OK )
                {
                    Console.WriteLine( "WARNING: Unable to compress admin packet, zlib error: {0}", error );
                    return p;
                }
                else
                {
                    return new AdminCompressedPacket( dest, destSize, source.Length );
                }
            }
            else
            {
                return p;
            }
        }
Пример #3
0
        public void Send( Packet p )
        {
            if ( m_Socket == null || m_BlockAllPackets )
                return;

            PacketProfile prof = PacketProfile.GetOutgoingProfile( (byte)p.PacketID );
            DateTime start = ( prof == null ? DateTime.MinValue : DateTime.Now );

            byte[] buffer = p.Compile( m_CompressionEnabled );

            if ( buffer != null )
            {
                if ( buffer.Length <= 0 )
                    return;

                int length = buffer.Length;

                if ( m_Encoder != null )
                    m_Encoder.EncodeOutgoingPacket( this, ref buffer, ref length );

                bool shouldBegin = false;

                lock ( m_SendQueue )
                    shouldBegin = ( m_SendQueue.Enqueue( buffer, length ) );

                if ( shouldBegin )
                {
                    int sendLength = 0;
                    byte[] sendBuffer = m_SendQueue.Peek( ref sendLength );

                    try
                    {
                        m_Socket.BeginSend( sendBuffer, 0, sendLength, SocketFlags.None, m_OnSend, null );
                        m_Sending = true;
                        //Console.WriteLine( "Send: {0}: Begin send of {1} bytes", this, sendLength );
                    }
                    catch // ( Exception ex )
                    {
                        //Console.WriteLine(ex);
                        Dispose( false );
                    }
                }

                if ( prof != null )
                    prof.Record( length, DateTime.Now - start );
            }
            else
            {
                Dispose();
            }
        }
Пример #4
0
        public virtual void Send( Packet p )
        {
            if ( m_Socket == null || m_BlockAllPackets ) {
                p.OnSend();
                return;
            }

            PacketSendProfile prof = PacketSendProfile.Acquire( p.GetType() );

            int length;
            byte[] buffer = p.Compile( m_CompressionEnabled, out length );

            if ( buffer != null ) {
                if ( buffer.Length <= 0 || length <= 0 ) {
                    p.OnSend();
                    return;
                }

                if ( prof != null ) {
                    prof.Start();
                }

                if ( m_Encoder != null ) {
                    m_Encoder.EncodeOutgoingPacket( this, ref buffer, ref length );
                }

                try {
                    SendQueue.Gram gram;

                    lock ( m_SendQueue ) {
                        gram = m_SendQueue.Enqueue( buffer, length );
                    }

                    if ( gram != null ) {
                        try {
                            m_Socket.BeginSend( gram.Buffer, 0, gram.Length, SocketFlags.None, m_OnSend, m_Socket );
                        } catch ( Exception ex ) {
                            TraceException( ex );
                            Dispose( false );
                        }
                    }
                } catch ( CapacityExceededException ) {
                    Console.WriteLine( "Client: {0}: Too much data pending, disconnecting...", this );
                    Dispose( false );
                }

                p.OnSend();

                if ( prof != null ) {
                    prof.Finish( length );
                }
            } else {
                Console.WriteLine( "Client: {0}: null buffer send, disconnecting...", this );
                using ( StreamWriter op = new StreamWriter( "null_send.log", true ) )
                {
                    op.WriteLine( "{0} Client: {1}: null buffer send, disconnecting...", DateTime.Now, this );
                    op.WriteLine( new System.Diagnostics.StackTrace() );
                }
                Dispose();
            }
        }
Пример #5
0
        public void Send( Packet p )
        {
            if ( m_BlockAllPackets )
            {
                p.OnSend();
                return;
            }

            PacketProfile prof = PacketProfile.GetOutgoingProfile( (byte) p.PacketID );
            DateTime start = ( prof == null ? DateTime.MinValue : DateTime.Now );

            int length;
            byte[] buffer = p.Compile( m_CompressionEnabled, out length );

            if ( buffer != null && buffer.Length > 0 && length > 0 )
            {
                m_NetState.Send( buffer, length );
            }

            if ( prof != null )
                prof.Record( length, DateTime.Now - start );

            p.OnSend();
        }
Пример #6
0
        public virtual void Send(Packet p)
        {
            if (m_Socket == null || m_BlockAllPackets)
            {
                p.OnSend();
                return;
            }

            int length;
            var buffer = p.Compile(m_CompressionEnabled, out length);

            if (buffer != null)
            {
                if (buffer.Length <= 0 || length <= 0)
                {
                    p.OnSend();
                    return;
                }

                PacketSendProfile prof = null;

                if (Core.Profiling)
                {
                    prof = PacketSendProfile.Acquire(p.GetType());
                }

                if (prof != null)
                {
                    prof.Start();
                }

                if (m_Encoder != null)
                {
                    m_Encoder.EncodeOutgoingPacket(this, ref buffer, ref length);
                }

                try
                {
                    SendQueue.Gram gram;

                    lock (_sendL)
                    {
                        lock (m_SendQueue)
                            gram = m_SendQueue.Enqueue(buffer, length);

                        if (gram != null && !_sending)
                        {
                            _sending = true;
#if NewAsyncSockets
                            m_SendEventArgs.SetBuffer(gram.Buffer, 0, gram.Length);
                            Send_Start();
#else
                            try
                            {
                                m_Socket.BeginSend(gram.Buffer, 0, gram.Length, SocketFlags.None, m_OnSend, m_Socket);
                            }
                            catch (Exception ex)
                            {
                                TraceException(ex);
                                Dispose(false);
                            }
#endif
                        }
                    }
                }
                catch (CapacityExceededException)
                {
                    Utility.PushColor(ConsoleColor.DarkRed);
                    Console.WriteLine("Client: {0}: Too much data pending, disconnecting...", this);
                    Utility.PopColor();
                    Dispose(false);
                }

                p.OnSend();

                if (prof != null)
                {
                    prof.Finish(length);
                }
            }
            else
            {
                Utility.PushColor(ConsoleColor.DarkRed);
                Console.WriteLine("Client: {0}: null buffer send, disconnecting...", this);
                Utility.PopColor();
                using (StreamWriter op = new StreamWriter("null_send.log", true))
                {
                    op.WriteLine("{0} Client: {1}: null buffer send, disconnecting...", DateTime.UtcNow, this);
                    op.WriteLine(new StackTrace());
                }
                Dispose();
            }
        }
Пример #7
0
        public virtual void Send(Packet p)
        {
            if (m_Socket == null || m_BlockAllPackets)
            {
                p.OnSend();
                return;
            }

            PacketSendProfile prof = PacketSendProfile.Acquire(p.GetType());

            int length;

            byte[] buffer = p.Compile(m_CompressionEnabled, out length);

            if (buffer != null)
            {
                if (buffer.Length <= 0 || length <= 0)
                {
                    p.OnSend();
                    return;
                }

                if (prof != null)
                {
                    prof.Start();
                }

                if (m_Encoder != null)
                {
                    m_Encoder.EncodeOutgoingPacket(this, ref buffer, ref length);
                }

                try {
                    SendQueue.Gram gram;

                    lock ( m_SendQueue ) {
                        gram = m_SendQueue.Enqueue(buffer, length);
                    }

                    if (gram != null)
                    {
#if Framework_4_0
                        m_SendEventArgs.SetBuffer(gram.Buffer, 0, gram.Length);
                        Send_Start();
#else
                        try {
                            m_Socket.BeginSend(gram.Buffer, 0, gram.Length, SocketFlags.None, m_OnSend, m_Socket);
                        } catch (Exception ex) {
                            TraceException(ex);
                            Dispose(false);
                        }
#endif
                    }
                } catch (CapacityExceededException) {
                    Console.WriteLine("Client: {0}: Too much data pending, disconnecting...", this);
                    Dispose(false);
                }

                p.OnSend();

                if (prof != null)
                {
                    prof.Finish(length);
                }
            }
            else
            {
                Console.WriteLine("Client: {0}: null buffer send, disconnecting...", this);
                using (StreamWriter op = new StreamWriter("null_send.log", true))
                {
                    op.WriteLine("{0} Client: {1}: null buffer send, disconnecting...", DateTime.Now, this);
                    op.WriteLine(new System.Diagnostics.StackTrace());
                }
                Dispose();
            }
        }
Пример #8
0
        public void Send(Packet p)
        {
            if (m_Socket == null)
            {
                return;
            }

            PacketProfile prof  = PacketProfile.GetOutgoingProfile((byte)p.PacketID);
            DateTime      start = (prof == null ? DateTime.MinValue : DateTime.Now);

            byte[] buffer = p.Compile(m_CompressionEnabled);

            if (buffer != null)
            {
                if (buffer.Length <= 0)
                {
                    return;
                }

                int length = buffer.Length;

                if (m_Encoder != null)
                {
                    m_Encoder.EncodeOutgoingPacket(this, ref buffer, ref length);
                }

                bool shouldBegin = false;

                lock (m_SendQueue)
                    shouldBegin = (m_SendQueue.Enqueue(buffer, length));

                if (m_Connecting)
                {
                    shouldBegin = false;
                }

                if (shouldBegin)
                {
                    int    sendLength = 0;
                    byte[] sendBuffer = m_SendQueue.Peek(ref sendLength);

                    try
                    {
                        m_Socket.BeginSend(sendBuffer, 0, sendLength, SocketFlags.None, m_OnSend, null);
                        m_Sending = true;
                        //Console.WriteLine( "Send: {0}: Begin send of {1} bytes", this, sendLength );
                    }
                    catch (Exception ex)
                    {
                        log.Error(ex);
                        Dispose(false);
                    }
                }

                if (prof != null)
                {
                    prof.Record(length, DateTime.Now - start);
                }
            }
            else
            {
                Dispose();
            }
        }