/// <summary> /// Unmarshal and validate the descriptor type from the marshaler buffer. /// </summary> /// <param name="marshaler">The marshaler containing raw data.</param> /// <returns>true indicates that the field is decoded successfully and valid.</returns> protected bool ReadDescriptorType(PduMarshaler marshaler) { bDescriptorType = UsbDescriptorTypes.UNKNOWN; byte b = marshaler.ReadByte(); // TODO: don't hard-code. if (b > 8 || b < 1) { return false; } bDescriptorType = (UsbDescriptorTypes)b; return true; }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { length = marshaler.ReadUInt16(); interfaceNumber = marshaler.ReadByte(); alternateSetting = marshaler.ReadByte(); class_field = marshaler.ReadByte(); subClass = marshaler.ReadByte(); protocol = marshaler.ReadByte(); padding = marshaler.ReadByte(); interfaceHandle = marshaler.ReadUInt32(); numberOfPipes = marshaler.ReadUInt32(); if (numberOfPipes > 0) { pipes = new TS_USBD_PIPE_INFORMATION_RESULT[numberOfPipes]; for (int i = 0; i < pipes.Length; i++) { pipes[i] = new TS_USBD_PIPE_INFORMATION_RESULT(); pipes[i].Decode(marshaler); } } else { pipes = null; } } catch (Exception) { return false; } return true; }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { this.Header.cbSize = marshaler.ReadUInt32(); this.Header.PacketType = (PacketTypeValues)marshaler.ReadUInt32(); this.PresentatioinId = marshaler.ReadByte(); this.ResponseFlags = marshaler.ReadByte(); this.ResultFlags = marshaler.ReadUInt16(); return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { if (!base.Decode(marshaler)) return false; this.tileSize = marshaler.ReadByte(); this.numRects = marshaler.ReadUInt16(); this.numQuant = marshaler.ReadByte(); this.numProgQuant = marshaler.ReadByte(); this.flags = marshaler.ReadByte(); this.decodedLen += 6; this.numTiles = marshaler.ReadUInt16(); this.tileDataSize = marshaler.ReadUInt32(); this.decodedLen += 6; this.rects = new TS_RFX_RECT[this.numRects]; for (int i = 0; i < this.numRects; i++) { this.rects[i].x = marshaler.ReadUInt16(); this.rects[i].y = marshaler.ReadUInt16(); this.rects[i].width = marshaler.ReadUInt16(); this.rects[i].height = marshaler.ReadUInt16(); this.decodedLen += (uint)Marshal.SizeOf(this.rects[i]); } this.quantVals = new TS_RFX_CODEC_QUANT[this.numQuant]; for (int i = 0; i < this.numQuant; i++) { this.quantVals[i].LL3_LH3 = marshaler.ReadByte(); this.quantVals[i].HL3_HH3 = marshaler.ReadByte(); this.quantVals[i].LH2_HL2 = marshaler.ReadByte(); this.quantVals[i].HH2_LH1 = marshaler.ReadByte(); this.quantVals[i].HL1_HH1 = marshaler.ReadByte(); this.decodedLen += 5; } this.quantProgVals = new RFX_PROGRESSIVE_CODEC_QUANT[this.numProgQuant]; for (int i = 0; i < this.numProgQuant; i++) { int quantProgSize = Marshal.SizeOf(this.quantProgVals[i]); byte[] rawData = marshaler.ReadBytes(quantProgSize); GCHandle handle = GCHandle.Alloc(rawData, GCHandleType.Pinned); try { IntPtr rawDataPtr = handle.AddrOfPinnedObject(); this.quantProgVals[i] = (RFX_PROGRESSIVE_CODEC_QUANT)Marshal.PtrToStructure(rawDataPtr, typeof(RFX_PROGRESSIVE_CODEC_QUANT)); } finally { handle.Free(); } this.decodedLen += (uint)quantProgSize; } return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { maximumPacketSize = marshaler.ReadUInt16(); endpointAddress = marshaler.ReadByte(); interval = marshaler.ReadByte(); pipeType = marshaler.ReadUInt32(); pipeHandle = marshaler.ReadUInt32(); maximumTransferSize = marshaler.ReadUInt32(); pipeFlags = marshaler.ReadUInt32(); } catch (Exception) { return false; } return true; }
public bool Decode(PduMarshaler marshaler) { try { byte t = marshaler.ReadByte(); c = (FOUR_BYTE_C_Values)(t >> 6); val1 = (byte)(t & 0x3F); if (c >= FOUR_BYTE_C_Values.TWO_BYTE_VAL) { val2 = marshaler.ReadByte(); } if (c >= FOUR_BYTE_C_Values.THREE_BYTE_VAL) { val3 = marshaler.ReadByte(); } if (c == FOUR_BYTE_C_Values.FOUR_BYTE_VAL) { val4 = marshaler.ReadByte(); } return true; } catch { return false; } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { if (!base.Decode(marshaler)) return false; this.quantIdxY = marshaler.ReadByte(); this.quantIdxCb = marshaler.ReadByte(); this.quantIdxCr = marshaler.ReadByte(); this.xIdx = marshaler.ReadUInt16(); this.yIdx = marshaler.ReadUInt16(); this.progressiveQuality = marshaler.ReadByte(); this.decodedLen += 8; this.ySrlLen = marshaler.ReadUInt16(); this.yRawLen = marshaler.ReadUInt16(); this.cbSrlLen = marshaler.ReadUInt16(); this.cbRawLen = marshaler.ReadUInt16(); this.crSrlLen = marshaler.ReadUInt16(); this.crRawLen = marshaler.ReadUInt16(); this.decodedLen += 12; this.ySrlData = marshaler.ReadBytes((int)this.ySrlLen); this.decodedLen += this.ySrlLen; this.yRawData = marshaler.ReadBytes((int)this.yRawLen); this.decodedLen += this.yRawLen; this.cbSrlData = marshaler.ReadBytes((int)this.cbSrlLen); this.decodedLen += this.cbSrlLen; this.cbRawData = marshaler.ReadBytes((int)this.cbRawLen); this.decodedLen += this.cbRawLen; this.crSrlData = marshaler.ReadBytes((int)this.crSrlLen); this.decodedLen += this.crSrlLen; this.crRawData = marshaler.ReadBytes((int)this.crRawLen); this.decodedLen += this.crRawLen; return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { this.descriptor = (DescriptorTypes)marshaler.ReadByte(); if (this.descriptor == DescriptorTypes.SINGLE) { this.bulkData = new RDP8_BULK_ENCODED_DATA(); this.bulkData.header = marshaler.ReadByte(); this.bulkData.data = marshaler.ReadToEnd(); } else { this.segmentCount = marshaler.ReadUInt16(); this.uncompressedSize = marshaler.ReadUInt32(); if (this.segmentCount > 0) { this.segmentArray = new RDP_DATA_SEGMENT[this.segmentCount]; for (int i = 0; i < this.segmentCount; i++) { this.segmentArray[i].size = marshaler.ReadUInt32(); if (this.segmentArray[i].size > 0) { this.segmentArray[i].bulkData = new RDP8_BULK_ENCODED_DATA(); this.segmentArray[i].bulkData.header = marshaler.ReadByte(); this.segmentArray[i].bulkData.data = marshaler.ReadBytes((int)this.segmentArray[i].size - 1); } } } } return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
public override bool Decode(PduMarshaler marshaler) { try { byte actionFlags = marshaler.ReadByte(); this.Action = (RDP_TUNNEL_ACTION_Values)(byte)(actionFlags & 0xF); this.Flags = (byte)(actionFlags & 0xF0); this.PayloadLength = marshaler.ReadUInt16(); this.HeaderLength = marshaler.ReadByte(); if (this.HeaderLength > 4) { int subHdTotalLen = this.HeaderLength - 4; int curDecodedLen = 0; List<RDP_TUNNEL_SUBHEADER> subHds = new List<RDP_TUNNEL_SUBHEADER>(); while (subHdTotalLen > curDecodedLen) { byte subHdLen = marshaler.ReadByte(); byte subHdType = marshaler.ReadByte(); byte[] subHdData = null; if (subHdLen > 2) { subHdData = marshaler.ReadBytes(subHdLen - 2); } RDP_TUNNEL_SUBHEADER subHd = new RDP_TUNNEL_SUBHEADER(); subHd.SubHeaderLength = subHdLen; subHd.SubHeaderType = (RDP_TUNNEL_SUBHEADER_TYPE_Values)subHdType; subHd.SubHeaderData = subHdData; subHds.Add(subHd); curDecodedLen += subHdLen; } this.SubHeaders = subHds.ToArray(); } return true; } catch { return false; ; } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { base.Decode(marshaler); bInterfaceNumber = marshaler.ReadByte(); bAlternateSetting = marshaler.ReadByte(); bNumEndpoints = marshaler.ReadByte(); bInterfaceClass = marshaler.ReadByte(); bInterfaceSubClass = marshaler.ReadByte(); bInterfaceProtocol = marshaler.ReadByte(); iInterface = marshaler.ReadByte(); return true; }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { this.cbGeometryData = marshaler.ReadUInt32(); this.Version = (RdpegtVersionValues)marshaler.ReadUInt32(); this.MappingId = marshaler.ReadUInt64(); this.UpdateType = (UpdateTypeValues)marshaler.ReadUInt32(); this.Flags = marshaler.ReadUInt32(); this.TopLevelId = marshaler.ReadUInt64(); this.Left = marshaler.ReadUInt32(); this.Top = marshaler.ReadUInt32(); this.Right = marshaler.ReadUInt32(); this.Bottom = marshaler.ReadUInt32(); this.TopLevelLeft = marshaler.ReadUInt32(); this.TopLevelTop = marshaler.ReadUInt32(); this.TopLevelRight = marshaler.ReadUInt32(); this.TopLevelBottom = marshaler.ReadUInt32(); this.GeometryType = (GeometryTypeValues)marshaler.ReadUInt32(); this.cbGeometryBuffer = marshaler.ReadUInt32(); //Decode RGNDATA this.pGeometryBuffer.rdh.dwSize = marshaler.ReadUInt32(); this.pGeometryBuffer.rdh.iType = marshaler.ReadUInt32(); this.pGeometryBuffer.rdh.nCount = marshaler.ReadUInt32(); this.pGeometryBuffer.rdh.nRgnSize = marshaler.ReadUInt32(); DecodeRect(marshaler, out this.pGeometryBuffer.rdh.rcBound); this.pGeometryBuffer.Buffer = new RECT[this.pGeometryBuffer.rdh.nCount]; for (int i = 0; i < this.pGeometryBuffer.Buffer.Length; i++) { DecodeRect(marshaler, out this.pGeometryBuffer.Buffer[i]); } this.Reserved2 = marshaler.ReadByte(); return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { base.Decode(marshaler); bEndpointAddress = marshaler.ReadByte(); bmAttributes = marshaler.ReadByte(); wMaxPacketSize = marshaler.ReadByte(); bInterval = marshaler.ReadByte(); return true; }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { base.Decode(marshaler); bcdUSB = marshaler.ReadUInt16(); bDeviceClass = marshaler.ReadByte(); bDeviceSubClass = marshaler.ReadByte(); bDeviceProtocol = marshaler.ReadByte(); bMaxPacketSize0 = marshaler.ReadByte(); idVendor = marshaler.ReadUInt16(); idProduct = marshaler.ReadUInt16(); bcdDevice = marshaler.ReadUInt16(); iManufacturer = marshaler.ReadByte(); iProduct = marshaler.ReadByte(); iSerialNumber = marshaler.ReadByte(); bNumConfigurations = marshaler.ReadByte(); return true; }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { base.Decode(marshaler); wTotalLength = marshaler.ReadUInt16(); bNumInterfaces = marshaler.ReadByte(); bConfigurationValue = marshaler.ReadByte(); iConfiguration = marshaler.ReadByte(); bmAttributes = marshaler.ReadByte(); MaxPower = marshaler.ReadByte(); return true; }
public bool Decode(PduMarshaler marshaler) { try { byte t = marshaler.ReadByte(); c = (TWO_BYTE_C_Values)(t >> 7); val1 = (byte)(t & 0x7F); if (c == TWO_BYTE_C_Values.TWO_BYTE_VAL) { val2 = marshaler.ReadByte(); } return true; } catch { return false; } }
public override bool Decode(PduMarshaler marshaler) { try { this.SubHeaderLength = marshaler.ReadByte(); this.SubHeaderType = (RDP_TUNNEL_SUBHEADER_TYPE_Values)marshaler.ReadByte(); if (this.SubHeaderLength > 2) { this.SubHeaderData = marshaler.ReadBytes(this.SubHeaderLength - 2); } return true; } catch { return false; } }
public bool Decode(PduMarshaler marshaler) { try { byte t = marshaler.ReadByte(); c = (EIGHT_BYTE_C_Values)(t >> 5); val1 = (byte)(t & 0x1F); if (c >= EIGHT_BYTE_C_Values.TWO_BYTE_VAL) { val2 = marshaler.ReadByte(); } if (c >= EIGHT_BYTE_C_Values.THREE_BYTE_VAL) { val3 = marshaler.ReadByte(); } if (c >= EIGHT_BYTE_C_Values.FOUR_BYTE_VAL) { val4 = marshaler.ReadByte(); } if (c >= EIGHT_BYTE_C_Values.FIVE_BYTE_VAL) { val5 = marshaler.ReadByte(); } if (c >= EIGHT_BYTE_C_Values.SIX_BYTE_VAL) { val6 = marshaler.ReadByte(); } if (c >= EIGHT_BYTE_C_Values.SEVEN_BYTE_VAL) { val7 = marshaler.ReadByte(); } if (c == EIGHT_BYTE_C_Values.EIGHT_BYTE_VAL) { val8 = marshaler.ReadByte(); } return true; } catch { return false; } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to encode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { base.Decode(marshaler); this.surfaceId = marshaler.ReadUInt16(); pduLen += 2; this.fillPixel.R = marshaler.ReadByte(); this.fillPixel.G = marshaler.ReadByte(); this.fillPixel.B = marshaler.ReadByte(); this.fillPixel.XA = marshaler.ReadByte(); pduLen += 4; this.fillRectCount = marshaler.ReadUInt16(); pduLen += 2; for (int i = 0; i < this.fillRectCount; i++) { RDPGFX_RECT16 rect; rect.left = marshaler.ReadUInt16(); rect.top = marshaler.ReadUInt16(); rect.right = marshaler.ReadUInt16(); rect.bottom = marshaler.ReadUInt16(); fillRectList.Add(rect); pduLen += (uint)Marshal.SizeOf(rect); } return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { if (!base.Decode(marshaler)) return false; this.quantIdxY = marshaler.ReadByte(); this.quantIdxCb = marshaler.ReadByte(); this.quantIdxCr = marshaler.ReadByte(); this.xIdx = marshaler.ReadUInt16(); this.yIdx = marshaler.ReadUInt16(); this.flags = marshaler.ReadBool(); this.decodedLen += 8; this.yLen = marshaler.ReadUInt16(); this.cbLen = marshaler.ReadUInt16(); this.crLen = marshaler.ReadUInt16(); this.tailLen = marshaler.ReadUInt16(); this.decodedLen += 8; this.yData = marshaler.ReadBytes((int)this.yLen); this.decodedLen += this.yLen; this.cbData = marshaler.ReadBytes((int)this.cbLen); this.decodedLen += this.cbLen; this.crData = marshaler.ReadBytes((int)this.crLen); this.decodedLen += this.crLen; this.tailData = marshaler.ReadBytes((int)this.tailLen); this.decodedLen += this.tailLen; return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { base.Decode(marshaler); this.surfaceId = marshaler.ReadUInt16(); pduLen += 2; this.codecId = (CodecType)marshaler.ReadUInt16(); pduLen += 2; this.pixelFormat = (PixelFormat)marshaler.ReadByte(); pduLen ++; // Destination rectangle. this.destRect.left = marshaler.ReadUInt16(); this.destRect.top = marshaler.ReadUInt16(); this.destRect.right = marshaler.ReadUInt16(); this.destRect.bottom = marshaler.ReadUInt16(); pduLen += 8; // Bitmap. this.bitmapDataLength = marshaler.ReadUInt32(); pduLen += 4; this.bitmapData = marshaler.ReadBytes((int)this.bitmapDataLength); pduLen += this.bitmapDataLength; return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { if (!base.Decode(marshaler)) return false; this.ctxId = marshaler.ReadByte(); this.tileSize = marshaler.ReadUInt16(); this.flags = marshaler.ReadByte(); this.decodedLen += 4; return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { base.Decode(marshaler); this.surfaceId = marshaler.ReadUInt16(); pduLen += 2; this.codecId = (CodecType)marshaler.ReadUInt16(); pduLen += 2; this.codecContextId = marshaler.ReadUInt32(); pduLen += 4; this.pixelFormat = (PixelFormat)marshaler.ReadByte(); pduLen++; // Bitmap. this.bitmapDataLength = marshaler.ReadUInt32(); pduLen += 4; this.bitmapData = marshaler.ReadBytes((int)this.bitmapDataLength); pduLen += this.bitmapDataLength; return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
public override bool Decode(PduMarshaler marshaler) { try { fecHeader.snSourceAck = marshaler.ReadUInt32(); fecHeader.uReceiveWindowSize = marshaler.ReadUInt16(); fecHeader.uFlags = (RDPUDP_FLAG)marshaler.ReadUInt16(); if (fecHeader.uFlags.HasFlag(RDPUDP_FLAG.RDPUDP_FLAG_SYN)) { RDPUDP_SYNDATA_PAYLOAD synData = new RDPUDP_SYNDATA_PAYLOAD(); synData.snInitialSequenceNumber = marshaler.ReadUInt32(); synData.uUpStreamMtu = marshaler.ReadUInt16(); synData.uDownStreamMtu = marshaler.ReadUInt16(); // This datagram MUST be zero-padded to increase the size of this datagram to 1232 bytes. if (fecHeader.uFlags.HasFlag(RDPUDP_FLAG.RDPUDP_FLAG_CORRELATION_ID)) { RDPUDP_CORRELATION_ID_PAYLOAD correlationId = new RDPUDP_CORRELATION_ID_PAYLOAD(); correlationId.uCorrelationId = marshaler.ReadBytes(16); this.CorrelationId = correlationId; correlationId.uReserved = marshaler.ReadBytes(16); } this.padding = marshaler.ReadToEnd(); this.SynData = synData; return true; } if (fecHeader.uFlags.HasFlag(RDPUDP_FLAG.RDPUDP_FLAG_ACK)) { // ACK. RDPUDP_ACK_VECTOR_HEADER ackVector = new RDPUDP_ACK_VECTOR_HEADER(); ackVector.uAckVectorSize = marshaler.ReadUInt16(); ackVector.AckVectorElement = new AckVector[ackVector.uAckVectorSize]; List<byte> ackVecElementList = new List<byte>(marshaler.ReadBytes(ackVector.AckVectorElement.Length)); ackVecElementList.Reverse(); for (int i = 0; i < ackVector.AckVectorElement.Length; i++) { byte vecByte = ackVecElementList[i]; ackVector.AckVectorElement[i].Length = (byte)(0x3F & vecByte); ackVector.AckVectorElement[i].State = (VECTOR_ELEMENT_STATE)(vecByte >> 6); } this.ackVectorHeader = ackVector; // Padding (variable): A variable-sized array, of length zero or more, // such that this structure ends on a DWORD ([MS-DTYP] section 2.2.9) boundary. int padLen = 4 - (2 + ackVector.AckVectorElement.Length) % 4; if (padLen > 0 && padLen != 4) { this.padding = marshaler.ReadBytes(padLen); } // Ack of Acks. if (fecHeader.uFlags.HasFlag(RDPUDP_FLAG.RDPUDP_FLAG_ACK_OF_ACKS)) { RDPUDP_ACK_OF_ACKVECTOR_HEADER aoaHeader = new RDPUDP_ACK_OF_ACKVECTOR_HEADER(); aoaHeader.snAckOfAcksSeqNum = marshaler.ReadUInt32(); this.ackOfAckVector = aoaHeader; } } if (fecHeader.uFlags.HasFlag(RDPUDP_FLAG.RDPUDP_FLAG_DATA)) { if (!fecHeader.uFlags.HasFlag(RDPUDP_FLAG.RDPUDP_FLAG_FEC)) { // Source Data. RDPUDP_SOURCE_PAYLOAD_HEADER srcHeader = new RDPUDP_SOURCE_PAYLOAD_HEADER(); srcHeader.snCoded = marshaler.ReadUInt32(); srcHeader.snSourceStart = marshaler.ReadUInt32(); this.sourceHeader = srcHeader; } else { // FEC Data. RDPUDP_FEC_PAYLOAD_HEADER fecDataHeader = new RDPUDP_FEC_PAYLOAD_HEADER(); fecDataHeader.snCoded = marshaler.ReadUInt32(); fecDataHeader.snSourceStart = marshaler.ReadUInt32(); fecDataHeader.uRange = marshaler.ReadByte(); fecDataHeader.uFecIndex = marshaler.ReadByte(); fecDataHeader.uPadding = marshaler.ReadUInt16(); this.fecPayloadHeader = fecDataHeader; } this.payload = marshaler.ReadToEnd(); } return true; } catch { return false; } }
/// <summary> /// Encode this PDU to the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to encode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { base.Decode(marshaler); this.surfaceId = marshaler.ReadUInt16(); pduLen += 2; this.width = marshaler.ReadUInt16(); pduLen += 2; this.height = marshaler.ReadUInt16(); pduLen += 2; this.pixFormat = (PixelFormat)(marshaler.ReadByte()); pduLen++; return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { len = marshaler.ReadUInt16(); numberOfPipes = marshaler.ReadUInt16(); interfaceNumber = marshaler.ReadByte(); alternateSetting = marshaler.ReadByte(); padding = marshaler.ReadUInt16(); numberOfPipes = marshaler.ReadUInt32(); informations = new TS_USBD_PIPE_INFORMATION[numberOfPipes]; for (int i = 0; i < numberOfPipes; i++) { informations[i].Decode(marshaler); } } catch (Exception) { // TODO: All generic exceptions should be got rid of. return false; } return true; }
public override bool Decode(PduMarshaler marshaler) { base.Decode(marshaler); contactId = marshaler.ReadByte(); return true; }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to encode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { this.Header.cbSize = marshaler.ReadUInt32(); this.Header.PacketType = (PacketTypeValues)marshaler.ReadUInt32(); this.PresentatioinId = marshaler.ReadByte(); this.Version = (RdpevorVersionValues)marshaler.ReadByte(); this.Command = (CommandValues)marshaler.ReadByte(); this.FrameRate = marshaler.ReadByte(); this.AverageBitrateKbps = marshaler.ReadUInt16(); this.Reserved = marshaler.ReadUInt16(); this.SourceWidth = marshaler.ReadUInt32(); this.SourceHeight = marshaler.ReadUInt32(); this.ScaledWidth = marshaler.ReadUInt32(); this.ScaledHeight = marshaler.ReadUInt32(); this.hnsTimestampOffset = marshaler.ReadUInt64(); this.GeometryMappingId = marshaler.ReadUInt64(); this.VideoSubtypeId = marshaler.ReadBytes(16); this.cbExtra = marshaler.ReadUInt32(); this.pExtraData = marshaler.ReadBytes((int)this.cbExtra); this.Reserved2 = marshaler.ReadByte(); return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
public override bool Decode(PduMarshaler marshaler) { try { if (!base.Decode(marshaler)) { return false; } encodeTime = new FOUR_BYTE_UNSIGNED_INTEGER(); if (!encodeTime.Decode(marshaler)) { return false; } frameCount = new TWO_BYTE_UNSIGNED_INTEGER(); if (!frameCount.Decode(marshaler)) { return false; } ushort count = frameCount.ToUShort(); if (count > 0) { frames = new RDPINPUT_TOUCH_FRAME[count]; } for (int i = 0; i < count; i++) { frames[i] = new RDPINPUT_TOUCH_FRAME(); if (!frames[i].contactCount.Decode(marshaler) || !frames[i].frameOffset.Decode(marshaler)) { return false; } ushort contactCount = frames[i].contactCount.ToUShort(); if (contactCount > 0) { frames[i].contacts = new RDPINPUT_CONTACT_DATA[contactCount]; } for (int j = 0; j < contactCount; j++) { frames[i].contacts[j] = new RDPINPUT_CONTACT_DATA(); frames[i].contacts[j].contactId = marshaler.ReadByte(); if (!frames[i].contacts[j].fieldsPresent.Decode(marshaler) || !frames[i].contacts[j].x.Decode(marshaler) || !frames[i].contacts[j].y.Decode(marshaler) || !frames[i].contacts[j].contactFlags.Decode(marshaler)) { return false; } ushort fieldsPresent = frames[i].contacts[j].fieldsPresent.ToUShort(); if ((ushort)(fieldsPresent & (ushort)(RDPINPUT_CONTACT_DATA_FieldsPresent.CONTACT_DATA_CONTACTRECT_PRESENT)) == (ushort)RDPINPUT_CONTACT_DATA_FieldsPresent.CONTACT_DATA_CONTACTRECT_PRESENT) { TWO_BYTE_SIGNED_INTEGER left = new TWO_BYTE_SIGNED_INTEGER(); if (!left.Decode(marshaler)) { return false; } frames[i].contacts[j].contactRectLeft = left; TWO_BYTE_SIGNED_INTEGER top = new TWO_BYTE_SIGNED_INTEGER(); if (!top.Decode(marshaler)) { return false; } frames[i].contacts[j].contactRectTop = top; TWO_BYTE_SIGNED_INTEGER right = new TWO_BYTE_SIGNED_INTEGER(); if (!right.Decode(marshaler)) { return false; } frames[i].contacts[j].contactRectRight = right; TWO_BYTE_SIGNED_INTEGER bottom = new TWO_BYTE_SIGNED_INTEGER(); if (!bottom.Decode(marshaler)) { return false; } frames[i].contacts[j].contactRectBottom = bottom; } if ((ushort)(fieldsPresent & (ushort)(RDPINPUT_CONTACT_DATA_FieldsPresent.CONTACT_DATA_ORIENTATION_PRESENT)) == (ushort)RDPINPUT_CONTACT_DATA_FieldsPresent.CONTACT_DATA_ORIENTATION_PRESENT) { FOUR_BYTE_UNSIGNED_INTEGER orientation = new FOUR_BYTE_UNSIGNED_INTEGER(); if (!orientation.Decode(marshaler)) { return false; } frames[i].contacts[j].orientation = orientation; } if ((ushort)(fieldsPresent & (ushort)(RDPINPUT_CONTACT_DATA_FieldsPresent.CONTACT_DATA_PRESSURE_PRESENT)) == (ushort)RDPINPUT_CONTACT_DATA_FieldsPresent.CONTACT_DATA_PRESSURE_PRESENT) { FOUR_BYTE_UNSIGNED_INTEGER pressure = new FOUR_BYTE_UNSIGNED_INTEGER(); if (!pressure.Decode(marshaler)) { return false; } frames[i].contacts[j].pressure = pressure; } } } return true; } catch { return false; } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to encode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { try { this.Header.cbSize = marshaler.ReadUInt32(); this.Header.PacketType = (PacketTypeValues)marshaler.ReadUInt32(); this.PresentatioinId = marshaler.ReadByte(); this.Version = (RdpevorVersionValues)marshaler.ReadByte(); this.Flags = (TsmmVideoData_FlagsValues)marshaler.ReadByte(); this.Reserved = marshaler.ReadByte(); this.HnsTimestamp = marshaler.ReadUInt64(); this.HnsDuration = marshaler.ReadUInt64(); this.CurrentPacketIndex = marshaler.ReadUInt16(); this.PacketsInSample = marshaler.ReadUInt16(); this.SampleNumber = marshaler.ReadUInt32(); this.cbSample = marshaler.ReadUInt32(); this.pSample = marshaler.ReadBytes((int)this.cbSample); this.Reserved2 = marshaler.ReadByte(); return true; } catch { marshaler.Reset(); throw new PDUDecodeException(this.GetType(), marshaler.ReadToEnd()); } }
/// <summary> /// Decode this PDU from the PduMarshaler. /// </summary> /// <param name="marshaler">This is used to decode the fields of this PDU.</param> public override bool Decode(PduMarshaler marshaler) { bLength = marshaler.ReadByte(); if (!ReadDescriptorType(marshaler)) { return false; } return true; }