Problem using DeviceIoControl from C#

I have a lot of other Win32 API calls working successfully in the app already, including other calls using DeviceIoControl.  It is just the 2 DeviceIoControl calls that use the structure, STORAGE_PROPERTY_QUERY, as one of the parameters that I am having trouble with.  

Maybe down the road as a last resort I might try what you suggest, but not at this point.

Thanks.

Well, the real problem is that I don't have enough understanding of what you are trying to do, in order to test and help.

Have you looked at pinvoke.net to see if there is a signature problem with the call?

Yes.  I loooked at pinvoke.net.  There are no entries for this structure, nor any of the others that are involved in my problem areas STORAGE_DEVICE_DESCRIPTOR and STORAGE_ADAPTER_DESCRIPTOR.  One needs to be careful when using pinvoke.net.  While it is helpful, it is after all, a WIKI, and there is a lot of false, contradicting or just plain wrong info on the site.

>Well, the real problem is that I don't have enough understanding of what you are trying to do
I will explain in more detail.  Tell me what it is that you need explained.  A 40,000 ft view of what I'm trying to do is get the properties of the USB devices attached to the computer - i.e. Partiton info, geometry, storage adapter info

Thanks

Which calls are you having a problem with?

Two of  my DeviceIoControl calls are failing.  I have others that execute successfully.  The common link between the 2 failing calls is that they both have the structure IOCTL_STORAGE_QUERY_PROPERTY as a parameter.  I don't know if it is that parameter, or one of the structures I am trying to fill with data that is causing the problem.

One failing call is -

STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY();
query.PropertyId = STORAGE_PROPERTY_ID.StorageAdapterProperty;
query.QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery;
query.AdditionalParameters = new byte[1];
// create ptr to query for DeviceIoControl
int nPtrQryBytes = Marshal.SizeOf(query);
IntPtr ptrQuery = Marshal.AllocHGlobal(nPtrQryBytes);

// Get StorageAdapterProperty
STORAGE_ADAPTER_DESCRIPTOR adpDesc = new STORAGE_ADAPTER_DESCRIPTOR();
int nAdpDescBytes = Marshal.SizeOf(adpDesc);
IntPtr ptrAdpDesc = Marshal.AllocHGlobal(nAdpDescBytes);
status = IOWrap.DeviceIoControl(hDevice,
IOWrap.IOCTL_STORAGE_QUERY_PROPERTY, // Operation to perform
ptrQuery, // STORAGE_PROPERTY_QUERY
nPtrQryBytes,
ptrAdpDesc, // Output buffer
512, // Output buf size
ref returnedLen, // bytes returned
IntPtr.Zero);

errMsg = new Win32Exception(Marshal.GetLastWin32Error()).Message;
if (status == false)
return false;

The returned value of status is false and GetLastWin32Error returns "the parameter is incorrect".

the other call that fails is -

STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY();
query.PropertyId = STORAGE_PROPERTY_ID.StorageAdapterProperty;
query.QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery;
query.AdditionalParameters = new byte[1];
// create ptr to query for DeviceIoControl
int nPtrQryBytes = Marshal.SizeOf(query);
IntPtr ptrQuery = Marshal.AllocHGlobal(nPtrQryBytes);
// Get StorageAdapterProperty
STORAGE_ADAPTER_DESCRIPTOR adpDesc = new STORAGE_ADAPTER_DESCRIPTOR();
int nAdpDescBytes = Marshal.SizeOf(adpDesc);
IntPtr ptrAdpDesc = Marshal.AllocHGlobal(nAdpDescBytes);
status = IOWrap.DeviceIoControl(hDevice,
IOWrap.IOCTL_STORAGE_QUERY_PROPERTY, // Operation to perform
ptrQuery, // STORAGE_PROPERTY_QUERY
nPtrQryBytes,
ptrAdpDesc, // Output buffer
512, // Output buf size
ref returnedLen, // bytes returned
IntPtr.Zero);

