Example #1
0
 /// <summary>
 /// 读取字节数据消息头信息
 /// </summary>
 /// <param name="buffer"></param>
 /// <returns></returns>
 public static Message_Head UnParseHead(byte[] buffer)
 {
     if (buffer.Length >= MessageConst.HEADER_LENGTH)
     {
         Message_Head head = new Message_Head();
         //读取标志符
         System.Array.Reverse(buffer, 0, 2);
         head.HEADER = System.BitConverter.ToInt16(buffer, 0);
         //读取消息长度
         System.Array.Reverse(buffer, 2, 2);
         head.Length = System.BitConverter.ToInt16(buffer, 2);
         //读取校验和
         System.Array.Reverse(buffer, 4, 2);
         head.CHECK_SUM = System.BitConverter.ToInt16(buffer, 4);
         //读取协议号
         System.Array.Reverse(buffer, 6, 2);
         head.ProtoVersion = System.BitConverter.ToInt16(buffer, 6);
         //读取TOID
         System.Array.Reverse(buffer, 8, 4);
         head.TOID = System.BitConverter.ToInt32(buffer, 8);
         //读取Ext1
         System.Array.Reverse(buffer, 12, 4);
         head.EXTID1 = System.BitConverter.ToInt32(buffer, 12);
         //读取Ext2
         System.Array.Reverse(buffer, 16, 4);
         head.EXTID2 = System.BitConverter.ToInt32(buffer, 16);
         return(head);
     }
     return(null);
 }
Example #2
0
    // 将消息头解析出来
    public static Message_Head UnParseHead(byte[] buffer)
    {
        if (buffer.Length >= 13)
        {
            Message_Head head = new Message_Head();
            head.HEAD_0       = buffer[0];
            head.HEAD_1       = buffer[1];
            head.HEAD_2       = buffer[2];
            head.HEAD_3       = buffer[3];
            head.ProtoVersion = buffer[4];
            // 以上都是byte类型

            // (5 6 7 8) (9 10 11 12) 这4位翻转,将网络大端序转换成C#的小端序
            // System.Array.Reverse(buffer, 5, 8);
            System.Array.Reverse(buffer, 5, 4);
            System.Array.Reverse(buffer, 9, 4);
            // 注意 reverse(5,8) 这是错误的,这样的意思version 和 length 刚好相反

            // ToInt32 => (value startIndex)
            head.ServerVersion = System.BitConverter.ToInt32(buffer, 5);  // ServerVersion 4位
            head.Length        = System.BitConverter.ToInt32(buffer, 9);  // Length 4位
            return(head);
        }
        return(null);
    }
Example #3
0
 // ############# 当有数据需要读取时,这里 自动 被调用
 private void _OnRead()
 {
     /*
      *  socket.Available 是从已经从网络接收的、可供读取的数据的字节数。
      *  这个值是指 缓冲区 中已接收数据的字节数,不是实际的数据大小。
      *  而且如果网络有延迟,Send之后马上读取Available属性不一定能读到正确的值,
      *  所以不能利用socket.Available来判断总共要接受的字节数。
      */
     if (m_Socket.Available > 0)
     {
         try
         {
             byte[] buffer = new byte[13];
             m_Socket.Receive(buffer, 13, SocketFlags.Peek);       // 开始读取 Peek 快速查看传入消息
             Message_Head head = MessageParse.UnParseHead(buffer); // 解析消息头
             if (head == null)
             {
                 _OnError(new SocketException((int)SocketError.ProtocolOption));
                 Close();
             }
             else
             {
                 // 13 = 5(协议头)+4(版本号)+4(消息体长度Length)
                 // 消息体长度 = command(int型4位)+msg(byte[])
                 int iLength = head.Length + 13;    // 总长度
                 if (iLength <= m_Socket.Available) // 消息全部到达
                 {
                     buffer = new byte[iLength];
                     m_Socket.Receive(buffer, 0, buffer.Length, SocketFlags.None); // 读取消息到buffer中
                     MessageData data = MessageParse.UnParse(buffer);              // 解析成Data
                     if (data != null)
                     {
                         lock (_lock)
                         {                          // 上锁,其他线程会被阻塞在外面直到锁被解开
                             m_Datas.Enqueue(data); // 数据入队列
                         }
                     }
                     else
                     {
                         _OnError(new SocketException((int)SocketError.ProtocolOption));  // 10042 Option unknown, or unsupported.
                         Close();
                     }
                 }
             }
         }
         catch (ObjectDisposedException)
         {
             Close();
         }
         catch (SocketException ex)
         {
             _OnError(ex);
             Close();
         }
     }
 }
Example #4
0
 public static Message_Head UnParseHead(byte[] buffer)
 {
     if (buffer.Length >= iHL)
     {
         Message_Head head = new Message_Head();
         head.Type   = (buffer[0] << 8) + buffer[1];
         head.Length = (buffer[2] << 24) + (buffer[3] << 16) + (buffer[4] << 8) + buffer[5];
         return(head);
     }
     return(null);
 }
