/// <summary> /// Establish a DVC after received a Create Request PDU /// </summary> /// <param name="createReq"></param> /// <param name="transportType"></param> /// <param name="receiveCallBack"></param> private void EstablishChannel(CreateReqDvcPdu createReq, DynamicVC_TransportType transportType, ReceiveData receiveCallBack = null) { if (channelDicbyId.ContainsKey(createReq.ChannelId)) { throw new InvalidOperationException("Cannot establish the DVC, since a channel with same channelId have been established. Channel ID is " + createReq.ChannelId); } DynamicVirtualChannel channel = new DynamicVirtualChannel(createReq.ChannelId, createReq.ChannelName, (ushort)createReq.HeaderBits.Sp, transportDic[transportType]); if (receiveCallBack != null) { // Add event method here can make sure processing the first DVC data packet channel.Received += receiveCallBack; } else { if (callBackMethodsDic != null && callBackMethodsDic.ContainsKey(createReq.ChannelName)) { channel.Received += callBackMethodsDic[createReq.ChannelName]; } } channelDicbyId.Add(createReq.ChannelId, channel); this.SendDVCCreateResponsePDU(createReq.ChannelId, 0, transportType); }
/// <summary> /// Expect server send a create SVC request /// </summary> /// <param name="timeout">Timeout</param> /// <param name="channelName">Channel Name</param> /// <param name="transportType">Transport Type</param> /// <returns></returns> public DynamicVirtualChannel ExpectChannel(TimeSpan timeout, string channelName, DynamicVC_TransportType transportType) { if (autoCreateChannel) { throw new InvalidOperationException("Cannot establish a DVC manually if autoCreateChannel is true!"); } if (!transportDic.ContainsKey(transportType)) { throw new InvalidOperationException("DVC transport:" + transportType + " does not exist."); } CreateReqDvcPdu createReq = this.ExpectDVCCreateRequestPDU(timeout, channelName, transportType); if (createReq == null) { throw new System.IO.IOException("Creation of channel: " + channelName + " failed, cannot receive a Create Request PDU"); } DynamicVirtualChannel channel = new DynamicVirtualChannel(createReq.ChannelId, channelName, (ushort)createReq.HeaderBits.Sp, transportDic[transportType]); channelDicbyId.Add(createReq.ChannelId, channel); this.SendDVCCreateResponsePDU(createReq.ChannelId, 0, transportType); return(channel); }
/// <summary> /// Create a dynamic virtual channel /// </summary> /// <param name="priority">Priority</param> /// <param name="channelName">Channel name</param> /// <param name="transportType">Transport type</param> /// <param name="receiveCallBack">Callback method called when received data</param> /// <returns>DVC created</returns> public DynamicVirtualChannel CreateChannel(TimeSpan timeout, ushort priority, string channelName, DynamicVC_TransportType transportType, ReceiveData receiveCallBack = null) { if (!transportDic.ContainsKey(transportType)) { throw new InvalidOperationException("Not create DVC transport:" + transportType); } UInt32 channelId = DynamicVirtualChannel.NewChannelId(); DynamicVirtualChannel channel = new DynamicVirtualChannel(channelId, channelName, priority, transportDic[transportType]); if (receiveCallBack != null) { // Add event method here can make sure processing the first DVC data packet channel.Received += receiveCallBack; } channelDicbyId.Add(channelId, channel); this.SendDVCCreateRequestPDU(priority, channelId, channelName, transportType); CreateRespDvcPdu createResp = this.ExpectDVCCreateResponsePDU(timeout, channelId, transportType); if (createResp == null) { throw new System.IO.IOException("Creation of channel: " + channelName + " failed, cannot receive a Create Response PDU"); } if (createResp.CreationStatus < 0) { //Create failed throw new System.IO.IOException("Creation of DVC failed with error code: " + createResp.CreationStatus + ", channel name is " + channelName); } return(channel); }
/// <summary> /// Close a channel after received a Close DVC PDU /// </summary> /// <param name="pdu"></param> private void CloseChannel(CloseDvcPdu pdu) { if (!channelDicbyId.ContainsKey(pdu.ChannelId)) { throw new InvalidOperationException("The channel has not been created, channel id:" + pdu.ChannelId); } DynamicVirtualChannel channel = channelDicbyId[pdu.ChannelId]; channelDicbyId.Remove(channel.ChannelId); channel.IsActive = false; }
/// <summary> /// Establish a DVC after received a Create Request PDU /// </summary> /// <param name="createReq"></param> /// <param name="transportType"></param> /// <param name="receiveCallBack"></param> private void EstablishChannel(CreateReqDvcPdu createReq, DynamicVC_TransportType transportType, ReceiveData receiveCallBack = null) { if (channelDicbyId.ContainsKey(createReq.ChannelId)) { throw new InvalidOperationException("Cannot establish the DVC, since a channel with same channelId have been established. Channel ID is " + createReq.ChannelId); } DynamicVirtualChannel channel = new DynamicVirtualChannel(createReq.ChannelId, createReq.ChannelName, (ushort)createReq.HeaderBits.Sp, transportDic[transportType]); channelDicbyId.Add(createReq.ChannelId, channel); this.SendDVCCreateResponsePDU(createReq.ChannelId, 0, transportType); }
/// <summary> /// Expect server send a close DVC request /// </summary> /// <param name="channelId">Channel Id</param> public void CloseChannel(UInt16 channelId) { if (!channelDicbyId.ContainsKey(channelId)) { throw new InvalidOperationException("The channel has not been created, channel id:" + channelId); } DynamicVirtualChannel channel = channelDicbyId[channelId]; // Send DVC close PDU this.SendDVCClosePDU(channelId, channel.TransportType); // Remove the channel from dictionary channelDicbyId.Remove(channelId); }
/// <summary> /// Expect to create a SVC /// </summary> /// <param name="timeout">Timeout</param> /// <param name="channelName">Channel Name</param> /// <param name="transportType">Transport Type</param> /// <returns></returns> public DynamicVirtualChannel ExpectChannel(TimeSpan timeout, string channelName, DynamicVC_TransportType transportType, ReceiveData receiveCallBack = null) { if (autoCreateChannel) { throw new InvalidOperationException("Cannot establish a DVC manually if autoCreateChannel is true!"); } if (!transportDic.ContainsKey(transportType)) { throw new InvalidOperationException("Not create DVC transport:" + transportType); } CreateReqDvcPdu createReq = this.ExpectDVCCreateRequestPDU(timeout, channelName, transportType); if (createReq == null) { throw new System.IO.IOException("Creation of channel: " + channelName + " failed, cannot receive a Create Request PDU"); } DynamicVirtualChannel channel = new DynamicVirtualChannel(createReq.ChannelId, channelName, (ushort)createReq.HeaderBits.Sp, transportDic[transportType]); if (receiveCallBack != null) { // Add event method here can make sure processing the first DVC data packet channel.Received += receiveCallBack; } else { if (callBackMethodsDic != null && callBackMethodsDic.ContainsKey(channelName)) { channel.Received += callBackMethodsDic[channelName]; } } channelDicbyId.Add(createReq.ChannelId, channel); this.SendDVCCreateResponsePDU(createReq.ChannelId, 0, transportType); return(channel); }
/// <summary> /// Receives an IOCONTROL_COMPLETION, URB_COMPLETION or URB_COMPLETION_NO_DATA request from the client. /// </summary> /// <param name="channel">The channel to be received in.</param> /// <returns>The received completion PDU. Returns null, if timeout or required .</returns> public EusbPdu ExpectCompletion(DynamicVirtualChannel channel) { EusbPdu pdu = this.rdpeusbServer.ExpectRdpeusbPdu<EusbPdu>(channel.ChannelId, waitTime); if (null == pdu) { return null; } bool isCompletionPdu = ( (pdu is EusbIoControlCompletionPdu) || (pdu is EusbUrbCompletionPdu) || (pdu is EusbUrbCompletionNoDataPdu) ); Site.Assert.IsTrue(isCompletionPdu, "Expect a completion PDU, current pdu is {0}.", pdu.ToString()); return pdu; }
/// <summary> /// Wait for creation of dynamic virtual channel for RDPEGT /// </summary> /// <param name="timeout"></param> /// <param name="transportType"></param> /// <returns></returns> public bool WaitForRdpegtDvcCreation(TimeSpan timeout, DynamicVC_TransportType transportType = DynamicVC_TransportType.RDP_TCP) { try { rdpegtDVC = rdpedycClient.ExpectChannel(timeout, RdpegtChannelName, transportType, OnDataReceived); } catch { } if (rdpegtDVC != null) { return true; } return false; }
/// <summary> /// Create a dynamic virtual channel /// </summary> /// <param name="priority">Priority</param> /// <param name="channelName">Channel name</param> /// <param name="transportType">Transport type</param> /// <param name="receiveCallBack">Callback method called when received data</param> /// <returns>DVC created</returns> public DynamicVirtualChannel CreateChannel(TimeSpan timeout, ushort priority, string channelName, DynamicVC_TransportType transportType, ReceiveData receiveCallBack = null, uint? channelId = null) { if (!transportDic.ContainsKey(transportType)) { throw new InvalidOperationException("Not create DVC transport:" + transportType); } if (channelId == null) channelId = DynamicVirtualChannel.NewChannelId(); DynamicVirtualChannel channel = new DynamicVirtualChannel((UInt32)channelId, channelName, priority, transportDic[transportType]); if (receiveCallBack != null) { // Add event method here can make sure processing the first DVC data packet channel.Received += receiveCallBack; } channelDicbyId.Add((UInt32)channelId, channel); this.SendDVCCreateRequestPDU(priority, (UInt32)channelId, channelName, transportType); CreateRespDvcPdu createResp = this.ExpectDVCCreateResponsePDU(timeout, (UInt32)channelId, transportType); if (createResp == null) { throw new System.IO.IOException("Creation of channel: " + channelName + " failed, cannot receive a Create Response PDU"); } if (createResp.CreationStatus < 0) { //Create failed throw new System.IO.IOException("Creation of DVC failed with error code: " + createResp.CreationStatus + ", channel name is " + channelName); } return channel; }
private void SendPdu(EusbPdu pdu, DynamicVirtualChannel channel) { Site.Assume.IsNotNull(channel, "DynamicVirtualChannel must be initialized."); channel.Send(PduMarshaler.Marshal(pdu)); Site.Log.Add(LogEntryKind.Debug, "Sending {0}: \r\n{1}\r\n", pdu.GetType().ToString(), pdu.ToString()); }
private bool IsChannelClosed(DynamicVirtualChannel channel) { double timeout = Config.Timeout.TotalMilliseconds; const int wait = 100; Thread.Sleep(wait); timeout -= wait; while (timeout >= 0 && channel.IsActive) { Thread.Sleep(wait); timeout -= wait; } if (channel.IsActive) { Site.Log.Add(LogEntryKind.Debug, "The channel {0} is not closed within {1}", channel.ChannelId, Config.Timeout.ToString("c")); } return true; }
/// <summary> /// Sends CHANNEL_CREATED to notify the client the channel has been created. /// </summary> /// <param name="channel">The channel to be sent in.</param> /// <param name="messageId">A unique ID for the request or response pair.</param> /// <param name="majorVersion">The major version of RDP USB redirection supported.</param> /// <param name="minorVersion">The minor version of RDP USB redirection supported.</param> /// <param name="capability">The capabilities of RDP USB redirection supported.</param> public void ChannelCreated(DynamicVirtualChannel channel, uint messageId, uint majorVersion, uint minorVersion, uint capability) { Site.Log.Add( LogEntryKind.Debug, "Sending CHANNEL_CREATED: Channel ID {0}, Message ID {1}, Version major {2} minor {3}, Capability {4}.", channel.ChannelId, messageId, majorVersion, minorVersion, capability ); EusbChannelCreatedPdu requestPdu = new EusbChannelCreatedPdu(true); requestPdu.MessageId = messageId; requestPdu.MajorVersion = majorVersion; requestPdu.MinorVersion = minorVersion; requestPdu.Capabilities = capability; SendPdu(requestPdu, channel); if (majorVersion == 1 && minorVersion == 0 && capability == 0) { // Positive tests so expect a valid response. Site.Log.Add(LogEntryKind.Debug, "Receiving CHANNEL_CREATED."); EusbChannelCreatedPdu responsePdu = this.rdpeusbServer.ExpectRdpeusbPdu<EusbChannelCreatedPdu>(channel.ChannelId, waitTime); #region Verify CHANNEL_CREATED Response Site.Assert.IsNotNull( responsePdu, "Expect that the response from the client is EusbChannelCreatedPdu."); // Log this PDU if responsePdu is not null LogPdu(responsePdu); Site.Assert.AreEqual<uint>( 0x000000003, responsePdu.InterfaceId, "Expect that the InterfaceId in the response PDU equals 0x000000003. The actual value is 0x{0:x8}.", responsePdu.InterfaceId); Site.Assert.AreEqual<FunctionId_Values>( FunctionId_Values.CHANNEL_CREATED, (FunctionId_Values)responsePdu.FunctionId, "Expect that the FunctionId in the response PDU is CHANNEL_CREATED. The actual value is 0x{0:x8}.", responsePdu.FunctionId); Site.Assert.AreEqual<uint>(responsePdu.MajorVersion, 1, "Expect that the MajorVersion in the response PDU is 1. The actual value is {0}.", responsePdu.MajorVersion); Site.Assert.AreEqual<uint>(responsePdu.MinorVersion, 0, "Expect that the MinorVersion in the response PDU is 0. The actual value is {0}.", responsePdu.MinorVersion); Site.Assert.AreEqual<uint>(responsePdu.Capabilities, 0, "Expect that the Capabilities in the response PDU is 0. The actual value is {0}.", responsePdu.Capabilities); #endregion } else { // Negative tests so expect the channel to be closed. bool channelClosed = IsChannelClosed(channel); Site.Assert.IsTrue(channelClosed, "Expect the channel {0} to be closed.", channel.ChannelId); } }
/// <summary> /// Negotiates the capability through the specified channel with the connected RDP client. /// </summary> /// <param name="channel">The channel which the negotiation is sent in.</param> /// <param name="messageId">A unique ID for the request or response pair.</param> /// <param name="capability">The server's capability.</param> public void NegotiateCapability(DynamicVirtualChannel channel, uint messageId, CapabilityValue_Values capability) { Site.Log.Add(LogEntryKind.Debug, "Sending RIM_EXCHANGE_CAPABILITY_REQUEST: Channel ID {0}, Message ID {1}, Capability {2}.", channel.ChannelId, messageId, capability.ToString()); EusbRimExchangeCapRequestPdu requestPdu = new EusbRimExchangeCapRequestPdu(); requestPdu.MessageId = messageId; SendPdu(requestPdu, channel); if (capability == CapabilityValue_Values.RIM_CAPABILITY_VERSION_01) { // Positive tests so expect a valid response. Site.Log.Add(LogEntryKind.Debug, "Receiving EusbRimExchangeCapResponsePdu."); EusbRimExchangeCapResponsePdu responsePdu = this.rdpeusbServer.ExpectRdpeusbPdu<EusbRimExchangeCapResponsePdu>(channel.ChannelId, waitTime); #region Verify RIM_EXCHANGE_CAPABILITY_RESPONSE Site.Assert.IsNotNull( responsePdu, "Expect that the response from the client is EusbRimExchangeCapResponsePdu."); Site.Assert.AreEqual<uint>( requestPdu.InterfaceId, responsePdu.InterfaceId, "Expect that the InterfaceId in the response PDU equals the InterfaceId in the request PDU. The actual value is 0x{0:x8}.", responsePdu.InterfaceId); Site.Assert.AreEqual<uint>( requestPdu.MessageId, responsePdu.MessageId, "Expect that the MessageId in the response PDU equals the MessageId in the request PDU. The actual value is 0x{0:x8}.", responsePdu.MessageId); Site.Assert.AreEqual<Mask_Values>( Mask_Values.STREAM_ID_NONE, responsePdu.Mask, "Expect that the Mask in the response PDU is STREAM_ID_NONE."); Site.Assert.AreEqual<uint>( (uint)CapabilityValue_Values.RIM_CAPABILITY_VERSION_01, responsePdu.CapabilityValue, "Expect that the CapabilityValue in the response PDU is 0x00000001."); Site.Assert.AreEqual<uint>( 0, responsePdu.Result, "Expect that the Result in the response PDU is 0x00000000. The actual value is 0x{0:x8}.", responsePdu.MessageId); #endregion } else { // Negative tests so expect the channel to be closed. bool channelClosed = IsChannelClosed(channel); Site.Assert.IsTrue(channelClosed, "Expect the channel {0} to be closed.", channel.ChannelId); } }
/// <summary> /// Expect to create a SVC /// </summary> /// <param name="timeout">Timeout</param> /// <param name="channelName">Channel Name</param> /// <param name="transportType">Transport Type</param> /// <returns></returns> public DynamicVirtualChannel ExpectChannel(TimeSpan timeout, string channelName, DynamicVC_TransportType transportType, ReceiveData receiveCallBack = null) { if (autoCreateChannel) { throw new InvalidOperationException("Cannot establish a DVC manually if autoCreateChannel is true!"); } if (!transportDic.ContainsKey(transportType)) { throw new InvalidOperationException("Not create DVC transport:" + transportType); } CreateReqDvcPdu createReq = this.ExpectDVCCreateRequestPDU(timeout, channelName, transportType); if (createReq == null) { throw new System.IO.IOException("Creation of channel: " + channelName + " failed, cannot receive a Create Request PDU"); } DynamicVirtualChannel channel = new DynamicVirtualChannel(createReq.ChannelId, channelName, (ushort)createReq.HeaderBits.Sp, transportDic[transportType]); if (receiveCallBack != null) { // Add event method here can make sure processing the first DVC data packet channel.Received += receiveCallBack; } else { if (callBackMethodsDic != null && callBackMethodsDic.ContainsKey(channelName)) { channel.Received += callBackMethodsDic[channelName]; } } channelDicbyId.Add(createReq.ChannelId, channel); this.SendDVCCreateResponsePDU(createReq.ChannelId, 0, transportType); return channel; }
/// <summary> /// Receives the ADD_VIRTUAL_CHANNEL request from the client. /// </summary> /// <param name="channelId">The channel received in.</param> public void ExpectAddVirtualChannel(DynamicVirtualChannel channel) { Site.Log.Add(LogEntryKind.Debug, "Receiving ADD_VIRTUAL_CHANNEL: Channel ID {0}", channel.ChannelId); EusbAddVirtualChannelPdu responsePdu = this.rdpeusbServer.ExpectRdpeusbPdu<EusbAddVirtualChannelPdu>(channel.ChannelId, waitTime); #region Verify ADD_VIRTUAL_CHANNEL Site.Assert.IsNotNull( responsePdu, "Expect that the response from the client is EusbAddVirtualChannelPdu."); // Log this PDU if responsePdu is not null LogPdu(responsePdu); Site.Assert.AreEqual<uint>( 0x00000001, responsePdu.InterfaceId, "Expect that the InterfaceId in the response PDU equals 0x00000001. The actual value is 0x{0:x8}.", responsePdu.InterfaceId); Site.Assert.AreEqual<Mask_Values>( Mask_Values.STREAM_ID_PROXY, responsePdu.Mask, "Expect that the Mask in the response PDU is STREAM_ID_PROXY."); Site.Assert.AreEqual<FunctionId_Values>( FunctionId_Values.ADD_VIRTUAL_CHANNEL, (FunctionId_Values)responsePdu.FunctionId, "Expect that the FunctionId in the response PDU is ADD_VIRTUAL_CHANNEL. The actual value is 0x{0:x8}.", responsePdu.FunctionId); #endregion }
/// <summary> /// Receives the ADD_DEVICE request from the client. /// </summary> /// <param name="channel">The channel to be received from.</param> /// <returns>The context of the device which is being added.</returns> public EusbDeviceContext ExpectAddDevice(DynamicVirtualChannel channel) { Site.Log.Add(LogEntryKind.Debug, "Receiving ADD_DEVICE, Channel ID {0}.", channel.ChannelId); EusbAddDevicePdu pdu = this.rdpeusbServer.ExpectRdpeusbPdu<EusbAddDevicePdu>(channel.ChannelId, waitTime); USB_DEVICE_CAPABILITIES cap = new USB_DEVICE_CAPABILITIES(); if (!PduMarshaler.Unmarshal(pdu.UsbDeviceCapabilities, cap)) { Site.Assert.Fail( "UsbDeviceCapabilities (size in bytes: {0}) in ADD_DEVICE cannot be decoded.", pdu.UsbDeviceCapabilities.Length ); } #region Verify ADD_DEVICE Site.Assert.IsNotNull( pdu, "Expect that the response from the client is EusbAddDevicePdu." ); Site.Assert.AreEqual<uint>( 0x00000001, pdu.InterfaceId, "Expect that the InterfaceId in the response PDU equals 0x00000001. The actual value is 0x{0:x8}.", pdu.InterfaceId); Site.Assert.AreEqual<Mask_Values>( Mask_Values.STREAM_ID_PROXY, pdu.Mask, "Expect that the Mask in the response PDU is STREAM_ID_PROXY."); Site.Assert.AreEqual<FunctionId_Values>( FunctionId_Values.ADD_DEVICE, (FunctionId_Values)pdu.FunctionId, "Expect that the FunctionId in the response PDU is ADD_DEVICE. The actual value is 0x{0:x8}.", pdu.FunctionId); Site.Assert.AreEqual<uint>( 0x00000001, pdu.NumUsbDevice, "Expect that the NumUsbDevice in the response PDU equals 0x00000001. The actual value is 0x{0:x8}.", pdu.NumUsbDevice); Site.Assert.AreNotEqual<uint>( 0x00000000, pdu.cchDeviceInstanceId, "Expect that the cchDeviceInstanceId in the response PDU is zero. The actual value is 0x{0:x8}.", pdu.cchDeviceInstanceId); if (Config.IsWindowsImplementation) { Site.Assert.AreNotEqual<uint>( 0x00000000, pdu.cchHwIds, "Expect that the cchHwIds in the response PDU is not zero in an implementation of Windows. The actual value is 0x{0:x8}.", pdu.cchHwIds); } #region Verify UsbDeviceCapabilities Site.Assert.AreEqual<uint>( (uint)USB_DEVICE_CAPABILITIES.USB_DEVICE_CAPABILITIES_SIZE, cap.CbSize, "Expect that the CbSize of the USB_DEVICE_CAPABILITIES in the response PDU equals 28. The actual value is {0}.", cap.CbSize); Site.Assert.IsTrue( cap.UsbBusInterfaceVersion == (uint)UsbBusInterfaceVersion_Values.USB_BUS_VERSION_0 || cap.UsbBusInterfaceVersion == (uint)UsbBusInterfaceVersion_Values.USB_BUS_VERSION_1 || cap.UsbBusInterfaceVersion == (uint)UsbBusInterfaceVersion_Values.USB_BUS_VERSION_2, "Expect that the UsbBusInterfaceVersion of the USB_DEVICE_CAPABILITIES in the response PDU equals 0x00000000 or 0x00000001 or 0x00000002. The actual value is {0}.", cap.UsbBusInterfaceVersion); Site.Assert.IsTrue( cap.USBDI_Version == (uint)USBDI_VER.USBDI_VERSION_5 || cap.USBDI_Version == (uint)USBDI_VER.USBDI_VERSION_6, "Expect that the USBDI_Version of the USB_DEVICE_CAPABILITIES in the response PDU equals 0x00000500 or 0x00000600. The actual value is {0}.", cap.USBDI_Version); Site.Assert.IsTrue( cap.Supported_USB_Version == (uint)Supported_USB_Version_Values.USB_1_0 || cap.Supported_USB_Version == (uint)Supported_USB_Version_Values.USB_1_1 || cap.Supported_USB_Version == (uint)Supported_USB_Version_Values.USB_2_0, "Expect that the Supported_USB_Version of the USB_DEVICE_CAPABILITIES in the response PDU equals 0x100 or 0x110 or 0x200. The actual value is {0}.", cap.Supported_USB_Version); Site.Assert.AreEqual<uint>( 0, cap.HcdCapabilities, "Expect that the HcdCapabilities of the USB_DEVICE_CAPABILITIES in the response PDU is zero. The actual value is {0}.", cap.HcdCapabilities); if (cap.UsbBusInterfaceVersion == (uint)UsbBusInterfaceVersion_Values.USB_BUS_VERSION_0) { Site.Assert.AreEqual<uint>( (uint)DeviceSpeed_Values.FULL_SPEED, cap.DeviceIsHighSpeed, "Expect that the DeviceIsHighSpeed of the USB_DEVICE_CAPABILITIES in the response PDU is zero when UsbBusInterfaceVersion is 0x00000000. The actual value is {0}.", cap.HcdCapabilities); } else { Site.Assert.IsTrue( cap.DeviceIsHighSpeed == (uint)DeviceSpeed_Values.FULL_SPEED || cap.DeviceIsHighSpeed == (uint)DeviceSpeed_Values.HIGH_SPEED, "Expect that the DeviceIsHighSpeed of the USB_DEVICE_CAPABILITIES in the response PDU equals 0x100 or 0x110 or 0x200. The actual value is {0}.", cap.DeviceIsHighSpeed); } if (cap.NoAckIsochWriteJitterBufferSizeInMs != 0) { Site.Assert.IsTrue( cap.NoAckIsochWriteJitterBufferSizeInMs >= 10 && cap.NoAckIsochWriteJitterBufferSizeInMs <= 512, "Expect that the NoAckIsochWriteJitterBufferSizeInMs of the USB_DEVICE_CAPABILITIES in the response PDU is greater than or equal to 10 and less than or equal to 512. The actual value is {0}.", cap.NoAckIsochWriteJitterBufferSizeInMs); } #endregion #endregion EusbDeviceContext device = new EusbDeviceContext(); device.VirtualChannel = channel; device.NoAckIsochWriteJitterBufferSizeInMs = (cap.NoAckIsochWriteJitterBufferSizeInMs != 0); device.UsbDeviceInterfaceId = pdu.UsbDevice; device.DeviceInstanceId = pdu.DeviceInstanceId; Site.Log.Add(LogEntryKind.Debug, "Received device request. Device: {0}", device); return device; }
/// <summary> /// Create dynamic virtual channel. /// </summary> /// <param name="transportType">selected transport type for created channels</param> /// <param name="timeout">Timeout</param> /// <returns>true if client supports this protocol; otherwise, return false.</returns> public bool CreateRdpegtDvc(TimeSpan timeout, DynamicVC_TransportType transportType = DynamicVC_TransportType.RDP_TCP) { const ushort priority = 0; rdpegtDVC = rdpedycServer.CreateChannel(timeout, priority, RdpegtChannelName, transportType, null); if (rdpegtDVC != null) { return true; } return false; }