// TODO: ILI ==> for test / debug
errMsg = new Win32Exception(Marshal.GetLastWin32Error()).Message;
if (status == false)
return false;

this returns a status value of true and the GetLastWin32Error returns "The operation completed successfully" but the value for returnedLen is 0 and the ptrAdpDesc buffer has not been populated.

All the structure definitions and dll imports are in the original code snippets I submitted.

Please note, that as I mentioned before, I have other DeviceIoControl calls that execute properly.  Only the ones that use the IOCTL_STORAGE_PROPERTY_QUERY structure fail.  It may be that structure or one of the other structures in those calls that are causing the problem.

thanks

One problem that I have seen with Win32 API calls is the calculation of size from the Marshal.SizeOf method.  I would suggest that you compare the results to what you would expect from a structure.

Example:

            STORAGE_ADAPTER_DESCRIPTOR adapter = new STORAGE_ADAPTER_DESCRIPTOR();
            int size = Marshal.SizeOf(adapter);


Result = 44

        public struct STORAGE_ADAPTER_DESCRIPTOR
        {
            public uint Version;                //4
            public uint Size;                   //4
            public uint MaximumTransferLength;  //4
            public uint MaximumPhysicalPages;   //4
            public uint AlignmentMask;          //4
            public bool AdapterUsesPio;         //1
            public bool AdapterScansDown;       //1
            public bool CommandQueueing;        //1
            public bool AcceleratedTransfer;    //1
            public byte BusType;                //1
            public ushort BusMajorVersion;      //2
            public ushort BusMinorVersion;      //2
 
        }
 
Result = 29
 
 
            unsafe
            {
                Console.WriteLine("sbyte: {0}", sizeof(sbyte));
                Console.WriteLine("byte: {0}", sizeof(byte));
                Console.WriteLine("short: {0}", sizeof(short));
                Console.WriteLine("ushort: {0}", sizeof(ushort));
                Console.WriteLine("int: {0}", sizeof(int));
                Console.WriteLine("uint: {0}", sizeof(uint));
                Console.WriteLine("long: {0}", sizeof(long));
                Console.WriteLine("ulong: {0}", sizeof(ulong));
                Console.WriteLine("char: {0}", sizeof(char));
                Console.WriteLine("float: {0}", sizeof(float));
                Console.WriteLine("double: {0}", sizeof(double));
                Console.WriteLine("decimal: {0}", sizeof(decimal));
                Console.WriteLine("bool: {0}", sizeof(bool));
 
            }
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

it is a possibility.  I'll look in to it.

thanks

I don't know why there is a difference in size between the marshalled and unmarshalled structure sizes (29 manually totaled vs 44 using Marshal.sizeof()).  I tried the call using both values, and neither one returned any data in the buffer

Thanks

To understand that SizeOf problem, you have to think about how bytes are stored in the structure value type.  If you don't use explicit layout rules, then bytes are aligned on "natural offsets".  You can change that behavior with StructLayout(LayoutKind.Explicit), and set byte offsets for each field, or set Pack = 1 ([StructLayout(LayoutKind.Sequential, Pack = 1)].   The structure will now be organized so that each field is on a byte boundary and can be read a byte at a time.

Thanks for the explanation, but unfortunately, I still have the problem.

It can be quite troublesome to get everything just right when converting from C++ to C#.  I have seen others who create VC++.NET managed wrappers in .NET to unmanaged C++ code, and then call that from C# applications.

I am a big proponent for getting hardware information with WMI.  I put together some test code to show you what I mean:

            Win32_DiskDrive drive = UsbDeviceHelper.DriveList[1];

            long size = drive.Size;
            int bytesPerSector = drive.BytesPerSector;
            int totalHeads = drive.TotalHeads;
            long totalCylinders = drive.TotalCylinders;
            long totalSectors = drive.TotalSectors;
            long totalTracks = drive.TotalTracks;
            int tracksPerCylinder = drive.TracksPerCylinder;
            string caption = drive.PartitionList[0].Caption;
            bool bootable = (int)drive.PartitionList[0].Bootable;

