Exemplo n.º 1
0
 public static ParsedPacketData Parse(byte[] packet)
 {
     ParsedPacketData parsed = new ParsedPacketData();
     // read protocol version
     byte[] ver = new byte[Packet.UINT32_SIZE];
     Buffer.BlockCopy(
         packet,
         Packet.OFFSET_VER,
         ver,
         0,
         Packet.UINT8_SIZE
     );
     uint version = BitConverter.ToUInt32(ver, 0);
     parsed.Version = version;
     if (version != VER0) {
         // invalid packet
         parsed.Invalid = true;
         return parsed;
     }
     // read payload size
     byte[] plen = new byte[Packet.UINT32_SIZE];
     Buffer.BlockCopy(
         packet,
         Packet.OFFSET_PLEN,
         plen,
         0,
         Packet.UINT32_SIZE
     );
     // array reverse for big endian conversion
     Array.Reverse(plen);
     uint payloadSize = BitConverter.ToUInt32(plen, 0);
     parsed.PayloadSize = payloadSize;
     if (payloadSize > packet.Length) {
         parsed.Invalid = true;
         return parsed;
     }
     // read reply flag
     byte[] rflag = new byte[Packet.UINT32_SIZE];
     Buffer.BlockCopy(
         packet,
         Packet.OFFSET_RFLAG,
         rflag,
         0,
         Packet.UINT8_SIZE
     );
     uint replyFlag = BitConverter.ToUInt32(rflag, 0);
     bool isReply = false;
     if (replyFlag == 0x01) {
         isReply = true;
     }
     parsed.IsReply = isReply;
     // read status
     byte[] stat = new byte[Packet.UINT32_SIZE];
     Buffer.BlockCopy(
         packet,
         Packet.OFFSET_STATUS,
         stat,
         0,
         Packet.UINT8_SIZE
     );
     uint status = BitConverter.ToUInt32(stat, 0);
     parsed.Status = status;
     // read sequence
     byte[] sequence = new byte[Packet.UINT16_SIZE];
     Buffer.BlockCopy(
         packet,
         Packet.OFFSET_SEQ,
         sequence,
         0,
         Packet.UINT16_SIZE
     );
     // array reverse for big endian conversion
     Array.Reverse(sequence);
     uint seq = BitConverter.ToUInt16(sequence, 0);
     parsed.Seq = seq;
     // read payload
     byte[] payload = new byte[payloadSize];
     Buffer.BlockCopy(
         packet,
         Packet.OFFSET_PAYLOAD,
         payload,
         0,
         (int)payloadSize
     );
     parsed.Payload = payload;
     // read stop
     byte[] mstop = new byte[Packet.UINT32_SIZE];
     Buffer.BlockCopy(
         packet,
         Packet.HEADER_SIZE + (int)Convert.ToUInt32(payloadSize),
         mstop,
         0,
         Packet.UINT32_SIZE
     );
     // array reverse for big endian conversion
     Array.Reverse(mstop);
     uint stop = BitConverter.ToUInt32(mstop, 0);
     if (stop != Packet.MSTOP) {
         parsed.Invalid = true;
         return parsed;
     }
     // done
     return parsed;
 }
Exemplo n.º 2
0
        public static ParsedPacketData Parse(byte[] packet)
        {
            ParsedPacketData parsed = new ParsedPacketData();

            // read protocol version
            byte[] ver = new byte[Packet.UINT32_SIZE];
            Buffer.BlockCopy(
                packet,
                Packet.OFFSET_VER,
                ver,
                0,
                Packet.UINT8_SIZE
                );
            uint version = BitConverter.ToUInt32(ver, 0);

            parsed.Version = version;
            if (version != VER0)
            {
                // invalid packet
                parsed.Invalid = true;
                return(parsed);
            }
            // read payload size
            byte[] plen = new byte[Packet.UINT32_SIZE];
            Buffer.BlockCopy(
                packet,
                Packet.OFFSET_PLEN,
                plen,
                0,
                Packet.UINT32_SIZE
                );
            // array reverse for big endian conversion
            Array.Reverse(plen);
            uint payloadSize = BitConverter.ToUInt32(plen, 0);

            parsed.PayloadSize = payloadSize;
            if (payloadSize > packet.Length)
            {
                parsed.Invalid = true;
                return(parsed);
            }
            // read reply flag
            byte[] rflag = new byte[Packet.UINT32_SIZE];
            Buffer.BlockCopy(
                packet,
                Packet.OFFSET_RFLAG,
                rflag,
                0,
                Packet.UINT8_SIZE
                );
            uint replyFlag = BitConverter.ToUInt32(rflag, 0);
            bool isReply   = false;

            if (replyFlag == 0x01)
            {
                isReply = true;
            }
            parsed.IsReply = isReply;
            // read status
            byte[] stat = new byte[Packet.UINT32_SIZE];
            Buffer.BlockCopy(
                packet,
                Packet.OFFSET_STATUS,
                stat,
                0,
                Packet.UINT8_SIZE
                );
            uint status = BitConverter.ToUInt32(stat, 0);

            parsed.Status = status;
            // read sequence
            byte[] sequence = new byte[Packet.UINT16_SIZE];
            Buffer.BlockCopy(
                packet,
                Packet.OFFSET_SEQ,
                sequence,
                0,
                Packet.UINT16_SIZE
                );
            // array reverse for big endian conversion
            Array.Reverse(sequence);
            uint seq = BitConverter.ToUInt16(sequence, 0);

            parsed.Seq = seq;
            // read payload
            byte[] payload = new byte[payloadSize];
            Buffer.BlockCopy(
                packet,
                Packet.OFFSET_PAYLOAD,
                payload,
                0,
                (int)payloadSize
                );
            parsed.Payload = payload;
            // read stop
            byte[] mstop = new byte[Packet.UINT32_SIZE];
            Buffer.BlockCopy(
                packet,
                Packet.HEADER_SIZE + (int)Convert.ToUInt32(payloadSize),
                mstop,
                0,
                Packet.UINT32_SIZE
                );
            // array reverse for big endian conversion
            Array.Reverse(mstop);
            uint stop = BitConverter.ToUInt32(mstop, 0);

            if (stop != Packet.MSTOP)
            {
                parsed.Invalid = true;
                return(parsed);
            }
            // done
            return(parsed);
        }