diff options
Diffstat (limited to 'usb/usbview/xmlhelper.cpp')
| -rw-r--r-- | usb/usbview/xmlhelper.cpp | 3058 |
1 files changed, 3058 insertions, 0 deletions
diff --git a/usb/usbview/xmlhelper.cpp b/usb/usbview/xmlhelper.cpp new file mode 100644 index 00000000..4221aeb0 --- /dev/null +++ b/usb/usbview/xmlhelper.cpp @@ -0,0 +1,3058 @@ +/*++ + + Copyright (c) 1997-2011 Microsoft Corporation + + Module Name: + + XMLHELPER.CPP + +Abstract: + +This source file contains helper APIs for reading writing XML + +Environment: + +user mode + +Revision History: + +05-05-11 : created + +--*/ + +/***************************************************************************** + I N C L U D E S + *****************************************************************************/ +#include "uvcview.h" +#include "h264.h" +#include "xmlhelper.h" + +// usbschema.hpp is autogenerated from schema during build PASS0 +#include "usbschema.hpp" + +// Include code analysis suppressions +#include "codeanalysis.h" + +/***************************************************************************** + D E F I N E S + *****************************************************************************/ +#define COBJMACROS + +#define PACHAR_TO_STRING(X) ((X != NULL)? gcnew String(Marshal::PtrToStringAnsi((IntPtr) X )):nullptr) +#define PWCHAR_TO_STRING(X) ((X != NULL)? gcnew String(Marshal::PtrToStringUni((IntPtr) X )):nullptr) + +#define MAX_STRING_DESCRIPTOR_LENGTH 512 +#define STRING_DESCRIPTOR_EN_LANGUAGE_ID 0x0409 +#define DEVICE_DESCRIPTOR_LENGTH 18 + +#define SERVICE_EHCI "usbehci" +#define SERVICE_XHCI "usbxhci" +#define SERVICE_OHCI "usbohci" +#define SERVICE_UHCI "usbuhci" + +#define USB_1_1 "USB 1.1" +#define USB_2_0 "USB 2.0" +#define USB_3_0 "USB 3.0" +#define USB_GENERIC "USB GENERIC (UNKNOWN)" + +/***************************************************************************** + N A M E S P A C E S + *****************************************************************************/ + +using namespace System; +using namespace System::IO; +using namespace System::Runtime::InteropServices; +using namespace System::Collections; +using namespace Microsoft::Kits::Samples::Usb; + + +/***************************************************************************** + G L O B A L S + *****************************************************************************/ + +namespace Microsoft +{ + namespace Kits + { + namespace Samples + { + namespace Usb + { + public ref class XmlGlobal sealed + { + private: + static XmlGlobal ^ pInstance = gcnew XmlGlobal(); + + // Empty private constructor + XmlGlobal() + { + } + + public: + // + // Globals for XML view + // + property UvcViewAll ^ ViewAll; + property bool XmlViewInitialized; + + // + // Stack of parents of a given node. This is used for finding + // where a given object should be added + // + +#if CODE_ANALYSIS + // ParentStack need not be constant since we will only have one instance of this object + [SuppressMessage("Microsoft.Usage", "CA2211:NonConstantFieldsShouldNotBeVisible")] +#endif + static Stack ^ ParentStack = gcnew Stack(); + + static XmlGlobal ^ Instance() + { + return pInstance; + } + }; + }; + }; + }; +}; + +#define gXmlView ((XmlGlobal::Instance())->ViewAll->UvcView) +#define gXmlViewInitialized ((XmlGlobal::Instance())->XmlViewInitialized) +#define gXmlStack ((XmlGlobal::Instance())->ParentStack) + +/***************************************************************************** + D E C L A R A T I O N S + *****************************************************************************/ + +String ^ XmlGetStringDescriptor(UCHAR index, PSTRING_DESCRIPTOR_NODE stringDesc, bool enOnly); +void XmlAddHostControllerPowerMapping( UsbHCPowerStateMappingType ^xmlPwrInfo, PUSB_POWER_INFO usbHCPowerInfo); +String ^ XmlGetDeviceClassString(UCHAR deviceClass); +void XmlAddHostControllerPowerMapping(UsbHCPowerStateMappingType ^xmlPwrInfo, PUSB_POWER_INFO usbHCPowerInfo); +void XmlAddHub30Descriptor(Hub30DescriptorType ^hub30Desc, PUSB_30_HUB_DESCRIPTOR hub30Descriptor); +void XmlAddHubDescriptor(HubDescriptorType ^hubDesc, PUSB_HUB_DESCRIPTOR hubDescriptor); +void XmlAddPortConnectorProps(PortConnectorType ^portXmlProps, PUSB_PORT_CONNECTOR_PROPERTIES portProps); +void XmlAddHubCharacteristics(HubInformationType ^hubI, WORD hubChar); +HRESULT XmlAddHubNodeInformation(HubNodeInformationType ^ni, PUSB_NODE_INFORMATION nodeInfo); +HRESULT XmlAddHubInformationEx(HubInformationExType ^ex, PUSB_HUB_INFORMATION_EX hubInfoEx); +HRESULT XmlAddHubCapabilitiesEx(HubCapabilitiesExType ^ex, USB_HUB_CAPABILITIES_EX hubCapEx); +ExternalHubType ^ AddExternalHub(Object ^parent); +NoDeviceType ^ AddDisconnectedPort(Object ^parent); +UsbDeviceType ^ AddUsbDevice(Object ^parent); +void XmlAddEndpointDescriptor( + EndpointDescriptorType ^usbXmlEndpointDescriptor, + PUSB_ENDPOINT_DESCRIPTOR endPointDescriptor, + UCHAR connectionSpeed); +void XmlAddPipeInformation( + array< UsbPipeInfoType ^> ^ usbXmlPipeInfoList, + PUSB_PIPE_INFO pipeInfo, + ULONG numPipes, + UCHAR connectionSpeed); +void XmlAddUsbDeviceDescriptor( + UsbDeviceDescriptorType ^usbXmlDeviceDescriptor, + PUSB_DEVICE_DESCRIPTOR usbDeviceDescriptor); +void XmlAddConfigurationDescriptor( + UsbConfigurationDescriptorType ^ confXmlDesc, + PUSBDEVICEINFO deviceInfo, + PUSB_CONFIGURATION_DESCRIPTOR configDesc, + PSTRING_DESCRIPTOR_NODE stringDesc); +void XmlAddDeviceQualDescriptor( + UsbDeviceQualifierDescriptorType ^ qualXmlDesc, + PUSB_DEVICE_QUALIFIER_DESCRIPTOR qualDesc); +void XmlAddDeviceConfiguration( + UsbDeviceConfigurationType ^ confXmlDesc, + PUSBDEVICEINFO deviceInfo, + PUSB_CONFIGURATION_DESCRIPTOR configDesc, + PSTRING_DESCRIPTOR_NODE stringDesc, + int numInterfaces); +void XmlAddConnectionInfoSt( + NodeConnectionInfoExStructType ^xmlConnectionInfoSt, + PUSB_NODE_CONNECTION_INFORMATION_EX connectionInfo, + PDEVICE_INFO_NODE pNode); +String ^ XmlGetLangIdString(UCHAR index, PSTRING_DESCRIPTOR_NODE stringDesc); +String ^ XmlGetStringDescriptor(UCHAR index, PSTRING_DESCRIPTOR_NODE stringDesc, bool enOnly); +String ^ XmlGetDeviceClassString(UCHAR deviceClass); +bool XmlAddDeviceClassDetails( + UsbDeviceClassDetailsType ^ deviceDetails, + PUSB_NODE_CONNECTION_INFORMATION_EX connectionInfo, + PUSBDEVICEINFO deviceInfo); +void XmlAddConnectionInfo( + NodeConnectionInfoExType ^xmlConnectionInfo, + PUSB_NODE_CONNECTION_INFORMATION_EX connectionInfo, + PUSBDEVICEINFO deviceInfo, + PSTRING_DESCRIPTOR_NODE stringDesc, + PDEVICE_INFO_NODE pNode); +void XmlAddHidDescriptor( + UsbDeviceHidDescriptorType ^ hidXmlDesc, + PUSB_HID_DESCRIPTOR hidDesc); +void XmlAddDeviceInterfaceDescriptor( + UsbDeviceInterfaceDescriptorType ^ ifXmlDesc, + PUSB_INTERFACE_DESCRIPTOR ifDesc, + PSTRING_DESCRIPTOR_NODE stringDesc); +void XmlAddOTGDescriptor( + UsbDeviceOTGDescriptorType ^ otgXmlDesc, + PUSB_OTG_DESCRIPTOR otgDesc); +void XmlAddIADDescriptor( + UsbDeviceIADDescriptorType ^ iadXmlDesc, + PUSB_IAD_DESCRIPTOR iadDesc, + PSTRING_DESCRIPTOR_NODE stringDesc, + int nInterfaces); +array < UsbDeviceConfigurationType ^> ^ XmlGetConfigDescriptors( + PUSBDEVICEINFO deviceInfo, + PUSB_CONFIGURATION_DESCRIPTOR configDescs, + PSTRING_DESCRIPTOR_NODE stringDesc); +UsbBosDescriptorType ^ XmlGetBosDescriptor(PUSB_BOS_DESCRIPTOR bosDesc); +UsbDeviceClassType ^ XmlGetDeviceClass(UCHAR deviceClass, UCHAR deviceSubClass, UCHAR deviceProtocol); +UsbDeviceUnknownDescriptorType ^ XmlGetUnknownDescriptor( + PUSB_COMMON_DESCRIPTOR unknownDesc + ); +UsbUsb20ExtensionDescriptorType ^ XmlGetUsb20CapabilityExtensionDescriptor( + PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR capDesc + ); +UsbSuperSpeedExtensionDescriptorType ^ XmlGetSuperSpeedCapabilityExtensionDescriptor( + PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR capDesc + ); +UsbDispContIdCapExtDescriptorType ^ XmlGetContainerIdCapabilityExtensionDescriptor( + PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR capDesc + ); + +/***************************************************************************** + D E F I N I T I O N S + *****************************************************************************/ + +/***************************************************************************** + XmlNotifyEndOfNodeList + + This function is called back by WalkTreeTopDown() function to notify us + that there are no more children to add for the current parent + + *****************************************************************************/ +VOID XmlNotifyEndOfNodeList(PVOID pContext) +{ + UNREFERENCED_PARAMETER(pContext); + + if (gXmlStack != nullptr && gXmlStack->Count > 0) + { + // Remove the last parent on the stack + gXmlStack->Pop(); + } +} + +/***************************************************************************** + + XmlAddHostControllerPowerMapping() + + add power info to xml structure + *****************************************************************************/ +void XmlAddHostControllerPowerMapping(UsbHCPowerStateMappingType ^xmlPwrInfo, PUSB_POWER_INFO usbHCPowerInfo) +{ + int i, powerState; + PUSB_POWER_INFO pUPI = usbHCPowerInfo; + UsbHCPowerStateType ^ pwrState = nullptr; + + xmlPwrInfo->PowerMap = gcnew array<UsbHCPowerStateType ^> (WdmUsbPowerSystemShutdown); + + for(i = 0, powerState = WdmUsbPowerSystemWorking; powerState < WdmUsbPowerSystemShutdown; i++, powerState++, pUPI++) + { + xmlPwrInfo->PowerMap[i] = gcnew UsbHCPowerStateType(); + pwrState = xmlPwrInfo->PowerMap[i]; + pwrState->SystemState = PACHAR_TO_STRING(GetPowerStateString(pUPI->SystemState)); + pwrState->HostControllerState = PACHAR_TO_STRING(GetPowerStateString(pUPI->HcDevicePowerState)); + pwrState->HubState = PACHAR_TO_STRING(GetPowerStateString(pUPI->RhDevicePowerState)); + pwrState->CanWakeUp = pUPI->CanWakeup? true:false; + pwrState->IsPowered = pUPI->IsPowered? true:false; + } + + xmlPwrInfo->LastSleepState = PACHAR_TO_STRING(GetPowerStateString(pUPI->LastSystemSleepState)); + return; +} + +/***************************************************************************** + + XmlAddHostController() + + Add an host controller to XML view + *****************************************************************************/ + +HRESULT XmlAddHostController(PSTR hcName, PUSBHOSTCONTROLLERINFO hcInfo) +{ + HRESULT hr = S_OK; + + UNREFERENCED_PARAMETER(hcName); + + HostControllerType ^ hc = nullptr; + // + // Check if the USB Tree array has been initialized + // It would have been great if XSD had a way of generating a list instead of array, but it does not + // So we have to do array.Resize everytime + // + if (gXmlView->UsbTree == nullptr) + { + // This is the first time we are being called, initialize the array with 1 element + gXmlView->UsbTree = gcnew array<HostControllerType ^>(1); + gXmlView->UsbTree[0] = gcnew HostControllerType(); + hc = gXmlView->UsbTree[0]; + } + else + { + // Create a new array every time as Array.Resize does not seem to work in our case (CLI) + // We do this using ArrayList. + ArrayList ^hcList = gcnew ArrayList; + hcList->AddRange(gXmlView->UsbTree); + hc = gcnew HostControllerType(); + hcList->Add(hc); + gXmlView->UsbTree = reinterpret_cast<array<HostControllerType ^>^> (hcList->ToArray(HostControllerType::typeid)); + } + + if (hc != nullptr) + { + ULONG debugPort = 0; + + UsbHCDeviceInfoType ^ ci = nullptr; + UsbHCPowerStateMappingType ^ pm = nullptr; + + if (NULL != hcInfo->UsbDeviceProperties) + { + hc->HwId = PACHAR_TO_STRING(hcInfo->UsbDeviceProperties->HwId); + hc->DeviceId = PACHAR_TO_STRING(hcInfo->UsbDeviceProperties->DeviceId); + hc->ServiceName = PACHAR_TO_STRING(hcInfo->UsbDeviceProperties->Service); + hc->DeviceName = PACHAR_TO_STRING(hcInfo->UsbDeviceProperties->DeviceDesc); + hc->DeviceClass = PACHAR_TO_STRING(hcInfo->UsbDeviceProperties->DeviceClass); + + if (_stricmp(hcInfo->UsbDeviceProperties->Service, SERVICE_OHCI) == 0) + { + hc->UsbProtocol = gcnew String(USB_1_1); + } + else if(_stricmp(hcInfo->UsbDeviceProperties->Service, SERVICE_EHCI) == 0 || + _stricmp(hcInfo->UsbDeviceProperties->Service, SERVICE_UHCI) == 0) + { + hc->UsbProtocol = gcnew String(USB_2_0); + } + else if (_stricmp(hcInfo->UsbDeviceProperties->Service, SERVICE_XHCI) == 0) + { + hc->UsbProtocol = gcnew String(USB_3_0); + } + else + { + USB_CONTROLLER_FLAVOR flavor = hcInfo->ControllerInfo->ControllerFlavor; + + // If protocol lookup failed based on service name, try Controller flavor + if(NULL != hcInfo->ControllerInfo) + { + if(flavor == USB_HcGeneric) + { + hc->UsbProtocol = gcnew String(USB_GENERIC); + } + else if(flavor >= OHCI_Generic && flavor < UHCI_Generic) + { + hc->UsbProtocol = gcnew String(USB_1_1); + } + else if(flavor >= UHCI_Generic && flavor < EHCI_Generic) + { + hc->UsbProtocol = gcnew String(USB_2_0); + } + else if(flavor >= EHCI_Generic) + { + hc->UsbProtocol = gcnew String(USB_3_0); + } + } + } + } + + hc->ControllerInfo = gcnew UsbHCDeviceInfoType(); + hc->PowerMapping = gcnew UsbHCPowerStateMappingType(); + ci = hc->ControllerInfo; + pm = hc->PowerMapping; + + ci->VendorId = hcInfo->VendorID; + ci->DeviceId = hcInfo->DeviceID; + ci->DriverKey = PACHAR_TO_STRING(hcInfo->DriverKey); + ci->SubSysId = hcInfo->SubSysID; + ci->Revision = hcInfo->Revision; + + if(NULL != hcInfo->ControllerInfo) + { + ci->NumberOfRootPorts = hcInfo->ControllerInfo->NumberOfRootPorts; + ci->ControllerFlavor = hcInfo->ControllerInfo->ControllerFlavor; + ci->PortSwitchingEnabled = (hcInfo->ControllerInfo->HcFeatureFlags & USB_HC_FEATURE_FLAG_PORT_POWER_SWITCHING)? true: false; + ci->SelectiveSuspendEnabled = (hcInfo->ControllerInfo->HcFeatureFlags & USB_HC_FEATURE_FLAG_SEL_SUSPEND)? true: false; + ci->LegacyBios = (hcInfo->ControllerInfo->HcFeatureFlags & USB_HC_FEATURE_LEGACY_BIOS)? true: false; + ci->ControllerFlavorString = PACHAR_TO_STRING(GetControllerFlavorString(hcInfo->ControllerInfo->ControllerFlavor)); + } + + // Add power mappings + XmlAddHostControllerPowerMapping(pm, (PUSB_POWER_INFO) (&(hcInfo->USBPowerInfo[0]))); + + // Add debug port + debugPort = GetEhciDebugPort(hcInfo->VendorID, hcInfo->DeviceID); + if (debugPort > 0) + { + ci->DebugPort = debugPort; + } + + gXmlStack->Push(hc); + + } + else + { + hr = E_FAIL; + } + + return hr; +} + +/***************************************************************************** + + XmlAddHub30Descriptor() + + Adds the hub 3.0 descriptor to the given hub object + *****************************************************************************/ +void XmlAddHub30Descriptor(Hub30DescriptorType ^hub30Desc, PUSB_30_HUB_DESCRIPTOR hub30Descriptor) +{ + + if (nullptr != hub30Desc && NULL != hub30Descriptor) + { + hub30Desc->Length = hub30Descriptor->bLength; + hub30Desc->DescriptorType = hub30Descriptor->bDescriptorType; + hub30Desc->NumberOfPorts = hub30Descriptor->bNumberOfPorts; + hub30Desc->HubCharacteristics = hub30Descriptor->wHubCharacteristics; + hub30Desc->PowerOntoPowerGood = hub30Descriptor->bPowerOnToPowerGood; + hub30Desc->HubControlCurrent = hub30Descriptor->bHubControlCurrent; + hub30Desc->HubHdrDecLat = hub30Descriptor->bHubHdrDecLat; + hub30Desc->DeviceRemovable = hub30Descriptor->DeviceRemovable; + } +} + +/***************************************************************************** + + XmlAddHubDescriptor() + + Adds the hub descriptor to the given hub object + *****************************************************************************/ +void XmlAddHubDescriptor(HubDescriptorType ^hubDesc, PUSB_HUB_DESCRIPTOR hubDescriptor) +{ + if (nullptr != hubDesc && NULL != hubDescriptor) + { + hubDesc->DescriptorLength = hubDescriptor->bDescriptorLength; + hubDesc->DescriptorType = hubDescriptor->bDescriptorType; + hubDesc->NumberOfPorts = hubDescriptor->bNumberOfPorts; + hubDesc->PowerOntoPowerGood = hubDescriptor->bPowerOnToPowerGood; + hubDesc->HubControlCurrent = hubDescriptor->bHubControlCurrent; + } +} + +/***************************************************************************** + + XmlAddPortConnectorProps() + + Adds the port connector properties to XML file + *****************************************************************************/ +void XmlAddPortConnectorProps(PortConnectorType ^portXmlProps, PUSB_PORT_CONNECTOR_PROPERTIES portProps) +{ + if (NULL != portProps) + { + portXmlProps->UsbPortProperties = gcnew UsbPortPropertiesType(); + + portXmlProps->ConnectionIndex = portProps->ConnectionIndex; + portXmlProps->ActualLength = portProps->ActualLength; + portXmlProps->CompanionIndex = portProps->CompanionIndex; + portXmlProps->CompanionPortNumber = portProps->CompanionPortNumber; + portXmlProps->CompanionHubSymbolicLinkName = PWCHAR_TO_STRING(portProps->CompanionHubSymbolicLinkName); + + portXmlProps->UsbPortProperties->PortIsUserConnectable = portProps->UsbPortProperties.PortIsUserConnectable? true:false; + portXmlProps->UsbPortProperties->PortIsDebugCapable = portProps->UsbPortProperties.PortIsDebugCapable? true:false; + } + return; +} + +/***************************************************************************** + + XmlAddConnectionInfoV2() + + Adds the V2 connection info structure + *****************************************************************************/ +void XmlAddConnectionInfoV2(NodeConnectionInfoExV2Type ^ connectionXmlInfo, PUSB_NODE_CONNECTION_INFORMATION_EX_V2 connectionInfo) +{ + if (NULL != connectionInfo) + { + connectionXmlInfo->ConnectionIndex = connectionInfo->ConnectionIndex; + connectionXmlInfo->Length = connectionInfo->Length; + + connectionXmlInfo->Usb110Supported = connectionInfo->SupportedUsbProtocols.Usb110? true:false; + connectionXmlInfo->Usb200Supported = connectionInfo->SupportedUsbProtocols.Usb200? true:false; + connectionXmlInfo->Usb300Supported = connectionInfo->SupportedUsbProtocols.Usb300? true:false; + + connectionXmlInfo->DeviceIsOperatingAtSuperSpeedOrHigher = + connectionInfo->Flags.DeviceIsOperatingAtSuperSpeedOrHigher; + + connectionXmlInfo->DeviceIsSuperSpeedCapableOrHigher = + connectionInfo->Flags.DeviceIsSuperSpeedCapableOrHigher; + + connectionXmlInfo->DeviceIsOperatingAtSuperSpeedPlusOrHigher = + connectionInfo->Flags.DeviceIsOperatingAtSuperSpeedPlusOrHigher; + + connectionXmlInfo->DeviceIsSuperSpeedPlusCapableOrHigher = + connectionInfo->Flags.DeviceIsSuperSpeedPlusCapableOrHigher; + + } + return; +} + +/***************************************************************************** + + XmlAddHubCharacteristics() + + Adds the hub characteristics to the given hub object + *****************************************************************************/ +void XmlAddHubCharacteristics(HubInformationType ^hubI, WORD hubChar) +{ + HubCharacteristicsType ^hubC = nullptr; + + hubI->HubCharacteristics = gcnew HubCharacteristicsType(); + hubC = hubI->HubCharacteristics; + hubC->HubCharacteristicsValue = hubChar; + switch(hubChar & 0x3) + { + case 0x0: + hubC->PowerSwitching = gcnew String("Ganged"); + break; + case 0x1: + hubC->PowerSwitching = gcnew String("Individual"); + break; + case 0x2: + case 0x3: + hubC->PowerSwitching = gcnew String("None"); + break; + default: + hubC->PowerSwitching = gcnew String("Unknown"); + } + + hubC->CompoundDevice = (hubChar & 0x4)? true:false; + + switch(hubChar & 0x18) + { + case 0x0: + hubC->OverCurrentProtection = gcnew String("Global"); + break; + case 0x8: + hubC->OverCurrentProtection = gcnew String("Individual"); + break; + case 0x10: + case 0x18: + hubC->OverCurrentProtection = gcnew String("No protection, bus power only"); + break; + default: + hubC->OverCurrentProtection = gcnew String("Unknown"); + } +} + +/***************************************************************************** + + XmlAddHubNodeInformation() + + Adds the node information to the hub object + *****************************************************************************/ +HRESULT XmlAddHubNodeInformation(HubNodeInformationType ^ni, PUSB_NODE_INFORMATION nodeInfo) +{ + PUSB_HUB_INFORMATION hubInfo = NULL; + + if (NULL == nodeInfo) + { + return E_FAIL; + } + + hubInfo = &(nodeInfo->u.HubInformation); + ni->HubNode = static_cast<HubNodeType> (nodeInfo->NodeType); + + ni->HubInformation = gcnew HubInformationType(); + ni->HubInformation->IsRootHub = true; + ni->HubInformation->IsBusPowered = hubInfo->HubIsBusPowered? true:false; + + // Add hub characteristics + XmlAddHubCharacteristics(ni->HubInformation, hubInfo->HubDescriptor.wHubCharacteristics); + // Add descriptor + ni->HubInformation->HubDescriptor = gcnew HubDescriptorType(); + XmlAddHubDescriptor(ni->HubInformation->HubDescriptor, &(hubInfo->HubDescriptor)); + + return S_OK; +} + +/***************************************************************************** + + XmlAddHubInformation() + + Adds the node information to the hub object + *****************************************************************************/ +HRESULT XmlAddHubInformationEx(HubInformationExType ^ex, PUSB_HUB_INFORMATION_EX hubInfoEx) +{ + HubDescriptorType ^hubDesc = nullptr; + Hub30DescriptorType ^hub30Desc = nullptr; + + if (NULL == hubInfoEx) + { + return E_FAIL; + } + + ex->HubType = static_cast<HubTypeType> (hubInfoEx->HubType); + ex->HighestPortNumber = hubInfoEx->HighestPortNumber; + switch(hubInfoEx->HubType) + { + case UsbRootHub: + case Usb20Hub: + ex->HubDescriptor = hubDesc = gcnew HubDescriptorType(); + XmlAddHubDescriptor(hubDesc, &(hubInfoEx->u.UsbHubDescriptor)); + break; + case Usb30Hub: + ex->Hub30Descriptor = hub30Desc = gcnew Hub30DescriptorType(); + XmlAddHub30Descriptor(hub30Desc, &(hubInfoEx->u.Usb30HubDescriptor)); + break; + } + return S_OK; +} + +/***************************************************************************** + + XmlAddHubCapabilitiesEx() + + Adds the hub capabilities information to the hub object + *****************************************************************************/ +HRESULT XmlAddHubCapabilitiesEx(HubCapabilitiesExType ^ex, PUSB_HUB_CAPABILITIES_EX hubCapEx) +{ + if(NULL != hubCapEx) + { + ex->HubIsHighSpeedCapable = hubCapEx->CapabilityFlags.HubIsHighSpeedCapable?true:false; + ex->HubIsHighSpeed = hubCapEx->CapabilityFlags.HubIsHighSpeed?true:false; + ex->HubIsMultiTtCapable = hubCapEx->CapabilityFlags.HubIsMultiTtCapable?true:false; + ex->HubIsMultiTt = hubCapEx->CapabilityFlags.HubIsMultiTt?true:false; + ex->HubIsRoot = hubCapEx->CapabilityFlags.HubIsRoot?true:false; + ex->HubIsArmedWakeOnConnect = hubCapEx->CapabilityFlags.HubIsArmedWakeOnConnect?true:false; + ex->HubIsBusPowered = hubCapEx->CapabilityFlags.HubIsBusPowered?true:false; + } + return S_OK; +} + +/***************************************************************************** + + ExternalHubType ^ AddExternalHub(Object ^parent) + + This routine finds the type of the parent and adds an external hub object to the + parent's list of external hubs. The newly created object is returned + We are using arrays insted of better types of collections becaused the code generated + by xsd.exe does not support other types. + *****************************************************************************/ +ExternalHubType ^ AddExternalHub(Object ^parent) +{ + RootHubType ^ rhParent = nullptr; + ExternalHubType ^ ehParent = nullptr; + array<ExternalHubType ^> ^ exHubArray = nullptr; + ExternalHubType ^ exHub = nullptr; + boolean arrayCreated = false; + + // An external hub can be connected to a Root Hub or another External Hub + // We need to determine the type of the object. + + // Try root hub first + + rhParent = dynamic_cast<RootHubType ^> (parent); + if (rhParent == nullptr) + { + // RootHub cast was not successfult, try external hub + ehParent = dynamic_cast<ExternalHubType ^> (parent); + if (ehParent != nullptr) + { + // External hub parent + if (ehParent->ExternalHub == nullptr) + { + // First hub in the list of external hubs + ehParent->ExternalHub = gcnew array<ExternalHubType ^> (1); + arrayCreated = true; + } + exHubArray = ehParent->ExternalHub; + } + + } + else + { + // Parent is a root hub + if (rhParent->ExternalHub == nullptr) + { + // First hub in root hub list + rhParent->ExternalHub = gcnew array<ExternalHubType ^>(1); + arrayCreated = true; + } + exHubArray = rhParent->ExternalHub; + } + + if (exHubArray != nullptr) + { + if (arrayCreated) + { + // We created the array in this function, so we use offset 0 + exHubArray[0] = gcnew ExternalHubType(); + exHub = exHubArray[0]; + } + else + { + // The array was already present, we need to do elaborate things + // as array.resize does not work. + ArrayList ^exList = gcnew ArrayList(); + exList->AddRange(exHubArray); + exHub = gcnew ExternalHubType(); + exList->Add(exHub); + + if (rhParent != nullptr) + { + rhParent->ExternalHub = reinterpret_cast<array<ExternalHubType ^>^> (exList->ToArray(ExternalHubType::typeid)); + } + else + { + ehParent->ExternalHub = reinterpret_cast<array<ExternalHubType ^>^> (exList->ToArray(ExternalHubType::typeid)); + } + } + } + return exHub; +} +/***************************************************************************** + + NoDeviceType ^ AddDisconnectedPort(Object ^parent) + + This routine finds the type of the parent and adds a empty port connection object to the + parent's list of devices. The newly created object is returned + We are using arrays insted of better types of collections becaused the code generated + by xsd.exe does not support other types. + *****************************************************************************/ +NoDeviceType ^ AddDisconnectedPort(Object ^parent) +{ + RootHubType ^ rhParent = nullptr; + ExternalHubType ^ ehParent = nullptr; + array<NoDeviceType ^> ^ devicesArray = nullptr; + NoDeviceType ^ noD = nullptr; + boolean arrayCreated = false; + + // An external hub can be connected to a Root Hub or another External Hub + // We need to determine the type of the object. + + // Try RH first + + rhParent = dynamic_cast<RootHubType ^> (parent); + if (rhParent == nullptr) + { + // RootHub cast was not successfult, try external hub + ehParent = dynamic_cast<ExternalHubType ^> (parent); + if (ehParent != nullptr) + { + // External hub parent + if (ehParent->NoDevice == nullptr) + { + // First hub in the list of external hubs + ehParent->NoDevice = gcnew array<NoDeviceType ^> (1); + arrayCreated = true; + } + devicesArray = ehParent->NoDevice; + } + + } + else + { + // Parent is a root hub + if (rhParent->NoDevice == nullptr) + { + // First hub in root hub list + rhParent->NoDevice = gcnew array<NoDeviceType ^>(1); + arrayCreated = true; + } + devicesArray = rhParent->NoDevice; + } + + if (devicesArray != nullptr) + { + if (arrayCreated) + { + // We created the array in this function, so we use offset 0 + devicesArray[0] = gcnew NoDeviceType(); + noD = devicesArray[0]; + } + else + { + // The array was already present, we need to do elaborate things + // as array.resize does not work. + ArrayList ^exList = gcnew ArrayList(); + exList->AddRange(devicesArray); + noD = gcnew NoDeviceType(); + exList->Add(noD); + + if (rhParent != nullptr) + { + rhParent->NoDevice = reinterpret_cast<array<NoDeviceType ^>^> (exList->ToArray(NoDeviceType::typeid)); + } + else + { + ehParent->NoDevice = reinterpret_cast<array<NoDeviceType ^>^> (exList->ToArray(NoDeviceType::typeid)); + } + } + } + return noD; +} + +/***************************************************************************** + + UsbDeviceType ^ AddUsbDevice(Object ^parent) + + This routine finds the type of the parent and adds a port connection object to the + parent's list of port connectors. The newly created object is returned + We are using arrays insted of better types of collections becaused the code generated + by xsd.exe does not support other types. + *****************************************************************************/ +UsbDeviceType ^ AddUsbDevice(Object ^parent) +{ + RootHubType ^ rhParent = nullptr; + ExternalHubType ^ ehParent = nullptr; + array<UsbDeviceType ^> ^ devicesArray = nullptr; + UsbDeviceType ^ usbD = nullptr; + boolean arrayCreated = false; + + // An external hub can be connected to a Root Hub or another External Hub + // We need to determine the type of the object. + + // Try RH first + + rhParent = dynamic_cast<RootHubType ^> (parent); + if (rhParent == nullptr) + { + // RootHub cast was not successfult, try external hub + ehParent = dynamic_cast<ExternalHubType ^> (parent); + if (ehParent != nullptr) + { + // External hub parent + if (ehParent->UsbDevice == nullptr) + { + // First hub in the list of external hubs + ehParent->UsbDevice = gcnew array<UsbDeviceType ^> (1); + arrayCreated = true; + } + devicesArray = ehParent->UsbDevice; + } + + } + else + { + // Parent is a root hub + if (rhParent->UsbDevice == nullptr) + { + // First hub in root hub list + rhParent->UsbDevice = gcnew array<UsbDeviceType ^>(1); + arrayCreated = true; + } + devicesArray = rhParent->UsbDevice; + } + + if (devicesArray != nullptr) + { + if (arrayCreated) + { + // We created the array in this function, so we use offset 0 + devicesArray[0] = gcnew UsbDeviceType(); + usbD = devicesArray[0]; + } + else + { + // The array was already present, we need to do elaborate things + // as array.resize does not work. + ArrayList ^exList = gcnew ArrayList(); + exList->AddRange(devicesArray); + usbD = gcnew UsbDeviceType(); + exList->Add(usbD); + + if (rhParent != nullptr) + { + rhParent->UsbDevice = reinterpret_cast<array<UsbDeviceType ^>^> (exList->ToArray(UsbDeviceType::typeid)); + } + else + { + ehParent->UsbDevice = reinterpret_cast<array<UsbDeviceType ^>^> (exList->ToArray(UsbDeviceType::typeid)); + } + } + } + return usbD; +} + +/***************************************************************************** + + XmlAddIADDescriptor() + + This routine adds usb IAD descriptor + *****************************************************************************/ +void XmlAddIADDescriptor( + UsbDeviceIADDescriptorType ^ iadXmlDesc, + PUSB_IAD_DESCRIPTOR iadDesc, + PSTRING_DESCRIPTOR_NODE stringDesc, + int nInterfaces) +{ + if (NULL == iadDesc || NULL == stringDesc) + { + return; + } + + // Update structure fields + iadXmlDesc->BLength = iadDesc->bLength; + iadXmlDesc->BDescriptorType = iadDesc->bDescriptorType; + iadXmlDesc->BFirstInterface = iadDesc->bFirstInterface; + iadXmlDesc->BInterfaceCount = iadDesc->bInterfaceCount; + iadXmlDesc->BFunctionClass = iadDesc->bFunctionClass; + iadXmlDesc->BFunctionSubclass = iadDesc->bFunctionSubClass; + iadXmlDesc->BFunctionProtocol = iadDesc->bFunctionProtocol; + iadXmlDesc->IFunction = iadDesc->iFunction; + + // Validate fields + if (iadDesc->bInterfaceCount == 1) + { + iadXmlDesc->InterfaceError = gcnew String("ERROR: bInterfaceCount must be greater than 1"); + } + if (nInterfaces < iadDesc->bFirstInterface + iadDesc->bInterfaceCount) + { + iadXmlDesc->InterfaceError = gcnew String("ERROR: The total number of interfaces"); + iadXmlDesc->InterfaceError += nInterfaces; + iadXmlDesc->InterfaceError += " must be greater than or equal to the highest linked interface number (base "; + iadXmlDesc->InterfaceError += iadDesc->bFirstInterface; + iadXmlDesc->InterfaceError += " + count "; + iadXmlDesc->InterfaceError += iadDesc->bInterfaceCount; + iadXmlDesc->InterfaceError += " = "; + iadXmlDesc->InterfaceError += (iadDesc->bFirstInterface + iadDesc->bInterfaceCount); + iadXmlDesc->InterfaceError += " )"; + } + if (iadDesc->bFunctionClass == 0) + { + iadXmlDesc->FunctionClassError = gcnew String("ERROR: bFunctionClass contains an illegal value 0"); + } + + iadXmlDesc->FunctionDetails = XmlGetDeviceClass( + iadDesc->bFunctionClass, + iadDesc->bFunctionSubClass, + iadDesc->bFunctionProtocol); + + // Protocol check + if (iadDesc->bFunctionClass == USB_DEVICE_CLASS_VIDEO) + { + if (iadDesc->bFunctionProtocol != PC_PROTOCOL_UNDEFINED) + { + iadXmlDesc->Protocol= gcnew String("WARNING: Protocol must be set to PC_PROTOCOL_UNDEFINED"); + iadXmlDesc->Protocol+= " for this class but is set to: "; + iadXmlDesc->Protocol+= iadDesc->bFunctionProtocol; + } + else + { + iadXmlDesc->Protocol = gcnew String("PC_PROTOCOL_UNDEFINED protocol"); + } + } + + if (iadDesc->iFunction) + { + // Add String descriptor + iadXmlDesc->StringDesc = XmlGetStringDescriptor( + iadDesc->iFunction, + stringDesc, + false); + } + + return; +} + +/***************************************************************************** + + XmlAddOTGDescriptor() + + This routine adds usb OTG descriptor + *****************************************************************************/ +void XmlAddOTGDescriptor( + UsbDeviceOTGDescriptorType ^ otgXmlDesc, + PUSB_OTG_DESCRIPTOR otgDesc) +{ + if (NULL == otgDesc) + { + return; + } + + otgXmlDesc->BLength = otgDesc->bLength; + otgXmlDesc->BDescriptorType = otgDesc->bDescriptorType; + otgXmlDesc->BmAttributes = otgDesc->bmAttributes; + + // Add descriptive fields + switch (otgDesc->bmAttributes) + { + case 0: + break; + case 1: + otgXmlDesc->AttributesString = gcnew String("SRP support"); + break; + case 2: + otgXmlDesc->AttributesString = gcnew String("HNP support"); + break; + case 3: + otgXmlDesc->AttributesString = gcnew String("SRP and HNP support"); + break; + default: + otgXmlDesc->AttributesString = gcnew String("ERROR: bmAttributes bits 2-7 are reserved should be 0)"); + break; + } + return; +} + +/***************************************************************************** + + XmlAddHidDescriptor() + + This routine adds usb HID descriptor + *****************************************************************************/ +void XmlAddHidDescriptor( + UsbDeviceHidDescriptorType ^ hidXmlDesc, + PUSB_HID_DESCRIPTOR hidDesc + ) +{ + int i = 0; + + if (NULL == hidDesc) + { + return; + } + + hidXmlDesc->BLength = hidDesc->bLength; + hidXmlDesc->BDescriptorType = hidDesc->bDescriptorType; + hidXmlDesc->BcdHID = hidDesc->bcdHID; + hidXmlDesc->BCountryCode = hidDesc->bCountryCode; + hidXmlDesc->BNumDescriptors = hidDesc->bNumDescriptors; + + // Add optional descriptors + if (hidDesc->bNumDescriptors > 0) + { + hidXmlDesc->OptionalDescriptor = gcnew array <UsbDeviceHidOptionalDescriptorsType ^>(hidDesc->bNumDescriptors); + for(i=0; i < hidDesc->bNumDescriptors; i++) + { + hidXmlDesc->OptionalDescriptor[i] = gcnew UsbDeviceHidOptionalDescriptorsType(); + hidXmlDesc->OptionalDescriptor[i]->BDescriptorType = hidDesc->OptionalDescriptors[i].bDescriptorType; + hidXmlDesc->OptionalDescriptor[i]->WDescriptorLength = hidDesc->OptionalDescriptors[i].wDescriptorLength; + } + } + return; +} + +/***************************************************************************** + + XmlGetUnknownDescriptor() + + This routine gets a usb unknown descriptor object form unknown descriptor + *****************************************************************************/ +UsbDeviceUnknownDescriptorType ^ XmlGetUnknownDescriptor( + PUSB_COMMON_DESCRIPTOR unknownDesc + ) +{ + int i = 0; + UsbDeviceUnknownDescriptorType ^ unknownXmlDesc = nullptr; + + if (NULL == unknownDesc) + { + return nullptr; + } + + unknownXmlDesc = gcnew UsbDeviceUnknownDescriptorType(); + unknownXmlDesc->BLength = unknownDesc->bLength; + unknownXmlDesc->BDescriptorType = unknownDesc->bDescriptorType; + + // Add optional descriptors + if (unknownDesc->bLength > 0) + { + unknownXmlDesc->UnknownDescriptor = gcnew String("Unknown descriptor->"); + for(i=0; i < unknownDesc->bLength; i++) + { + unknownXmlDesc->UnknownDescriptor += String::Format("0x{0:X} ", ((PUCHAR) unknownDesc)[i]); + } + } + return unknownXmlDesc; +} + +/***************************************************************************** + + XmlAddEndpointDescriptor() + + This routine adds usb endpoint descriptor and verbose fields + *****************************************************************************/ +void XmlAddEndpointDescriptor( + EndpointDescriptorType ^usbXmlEndpointDescriptor, + PUSB_ENDPOINT_DESCRIPTOR endPointDescriptor, + UCHAR connectionSpeed + ) +{ + EndpointDescriptorType ^ue = usbXmlEndpointDescriptor; + ULONG maxBytes = endPointDescriptor->wMaxPacketSize & 0x7FF; + + // Add structure values + ue->Length = endPointDescriptor->bLength; + ue->DescriptorType = endPointDescriptor->bDescriptorType; + ue->EndpointAddress = endPointDescriptor->bEndpointAddress; + ue->Attributes = endPointDescriptor->bmAttributes; + ue->MaxPacketSize = endPointDescriptor->wMaxPacketSize; + + // Add verbose fields + ue->EndpointId = endPointDescriptor->bEndpointAddress & 0x0F; + + // Add endpoint direction + if (USB_ENDPOINT_DIRECTION_OUT(endPointDescriptor->bEndpointAddress)) + { + ue->EndpointDirection = gcnew String("Out"); + } + else if (USB_ENDPOINT_DIRECTION_IN(endPointDescriptor->bEndpointAddress)) + { + ue->EndpointDirection = gcnew String("In"); + } + + // Add endpoint type + switch (endPointDescriptor->bmAttributes & USB_ENDPOINT_TYPE_MASK) + { + case USB_ENDPOINT_TYPE_CONTROL: + ue->EndpointType = gcnew String("Control Transfer Type"); + break; + case USB_ENDPOINT_TYPE_ISOCHRONOUS: + switch (endPointDescriptor->bmAttributes & 0x0C) + { + case 0x00: + ue->EndpointType = gcnew String("Ischronous Transfer Type - No Synchronization"); + break; + + case 0x04: + ue->EndpointType = gcnew String("Ischronous Transfer Type - Asynchronous"); + break; + + case 0x08: + ue->EndpointType = gcnew String("Ischronous Transfer Type - Adaptive"); + break; + + case 0x0C: + ue->EndpointType = gcnew String("Ischronous Transfer Type - Synchronous"); + break; + } + break; + case USB_ENDPOINT_TYPE_BULK: + ue->EndpointType = gcnew String("Bulk Transfer Type"); + break; + + case USB_ENDPOINT_TYPE_INTERRUPT: + ue->EndpointType = gcnew String("Interrupt Transfer Type"); + break; + } + + // Add packet info + switch (connectionSpeed) + { + case UsbHighSpeed: + if (endPointDescriptor->bmAttributes & 1) { + ULONG transactions = ((endPointDescriptor->wMaxPacketSize & 0x1800) >> 11) + 1; + // Isoc or Interrupt endpoint + ue->EndpointPacketInfo = gcnew String( + transactions + " transactions per microframe, " + + maxBytes + " max bytes"); + } + else + { + // Bulk endpoint + ue->EndpointPacketInfo = gcnew String(maxBytes + " max bytes"); + } + break; + case UsbFullSpeed: + ue->EndpointPacketInfo = gcnew String(maxBytes + " max bytes"); + break; + default: + // Low or Invalid speed + ue->EndpointPacketInfo = gcnew String("Invalid bus speed"); + break; + } + + // Add validation + if (endPointDescriptor->wMaxPacketSize & 0xE000) + { + ue->EndpointPacketSizeValidation = gcnew String("ERROR: wMaxPacketSize bits 15-13 should be 0"); + } else if (connectionSpeed==UsbHighSpeed) + { + USHORT hsMux; + + hsMux = (endPointDescriptor->wMaxPacketSize >> 11) & 0x03; + + switch (endPointDescriptor->bmAttributes & USB_ENDPOINT_TYPE_MASK) + { + case USB_ENDPOINT_TYPE_ISOCHRONOUS: + case USB_ENDPOINT_TYPE_INTERRUPT: + switch (hsMux) { + case 0: + if ((maxBytes < 1) || (maxBytes > 1024)) + { + ue->EndpointPacketSizeValidation = gcnew String("ERROR: Invalid maximum packet size, should be between 1 and 1024"); + } + break; + + case 1: + if ((maxBytes < 513) || (maxBytes > 1024)) + { + ue->EndpointPacketSizeValidation = gcnew String("ERROR: Invalid maximum packet size, should be between 513 and 1024"); + } + break; + + case 2: + if ((maxBytes < 683) || (maxBytes > 1024)) + { + ue->EndpointPacketSizeValidation = gcnew String("ERROR: Invalid maximum packet size, should be between 683 and 1024"); + } + break; + + case 3: + ue->EndpointPacketSizeValidation = gcnew String("ERROR: Bits 12-11 set to reserved value\r\n"); + break; + } + } + } + + // Add interval + if (endPointDescriptor->bLength == sizeof(USB_ENDPOINT_DESCRIPTOR)) + { + ue->Interval = endPointDescriptor->bInterval; + } + else + { + PUSB_ENDPOINT_DESCRIPTOR2 endpointDesc2 = (PUSB_ENDPOINT_DESCRIPTOR2) endPointDescriptor; + ue->WInterval = endpointDesc2->wInterval; + ue->SyncAddress = endpointDesc2->bSyncAddress; + } + return; +} + +/***************************************************************************** + + XmlAddPipeInformation() + + This routine adds all the pipe information for device + *****************************************************************************/ +void XmlAddPipeInformation( + array< UsbPipeInfoType ^> ^ usbXmlPipeInfoList, + PUSB_PIPE_INFO pipeInfo, + ULONG numPipes, + UCHAR connectionSpeed + ) +{ + ULONG i = 0; + + for(i = 0; i< numPipes; i++) + { + // Add all pipe in the list + usbXmlPipeInfoList[i] = gcnew UsbPipeInfoType(); + usbXmlPipeInfoList[i]->EndpointDescriptor = gcnew EndpointDescriptorType(); + XmlAddEndpointDescriptor( + usbXmlPipeInfoList[i]->EndpointDescriptor, + &pipeInfo[i].EndpointDescriptor, + connectionSpeed); + usbXmlPipeInfoList[i]->ScheduleOffset = pipeInfo->ScheduleOffset; + } + return; +} + +/***************************************************************************** + + XmlAddUsbDeviceDescriptor() + + This routine adds usb device descriptor + *****************************************************************************/ +void XmlAddUsbDeviceDescriptor( + UsbDeviceDescriptorType ^usbXmlDeviceDescriptor, + PUSB_DEVICE_DESCRIPTOR usbDeviceDescriptor) +{ + UsbDeviceDescriptorType ^ud = usbXmlDeviceDescriptor; + + // Map all fields explicitly + + ud->Length = usbDeviceDescriptor->bLength; + ud->DescriptorType = usbDeviceDescriptor->bDescriptorType; + ud->CdUSB= usbDeviceDescriptor->bcdUSB; + ud->DeviceClass = usbDeviceDescriptor->bDeviceClass; + ud->DeviceSubclass = usbDeviceDescriptor->bDeviceSubClass; + ud->DeviceProtocol = usbDeviceDescriptor->bDeviceProtocol; + ud->MaxPacketSize0 = usbDeviceDescriptor->bMaxPacketSize0; + ud->IdVendor = usbDeviceDescriptor->idVendor; + ud->IdProduct = usbDeviceDescriptor->idProduct ; + ud->CdDevice = usbDeviceDescriptor->bcdDevice; + ud->IManufacturer = usbDeviceDescriptor->iManufacturer; + ud->IProduct = usbDeviceDescriptor->iProduct; + ud->ISerialNumber = usbDeviceDescriptor->iSerialNumber; + ud->NumConfigurations = usbDeviceDescriptor->bNumConfigurations; + return; +} + +/***************************************************************************** + + XmlAddConfigurationDescriptor() + + This routine adds the configuration descriptor + *****************************************************************************/ +void XmlAddConfigurationDescriptor( + UsbConfigurationDescriptorType ^ confXmlDesc, + PUSBDEVICEINFO deviceInfo, + PUSB_CONFIGURATION_DESCRIPTOR configDesc, + PSTRING_DESCRIPTOR_NODE stringDesc + ) + +{ + UINT uCount = 0; + BOOL isSuperSpeed = FALSE; + + if (NULL == configDesc || NULL == deviceInfo) + { + return; + } + + if(deviceInfo->ConnectionInfoV2 && + (deviceInfo->ConnectionInfoV2->Flags.DeviceIsOperatingAtSuperSpeedOrHigher || + deviceInfo->ConnectionInfoV2->Flags.DeviceIsOperatingAtSuperSpeedPlusOrHigher)) + { + isSuperSpeed = TRUE; + } + + confXmlDesc->BLength = configDesc->bLength; + confXmlDesc->BDescriptorType = configDesc->bDescriptorType; + confXmlDesc->WTotalLength = configDesc->wTotalLength; + confXmlDesc->BNumInterfaces = configDesc->bNumInterfaces; + confXmlDesc->BConfigurationValue = configDesc->bConfigurationValue; + confXmlDesc->IConfiguration = configDesc->iConfiguration; + confXmlDesc->BmAttributes = configDesc->bmAttributes; + confXmlDesc->MaxPower = configDesc->MaxPower; + + uCount = GetConfigurationSize(deviceInfo); + + if (uCount != configDesc->wTotalLength) + { + confXmlDesc->ConfigDescError = gcnew String("ERROR: Invalid total configuration size " + + configDesc->wTotalLength + ", should be " + uCount); + } + + if (configDesc->bConfigurationValue != 1) + { + confXmlDesc->ConfValueError = gcnew String("CAUTION: Most host controllers will only work with one configuration per speed"); + } + + if (configDesc->iConfiguration) + { + confXmlDesc->ConfStringDesc = XmlGetStringDescriptor( + configDesc->iConfiguration, + stringDesc, + false); + } + + if (configDesc->bmAttributes & USB_CONFIG_BUS_POWERED) + { + confXmlDesc->AttributesStr = gcnew String("Bus Powered"); + } + else if (configDesc->bmAttributes & USB_CONFIG_SELF_POWERED) + { + confXmlDesc->AttributesStr = gcnew String("Self Powered"); + } + else if (configDesc->bmAttributes & USB_CONFIG_REMOTE_WAKEUP) + { + confXmlDesc->AttributesStr = gcnew String("Remote Wakeup"); + } + else + { + confXmlDesc->AttributesStr = gcnew String("WARNING: bmAttributes is using reserved space"); + } + + confXmlDesc->MaxCurrent = gcnew String(""); + confXmlDesc->MaxCurrent += (isSuperSpeed?configDesc->MaxPower * 8:configDesc->MaxPower * 2); + confXmlDesc->MaxCurrent += " mA"; + + return; +} + +/***************************************************************************** + + XmlGetDeviceClass() + + This routine returns the interface class and subclass for given interface descriptor + *****************************************************************************/ +UsbDeviceClassType ^ XmlGetDeviceClass(UCHAR bInterfaceClass, UCHAR bInterfaceSubclass, UCHAR bInterfaceProtocol) +{ + String ^ deviceClass = nullptr; + String ^ deviceSubclass = nullptr; + UsbDeviceClassType ^ deviceDetails = gcnew UsbDeviceClassType(); + + switch (bInterfaceClass) + { + case USB_DEVICE_CLASS_AUDIO: + deviceClass = gcnew String("Audio Interface"); + + switch (bInterfaceSubclass) + { + case USB_AUDIO_SUBCLASS_AUDIOCONTROL: + deviceSubclass = gcnew String("Audio Control Interface"); + break; + + case USB_AUDIO_SUBCLASS_AUDIOSTREAMING: + deviceSubclass = gcnew String("Audio Streaming Interface"); + break; + + case USB_AUDIO_SUBCLASS_MIDISTREAMING: + deviceSubclass = gcnew String("MIDI Streaming Interface"); + break; + + default: + deviceSubclass = gcnew String("CAUTION: This appears to be an invalid bInterfaceSubclass : "); + deviceSubclass += bInterfaceSubclass; + break; + } + break; + + case USB_DEVICE_CLASS_VIDEO: + deviceClass = gcnew String("Video Interface"); + + switch(bInterfaceSubclass) + { + case VIDEO_SUBCLASS_CONTROL: + deviceSubclass = gcnew String("Video Control"); + break; + + case VIDEO_SUBCLASS_STREAMING: + deviceSubclass = gcnew String("Video Streaming"); + break; + + default: + deviceSubclass = gcnew String("CAUTION: This appears to be an invalid bInterfaceSubclass : "); + deviceSubclass += bInterfaceSubclass; + break; + } + break; + + case USB_DEVICE_CLASS_VENDOR_SPECIFIC: + deviceClass = gcnew String("Vendor Specific Device"); + break; + + case USB_DEVICE_CLASS_HUMAN_INTERFACE: + + deviceClass = gcnew String("HID Interface"); + break; + + case USB_DEVICE_CLASS_HUB: + deviceClass = gcnew String("HUB Interface"); + break; + + case USB_DEVICE_CLASS_RESERVED: + deviceClass = gcnew String("CAUTION: Reserved USB Device Interface Class"); + break; + + case USB_DEVICE_CLASS_COMMUNICATIONS: + deviceClass = gcnew String("Communications (CDC Control) USB Device\r\n"); + break; + + case USB_DEVICE_CLASS_MONITOR: + deviceClass = gcnew String("Monitor USB Device Interface Class*** (This may be obsolete)"); + break; + + case USB_DEVICE_CLASS_PHYSICAL_INTERFACE: + deviceClass = gcnew String("Physical Interface USB Device"); + break; + + case USB_DEVICE_CLASS_POWER: + if (bInterfaceSubclass == 1 && bInterfaceProtocol == 1) + { + deviceClass = gcnew String("Image USB Device"); + } + else + { + deviceClass = gcnew String("Power USB Device (This may be obsolete)"); + } + break; + + case USB_DEVICE_CLASS_PRINTER: + deviceClass = gcnew String("Printer USB Device"); + break; + + case USB_DEVICE_CLASS_STORAGE: + deviceClass = gcnew String("Mass Storage USB Device"); + break; + + case USB_CDC_DATA_INTERFACE: + deviceClass = gcnew String("CDC Data USB Device"); + break; + + case USB_CHIP_SMART_CARD_INTERFACE: + deviceClass = gcnew String("Chip/Smart Card USB Device"); + break; + + case USB_CONTENT_SECURITY_INTERFACE: + deviceClass = gcnew String("Content Security USB Device"); + break; + + case USB_DIAGNOSTIC_DEVICE_INTERFACE: + if (bInterfaceSubclass == 1 && bInterfaceProtocol == 1) + { + deviceClass = gcnew String("Reprogrammable USB2 Compliance Diagnostic Device USB Device"); + } + else + { + deviceClass = gcnew String("CAUTION: This appears to be an invalid device class: "); + deviceClass += bInterfaceClass; + } + break; + + case USB_WIRELESS_CONTROLLER_INTERFACE: + if (bInterfaceSubclass == 1 && bInterfaceProtocol == 1) + { + deviceClass = gcnew String("Wireless RF Controller USB Device Interface Class with Bluetooth Programming Interface"); + } + else + { + deviceClass = gcnew String("CAUTION: This appears to be an invalid device class: "); + deviceClass += bInterfaceClass; + } + break; + + case USB_APPLICATION_SPECIFIC_INTERFACE: + deviceClass = gcnew String("Application Specific USB Device"); + + switch(bInterfaceSubclass) + { + case 1: + deviceSubclass = gcnew String("Device Firmware Application Specific USB Device"); + break; + case 2: + deviceSubclass = gcnew String("IrDA Bridge Application Specific USB Device"); + break; + case 3: + deviceSubclass = gcnew String("Test & Measurement Class (USBTMC) Application Specific USB Device"); + break; + default: + deviceSubclass = gcnew String("CAUTION: This appears to be an invalid bInterfaceSubclass : "); + deviceSubclass += bInterfaceSubclass; + } + break; + + default: + + deviceClass = gcnew String("Interface Class unknown : "); + deviceClass += bInterfaceClass; + break; + } + + // Return class and subclass + + deviceDetails->DeviceClass = deviceClass; + deviceDetails->DeviceSubclass = deviceSubclass; + + return deviceDetails; +} + +/***************************************************************************** + + XmlAddInterfaceDescriptor() + + This routine adds the device interface descriptor + *****************************************************************************/ +void XmlAddDeviceInterfaceDescriptor( + UsbDeviceInterfaceDescriptorType ^ ifXmlDesc, + PUSB_INTERFACE_DESCRIPTOR ifDesc, + PSTRING_DESCRIPTOR_NODE stringDesc) +{ + if (NULL == ifDesc || NULL == stringDesc) + { + return; + } + + // Update structure fields + ifXmlDesc->BLength = ifDesc->bLength; + ifXmlDesc->BDescriptorType = ifDesc->bDescriptorType; + ifXmlDesc->BInterfaceNumber = ifDesc->bInterfaceNumber; + ifXmlDesc->BAlternateSetting = ifDesc->bAlternateSetting; + ifXmlDesc->BNumEndpoints = ifDesc->bNumEndpoints; + ifXmlDesc->BInterfaceClass = ifDesc->bInterfaceClass; + ifXmlDesc->BInterfaceSubclass = ifDesc->bInterfaceSubClass; + ifXmlDesc->BInterfaceProtocol = ifDesc->bInterfaceProtocol; + ifXmlDesc->IInterface = ifDesc->iInterface; + + // Update class and sub class + ifXmlDesc->InterfaceDetails = XmlGetDeviceClass( + ifDesc->bInterfaceClass, + ifDesc->bInterfaceSubClass, + ifDesc->bInterfaceProtocol); + + //This is basically the check for PC_PROTOCOL_UNDEFINED + if ((ifDesc->bInterfaceClass == USB_DEVICE_CLASS_VIDEO) || + (ifDesc->bInterfaceClass == USB_DEVICE_CLASS_AUDIO)) + { + if (ifDesc->bInterfaceProtocol != PC_PROTOCOL_UNDEFINED) + { + ifXmlDesc->ProtocolError = gcnew String("WARNING: Protocol must be set to PC_PROTOCOL_UNDEFINED"); + ifXmlDesc->ProtocolError += " for this class but is set to: "; + ifXmlDesc->ProtocolError += ifDesc->bInterfaceProtocol; + } + } + + if (ifDesc->iInterface) + { + // Add String descriptor + ifXmlDesc->StringDesc = XmlGetStringDescriptor( + ifDesc->iInterface, + stringDesc, + false); + } + + if (ifDesc->bLength == sizeof(USB_INTERFACE_DESCRIPTOR2)) + { + PUSB_INTERFACE_DESCRIPTOR2 interfaceDesc2; + + interfaceDesc2 = (PUSB_INTERFACE_DESCRIPTOR2)ifDesc; + + ifXmlDesc->WNumClasses = interfaceDesc2->wNumClasses; + } + return; +} + +/***************************************************************************** + + XmlAddDeviceQualDescriptor() + + This routine adds the device qualifier descriptor + *****************************************************************************/ + +void XmlAddDeviceQualDescriptor( + UsbDeviceQualifierDescriptorType ^ qualXmlDesc, + PUSB_DEVICE_QUALIFIER_DESCRIPTOR qualDesc) +{ + if (NULL == qualDesc) + { + return; + } + + // Add structure fields + qualXmlDesc->BLength = qualDesc->bLength; + qualXmlDesc->BDescriptorType = qualDesc->bDescriptorType; + qualXmlDesc->BcdUSB = qualDesc->bcdUSB; + qualXmlDesc->BDeviceClass = qualDesc->bDeviceClass; + qualXmlDesc->BDeviceSubclass = qualDesc->bDeviceSubClass; + qualXmlDesc->BDeviceProtocol = qualDesc->bDeviceProtocol; + qualXmlDesc->BMaxPacketSize0 = qualDesc->bMaxPacketSize0; + qualXmlDesc->NumConfigurations = qualDesc->bNumConfigurations; + + // Get device class string + qualXmlDesc->DeviceClass = XmlGetDeviceClassString(qualDesc->bDeviceClass); + + if (qualDesc->bDeviceSubClass > 0x00 && qualDesc->bDeviceSubClass < 0xFF) + { + qualXmlDesc->DeviceSubclassError = gcnew String("ERROR: bDeviceSubClass is invalid : "); + qualXmlDesc->DeviceSubclassError += qualDesc->bDeviceSubClass; + } + + if (qualDesc->bDeviceProtocol > 0x00 && qualDesc->bDeviceProtocol < 0xFF) + { + qualXmlDesc->DeviceProtocolError = gcnew String("ERROR: bDeviceProtocol is invalid : "); + qualXmlDesc->DeviceProtocolError += qualDesc->bDeviceProtocol; + } + + qualXmlDesc->MaxPacketSizeInBytes = qualDesc->bMaxPacketSize0; + + if (qualDesc->bNumConfigurations != 1) + { + qualXmlDesc->DeviceNumConfigError = gcnew String( + "CAUTION: Most host controllers will only work with one configuration per speed"); + } + + if (qualDesc->bReserved != 0) + { + qualXmlDesc->ReservedError = gcnew String("WARNING: bReserved needs to be set to 0 to be valid - " + + qualDesc->bReserved); + } + + return; +} + +/***************************************************************************** + + XmlAddAddConfigDescriptors() + + This routine adds the all the config descriptors + *****************************************************************************/ +array < UsbDeviceConfigurationType ^> ^ XmlGetConfigDescriptors( + PUSBDEVICEINFO deviceInfo, + PUSB_CONFIGURATION_DESCRIPTOR configDescs, + PSTRING_DESCRIPTOR_NODE stringDesc + ) +{ + array < UsbDeviceConfigurationType ^> ^ confXmlDescs = nullptr; + PUSB_COMMON_DESCRIPTOR commonDesc = NULL; + PUCHAR descEnd = NULL; + ArrayList ^confList = gcnew ArrayList; + UsbDeviceConfigurationType ^ deviceConf = nullptr; + + commonDesc = (PUSB_COMMON_DESCRIPTOR) configDescs; + descEnd = (PUCHAR) configDescs + configDescs->wTotalLength; + + while ((PUCHAR)commonDesc + sizeof(USB_COMMON_DESCRIPTOR) < descEnd && + (PUCHAR)commonDesc + commonDesc->bLength <= descEnd) + { + // Add the config descriptor + deviceConf = gcnew UsbDeviceConfigurationType(); + + XmlAddDeviceConfiguration( + deviceConf, + deviceInfo, + (PUSB_CONFIGURATION_DESCRIPTOR) commonDesc, + stringDesc, + configDescs->bNumInterfaces + ); + + confList->Add(deviceConf); + commonDesc = (PUSB_COMMON_DESCRIPTOR) ((PUCHAR) commonDesc + commonDesc->bLength); + } + + confXmlDescs = reinterpret_cast<array<UsbDeviceConfigurationType ^>^> (confList->ToArray(UsbDeviceConfigurationType::typeid)); + return confXmlDescs; +} + +/***************************************************************************** + + XmlAddDeviceConfiguration() + + This routine adds the device configuration + *****************************************************************************/ +void XmlAddDeviceConfiguration( + UsbDeviceConfigurationType ^ confXmlDesc, + PUSBDEVICEINFO deviceInfo, + PUSB_CONFIGURATION_DESCRIPTOR configDesc, + PSTRING_DESCRIPTOR_NODE stringDesc, + int numInterfaces + ) +{ + PUSB_COMMON_DESCRIPTOR commonDesc = NULL; + UCHAR bInterfaceClass = 0; + UCHAR bInterfaceSubclass = 0; + UCHAR bInterfaceProtocol = 0; + BOOL displayUnknown = FALSE; + + if (NULL == deviceInfo || NULL == configDesc || NULL == stringDesc) + { + return; + } + + commonDesc = (PUSB_COMMON_DESCRIPTOR)configDesc; + displayUnknown = FALSE; + + switch (commonDesc->bDescriptorType) + { + case USB_DEVICE_QUALIFIER_DESCRIPTOR_TYPE: + if (commonDesc->bLength != sizeof(USB_DEVICE_QUALIFIER_DESCRIPTOR)) + { + // Validate descriptor + confXmlDesc->DeviceQualifierError = String::Format( + "ERROR: Device Qualifier bLength value incorrect Obtained: {0} Expected {1}", + commonDesc->bLength, + sizeof(USB_DEVICE_QUALIFIER_DESCRIPTOR)); + displayUnknown = TRUE; + break; + } + // Add device Qual descriptor + confXmlDesc->DeviceQualifierDescriptor = gcnew UsbDeviceQualifierDescriptorType(); + + XmlAddDeviceQualDescriptor( + confXmlDesc->DeviceQualifierDescriptor, + (PUSB_DEVICE_QUALIFIER_DESCRIPTOR) commonDesc); + break; + + case USB_OTHER_SPEED_CONFIGURATION_DESCRIPTOR_TYPE: + if (commonDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR)) + { + // Validate descriptor + confXmlDesc->SpeedConfigurationError = String::Format( + "ERROR: Other speed configuration bLength value incorrect Obtained: {0} Expected {1}", + commonDesc->bLength, + sizeof(USB_CONFIGURATION_DESCRIPTOR)); + displayUnknown = TRUE; + } + + // Add configuration desc + confXmlDesc->ConfigurationDescriptor = gcnew UsbConfigurationDescriptorType(); + + XmlAddConfigurationDescriptor( + confXmlDesc->ConfigurationDescriptor, + deviceInfo, + (PUSB_CONFIGURATION_DESCRIPTOR) commonDesc, + stringDesc); + break; + + case USB_CONFIGURATION_DESCRIPTOR_TYPE: + if (commonDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR)) + { + // Validate descriptor + confXmlDesc->SpeedConfigurationError = String::Format( + "ERROR: Configuration bLength value incorrect Obtained: {0} Expected {1}", + commonDesc->bLength, + sizeof(USB_CONFIGURATION_DESCRIPTOR)); + displayUnknown = TRUE; + break; + } + + // Add configuration desc + confXmlDesc->ConfigurationDescriptor = gcnew UsbConfigurationDescriptorType(); + XmlAddConfigurationDescriptor( + confXmlDesc->ConfigurationDescriptor, + deviceInfo, + (PUSB_CONFIGURATION_DESCRIPTOR) commonDesc, + stringDesc); + break; + + case USB_INTERFACE_DESCRIPTOR_TYPE: + if ((commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR)) && + (commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR2))) + { + // Validate descriptor + confXmlDesc->InterfaceError = String::Format( + "ERROR: Interface bLength value incorrect Obtained: {0} Expected: {1} or {2}", + commonDesc->bLength, + sizeof(USB_INTERFACE_DESCRIPTOR), + sizeof(USB_INTERFACE_DESCRIPTOR2)); + displayUnknown = TRUE; + break; + } + + // Add interface descriptor + bInterfaceClass = ((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->bInterfaceClass; + bInterfaceSubclass = ((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->bInterfaceSubClass; + bInterfaceProtocol = ((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->bInterfaceProtocol; + + confXmlDesc->InterfaceDescriptor = gcnew UsbDeviceInterfaceDescriptorType(); + XmlAddDeviceInterfaceDescriptor( + confXmlDesc->InterfaceDescriptor, + (PUSB_INTERFACE_DESCRIPTOR) commonDesc, + stringDesc + ); + + case USB_ENDPOINT_DESCRIPTOR_TYPE: + if ((commonDesc->bLength != sizeof(USB_ENDPOINT_DESCRIPTOR)) && + (commonDesc->bLength != sizeof(USB_ENDPOINT_DESCRIPTOR2))) + { + // Validate endpoint descriptor + confXmlDesc->EndpointError = String::Format( + "ERROR: Endpoint bLength value incorrect Obtained: {0} Expected: {1} or {2}", + commonDesc->bLength, + sizeof(USB_ENDPOINT_DESCRIPTOR), + sizeof(USB_ENDPOINT_DESCRIPTOR2)); + displayUnknown = TRUE; + break; + } + + confXmlDesc->EndpointDescriptor = gcnew EndpointDescriptorType(); + + if (NULL != deviceInfo->ConnectionInfo) + { + // Add endpoint descriptor + XmlAddEndpointDescriptor( + confXmlDesc->EndpointDescriptor, + (PUSB_ENDPOINT_DESCRIPTOR) commonDesc, + deviceInfo->ConnectionInfo->Speed); + } + + break; + + case USB_HID_DESCRIPTOR_TYPE: + if (commonDesc->bLength < sizeof(USB_HID_DESCRIPTOR)) + { + // Validate HID + confXmlDesc->HidError = String::Format( + "ERROR: HID bLength value incorrect Obtained: {0} Expected: {1}", + commonDesc->bLength, + sizeof(USB_HID_DESCRIPTOR)); + displayUnknown = TRUE; + break; + } + + // Add HID descriptor + confXmlDesc->HidDescriptor = gcnew UsbDeviceHidDescriptorType(); + XmlAddHidDescriptor( + confXmlDesc->HidDescriptor, + (PUSB_HID_DESCRIPTOR) commonDesc + ); + break; + + case USB_OTG_DESCRIPTOR_TYPE: + if (commonDesc->bLength < sizeof(USB_OTG_DESCRIPTOR)) + { + // Validate length + confXmlDesc->HidError = String::Format( + "ERROR: OTG bLength value incorrect Obtained: {0} Expected: {1}", + commonDesc->bLength, + sizeof(USB_OTG_DESCRIPTOR)); + displayUnknown = TRUE; + break; + } + + // Add OTG descriptor + confXmlDesc->OtgDescriptor = gcnew UsbDeviceOTGDescriptorType(); + XmlAddOTGDescriptor( + confXmlDesc->OtgDescriptor, + (PUSB_OTG_DESCRIPTOR) commonDesc + ); + break; + + case USB_IAD_DESCRIPTOR_TYPE: + if (commonDesc->bLength < sizeof(USB_IAD_DESCRIPTOR)) + { + // Validate length + confXmlDesc->IadError = String::Format( + "ERROR: IAD bLength value incorrect", + commonDesc->bLength, + sizeof(USB_OTG_DESCRIPTOR)); + displayUnknown = TRUE; + } + + // Add IAD descriptor + confXmlDesc->IadDescriptor = gcnew UsbDeviceIADDescriptorType(); + XmlAddIADDescriptor( + confXmlDesc->IadDescriptor, + (PUSB_IAD_DESCRIPTOR) commonDesc, + stringDesc, + numInterfaces + ); + break; + + default: + // Interface class device (?) + confXmlDesc->DeviceDetails = XmlGetDeviceClass( + ((PUSB_INTERFACE_DESCRIPTOR) commonDesc)->bInterfaceClass, + ((PUSB_INTERFACE_DESCRIPTOR) commonDesc)->bInterfaceSubClass, + ((PUSB_INTERFACE_DESCRIPTOR) commonDesc)->bInterfaceProtocol + ); + break; + } + + if (displayUnknown) + { + // Add unknown descriptor + confXmlDesc->UnknownDescriptor = XmlGetUnknownDescriptor(commonDesc); + } + return; +} + +/***************************************************************************** + + XmlAddConnectionInfoSt() + + This routine adds connection information structures for the device + *****************************************************************************/ +void XmlAddConnectionInfoSt( + NodeConnectionInfoExStructType ^xmlConnectionInfoSt, + PUSB_NODE_CONNECTION_INFORMATION_EX connectionInfo, + PDEVICE_INFO_NODE pNode) +{ + NodeConnectionInfoExStructType ^nS = xmlConnectionInfoSt; + + nS->ConnectionIndex = connectionInfo->ConnectionIndex; + + nS->DeviceDescriptor = gcnew UsbDeviceDescriptorType(); + + XmlAddUsbDeviceDescriptor(nS->DeviceDescriptor, &(connectionInfo->DeviceDescriptor)); + + nS->CurrentConfigurationValue = connectionInfo->CurrentConfigurationValue; + nS->Speed = connectionInfo->Speed; + nS->SpeedStr = static_cast<UsbConnectionSpeedType> (connectionInfo->Speed); + nS->DeviceIsHub = connectionInfo->DeviceIsHub? true: false; + nS->NumOfOpenPipes = connectionInfo->NumberOfOpenPipes; + nS->UsbConnectionStatus = static_cast<UsbConnectionStatusType> (connectionInfo->ConnectionStatus); + + if(NULL != pNode) + { + nS->DevicePowerState = static_cast<DevicePowerStateType>(pNode->LatestDevicePowerState); + } + else + { + nS->DevicePowerState = static_cast<DevicePowerStateType>(PowerDeviceUnspecified); + } + + // Add the pipe list + if (connectionInfo->NumberOfOpenPipes > 0) + { + nS->Pipe = gcnew array <UsbPipeInfoType ^>(connectionInfo->NumberOfOpenPipes); + XmlAddPipeInformation( + nS->Pipe, + connectionInfo->PipeList, + connectionInfo->NumberOfOpenPipes, + connectionInfo->Speed + ); + } + + return; +} + +/***************************************************************************** + + XmlGetLangIdString() + + Obtains the language string for given string descriptor index + *****************************************************************************/ +String ^ XmlGetLangIdString(UCHAR index, PSTRING_DESCRIPTOR_NODE stringDesc) +{ + String ^langIdStr = nullptr; + bool foundDescriptor = false; + + while(stringDesc) + { + if (stringDesc->DescriptorIndex == index) + { + langIdStr = PACHAR_TO_STRING(GetLangIDString(stringDesc->LanguageID)); + + if (langIdStr == nullptr) + { + langIdStr = gcnew String("WARNING: Invalid language ID: " + stringDesc->LanguageID); + } + foundDescriptor = true; + break; + } + stringDesc = stringDesc->Next; + } + + if (foundDescriptor == false) + { + // If no descriptor was found, return error message in field + langIdStr = gcnew String("ERROR: No String descriptor for index " + index); + } + + return langIdStr; +} + +/***************************************************************************** + + XmlGetStringDescriptor() + + Obtains the string descriptor for given string descriptor index + *****************************************************************************/ + +String ^ XmlGetStringDescriptor(UCHAR index, PSTRING_DESCRIPTOR_NODE stringDesc, bool enOnly) +{ + ULONG nBytes = 0; + + CHAR pString[MAX_STRING_DESCRIPTOR_LENGTH]; + String ^desc = nullptr; + bool foundDescriptor = false; + bool foundNonEnglishDescriptor = false; + + ZeroMemory(pString, MAX_STRING_DESCRIPTOR_LENGTH); + + while(stringDesc) + { + if (stringDesc->DescriptorIndex == index) + { + if (enOnly && stringDesc->LanguageID != STRING_DESCRIPTOR_EN_LANGUAGE_ID) + { + // If we are required to return only english descriptor, continue + foundNonEnglishDescriptor = true; + continue; + } + + nBytes = WideCharToMultiByte( + CP_ACP, + WC_NO_BEST_FIT_CHARS, + stringDesc->StringDescriptor->bString, + (stringDesc->StringDescriptor->bLength -2)/2, + pString, + MAX_STRING_DESCRIPTOR_LENGTH, + NULL, + NULL + ); + + if (nBytes) + { + foundDescriptor = true; + desc = PACHAR_TO_STRING(pString); + } + break; + } + stringDesc = stringDesc->Next; + } + + if ((foundDescriptor == false) && (foundNonEnglishDescriptor == false)) + { + // If no descriptor was found, return error message in field + desc = gcnew String("ERROR: No String descriptor for index " + + index); + } + else if ((foundDescriptor == false) && (foundNonEnglishDescriptor == true) && (enOnly)) + { + desc = gcnew String("ERROR: The index " + index + " does not support English(US)"); + } + + return desc; +} + +/***************************************************************************** + + XmlGetDeviceClassString() + + Returns the device class string for given device class ID + *****************************************************************************/ + +String ^ XmlGetDeviceClassString(UCHAR deviceClass) +{ + String ^ deviceClassStr = nullptr; + + // Not an IAD device + switch (deviceClass) + { + case USB_INTERFACE_CLASS_DEVICE: + deviceClassStr = gcnew String("Interface Class Defined Device"); + break; + + case USB_COMMUNICATION_DEVICE: + deviceClassStr = gcnew String("Communication Device"); + break; + + case USB_HUB_DEVICE: + deviceClassStr = gcnew String("Hub Device"); + break; + + case USB_DIAGNOSTIC_DEVICE: + deviceClassStr = gcnew String("Diagnostic Device"); + break; + + case USB_WIRELESS_CONTROLLER_DEVICE: + deviceClassStr = gcnew String("Wireless Controller(Bluetooth) Device"); + break; + + case USB_VENDOR_SPECIFIC_DEVICE: + deviceClassStr = gcnew String("Vendor specific device"); + break; + + default: + deviceClassStr= gcnew String("ERROR: unknown bDeviceClass" + deviceClass); + break; + } + return deviceClassStr; +} + + +/***************************************************************************** + + XmlAddDeviceClassDetails() + + This routine adds device class details + *****************************************************************************/ +bool XmlAddDeviceClassDetails( + UsbDeviceClassDetailsType ^ deviceDetails, + PUSB_NODE_CONNECTION_INFORMATION_EX connectionInfo, + PUSBDEVICEINFO deviceInfo) +{ + UINT uIADcount = 0; + bool tog = true; + + uIADcount = IsIADDevice((PUSBDEVICEINFO) deviceInfo); + + if (uIADcount) + { + // IAD device, check validity of device class + if (connectionInfo->DeviceDescriptor.bDeviceClass == USB_MISCELLANEOUS_DEVICE) + { + tog = false; + deviceDetails->DeviceType = gcnew String("Multi-interface Function Code Device"); + } + else { + deviceDetails->DeviceTypeError = gcnew String("ERROR: device class should be Multi-interface Function " + + USB_MISCELLANEOUS_DEVICE + + "is used"); + } + deviceDetails->UvcVersion = IsUVCDevice((PUSBDEVICEINFO) deviceInfo); + + // This device configuration has 1 or more IAD descriptors + if (connectionInfo->DeviceDescriptor.bDeviceSubClass == USB_COMMON_SUB_CLASS) + { + deviceDetails->SubclassType = gcnew String("Common Class Sub Class"); + } + else + { + deviceDetails->SubclassTypeError = gcnew String("ERROR: device SubClass should be USB Common Sub Class" + + USB_COMMON_SUB_CLASS + + " when IAD descriptor is used"); + } + + // Check device protocol + if (connectionInfo->DeviceDescriptor.bDeviceProtocol == USB_IAD_PROTOCOL) + { + deviceDetails->DeviceProtocol = gcnew String("Interface Association Descriptor protocol"); + } + else + { + deviceDetails->DeviceProtocolError = gcnew String("ERROR: device Protocol should be USB IAD Protocol " + + USB_IAD_PROTOCOL + + " when IAD descriptor is used"); + } + + } + else + { + deviceDetails->DeviceType = XmlGetDeviceClassString(connectionInfo->DeviceDescriptor.bDeviceClass); + + if (connectionInfo->DeviceDescriptor.bDeviceClass == USB_MISCELLANEOUS_DEVICE) + { + deviceDetails->DeviceTypeError = gcnew String("ERROR: Multi-interface Function code " + + connectionInfo->DeviceDescriptor.bDeviceClass + + " used for device with no IAD descriptors"); + } + + if (connectionInfo->DeviceDescriptor.bDeviceClass == USB_COMMUNICATION_DEVICE || + connectionInfo->DeviceDescriptor.bDeviceClass == USB_HUB_DEVICE || + connectionInfo->DeviceDescriptor.bDeviceClass == USB_DIAGNOSTIC_DEVICE || + connectionInfo->DeviceDescriptor.bDeviceClass == USB_WIRELESS_CONTROLLER_DEVICE || + connectionInfo->DeviceDescriptor.bDeviceClass == USB_MISCELLANEOUS_DEVICE || + connectionInfo->DeviceDescriptor.bDeviceClass == USB_VENDOR_SPECIFIC_DEVICE) + { + tog = false; + } + + // Not an IAD device, so all subclass values are invalid + if (connectionInfo->DeviceDescriptor.bDeviceSubClass > 0x00 && + connectionInfo->DeviceDescriptor.bDeviceSubClass < 0xFF) + { + deviceDetails->SubclassTypeError = gcnew String("ERROR: bDeviceSubClass is invalid - " + + connectionInfo->DeviceDescriptor.bDeviceSubClass); + } + + // Not an IAD device, so all subclass values are invalid, check protocol + if (connectionInfo->DeviceDescriptor.bDeviceProtocol > 0x00 && + connectionInfo->DeviceDescriptor.bDeviceProtocol < 0xFF && tog==1) + { + deviceDetails->DeviceProtocolError = gcnew String("ERROR: bDeviceProtocol is invalid - " + + connectionInfo->DeviceDescriptor.bDeviceProtocol); + } + } + + return tog; +} + +/***************************************************************************** + + XmlAddConnectionInfo() + + This routine adds connection information for the device + *****************************************************************************/ +void XmlAddConnectionInfo( + NodeConnectionInfoExType ^xmlConnectionInfo, + PUSB_NODE_CONNECTION_INFORMATION_EX connectionInfo, + PUSBDEVICEINFO deviceInfo, + PSTRING_DESCRIPTOR_NODE stringDesc, + PDEVICE_INFO_NODE pNode) +{ + NodeConnectionInfoExType ^ nc = xmlConnectionInfo; + bool tog = true; + nc->ConnectionInfoStruct = gcnew NodeConnectionInfoExStructType(); + + // Update the structure + XmlAddConnectionInfoSt(nc->ConnectionInfoStruct, connectionInfo, pNode); + + // Add verbose fields + if (connectionInfo->ConnectionStatus == NoDeviceConnected) + { + // No device connected, nothing to do + return; + } + + if (connectionInfo->DeviceDescriptor.iProduct) + { + // Add EN version of string descriptor + + nc->IProductStringDescEn = XmlGetStringDescriptor( + connectionInfo->DeviceDescriptor.iProduct, + stringDesc, + true); + } + + // Check open pipes count + if (connectionInfo->NumberOfOpenPipes == 0) + { + nc->PipeInfoError = gcnew String("ERROR: No open pipes"); + } + + // Check device descriptor length + if (connectionInfo->DeviceDescriptor.bLength != DEVICE_DESCRIPTOR_LENGTH) + { + nc->LengthError = gcnew String("ERROR: bLength " + + connectionInfo->DeviceDescriptor.bLength + + " incorrect, should be " + + DEVICE_DESCRIPTOR_LENGTH + ); + } + + // Check for device error + if ((connectionInfo->ConnectionStatus == DeviceFailedEnumeration) || + (connectionInfo->ConnectionStatus == DeviceGeneralFailure)) + { + nc->DeviceError = gcnew String("ERROR: Device enumeration failure"); + } + else + { + nc->DeviceClassDetails = gcnew UsbDeviceClassDetailsType(); + + // Add device class details + tog = XmlAddDeviceClassDetails( + nc->DeviceClassDetails, + connectionInfo, + deviceInfo); + + nc->MaxPacketSizeInBytes = connectionInfo->DeviceDescriptor.bMaxPacketSize0; + + // Validate speed + switch (connectionInfo->Speed) + { + case UsbLowSpeed: + if (connectionInfo->DeviceDescriptor.bMaxPacketSize0 != 8) + { + nc->PacketSizeError = gcnew String("ERROR: Low Speed Devices require bMaxPacketSize0 = 8"); + } + break; + case UsbFullSpeed: + if (!(connectionInfo->DeviceDescriptor.bMaxPacketSize0 == 8 || + connectionInfo->DeviceDescriptor.bMaxPacketSize0 == 16 || + connectionInfo->DeviceDescriptor.bMaxPacketSize0 == 32 || + connectionInfo->DeviceDescriptor.bMaxPacketSize0 == 64)) + { + nc->PacketSizeError = gcnew String("ERROR: Full Speed Devices require bMaxPacketSize0 = 8, 16, 32, or 64"); + } + break; + case UsbHighSpeed: + if (connectionInfo->DeviceDescriptor.bMaxPacketSize0 != 64) + { + nc->PacketSizeError = gcnew String("ERROR: High Speed Devices require bMaxPacketSize0 = 64"); + } + break; + } + + // Get string descriptors + nc->VendorString = PACHAR_TO_STRING(GetVendorString(connectionInfo->DeviceDescriptor.idVendor)); + + nc->ManufacturerString = XmlGetStringDescriptor(connectionInfo->DeviceDescriptor.iManufacturer, stringDesc, false); + nc->ProductString = XmlGetStringDescriptor(connectionInfo->DeviceDescriptor.iProduct, stringDesc, false); + nc->LangIdString = XmlGetLangIdString(connectionInfo->DeviceDescriptor.iProduct, stringDesc); + nc->SerialString = XmlGetStringDescriptor(connectionInfo->DeviceDescriptor.iSerialNumber, stringDesc, false); + + // Validate configuration + if (connectionInfo->DeviceDescriptor.bNumConfigurations != 1) + { + nc->ConfigurationCountError = gcnew String("WARNING: Most host controllers will only work with "\ + "one configuration per speed"); + } + } + return; +} + + +/***************************************************************************** + + XmlAddExternalHub() + + Add a external to the parent Host Controller or hub. This is determined by the + last object pushed on the stack + *****************************************************************************/ +HRESULT XmlAddExternalHub(PSTR ehName, PUSBEXTERNALHUBINFO ehInfo) +{ + HRESULT hr = S_OK; + Object ^ parent = gXmlStack->Peek(); + ExternalHubType ^exHub = nullptr; + + UNREFERENCED_PARAMETER(ehName); + + if (NULL == ehInfo) + { + return E_FAIL; + } + + exHub = AddExternalHub(parent); + + if (exHub != nullptr) + { + exHub->HubName = PACHAR_TO_STRING(ehInfo->HubName); + + if (NULL != ehInfo->UsbDeviceProperties) + { + exHub->HwId = PACHAR_TO_STRING(ehInfo->UsbDeviceProperties->HwId); + exHub->DeviceId = PACHAR_TO_STRING(ehInfo->UsbDeviceProperties->DeviceId); + exHub->ServiceName = PACHAR_TO_STRING(ehInfo->UsbDeviceProperties->Service); + exHub->DeviceName = PACHAR_TO_STRING(ehInfo->UsbDeviceProperties->DeviceDesc); + exHub->DeviceClass = PACHAR_TO_STRING(ehInfo->UsbDeviceProperties->DeviceClass); + } + + exHub->HubNodeInformation = gcnew HubNodeInformationType(); + XmlAddHubNodeInformation(exHub->HubNodeInformation, ehInfo->HubInfo); + + exHub->HubInformationEx = gcnew HubInformationExType(); + XmlAddHubInformationEx(exHub->HubInformationEx, ehInfo->HubInfoEx); + + exHub->HubCapabilityEx = gcnew HubCapabilitiesExType(); + XmlAddHubCapabilitiesEx(exHub->HubCapabilityEx, ehInfo->HubCapabilityEx); + + exHub->ConnectionInfo = gcnew NodeConnectionInfoExType(); + + // Update protocol + if (NULL != ehInfo->ConnectionInfo) + { + switch(ehInfo->ConnectionInfo->Speed) + { + case UsbLowSpeed: + case UsbFullSpeed: + exHub->UsbProtocol = gcnew String(USB_1_1); + break; + case UsbHighSpeed: + exHub->UsbProtocol = gcnew String(USB_2_0); + break; + case UsbSuperSpeed: + exHub->UsbProtocol = gcnew String(USB_3_0); + break; + } + } + + // Add connection info + XmlAddConnectionInfo( + exHub->ConnectionInfo, + ehInfo->ConnectionInfo, + (PUSBDEVICEINFO) ehInfo, + ehInfo->StringDescs, + ehInfo->DeviceInfoNode + ); + + // Add port connectors + if (NULL != ehInfo->PortConnectorProps) + { + exHub->PortConnector = gcnew PortConnectorType(); + + XmlAddPortConnectorProps( + exHub->PortConnector, + ehInfo->PortConnectorProps + ); + } + // Add connection info V2 + exHub->ConnectionInfoV2 = gcnew NodeConnectionInfoExV2Type(); + + XmlAddConnectionInfoV2( + exHub->ConnectionInfoV2, + ehInfo->ConnectionInfoV2 + ); + + // Add configuration descriptor + if (NULL != ehInfo->ConfigDesc) + { + exHub->DeviceConfiguration = XmlGetConfigDescriptors( + (PUSBDEVICEINFO) ehInfo, + (PUSB_CONFIGURATION_DESCRIPTOR) (ehInfo->ConfigDesc + 1), + ehInfo->StringDescs + ); + } + + // Add BOS descriptor + if (NULL != ehInfo->BosDesc) + { + exHub->BosDescriptor = XmlGetBosDescriptor((PUSB_BOS_DESCRIPTOR) (ehInfo->BosDesc + 1)); + } + + gXmlStack->Push(exHub); + } + else + { + hr = E_FAIL; + } + return hr; +} + +/***************************************************************************** + + XmlGetBosDescriptor() + + Gets the Bos descriptor object for given BOS descriptor + *****************************************************************************/ +UsbBosDescriptorType ^ XmlGetBosDescriptor(PUSB_BOS_DESCRIPTOR bosDesc) +{ + PUSB_COMMON_DESCRIPTOR commonDesc = NULL; + PUSB_DEVICE_CAPABILITY_DESCRIPTOR capDesc = NULL; + UsbBosDescriptorType ^ bosXmlDesc = nullptr; + ArrayList ^usb20CapExtDescList = gcnew ArrayList(); + ArrayList ^usbSuperSpeedExtDescList = gcnew ArrayList(); + ArrayList ^usbContIdCapExtDescList = gcnew ArrayList(); + ArrayList ^usbUnknownDescList = gcnew ArrayList(); + + if(NULL == bosDesc) + { + return nullptr; + } + + // Initialize attributes + bosXmlDesc = gcnew UsbBosDescriptorType(); + bosXmlDesc->BLength = bosDesc->bLength; + bosXmlDesc->BDescriptorType = bosDesc->bDescriptorType; + bosXmlDesc->WTotalLength = bosDesc->wTotalLength; + bosXmlDesc->BNumDeviceCaps = bosDesc->bNumDeviceCaps; + + commonDesc = (PUSB_COMMON_DESCRIPTOR) bosDesc; + + while ((commonDesc = GetNextDescriptor((PUSB_COMMON_DESCRIPTOR) bosDesc, + bosDesc->wTotalLength, + commonDesc, + -1)) != NULL) + { + switch (commonDesc->bDescriptorType) + { + case USB_DEVICE_CAPABILITY_DESCRIPTOR_TYPE: + capDesc = (PUSB_DEVICE_CAPABILITY_DESCRIPTOR)commonDesc; + switch (capDesc->bDevCapabilityType) + { + case USB_DEVICE_CAPABILITY_USB20_EXTENSION: + usb20CapExtDescList->Add( + XmlGetUsb20CapabilityExtensionDescriptor( + (PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR)capDesc + ) + ); + break; + case USB_DEVICE_CAPABILITY_SUPERSPEED_USB: + usbSuperSpeedExtDescList->Add( + XmlGetSuperSpeedCapabilityExtensionDescriptor( + (PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR)capDesc + ) + ); + break; + case USB_DEVICE_CAPABILITY_CONTAINER_ID: + usbContIdCapExtDescList->Add( + XmlGetContainerIdCapabilityExtensionDescriptor( + (PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR)capDesc + ) + ); + break; + default: + usbUnknownDescList->Add( + XmlGetUnknownDescriptor( + (PUSB_COMMON_DESCRIPTOR) capDesc + ) + ); + break; + } + break; + default: + usbUnknownDescList->Add(XmlGetUnknownDescriptor(commonDesc)); + break; + } + } + + // Convert lists to arrays for and add to Bos Descriptor + bosXmlDesc->UnknownDescriptor = reinterpret_cast<array<UsbDeviceUnknownDescriptorType ^>^> ( + usbUnknownDescList->ToArray(UsbDeviceUnknownDescriptorType::typeid) + ); + bosXmlDesc->UsbSuperSpeedExtensionDescriptor = reinterpret_cast<array<UsbSuperSpeedExtensionDescriptorType ^>^> ( + usbSuperSpeedExtDescList->ToArray(UsbSuperSpeedExtensionDescriptorType::typeid) + ); + bosXmlDesc->UsbUsb20ExtensionDescriptor = reinterpret_cast<array<UsbUsb20ExtensionDescriptorType ^>^> ( + usb20CapExtDescList->ToArray(UsbUsb20ExtensionDescriptorType::typeid) + ); + bosXmlDesc->UsbDispContIdCapExtDescriptor = reinterpret_cast<array<UsbDispContIdCapExtDescriptorType ^>^> ( + usbContIdCapExtDescList->ToArray(UsbDispContIdCapExtDescriptorType::typeid) + ); + + return bosXmlDesc; +} + + +/***************************************************************************** + + XmlGetUsb20CapabilityExtensionDescriptor() + + Gets a Usb20Capability extension descriptor object from the given descriptor + *****************************************************************************/ +UsbUsb20ExtensionDescriptorType ^ XmlGetUsb20CapabilityExtensionDescriptor( + PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR capDesc + ) +{ + UsbUsb20ExtensionDescriptorType ^ capXmlDesc = nullptr; + + if(NULL == capDesc) + { + return nullptr; + } + + capXmlDesc = gcnew UsbUsb20ExtensionDescriptorType(); + + capXmlDesc->BLength = capDesc->bLength; + capXmlDesc->BDescriptorType = capDesc->bDescriptorType; + capXmlDesc->BDevCapabilityType = capDesc->bDevCapabilityType; + capXmlDesc->BmAttributes = capDesc->bmAttributes.AsUlong; + + if (capDesc->bmAttributes.AsUlong & USB_DEVICE_CAPABILITY_USB20_EXTENSION_BMATTRIBUTES_RESERVED_MASK) + { + capXmlDesc->ReservedBitError = gcnew String("ERROR: bits 31..2 and bit 0 are reserved and must be 0"); + } + if (capDesc->bmAttributes.LPMCapable == 1) + { + capXmlDesc->SupportsLinkPowerManagement = true; + } + + return capXmlDesc; +} + +/***************************************************************************** + + XmlGetSuperSpeedCapabilityExtensionDescriptor() + + Gets a Super speed capability extension descriptor object from the given descriptor + *****************************************************************************/ +UsbSuperSpeedExtensionDescriptorType ^ XmlGetSuperSpeedCapabilityExtensionDescriptor( + PUSB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR capDesc + ) +{ + UsbSuperSpeedExtensionDescriptorType ^ capXmlDesc = nullptr; + + if(NULL == capDesc) + { + return nullptr; + } + + capXmlDesc = gcnew UsbSuperSpeedExtensionDescriptorType(); + + capXmlDesc->BLength = capDesc->bLength; + capXmlDesc->BDescriptorType = capDesc->bDescriptorType; + capXmlDesc->BDevCapabilityType = capDesc->bDevCapabilityType; + capXmlDesc->BmAttributes = capDesc->bmAttributes; + capXmlDesc->BU1DevExitLat = capDesc->bU1DevExitLat; + capXmlDesc->WSpeedsSupported = capDesc->wSpeedsSupported; + capXmlDesc->WU2DevExitLat = capDesc->wU2DevExitLat; + capXmlDesc->BFunctionalitySupport = capDesc->bFunctionalitySupport; + + // Add descriptive fields + if (capDesc->bmAttributes & USB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_RESERVED_MASK) + { + capXmlDesc->ReservedAttributesBitError = gcnew String("ERROR: bits 7:2 and bit 0 are reserved"); + } + if (capDesc->bmAttributes & USB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_LTM_CAPABLE) + { + capXmlDesc->LatencyToleranceMsgCapable = true; + } + if (capDesc->wSpeedsSupported & USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_LOW) + { + capXmlDesc->SupportsLowSpeed = true; + } + if (capDesc->wSpeedsSupported & USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_FULL) + { + capXmlDesc->SupportsFullSpeed = true; + } + if (capDesc->wSpeedsSupported & USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_HIGH) + { + capXmlDesc->SupportsHighSpeed = true; + } + if (capDesc->wSpeedsSupported & USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_SUPER) + { + capXmlDesc->SupportsSuperSpeed = true; + } + if (capDesc->wSpeedsSupported & USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_RESERVED_MASK) + { + capXmlDesc->ReservedSpeedError = gcnew String("ERROR: bits 15:4 are reserved"); + } + + + switch (capDesc->bFunctionalitySupport) + { + case UsbLowSpeed: + capXmlDesc->LowestSpeed = gcnew String("low-speed"); + break; + case UsbFullSpeed: + capXmlDesc->LowestSpeed = gcnew String("full-speed"); + break; + case UsbHighSpeed: + capXmlDesc->LowestSpeed = gcnew String("high-speed"); + break; + case UsbSuperSpeed: + capXmlDesc->LowestSpeed = gcnew String("SuperSpeed"); + break; + default: + capXmlDesc->LowestSpeed = gcnew String("ERROR: Invalid value"); + break; + } + + if (capDesc->bU1DevExitLat <= USB_DEVICE_CAPABILITY_SUPERSPEED_U1_DEVICE_EXIT_MAX_VALUE) + { + capXmlDesc->U1DevExitLatencyString = String::Format("Less than {0} micro-seconds", capDesc->bU1DevExitLat); + } + else + { + capXmlDesc->U1DevExitLatencyString = gcnew String("ERROR: Invalid value"); + } + + if (capDesc->wU2DevExitLat <= USB_DEVICE_CAPABILITY_SUPERSPEED_U2_DEVICE_EXIT_MAX_VALUE) + { + capXmlDesc->U2DevExitLatencyString = String::Format("Less than {0} micro-seconds", capDesc->wU2DevExitLat); + } + else + { + capXmlDesc->U2DevExitLatencyString = gcnew String("ERROR: Invalid value"); + } + + return capXmlDesc; +} + +/***************************************************************************** + + XmlGetContainerIdCapabilityExtensionDescriptor() + + Gets a Usb20Capability extension descriptor object from the given descriptor + *****************************************************************************/ +UsbDispContIdCapExtDescriptorType ^ XmlGetContainerIdCapabilityExtensionDescriptor( + PUSB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR capDesc + ) +{ + UsbDispContIdCapExtDescriptorType ^ capXmlDesc = nullptr; + LPGUID pGuid = NULL; + + if(NULL == capDesc) + { + return nullptr; + } + + capXmlDesc = gcnew UsbDispContIdCapExtDescriptorType(); + + capXmlDesc->BLength = capDesc->bLength; + capXmlDesc->BDescriptorType = capDesc->bDescriptorType; + capXmlDesc->BDevCapabilityType = capDesc->bDevCapabilityType; + capXmlDesc->BReserved = capDesc->bReserved; + + if (capDesc->bReserved != 0) + { + capXmlDesc->ReservedBitError = gcnew String("ERROR: field is reserved and should be zero"); + } + + pGuid = (LPGUID) capDesc->ContainerID; + + capXmlDesc->ContainerIdStr = String::Format("{0:X}-{1:X}-{2:X}-{3:X}{4:X}-{5:X}{6:X}{7:X}{8:X}{9:X}{10:X}", + pGuid->Data1, + pGuid->Data2, + pGuid->Data3, + pGuid->Data4[0], + pGuid->Data4[1], + pGuid->Data4[2], + pGuid->Data4[3], + pGuid->Data4[4], + pGuid->Data4[5], + pGuid->Data4[6], + pGuid->Data4[7]); + + return capXmlDesc; +} + +/***************************************************************************** + + XmlAddUsbDevice() + + Add a external to the parent Host Controller or hub. This is determined by the + last object pushed on the stack + *****************************************************************************/ +HRESULT XmlAddUsbDevice(PSTR devName, PUSBDEVICEINFO deviceInfo) +{ + HRESULT hr = S_OK; + Object ^ parent = gXmlStack->Peek(); + UsbDeviceType ^usbDevice = nullptr; + NoDeviceType ^noDevice = nullptr; + + if (NULL == deviceInfo) + { + return E_FAIL; + } + + if (deviceInfo->ConfigDesc == NULL) + { + // There is no USB device on this port, add a NoDevice type here instead of USB device + noDevice = AddDisconnectedPort(parent); + + if (nullptr != noDevice) + { + noDevice->UsbPortNumber = gcnew String(""); + noDevice->UsbPortNumber += deviceInfo->ConnectionInfo->ConnectionIndex; + noDevice->Name = PACHAR_TO_STRING(devName); + } + else + { + hr = E_FAIL; + } + } + + else + { + usbDevice = AddUsbDevice(parent); + + if (nullptr != usbDevice) + { + // Update device information + if (NULL != deviceInfo->UsbDeviceProperties) + { + usbDevice->HwId = PACHAR_TO_STRING(deviceInfo->UsbDeviceProperties->HwId); + usbDevice->DeviceId = PACHAR_TO_STRING(deviceInfo->UsbDeviceProperties->DeviceId); + usbDevice->ServiceName = PACHAR_TO_STRING(deviceInfo->UsbDeviceProperties->Service); + usbDevice->DeviceName = PACHAR_TO_STRING(deviceInfo->UsbDeviceProperties->DeviceDesc); + usbDevice->DeviceClass = PACHAR_TO_STRING(deviceInfo->UsbDeviceProperties->DeviceClass); + } + + // Update port number + usbDevice->UsbPortNumber = gcnew String(""); + usbDevice->UsbPortNumber += deviceInfo->ConnectionInfo->ConnectionIndex; + usbDevice->ConnectionInfo = gcnew NodeConnectionInfoExType(); + + // Update protocol + if (NULL != deviceInfo->ConnectionInfo) + { + switch(deviceInfo->ConnectionInfo->Speed) + { + case UsbLowSpeed: + case UsbFullSpeed: + usbDevice->UsbProtocol = gcnew String(USB_1_1); + break; + case UsbHighSpeed: + usbDevice->UsbProtocol = gcnew String(USB_2_0); + break; + case UsbSuperSpeed: + usbDevice->UsbProtocol = gcnew String(USB_3_0); + break; + } + } + + // Add connection info + XmlAddConnectionInfo( + usbDevice->ConnectionInfo, + deviceInfo->ConnectionInfo, + (PUSBDEVICEINFO) deviceInfo, + deviceInfo->StringDescs, + deviceInfo->DeviceInfoNode + ); + + // Add port connector + if (NULL != deviceInfo->PortConnectorProps) + { + usbDevice->PortConnector = gcnew PortConnectorType(); + + XmlAddPortConnectorProps( + usbDevice->PortConnector, + deviceInfo->PortConnectorProps + ); + } + + // Add connectiontion info V2 + if (NULL != deviceInfo->ConnectionInfoV2) + { + usbDevice->ConnectionInfoV2 = gcnew NodeConnectionInfoExV2Type(); + XmlAddConnectionInfoV2( + usbDevice->ConnectionInfoV2, + deviceInfo->ConnectionInfoV2 + ); + } + + // Add configuration descriptor + if (NULL != deviceInfo->ConfigDesc) + { + // The device configuration is allocated by XmlGetConfigDescriptors() + usbDevice->DeviceConfiguration = XmlGetConfigDescriptors( + (PUSBDEVICEINFO) deviceInfo, + (PUSB_CONFIGURATION_DESCRIPTOR) (deviceInfo->ConfigDesc + 1), + deviceInfo->StringDescs + ); + } + + // Add BOS descriptor + if (NULL != deviceInfo->BosDesc) + { + usbDevice->BosDescriptor = XmlGetBosDescriptor((PUSB_BOS_DESCRIPTOR) (deviceInfo->BosDesc + 1)); + } + } + else + { + hr = E_FAIL; + } + } + return hr; +} + +/***************************************************************************** + + XmlAddRootHub() + + Add a root hub to the parent Host Controller + *****************************************************************************/ +HRESULT XmlAddRootHub(PSTR rhName, PUSBROOTHUBINFO rhInfo) +{ + HRESULT hr = S_OK; + Object ^ parent = gXmlStack->Peek(); + HostControllerType ^ hcParent = nullptr; + PSTR rootHubName = rhInfo->HubName; + + UNREFERENCED_PARAMETER(rhName); + + hcParent = dynamic_cast<HostControllerType ^> (parent); + + if (hcParent != nullptr) + { + RootHubType ^ rh = nullptr; + hcParent = (HostControllerType ^) parent; + hcParent->RootHub = gcnew RootHubType(); + + rh = hcParent->RootHub; + rh->HubName = PACHAR_TO_STRING(rootHubName); + + if (NULL != rhInfo->UsbDeviceProperties) + { + rh->HwId = PACHAR_TO_STRING(rhInfo->UsbDeviceProperties->HwId); + rh->DeviceId = PACHAR_TO_STRING(rhInfo->UsbDeviceProperties->DeviceId); + rh->ServiceName = PACHAR_TO_STRING(rhInfo->UsbDeviceProperties->Service); + rh->DeviceName = PACHAR_TO_STRING(rhInfo->UsbDeviceProperties->DeviceDesc); + rh->DeviceClass = PACHAR_TO_STRING(rhInfo->UsbDeviceProperties->DeviceClass); + + // Roothub protocol is same as HC protocol + rh->UsbProtocol = hcParent->UsbProtocol; + } + + rh->HubNodeInformation = gcnew HubNodeInformationType(); + XmlAddHubNodeInformation(rh->HubNodeInformation, rhInfo->HubInfo); + + rh->HubInformationEx = gcnew HubInformationExType(); + XmlAddHubInformationEx(rh->HubInformationEx, rhInfo->HubInfoEx); + + rh->HubCapabilityEx = gcnew HubCapabilitiesExType(); + XmlAddHubCapabilitiesEx(rh->HubCapabilityEx, rhInfo->HubCapabilityEx); + + // Push root hub on to stack + gXmlStack->Push(rh); + } + else + { + // Root hub should be connected to a host controller + hr = E_FAIL; + } + return S_OK; +} + +/***************************************************************************** + + XmlSetVersion() + + Set version information in XML tree + *****************************************************************************/ +VOID XmlSetVersion( + UCHAR uvcMajorVersion, + UCHAR uvcMinorVersion, + UCHAR uvcMajorSpecVersion, + UCHAR uvcMinorSpecVersion + ) +{ + MachineInfoType ^ mInfo; + gXmlView->MachineInfo = gcnew MachineInfoType(); + + mInfo = gXmlView->MachineInfo; + + mInfo->UvcMajorVersion = uvcMajorVersion; + mInfo->UvcMinorVersion = uvcMinorVersion; + mInfo->UvcMajorSpecVersion = uvcMajorSpecVersion; + mInfo->UvcMinorSpecVersion = uvcMinorSpecVersion; + +} + +/***************************************************************************** + + InitXmlHelper() + + Initialize XML helper + *****************************************************************************/ +HRESULT InitXmlHelper() +{ + HRESULT hr = S_OK; + + (XmlGlobal::Instance())->ViewAll = gcnew UvcViewAll(); + (XmlGlobal::Instance())->ViewAll->UvcView = gcnew UvcViewType(); + + // + // Initialize fields to null so we can check against them for allocation + // + (XmlGlobal::Instance())->ViewAll->UvcView->MachineInfo = nullptr; + (XmlGlobal::Instance())->ViewAll->UvcView->UsbTree = nullptr; + + XmlSetVersion( + UVC_SPEC_MAJOR_VERSION, + UVC_SPEC_MINOR_VERSION, + USBVIEW_MAJOR_VERSION, + USBVIEW_MINOR_VERSION + ); + + gXmlStack->Push(gXmlView); + + gXmlViewInitialized = TRUE; + + return hr; +} + +/***************************************************************************** + + SaveXml() + + Saves the inmemory USB view as XML file + *****************************************************************************/ +HRESULT SaveXml(LPTSTR szfileName, DWORD dwCreationDisposition) +{ + HRESULT hr = S_OK; + + if (gXmlViewInitialized) + { + try + { + String ^fileName = PACHAR_TO_STRING(szfileName); + XmlSerializer ^ serializer = gcnew XmlSerializer(UvcViewAll::typeid); + TextWriter ^ writer = nullptr; + + if (dwCreationDisposition != CREATE_ALWAYS) + { + // Check if file exits and return failure if it does + if (File::Exists(fileName)) + { + hr = HRESULT_FROM_WIN32(ERROR_FILE_EXISTS); + } + } + + // Check if file name is NULL + if (String::IsNullOrEmpty(fileName)) + { + hr = E_INVALIDARG; + } + + if (SUCCEEDED(hr)) + { + writer = gcnew StreamWriter(fileName); + serializer->Serialize(writer, (XmlGlobal::Instance())->ViewAll); + writer->Close(); + } + + // Release and reinit XML View for next iteration if requested + ReleaseXmlWriter(); + InitXmlHelper(); + + } + catch(Exception ^ ex) + { + hr = (HRESULT) Marshal::GetHRForException(ex); + } + } + else + { + hr = E_FAIL; + } + + return hr; +} + + +/***************************************************************************** + + ReleaseXmlWriter() + + *****************************************************************************/ +HRESULT ReleaseXmlWriter() +{ + HRESULT hr = S_OK; + + if (gXmlViewInitialized) + { + gXmlViewInitialized = FALSE; + delete XmlGlobal::Instance(); + } + + return hr; +} + |