示例#1
0
        private void ParsePacket()
        {
            /** Can we parse it? **/
            try
            {
                var packet = Packet.Packet;
                if (packet.Type == PacketType.VOLTRON)
                {
                    var voltronClazz = VoltronPackets.GetByPacketCode((ushort)packet.SubType);
                    if (voltronClazz != null)
                    {
                        IVoltronPacket parsed = (IVoltronPacket)Activator.CreateInstance(voltronClazz);
                        //TODO: VoltronContext
                        parsed.Deserialize(IoBuffer.Wrap(GetBytes()), Context);

                        this.ParsedPacket = parsed;
                        this.parsedInspetor.SelectedObject = ParsedPacket;
                    }
                }
                else if (packet.Type == PacketType.ARIES)
                {
                    var ariesClazz = AriesPackets.GetByPacketCode(packet.SubType);
                    if (ariesClazz != null)
                    {
                        IAriesPacket parsed = (IAriesPacket)Activator.CreateInstance(ariesClazz);
                        parsed.Deserialize(IoBuffer.Wrap(GetBytes()), Context);
                        this.ParsedPacket = parsed;
                        this.parsedInspetor.SelectedObject = ParsedPacket;
                    }
                }
            }
            catch (Exception ex)
            {
            }
        }
        protected override bool DoDecode(IoSession session, IoBuffer buffer, IProtocolDecoderOutput output)
        {
            if (buffer.Remaining < 12)
            {
                return(false);
            }

            /**
             * We expect aries, voltron or electron packets
             */
            var startPosition = buffer.Position;

            buffer.Order = ByteOrder.LittleEndian;
            uint packetType  = buffer.GetUInt32();
            uint timestamp   = buffer.GetUInt32();
            uint payloadSize = buffer.GetUInt32();

            if (buffer.Remaining < payloadSize)
            {
                /** Not all here yet **/
                buffer.Position = startPosition;
                return(false);
            }

            //LOG.Info("[ARIES] " + packetType + " (" + payloadSize + ")");

            if (packetType == AriesPacketType.Voltron.GetPacketCode())
            {
                DecodeVoltronStylePackets(buffer, ref payloadSize, output, VoltronPackets.GetByPacketCode);
            }
            else if (packetType == AriesPacketType.Electron.GetPacketCode())
            {
                DecodeVoltronStylePackets(buffer, ref payloadSize, output, ElectronPackets.GetByPacketCode);
            }
            else if (packetType == AriesPacketType.Gluon.GetPacketCode())
            {
                DecodeVoltronStylePackets(buffer, ref payloadSize, output, GluonPackets.GetByPacketCode);
            }
            else
            {
                //Aries
                var packetClass = AriesPackets.GetByPacketCode(packetType);
                if (packetClass != null)
                {
                    byte[] data = new byte[(int)payloadSize];
                    buffer.Get(data, 0, (int)payloadSize);

                    IAriesPacket packet = (IAriesPacket)Activator.CreateInstance(packetClass);
                    packet.Deserialize(IoBuffer.Wrap(data), Context);
                    output.Write(packet);

                    payloadSize = 0;
                }
                else
                {
                    buffer.Skip((int)payloadSize);
                    payloadSize = 0;
                }
            }

            return(true);
        }