// Add a reference to System.Management.dll. 
 
using System;
using System.Management;
using System.Reflection;
using System.Collections.Generic;
 
 
public class UsbDeviceHelper
{
 
    private static Dictionary<int, Win32_DiskDrive> _driveList;
 
    static UsbDeviceHelper()
    {
        Win32_DiskDrive driveHelper = new Win32_DiskDrive();
 
        Dictionary<int, Win32_DiskDrive> allDrives = driveHelper.GetList();
 
        _driveList = new Dictionary<int, Win32_DiskDrive>();
 
        foreach (Win32_DiskDrive drive in allDrives.Values)
        {
            if (drive.InterfaceType == "USB")
            {
                _driveList.Add(drive.Index, drive);
            }
        }
 
    }
 
    public static Dictionary<int, Win32_DiskDrive> DriveList
    {
        get { return _driveList; }
    }
 
}
 
public class Win32_DiskPartition
{
    public ushort Access;
    public ushort Availability;
    public ulong BlockSize;
    public bool Bootable;
    public bool BootPartition;
    public string Caption;
    public uint ConfigManagerErrorCode;
    public bool ConfigManagerUserConfig;
    public string CreationClassName;
    public string Description;
    public string DeviceID;
    public uint DiskIndex;
    public bool ErrorCleared;
    public string ErrorDescription;
    public string ErrorMethodology;
    public uint HiddenSectors;
    public uint Index;
    public DateTime InstallDate;
    public uint LastErrorCode;
    public string Name;
    public ulong NumberOfBlocks;
    public string PNPDeviceID;
    public bool PrimaryPartition;
    public string Purpose;
    public bool RewritePartition;
    public ulong Size;
    public ulong StartingOffset;
    public string Status;
    public ushort StatusInfo;
    public string SystemCreationClassName;
    public string SystemName;
    public string Type;
 
    public static List<Win32_DiskPartition> GetList(int driveIndex)
    {
        string query = "Select * From Win32_DiskPartition Where DiskIndex=" + driveIndex;
 
        ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);
 
        List<Win32_DiskPartition> list = new List<Win32_DiskPartition>();
 
        foreach (ManagementObject obj in searcher.Get())
        {
            Win32_DiskPartition entry = new Win32_DiskPartition();
 
            foreach (FieldInfo field in typeof(Win32_DiskPartition).GetFields())
                field.SetValue(entry, Conversion.ConvertValue(obj[field.Name], field.FieldType));
 
            list.Add(entry);
        }
        return list;
    }
 
}
 
public class Win32_DiskDrive
{
 
    public short Availability;
    public int BytesPerSector;
    public string CompressionMethod;
    public long DefaultBlockSize;
    public string Description;
    public string DeviceID;
    public bool ErrorCleared;
    public string ErrorDescription;
    public string ErrorMethodology;
    public int Index;
    public DateTime InstallDate;
    public string InterfaceType;
    public string Manufacturer;
    public long MaxBlockSize;
    public long MaxMediaSize;
    public bool MediaLoaded;
    public string MediaType;
    public long MinBlockSize;
    public string Model;
    public string Name;
    public bool NeedsCleaning;
    public int NumberOfMediaSupported;
    public int Partitions;
    public string PNPDeviceID;
    public bool PowerManagementSupported;
    public int SCSIBus;
    public short SCSILogicalUnit;
    public short SCSIPort;
    public short SCSITargetId;
    public int SectorsPerTrack;
    public long Signature;
    public long Size;
    public string Status;
    public short StatusInfo;
    public long TotalCylinders;
    public int TotalHeads;
    public long TotalSectors;
    public long TotalTracks;
    public int TracksPerCylinder;
 
