public override bool ReadPipe(UsbEndpointBase endPointBase,
IntPtr buffer,
int bufferLength,
out int lengthTransferred,
int isoPacketSize,
IntPtr pOverlapped)
{
LibUsbRequest req = new LibUsbRequest();
req.Endpoint.ID = endPointBase.EpNum;
req.Endpoint.PacketSize = isoPacketSize;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
int cltCode = endPointBase.Type == EndpointType.Isochronous ? LibUsbIoCtl.ISOCHRONOUS_READ : LibUsbIoCtl.INTERRUPT_OR_BULK_READ;
return(Kernel32.DeviceIoControl(endPointBase.Device.Handle,
cltCode,
req,
LibUsbRequest.Size,
buffer,
bufferLength,
out lengthTransferred,
pOverlapped));
}
public bool ResetDevice(SafeHandle interfaceHandle)
{
LibUsbRequest req = new LibUsbRequest();
int ret;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
return LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.RESET_DEVICE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret);
}
public bool ResetDevice(SafeHandle interfaceHandle)
{
LibUsbRequest req = new LibUsbRequest();
int ret;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
return(LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.RESET_DEVICE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret));
}
public override bool AbortPipe(SafeHandle interfaceHandle, byte pipeID)
{
LibUsbRequest req = new LibUsbRequest();
int ret;
req.Endpoint.ID = pipeID;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
return LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.ABORT_ENDPOINT, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret);
}
public override bool AbortPipe(SafeHandle interfaceHandle, byte pipeID)
{
LibUsbRequest req = new LibUsbRequest();
int ret;
req.Endpoint.ID = pipeID;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
return(LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.ABORT_ENDPOINT, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret));
}
internal static bool ControlTransferEx(SafeHandle interfaceHandle,
UsbSetupPacket setupPacket,
IntPtr buffer,
int bufferLength,
out int lengthTransferred,
int timeout)
{
lengthTransferred = 0;
LibUsbRequest req = new LibUsbRequest();
req.Timeout = timeout;
req.Control.RequestType = (byte)setupPacket.RequestType;
req.Control.Request = (byte)setupPacket.Request;
req.Control.Value = (ushort)setupPacket.Value;
req.Control.Index = (ushort)setupPacket.Index;
req.Control.Length = (ushort)setupPacket.Length;
/* in request? */
Byte[] reqBytes = req.Bytes;
Byte[] inBytes = reqBytes;
if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0)
{
inBytes = new byte[LibUsbRequest.Size + bufferLength];
reqBytes.CopyTo(inBytes, 0);
if (buffer != IntPtr.Zero)
{
Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength);
}
buffer = IntPtr.Zero;
bufferLength = 0;
}
if (UsbIOSync(interfaceHandle, LibUsbIoCtl.CONTROL_TRANSFER, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred))
{
/* in request? */
if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0)
{
lengthTransferred = (inBytes.Length - reqBytes.Length);
}
return(true);
}
return(false);
}
public override bool GetDescriptor(SafeHandle interfaceHandle,
byte descriptorType,
byte index,
ushort languageID,
IntPtr buffer,
int bufferLength,
out int lengthTransferred)
{
LibUsbRequest req = new LibUsbRequest();
req.Descriptor.Index = index;
req.Descriptor.LangID = languageID;
req.Descriptor.Recipient = (byte) UsbEndpointDirection.EndpointIn & 0x1F;
req.Descriptor.Type = descriptorType;
return LibUsbDriverIO.UsbIOSync(interfaceHandle,
LibUsbIoCtl.GET_DESCRIPTOR,
req,
LibUsbRequest.Size,
buffer,
bufferLength,
out lengthTransferred);
}
public override bool GetDescriptor(SafeHandle interfaceHandle,
byte descriptorType,
byte index,
ushort languageID,
IntPtr buffer,
int bufferLength,
out int lengthTransferred)
{
LibUsbRequest req = new LibUsbRequest();
req.Descriptor.Index = index;
req.Descriptor.LangID = languageID;
req.Descriptor.Recipient = (byte)UsbEndpointDirection.EndpointIn & 0x1F;
req.Descriptor.Type = descriptorType;
return(LibUsbDriverIO.UsbIOSync(interfaceHandle,
LibUsbIoCtl.GET_DESCRIPTOR,
req,
LibUsbRequest.Size,
buffer,
bufferLength,
out lengthTransferred));
}
public static byte[] RegSetStringRequest(string name, string value)
{
LibUsbRequest req = new LibUsbRequest();
int uOffset = LibUsbRequest.Size;
req.DeviceRegKey.KeyType = (int) KeyType.RegSz;
byte[] bytesName = Encoding.Unicode.GetBytes(name + "\0");
byte[] bytesValue = Encoding.Unicode.GetBytes(value + "\0");
req.DeviceRegKey.NameOffset = uOffset;
uOffset += bytesName.Length;
req.DeviceRegKey.ValueOffset = uOffset;
req.DeviceRegKey.ValueLength = bytesValue.Length;
uOffset += bytesValue.Length;
byte[] buffer = new byte[uOffset];
byte[] regBytes = req.Bytes;
Array.Copy(regBytes, buffer, regBytes.Length);
Array.Copy(bytesName, 0, buffer, req.DeviceRegKey.NameOffset, bytesName.Length);
Array.Copy(bytesValue, 0, buffer, req.DeviceRegKey.ValueOffset, bytesValue.Length);
return buffer;
}
public static byte[] RegGetRequest(string name, int valueBufferSize)
{
if (valueBufferSize < 1 || name.Trim().Length == 0) throw new UsbException("Global", "Invalid DeviceRegistry het parameter.");
LibUsbRequest req = new LibUsbRequest();
int uOffset = LibUsbRequest.Size;
req.DeviceRegKey.KeyType = (int) KeyType.RegBinary;
byte[] bytesName = Encoding.Unicode.GetBytes(name + "\0");
req.DeviceRegKey.NameOffset = uOffset;
uOffset += bytesName.Length;
req.DeviceRegKey.ValueOffset = uOffset;
req.DeviceRegKey.ValueLength = (valueBufferSize);
uOffset += Math.Max(uOffset + 1, valueBufferSize - (LibUsbRequest.Size + bytesName.Length));
byte[] buffer = new byte[uOffset];
byte[] regBytes = req.Bytes;
Array.Copy(regBytes, buffer, regBytes.Length);
Array.Copy(bytesName, 0, buffer, req.DeviceRegKey.NameOffset, bytesName.Length);
return buffer;
}
private void GetPropertiesSPDRP(SafeHandle usbHandle)
{
byte[] propBuffer = new byte[1024];
GCHandle gcPropBuffer = GCHandle.Alloc(propBuffer, GCHandleType.Pinned);
LibUsbRequest req = new LibUsbRequest();
Dictionary<string, int> allProps = Helper.GetEnumData(typeof (DevicePropertyType));
foreach (KeyValuePair<string, int> prop in allProps)
{
object oValue = String.Empty;
req.DeviceProperty.ID = prop.Value;
int iReturnBytes;
bool bSuccess = LibUsbDriverIO.UsbIOSync(usbHandle,
LibUsbIoCtl.GET_REG_PROPERTY,
req,
LibUsbRequest.Size,
gcPropBuffer.AddrOfPinnedObject(),
propBuffer.Length,
out iReturnBytes);
if (bSuccess)
{
switch ((DevicePropertyType) prop.Value)
{
case DevicePropertyType.PhysicalDeviceObjectName:
case DevicePropertyType.LocationInformation:
case DevicePropertyType.Class:
case DevicePropertyType.Mfg:
case DevicePropertyType.DeviceDesc:
case DevicePropertyType.Driver:
case DevicePropertyType.EnumeratorName:
case DevicePropertyType.FriendlyName:
case DevicePropertyType.ClassGuid:
oValue = GetAsString(propBuffer, iReturnBytes);
break;
case DevicePropertyType.HardwareId:
case DevicePropertyType.CompatibleIds:
oValue = GetAsStringArray(propBuffer, iReturnBytes);
break;
case DevicePropertyType.BusNumber:
case DevicePropertyType.InstallState:
case DevicePropertyType.LegacyBusType:
case DevicePropertyType.RemovalPolicy:
case DevicePropertyType.UiNumber:
case DevicePropertyType.Address:
oValue = GetAsStringInt32(propBuffer, iReturnBytes);
break;
case DevicePropertyType.BusTypeGuid:
oValue = GetAsGuid(propBuffer, iReturnBytes);
break;
}
}
else
oValue = String.Empty;
mDeviceProperties.Add(prop.Key, oValue);
}
gcPropBuffer.Free();
}
/// <summary>
/// Sets an alternate interface for the specified interface.
/// </summary>
/// <param name="interfaceID">The interface index to specify an alternate setting for.</param>
/// <param name="alternateID">The alternate interface setting.</param>
/// <returns>True on success.</returns>
public bool SetAltInterface(int interfaceID, int alternateID)
{
if (!mClaimedInterfaces.Contains(interfaceID))
throw new UsbException(this, String.Format("You must claim interface {0} before setting an alternate interface.", interfaceID));
LibUsbRequest req = new LibUsbRequest();
req.Iface.ID = interfaceID;
req.Iface.AlternateID = alternateID;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
int ret;
if (UsbIoSync(LibUsbIoCtl.SET_INTERFACE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret))
{
UsbAltInterfaceSettings[interfaceID] = (byte) alternateID;
return true;
}
return false;
}
/// <summary>
/// Releases an interface that was previously claimed with <see cref="ClaimInterface"/>.
/// </summary>
/// <param name="interfaceID">The interface to release.</param>
/// <returns>True on success.</returns>
public bool ReleaseInterface(int interfaceID)
{
LibUsbRequest req = new LibUsbRequest();
req.Iface.ID = interfaceID;
if (!mClaimedInterfaces.Remove(interfaceID)) return true;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
int ret;
// NOTE: A claimed interface is ALWAYS removed from the internal list.
bool bSuccess = UsbIoSync(LibUsbIoCtl.RELEASE_INTERFACE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret);
return bSuccess;
}
/// <summary>
/// Gets the alternate interface number for the specified interfaceID.
/// </summary>
/// <param name="interfaceID">The interface number of to get the alternate setting for.</param>
/// <param name="alternateID">The currrently selected alternate interface number.</param>
/// <returns>True on success.</returns>
public bool GetAltInterface(int interfaceID, out int alternateID)
{
LibUsbRequest req = new LibUsbRequest();
req.Iface.ID = interfaceID;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
int ret;
GCHandle gc = GCHandle.Alloc(req, GCHandleType.Pinned);
bool success;
alternateID = -1;
if ((success = UsbIoSync(LibUsbIoCtl.GET_INTERFACE, req, LibUsbRequest.Size, gc.AddrOfPinnedObject(), 1, out ret)) == true)
{
alternateID = Marshal.ReadByte(gc.AddrOfPinnedObject());
UsbAltInterfaceSettings[interfaceID] = (byte)alternateID;
}
gc.Free();
return success;
}
/// <summary>
/// Claims the specified interface of the device.
/// </summary>
/// <param name="interfaceID">The interface to claim.</param>
/// <returns>True on success.</returns>
public bool ClaimInterface(int interfaceID)
{
if (mClaimedInterfaces.Contains(interfaceID)) return true;
LibUsbRequest req = new LibUsbRequest();
req.Iface.ID = interfaceID;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
int ret;
bool bSuccess = UsbIoSync(LibUsbIoCtl.CLAIM_INTERFACE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret);
if (bSuccess)
mClaimedInterfaces.Add(interfaceID);
return bSuccess;
}
internal static bool ControlTransfer(SafeHandle interfaceHandle,
UsbSetupPacket setupPacket,
IntPtr buffer,
int bufferLength,
out int lengthTransferred,
int timeout)
{
lengthTransferred = 0;
LibUsbRequest req = new LibUsbRequest();
int code;
req.Timeout = timeout;
switch ((UsbRequestType)(setupPacket.RequestType & (0x03 << 5)))
{
case UsbRequestType.TypeStandard:
switch ((UsbStandardRequest)setupPacket.Request)
{
case UsbStandardRequest.GetStatus:
req.Status.Recipient = (int) setupPacket.RequestType & 0x1F;
req.Status.Index = setupPacket.Index;
code = LibUsbIoCtl.GET_STATUS;
break;
case UsbStandardRequest.ClearFeature:
req.Feature.Recipient = (int) setupPacket.RequestType & 0x1F;
req.Feature.ID = setupPacket.Value;
req.Feature.Index = setupPacket.Index;
code = LibUsbIoCtl.CLEAR_FEATURE;
break;
case UsbStandardRequest.SetFeature:
req.Feature.Recipient = (int) setupPacket.RequestType & 0x1F;
req.Feature.ID = setupPacket.Value;
req.Feature.Index = setupPacket.Index;
code = LibUsbIoCtl.SET_FEATURE;
break;
case UsbStandardRequest.GetDescriptor:
req.Descriptor.Recipient = (int) setupPacket.RequestType & 0x1F;
req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF;
req.Descriptor.Index = setupPacket.Value & 0xFF;
req.Descriptor.LangID = setupPacket.Index;
code = LibUsbIoCtl.GET_DESCRIPTOR;
break;
case UsbStandardRequest.SetDescriptor:
req.Descriptor.Recipient = (int) setupPacket.RequestType & 0x1F;
req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF;
req.Descriptor.Index = setupPacket.Value & 0xFF;
req.Descriptor.LangID = setupPacket.Index;
code = LibUsbIoCtl.SET_DESCRIPTOR;
break;
case UsbStandardRequest.GetConfiguration:
code = LibUsbIoCtl.GET_CONFIGURATION;
break;
case UsbStandardRequest.SetConfiguration:
req.Config.ID = setupPacket.Value;
code = LibUsbIoCtl.SET_CONFIGURATION;
break;
case UsbStandardRequest.GetInterface:
req.Iface.ID = setupPacket.Index;
code = LibUsbIoCtl.GET_INTERFACE;
break;
case UsbStandardRequest.SetInterface:
req.Iface.ID = setupPacket.Index;
req.Iface.AlternateID = setupPacket.Value;
code = LibUsbIoCtl.SET_INTERFACE;
break;
default:
UsbError.Error(ErrorCode.IoControlMessage,0,
String.Format("Invalid request: 0x{0:X8}", setupPacket.Request),
typeof(LibUsbDriverIO));
return false;
}
break;
case UsbRequestType.TypeVendor:
case UsbRequestType.TypeClass:
req.Vendor.Type = ((byte) setupPacket.RequestType >> 5) & 0x03;
req.Vendor.Recipient = (int) setupPacket.RequestType & 0x1F;
req.Vendor.Request = (int) setupPacket.Request;
req.Vendor.ID = setupPacket.Value;
req.Vendor.Index = setupPacket.Index;
code = ((byte) setupPacket.RequestType & 0x80) > 0 ? LibUsbIoCtl.VENDOR_READ : LibUsbIoCtl.VENDOR_WRITE;
break;
case UsbRequestType.TypeReserved:
default:
UsbError.Error(ErrorCode.IoControlMessage,0,
String.Format("invalid or unsupported request type: 0x{0:X8}", setupPacket.RequestType),
typeof(LibUsbDriverIO));
return false;
}
/* in request? */
Byte[] reqBytes = req.Bytes;
Byte[] inBytes = reqBytes;
if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0)
{
inBytes = new byte[LibUsbRequest.Size + bufferLength];
reqBytes.CopyTo(inBytes, 0);
if (buffer != IntPtr.Zero) Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength);
buffer = IntPtr.Zero;
bufferLength = 0;
}
if (UsbIOSync(interfaceHandle, code, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred))
{
/* in request? */
if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0)
lengthTransferred = (inBytes.Length - reqBytes.Length);
return true;
}
return false;
}
internal static bool ControlTransferEx(SafeHandle interfaceHandle,
UsbSetupPacket setupPacket,
IntPtr buffer,
int bufferLength,
out int lengthTransferred,
int timeout)
{
lengthTransferred = 0;
LibUsbRequest req = new LibUsbRequest();
req.Timeout = timeout;
req.Control.RequestType = (byte) setupPacket.RequestType;
req.Control.Request = (byte) setupPacket.Request;
req.Control.Value = (ushort) setupPacket.Value;
req.Control.Index = (ushort) setupPacket.Index;
req.Control.Length = (ushort) setupPacket.Length;
/* in request? */
Byte[] reqBytes = req.Bytes;
Byte[] inBytes = reqBytes;
if ((setupPacket.RequestType & (byte) UsbEndpointDirection.EndpointIn) == 0)
{
inBytes = new byte[LibUsbRequest.Size + bufferLength];
reqBytes.CopyTo(inBytes, 0);
if (buffer != IntPtr.Zero) Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength);
buffer = IntPtr.Zero;
bufferLength = 0;
}
if (UsbIOSync(interfaceHandle, LibUsbIoCtl.CONTROL_TRANSFER, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred))
{
/* in request? */
if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0)
lengthTransferred = (inBytes.Length - reqBytes.Length);
return true;
}
return false;
}
internal static bool ControlTransfer(SafeHandle interfaceHandle,
UsbSetupPacket setupPacket,
IntPtr buffer,
int bufferLength,
out int lengthTransferred,
int timeout)
{
lengthTransferred = 0;
LibUsbRequest req = new LibUsbRequest();
int code;
req.Timeout = timeout;
switch ((UsbRequestType)(setupPacket.RequestType & (0x03 << 5)))
{
case UsbRequestType.TypeStandard:
switch ((UsbStandardRequest)setupPacket.Request)
{
case UsbStandardRequest.GetStatus:
req.Status.Recipient = (int)setupPacket.RequestType & 0x1F;
req.Status.Index = setupPacket.Index;
code = LibUsbIoCtl.GET_STATUS;
break;
case UsbStandardRequest.ClearFeature:
req.Feature.Recipient = (int)setupPacket.RequestType & 0x1F;
req.Feature.ID = setupPacket.Value;
req.Feature.Index = setupPacket.Index;
code = LibUsbIoCtl.CLEAR_FEATURE;
break;
case UsbStandardRequest.SetFeature:
req.Feature.Recipient = (int)setupPacket.RequestType & 0x1F;
req.Feature.ID = setupPacket.Value;
req.Feature.Index = setupPacket.Index;
code = LibUsbIoCtl.SET_FEATURE;
break;
case UsbStandardRequest.GetDescriptor:
req.Descriptor.Recipient = (int)setupPacket.RequestType & 0x1F;
req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF;
req.Descriptor.Index = setupPacket.Value & 0xFF;
req.Descriptor.LangID = setupPacket.Index;
code = LibUsbIoCtl.GET_DESCRIPTOR;
break;
case UsbStandardRequest.SetDescriptor:
req.Descriptor.Recipient = (int)setupPacket.RequestType & 0x1F;
req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF;
req.Descriptor.Index = setupPacket.Value & 0xFF;
req.Descriptor.LangID = setupPacket.Index;
code = LibUsbIoCtl.SET_DESCRIPTOR;
break;
case UsbStandardRequest.GetConfiguration:
code = LibUsbIoCtl.GET_CONFIGURATION;
break;
case UsbStandardRequest.SetConfiguration:
req.Config.ID = setupPacket.Value;
code = LibUsbIoCtl.SET_CONFIGURATION;
break;
case UsbStandardRequest.GetInterface:
req.Iface.ID = setupPacket.Index;
code = LibUsbIoCtl.GET_INTERFACE;
break;
case UsbStandardRequest.SetInterface:
req.Iface.ID = setupPacket.Index;
req.Iface.AlternateID = setupPacket.Value;
code = LibUsbIoCtl.SET_INTERFACE;
break;
default:
UsbError.Error(ErrorCode.IoControlMessage, 0,
String.Format("Invalid request: 0x{0:X8}", setupPacket.Request),
typeof(LibUsbDriverIO));
return(false);
}
break;
case UsbRequestType.TypeVendor:
case UsbRequestType.TypeClass:
req.Vendor.Type = ((byte)setupPacket.RequestType >> 5) & 0x03;
req.Vendor.Recipient = (int)setupPacket.RequestType & 0x1F;
req.Vendor.Request = (int)setupPacket.Request;
req.Vendor.ID = setupPacket.Value;
req.Vendor.Index = setupPacket.Index;
code = ((byte)setupPacket.RequestType & 0x80) > 0 ? LibUsbIoCtl.VENDOR_READ : LibUsbIoCtl.VENDOR_WRITE;
break;
case UsbRequestType.TypeReserved:
default:
UsbError.Error(ErrorCode.IoControlMessage, 0,
String.Format("invalid or unsupported request type: 0x{0:X8}", setupPacket.RequestType),
typeof(LibUsbDriverIO));
return(false);
}
/* in request? */
Byte[] reqBytes = req.Bytes;
Byte[] inBytes = reqBytes;
if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0)
{
inBytes = new byte[LibUsbRequest.Size + bufferLength];
reqBytes.CopyTo(inBytes, 0);
if (buffer != IntPtr.Zero)
{
Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength);
}
buffer = IntPtr.Zero;
bufferLength = 0;
}
if (UsbIOSync(interfaceHandle, code, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred))
{
/* in request? */
if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0)
{
lengthTransferred = (inBytes.Length - reqBytes.Length);
}
return(true);
}
return(false);
}
public override bool ReadPipe(UsbEndpointBase endPointBase,
IntPtr buffer,
int bufferLength,
out int lengthTransferred,
int isoPacketSize,
IntPtr pOverlapped)
{
LibUsbRequest req = new LibUsbRequest();
req.Endpoint.ID = endPointBase.EpNum;
req.Endpoint.PacketSize = isoPacketSize;
req.Timeout = UsbConstants.DEFAULT_TIMEOUT;
int cltCode = endPointBase.Type == EndpointType.Isochronous ? LibUsbIoCtl.ISOCHRONOUS_READ : LibUsbIoCtl.INTERRUPT_OR_BULK_READ;
return Kernel32.DeviceIoControl(endPointBase.Device.Handle,
cltCode,
req,
LibUsbRequest.Size,
buffer,
bufferLength,
out lengthTransferred,
pOverlapped);
}
private bool GetObjectName(SafeFileHandle usbHandle, int objectNameIndex, out string objectName)
{
int objNameLength;
Byte[] regKeyPathname = new byte[512];
GCHandle gcRegKeyPathname = GCHandle.Alloc(regKeyPathname, GCHandleType.Pinned);
#if RESERVED_FOR_FUTURE_USE
LibUsbRequest req=new LibUsbRequest();
req.ObjectName.Index = objectNameIndex;
Marshal.Copy(req.Bytes, 0, gcRegKeyPathname.AddrOfPinnedObject(),LibUsbRequest.Size);
#endif
bool bSuccess = LibUsbDriverIO.UsbIOSync(usbHandle,
LibUsbIoCtl.GET_OBJECT_NAME,
regKeyPathname,
regKeyPathname.Length,
gcRegKeyPathname.AddrOfPinnedObject(),
regKeyPathname.Length,
out objNameLength);
gcRegKeyPathname.Free();
if (bSuccess && objNameLength > 1)
objectName = Encoding.ASCII.GetString(regKeyPathname, 0, objNameLength-1);
else
objectName = String.Empty;
return bSuccess;
}