Example #5
0
	public static Message_Head UnParseHead (byte[] buffer) {
		if (buffer.Length >= 13) {
			Message_Head head = new Message_Head();
			head.HEAD_0 = buffer[0];
			head.HEAD_1 = buffer[1];
			head.HEAD_2 = buffer[2];
			head.HEAD_3 = buffer[3];
			head.ProtoVersion = buffer[4];
			head.ServerVersion = System.BitConverter.ToInt32(buffer, 5);
			System.Array.Reverse(buffer, 9, 4);
			head.Length = System.BitConverter.ToInt32(buffer, 9);
			return head;
		}
		return null;
	}
Example #6
0
 private void _OnRead()
 {
     if (m_Socket.Available > 0)
     {
         try
         {
             byte[] buffer = new byte[13];
             m_Socket.Receive(buffer, 13, SocketFlags.Peek);
             Message_Head head = MessageParse.UnParseHead(buffer);
             if (head == null)
             {
                 _OnError(new SocketException(10042));
                 Close();
             }
             else
             {
                 int iLength = head.Length + 13;
                 if (iLength <= m_Socket.Available)
                 {
                     buffer = new byte[iLength];
                     m_Socket.Receive(buffer, 0, buffer.Length, SocketFlags.None);
                     MessageData data = MessageParse.UnParse(buffer);
                     if (data != null)
                     {
                         lock (_lock)
                         {
                             m_Datas.Enqueue(data);
                         }
                     }
                     else
                     {
                         _OnError(new SocketException(10042));
                         Close();
                     }
                 }
             }
         }
         catch (ObjectDisposedException)
         {
             Close();
         }
         catch (SocketException ex)
         {
             _OnError(ex);
             Close();
         }
     }
 }
Example #7
0
 public static Message_Head UnParseHead(byte[] buffer)
 {
     if (buffer.Length >= 13)
     {
         Message_Head head = new Message_Head();
         head.HEAD_0        = buffer[0];
         head.HEAD_1        = buffer[1];
         head.HEAD_2        = buffer[2];
         head.HEAD_3        = buffer[3];
         head.ProtoVersion  = buffer[4];
         head.ServerVersion = System.BitConverter.ToInt32(buffer, 5);
         System.Array.Reverse(buffer, 9, 4);
         head.Length = System.BitConverter.ToInt32(buffer, 9);
         return(head);
     }
     return(null);
 }
Example #8
0
    public static MessageData UnParse(byte[] buffer)
    {
        int iHead = iHL;

        {
            Message_Head head = UnParseHead(buffer);
            if (head != null && head.Length <= (buffer.Length - iHead))
            {
                Message_Body body = new Message_Body();
                body.body = new byte[head.Length];
                System.Array.Copy(buffer, iHL, body.body, 0, head.Length);
                MessageData data = new MessageData();
                data.head = head;
                data.body = body;
                return(data);
            }
        }
        return(null);
    }
Example #9
0
    public static MessageData UnParse(byte[] buffer)
    {
        int iHead = 13;

        {
            Message_Head head = UnParseHead(buffer);
            if (head != null && head.Length <= (buffer.Length - iHead))
            {
                Message_Body body = new Message_Body();
                System.Array.Reverse(buffer, 13, 4);
                body.iCommand = System.BitConverter.ToInt32(buffer, 13);
                body.body     = new byte[head.Length - 4];
                System.Array.Copy(buffer, iHead + 4, body.body, 0, body.body.Length);
                MessageData data = new MessageData();
                data.head = head;
                data.body = body;
                return(data);
            }
        }
        return(null);
    }
Example #10
0
    /// <summary>
    /// 读取字节数据消息体信息
    /// </summary>
    /// <param name="buffer"></param>
    /// <returns></returns>
    public static MessageData UnParse(byte[] buffer)
    {
        int iHead = MessageConst.HEADER_LENGTH;

        {
            Message_Head head = UnParseHead(buffer);
            if (head != null && head.Length == buffer.Length)
            {
                Message_Body body = new Message_Body();
                System.Array.Reverse(buffer, iHead, 4);
                body.iCommand  = System.BitConverter.ToInt32(buffer, iHead);
                body.buffBytes = new byte[head.Length - 4];
                System.Array.Copy(buffer, iHead + 4, body.buffBytes, 0, body.buffBytes.Length);
                MessageData data = new MessageData();
                data.head = head;
                data.body = body;
                return(data);
            }
        }
        return(null);
    }