    private List<Win32_DiskPartition> _partitionList;
 
    public List<Win32_DiskPartition> PartitionList
    {
        get { return _partitionList; }
    }
 
    public Dictionary<int, Win32_DiskDrive> GetList()
    {
        string query = "Select * From Win32_DiskDrive";
 
        ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);
 
        Dictionary<int, Win32_DiskDrive> list = new Dictionary<int, Win32_DiskDrive>();
 
        foreach (ManagementObject obj in searcher.Get())
        {
            Win32_DiskDrive entry = new Win32_DiskDrive();
 
            foreach (FieldInfo field in typeof(Win32_DiskDrive).GetFields())
                field.SetValue(entry, Conversion.ConvertValue(obj[field.Name], field.FieldType));
 
            entry._partitionList = Win32_DiskPartition.GetList(entry.Index);
 
            list.Add(entry.Index, entry);
        }
        return list;
    }
 
}
 
internal class Conversion
{
 
    internal static object ConvertValue(object value, Type type)
    {
        if (value != null)
        {
            if (type == typeof(DateTime))
            {
                string time = value.ToString();
                time = time.Substring(0, time.IndexOf("."));
                return DateTime.ParseExact(time, "yyyyMMddHHmmss", null);
            }
            else if (type == typeof(long))
                return Convert.ToInt64(value);
            else if (type == typeof(int))
                return Convert.ToInt32(value);
            else if (type == typeof(short))
                return Convert.ToInt16(value);
            else if (type == typeof(string))
                return value.ToString();
        }
        return null;
    }
 
 
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:

I want the new app to be all in C# so I want to avoid created a Managed C++.NET wrapper.  As this problem has dragged on, I have been entertaining the idea of switching to WMI.  Your test code may be just the push I needed to switch gears.  As soon as I get a chance I will incorporate your test code in to an app and test it out.

By the way, I just picked out a random sample of property values from the Win32_DiskDrive and Win32_DiskPartition classes that might be the type of values that you would be looking for.  

Hi,
I have looked over the WMI info you sent me and I think that is the way I am going to go.  I have even gone so far as to implement a simple WMI query in to my app.  I have the PNPDeviceID and I want the DeviceID so I used the query -
SELECT * FROM Win32_DiskDrive WHERE PNPDeviceID = "ide\\diskwdc_wd800aajs-00psa0____________________05.06h05\\5&1327b7ae&0&0.0.0"

I have some other info that I need to get about the device that I am not sure how to get.  For example, I need the bus type for the same device.  I am currently doing it in my code with DeviceIoControl like so -
 STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY();
            query.PropertyId = STORAGE_PROPERTY_ID.StorageAdapterProperty;
            query.QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery;
            query.AdditionalParameters = new byte[1];

            // create ptr to query for DeviceIoControl
            int nPtrQryBytes = Marshal.SizeOf(query);
            IntPtr ptrQuery = Marshal.AllocHGlobal(nPtrQryBytes);

            // Get StorageAdapterProperty
            STORAGE_ADAPTER_DESCRIPTOR adpDesc = new STORAGE_ADAPTER_DESCRIPTOR();
            int nAdpDescBytes = Marshal.SizeOf(adpDesc);
            IntPtr ptrAdpDesc = Marshal.AllocHGlobal(nAdpDescBytes);
            Marshal.StructureToPtr(adpDesc, ptrAdpDesc, true);
            status = IOWrap.DeviceIoControl(hDevice,
                                            IOWrap.IOCTL_STORAGE_QUERY_PROPERTY,    // Operation to perform
                                            ptrQuery,                               // STORAGE_PROPERTY_QUERY
                                            nPtrQryBytes,
                                            ptrAdpDesc,                             // Output buffer
                                            29,                                    // Output buf size
                                            ref returnedLen,                        // bytes returned
                                            IntPtr.Zero);


