Пример #1
0
        private void ParseControlCommand()
        {
            List<PacketSlice> slices = new List<PacketSlice>(2);

            UInt16 cmdTypeRaw, cmdLen;
            RRACCommand cmdType;
            string cmdTypeStr;
            List<PacketSlice> cmdTypeSlices = new List<PacketSlice>(1);
            List<PacketSlice> cmdLenSlices = new List<PacketSlice>(1);

            UInt32 u32;
            byte[] bytes;

            try
            {
                // Command type
                cmdTypeRaw = stream.ReadU16(cmdTypeSlices);

                // Command length
                cmdLen = stream.ReadU16(cmdLenSlices);

                ParseCommandType(cmdTypeRaw, out cmdType, out cmdTypeStr);

                TransactionNode cmd = new TransactionNode(cmdTypeStr);

                cmd.AddField("CommandType", cmdTypeStr,
                    "Command type.", cmdTypeSlices);
                cmd.AddField("CommandLength", Convert.ToString(cmdLen),
                    "Number of bytes following this field.", cmdLenSlices);

                if (cmdType != RRACCommand.Response)
                {
                    cmd.Description = cmd.Name;
                }

                bool handled = true;

                switch (cmdType)
                {
                    case RRACCommand.GetMetaData:
                        u32 = stream.ReadU32(slices);
                        cmd.AddField("GetMask", Util.FormatFlags(u32),
                            "A bitmask specifying what metadata to get.", slices);

                        pendingReplies[cmdType] = new GetMetaDataCmd(u32);
                        break;
                    case RRACCommand.SetMetaData:
                        u32 = stream.ReadU32(slices);
                        cmd.AddField("PayloadSize", Convert.ToString(u32),
                            "The number of bytes of payload following this field.", slices);

                        u32 = stream.ReadU32(slices);
                        cmd.AddField("MagicValue", Util.FormatFlags(u32),
                            "Magic value that must be 0xF0000001.", slices);

                        u32 = stream.ReadU32(slices);
                        cmd.AddField("SetOid", FormatSetType(u32),
                            "The identifier of the object to set.", slices);

                        pendingReplies[cmdType] = new SetMetaDataCmd(u32);

                        switch (u32)
                        {
                            case SetMetaDataCmd.TYPE_BORING_SSPIDS:
                                bytes = stream.ReadBytes(16, slices);
                                cmd.AddField("FourUnknownDWORDs", Util.FormatByteArray(bytes),
                                    "Four unknown DWORDs.", slices);

                                UInt32 numObjects = stream.ReadU32(slices);
                                cmd.AddField("NumBoringObjects", Convert.ToString(numObjects),
                                    "Number of boring objects following this field.", slices);

                                TransactionNode boringObjects = new TransactionNode("BoringObjects");
                                cmd.AddChild(boringObjects);

                                for (int i = 0; i < numObjects; i++)
                                {
                                    u32 = stream.ReadU32(slices);
                                    boringObjects.AddField(Convert.ToString(i), Util.FormatFlags(u32),
                                        "Object type ID.", slices);
                                }
                                break;
                            default:
                                handled = false;
                                cmdLen -= 4 * 3;
                                break;
                        }
                        break;
                    case RRACCommand.Notify:
                        UInt32 notifyType = stream.ReadU32(slices);
                        cmd.AddField("NotifyType", FormatNotifyType(notifyType),
                            "Type of notification.", slices);

                        switch (notifyType)
                        {
                            case NotifyCmd.TYPE_PARTNERSHIPS:
                                u32 = stream.ReadU32(slices);
                                cmd.AddField("Unknown1", Util.FormatFlags(u32),
                                    "Unknown field 1.", slices);

                                u32 = stream.ReadU32(slices);
                                cmd.AddField("Unknown2", Util.FormatFlags(u32),
                                    "Unknown field 2.", slices);

                                u32 = stream.ReadU32(slices);
                                cmd.AddField("Size", Convert.ToString(u32),
                                    "Size of the remaining fields.", slices);

                                u32 = stream.ReadU32(slices);
                                cmd.AddField("PCur", Convert.ToString(u32),
                                    "Current partner index.", slices);

                                u32 = stream.ReadU32(slices);
                                cmd.AddField("P1", Util.FormatFlags(u32),
                                    "Partner 1 ID.", slices);

                                u32 = stream.ReadU32(slices);
                                cmd.AddField("P2", Util.FormatFlags(u32),
                                    "Partner 2 ID.", slices);
                                break;
                            default:
                                handled = false;
                                cmdLen -= 4;
                                break;
                        }
                        break;
                    case RRACCommand.Response:
                        ParseCommandReply(cmd, cmdLen);
                        break;
                    default:
                        handled = false;
                        break;
                }

                if (!handled)
                {
                    if (cmdLen > 0)
                    {
                        bytes = stream.ReadBytes((int)cmdLen, slices);
                        cmd.AddField("UnknownData", Util.FormatByteArray(bytes), "Unknown data.", slices);
                    }
                }

                AddTransactionNode(cmd);
            }
            catch (EndOfStreamException e)
            {
                throw new StreamSessionParseError(e.Message);
            }
        }