Example #11
0
    // 将消息体解析出来
    public static MessageData UnParse(byte[] buffer)
    {
        int iHead = 13;

        {
            Message_Head head = UnParseHead(buffer);
            if (head != null && head.Length <= (buffer.Length - iHead))
            {
                Message_Body body = new Message_Body();
                System.Array.Reverse(buffer, 13, 4);
                // 13 14 15 16 这4位翻转,将网络大端序转换成C#的小端序
                body.iCommand = System.BitConverter.ToInt32(buffer, 13);
                body.body     = new byte[head.Length - 4];                            // 消息体长度Length = command(int型4位) + msg长度(byte[])
                System.Array.Copy(buffer, iHead + 4, body.body, 0, body.body.Length); // 获得msg
                MessageData data = new MessageData();
                data.head = head;
                data.body = body;
                return(data);
            }
        }
        return(null);
    }
Example #12
0
    private void _OnRead()
    {
        if (m_Socket.Available >= MessageConst.HEADER_LENGTH)
        {
            try {
                byte[] buffer = new byte[MessageConst.HEADER_LENGTH];
                //试读取消息头数据
                m_Socket.Receive(buffer, MessageConst.HEADER_LENGTH, SocketFlags.Peek);

                if (buffer.Length >= MessageConst.HEADER_LENGTH)//首先保证读取满足消息头的字节数据
                {
                    byte[] headTemp = MessageParse.Decrypt(buffer, 4, MessageParse.CopyByteArray(RECEIVE_KEY));
                    System.Array.Reverse(headTemp, 0, 2);
                    System.Array.Reverse(headTemp, 2, 4);

                    short flag = System.BitConverter.ToInt16(headTemp, 0);
                    short len  = System.BitConverter.ToInt16(headTemp, 2);
                    if (flag == MessageConst.HEADER)   //验证标志符
                    {
                        if (len <= m_Socket.Available) //满足完整消息的字节长度
                        {
                            //解密头消息
                            headTemp = MessageParse.Decrypt(buffer, MessageConst.HEADER_LENGTH, MessageParse.CopyByteArray(RECEIVE_KEY));
                            //解析头信息数据
                            Message_Head head = MessageParse.UnParseHead(headTemp);
                            if (head == null)//验证头信息有效性
                            {
                                _OnError(new SocketException(10042));
                                Close();
                            }
                            else
                            {
                                int iLength = head.Length;
                                buffer = new byte[iLength];
                                m_Socket.Receive(buffer, 0, buffer.Length, SocketFlags.None);
                                //解密字节数据
                                byte[] buffer1 = MessageParse.Decrypt(buffer, iLength, MessageParse.CopyByteArray(RECEIVE_KEY));
                                //正式解析整个消息信息数据
                                MessageData data = MessageParse.UnParse(buffer1);
                                if (data != null)
                                {
                                    //计算数据校验和
                                    int checksum = MessageParse.CalculateCheckSum(buffer1);
                                    //验证校验和有效性
                                    if (checksum == data.head.CHECK_SUM)
                                    {
                                        lock (_lock)
                                        {
                                            m_Datas.Enqueue(data);
                                        }
                                    }
                                }
                                else
                                {
                                    _OnError(new SocketException(10042));
                                    Close();
                                }
                            }
                        }
                    }
                }
            }
            catch (ObjectDisposedException)
            {
                Close();
            }
            catch (SocketException ex) {
                _OnError(ex);
                Close();
            }
        }
    }
Example #13
0
 /// <summary>
 /// ��ȡ�ֽ�������Ϣͷ��Ϣ
 /// </summary>
 /// <param name="buffer"></param>
 /// <returns></returns>
 public static Message_Head UnParseHead(byte[] buffer)
 {
     if (buffer.Length >= MessageConst.HEADER_LENGTH) {
         Message_Head head = new Message_Head();
         //��ȡ��־��
         System.Array.Reverse(buffer, 0, 2);
         head.HEADER = System.BitConverter.ToInt16(buffer, 0);
         //��ȡ��Ϣ����
         System.Array.Reverse(buffer, 2, 2);
         head.Length = System.BitConverter.ToInt16(buffer, 2);
         //��ȡУ���
         System.Array.Reverse(buffer, 4, 2);
         head.CHECK_SUM = System.BitConverter.ToInt16(buffer, 4);
         //��ȡЭ���
         System.Array.Reverse(buffer, 6, 2);
         head.ProtoVersion = System.BitConverter.ToInt16(buffer, 6);
         //��ȡTOID
         System.Array.Reverse(buffer, 8, 4);
         head.TOID = System.BitConverter.ToInt32(buffer, 8);
         //��ȡExt1
         System.Array.Reverse(buffer, 12, 4);
         head.EXTID1 = System.BitConverter.ToInt32(buffer, 12);
         //��ȡExt2
         System.Array.Reverse(buffer, 16, 4);
         head.EXTID2 = System.BitConverter.ToInt32(buffer, 16);
         return head;
     }
     return null;
 }