          adpDesc = (STORAGE_ADAPTER_DESCRIPTOR)Marshal.PtrToStructure(ptrAdpDesc, typeof(STORAGE_ADAPTER_DESCRIPTOR));
           
and then I can get the bus type form adpDesc.

I do not see a bus type as part of the Win32_DiskDrive class.   I Do see a Win32_Bus class, that has a BusType member.  I wonder if there is a way to do a join in a WMI query so that I can get the bus type given I have some other piece of data, in this case I have the PNPDeviceID.

I am also tryin to get RemovableMedia info, VendorIdOffset, ProductIdOffset, SerialNumberOffset among other things.  I was trying to use the following DeviceIoControl code -
 
              STORAGE_PROPERTY_QUERY query = new STORAGE_PROPERTY_QUERY();
           query.PropertyId = STORAGE_PROPERTY_ID.StorageDeviceProperty;
           query.QueryType = STORAGE_QUERY_TYPE.PropertyStandardQuery;
           query.AdditionalParameters = new byte[1];


           int nPtrQryBytes = Marshal.SizeOf(query);
           IntPtr ptrQry = Marshal.AllocHGlobal(nPtrQryBytes);

           IOWrap.STORAGE_DEVICE_DESCRIPTOR device = new IOWrap.STORAGE_DEVICE_DESCRIPTOR();
           int nDevicePtrBytes = Marshal.SizeOf(device);
           IntPtr ptrDevice = Marshal.AllocHGlobal(nDevicePtrBytes);


           bool status = IOWrap.DeviceIoControl(hDevice, IOWrap.IOCTL_STORAGE_QUERY_PROPERTY,
                                                ptrQry, nPtrQryBytes,
                                                ptrDevice, 512, //nDevicePtrBytes,
                                                ref returnedLength,
                                                IntPtr.Zero);

       
           errMsg = new Win32Exception(Marshal.GetLastWin32Error()).Message;

 device = (IOWrap.STORAGE_DEVICE_DESCRIPTOR)Marshal.PtrToStructure(ptrDevice, typeof(IOWrap.STORAGE_DEVICE_DESCRIPTOR));

and then would get the VendorIdOffset, ProductIdoffset etc from the device buffer.

Again, those values are not in the Win32_DiskDrive or Win32_Partition so would I have to make a join in my query?

Thanks

Hi,
I found that the Win32_Bus class does have a PNPDeviceID property so that problem is solved.  I'm still however need to get the VendorIdOffset, ProductIDOffset RemovableMedi info among other data but I just don't know what Win32_xxxx class it would be in.

thanks

Hi,
I've looked in to the Win32_Bus class and ran some queries through a query tool but it doesn't seem to be what I want.  when I run the query SELECT * FROM Win32_Bus where PNPDevice ID = (my device ID) it returns nothing.  If I run the query SELECT * FROM Win32_Bus, I get about 6 or 7 objects, only one of which has a PNPDeviceId and it does not match any of the USB devices I'm interested in.  I"m guessing that this PNPDeviceID is not the same PNPDeviceID I use in the Win32_DiskDrive query.  So that brings me back to my original question, of how to find the bus type

Drive serial number:  Win32_PhysicalMedia
Manufacturer:  Win32_PhysicalMedia, Win32_DiskDrive
Product:  ?

I've looked at the Win32_DiskDrive and it seems that most of what I need (information similar to that that was being colleced with DeviceIoControl in the old code) is there but with names quite different than I was looking for.

I was unaware of the win32_PhysicalMedia class.  that looks like it would provide the info I need but when I run a query on my system - Select * from Win32_PhysicalMedia - the only field that gets populated is the tag (\\.\PhysicalDrive0, \\.\PhysicalDrive2, etc). None of the other fields return data?  Any thoughts.

You've been quite helpful.   How do I mark this issue closed and make sure you get the points associated with this issue?

thanks