Пример #2
0
        private void ParseControlCommand()
        {
            List <PacketSlice> slices = new List <PacketSlice>(2);

            UInt16             cmdTypeRaw, cmdLen;
            RRACCommand        cmdType;
            string             cmdTypeStr;
            List <PacketSlice> cmdTypeSlices = new List <PacketSlice>(1);
            List <PacketSlice> cmdLenSlices  = new List <PacketSlice>(1);

            UInt32 u32;

            byte[] bytes;

            try
            {
                // Command type
                cmdTypeRaw = stream.ReadU16(cmdTypeSlices);

                // Command length
                cmdLen = stream.ReadU16(cmdLenSlices);

                ParseCommandType(cmdTypeRaw, out cmdType, out cmdTypeStr);

                TransactionNode cmd = new TransactionNode(cmdTypeStr);

                cmd.AddField("CommandType", cmdTypeStr,
                             "Command type.", cmdTypeSlices);
                cmd.AddField("CommandLength", Convert.ToString(cmdLen),
                             "Number of bytes following this field.", cmdLenSlices);

                if (cmdType != RRACCommand.Response)
                {
                    cmd.Description = cmd.Name;
                }

                bool handled = true;

                switch (cmdType)
                {
                case RRACCommand.GetMetaData:
                    u32 = stream.ReadU32(slices);
                    cmd.AddField("GetMask", Util.FormatFlags(u32),
                                 "A bitmask specifying what metadata to get.", slices);

                    pendingReplies[cmdType] = new GetMetaDataCmd(u32);
                    break;

                case RRACCommand.SetMetaData:
                    u32 = stream.ReadU32(slices);
                    cmd.AddField("PayloadSize", Convert.ToString(u32),
                                 "The number of bytes of payload following this field.", slices);

                    u32 = stream.ReadU32(slices);
                    cmd.AddField("MagicValue", Util.FormatFlags(u32),
                                 "Magic value that must be 0xF0000001.", slices);

                    u32 = stream.ReadU32(slices);
                    cmd.AddField("SetOid", FormatSetType(u32),
                                 "The identifier of the object to set.", slices);

                    pendingReplies[cmdType] = new SetMetaDataCmd(u32);

                    switch (u32)
                    {
                    case SetMetaDataCmd.TYPE_BORING_SSPIDS:
                        bytes = stream.ReadBytes(16, slices);
                        cmd.AddField("FourUnknownDWORDs", Util.FormatByteArray(bytes),
                                     "Four unknown DWORDs.", slices);

                        UInt32 numObjects = stream.ReadU32(slices);
                        cmd.AddField("NumBoringObjects", Convert.ToString(numObjects),
                                     "Number of boring objects following this field.", slices);

                        TransactionNode boringObjects = new TransactionNode("BoringObjects");
                        cmd.AddChild(boringObjects);

                        for (int i = 0; i < numObjects; i++)
                        {
                            u32 = stream.ReadU32(slices);
                            boringObjects.AddField(Convert.ToString(i), Util.FormatFlags(u32),
                                                   "Object type ID.", slices);
                        }
                        break;

                    default:
                        handled = false;
                        cmdLen -= 4 * 3;
                        break;
                    }
                    break;

                case RRACCommand.Notify:
                    UInt32 notifyType = stream.ReadU32(slices);
                    cmd.AddField("NotifyType", FormatNotifyType(notifyType),
                                 "Type of notification.", slices);

                    switch (notifyType)
                    {
                    case NotifyCmd.TYPE_PARTNERSHIPS:
                        u32 = stream.ReadU32(slices);
                        cmd.AddField("Unknown1", Util.FormatFlags(u32),
                                     "Unknown field 1.", slices);

                        u32 = stream.ReadU32(slices);
                        cmd.AddField("Unknown2", Util.FormatFlags(u32),
                                     "Unknown field 2.", slices);

                        u32 = stream.ReadU32(slices);
                        cmd.AddField("Size", Convert.ToString(u32),
                                     "Size of the remaining fields.", slices);

                        u32 = stream.ReadU32(slices);
                        cmd.AddField("PCur", Convert.ToString(u32),
                                     "Current partner index.", slices);

                        u32 = stream.ReadU32(slices);
                        cmd.AddField("P1", Util.FormatFlags(u32),
                                     "Partner 1 ID.", slices);

                        u32 = stream.ReadU32(slices);
                        cmd.AddField("P2", Util.FormatFlags(u32),
                                     "Partner 2 ID.", slices);
                        break;

                    default:
                        handled = false;
                        cmdLen -= 4;
                        break;
                    }
                    break;

                case RRACCommand.Response:
                    ParseCommandReply(cmd, cmdLen);
                    break;

                default:
                    handled = false;
                    break;
                }

                if (!handled)
                {
                    if (cmdLen > 0)
                    {
                        bytes = stream.ReadBytes((int)cmdLen, slices);
                        cmd.AddField("UnknownData", Util.FormatByteArray(bytes), "Unknown data.", slices);
                    }
                }

                AddTransactionNode(cmd);
            }
            catch (EndOfStreamException e)
            {
                throw new StreamSessionParseError(e.Message);
            }
        }