Форум программистов, компьютерный форум, киберфорум
Наши страницы
C++: WinAPI
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.87/23: Рейтинг темы: голосов - 23, средняя оценка - 4.87
ISergey
Maniac
Эксперт С++
1427 / 933 / 154
Регистрация: 02.01.2009
Сообщений: 2,779
Записей в блоге: 1
1

Получить пути к USB накопителям

13.05.2011, 23:42. Просмотров 4625. Ответов 5
Метки нет (Все метки)

Здравствуйте. Я получаю список подключенных USB носителей вот таким образом
C++
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
#include <windows.h>
#include <Setupapi.h>
#include <tchar.h>
#include <iostream>
 
void OutFormatMsg(const TCHAR *Msg){
    LPVOID lpMsgBuf;
 
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        GetLastError(),
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (TCHAR*) &lpMsgBuf,
        0,
        NULL
        );
 
    
    _tprintf(_T("%s: %s\n"), Msg, (TCHAR*)lpMsgBuf);
    LocalFree(lpMsgBuf);
}
 
#define LocalFreeIf(Pointer) if(Pointer) { LocalFree(Pointer); Pointer = NULL; }
 
int main()
{
    setlocale(0, "");
 
    PSP_DEVICE_INTERFACE_DETAIL_DATA pDeviceInterfaceDetailData = NULL;
    SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
    SP_DEVINFO_DATA DeviceInfoData;
    HDEVINFO hDevInfo;
    TCHAR *lpBuffer = NULL;
 
    const GUID InterfaceGuid = { 0x53F56307,0xB6BF,0x11D0,{0x94,0xF2,0x00,0xA0,0xC9,0x1E,0xFB,0x8B} };
 
    hDevInfo = SetupDiGetClassDevs( &InterfaceGuid,0, 0, DIGCF_PRESENT  | DIGCF_DEVICEINTERFACE  );
 
    if (hDevInfo == INVALID_HANDLE_VALUE) {
        OutFormatMsg(_T("SetupDiGetClassDevs"));
        return 1;
    }
 
    DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
    DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
    for(DWORD i = 0; SetupDiEnumDeviceInterfaces(hDevInfo, 0, &InterfaceGuid, i, &DeviceInterfaceData); ++i)
    {
        ULONG RequiredLength = 0;
 
        while ( !SetupDiGetDeviceInterfaceDetail( hDevInfo, 
            &DeviceInterfaceData, pDeviceInterfaceDetailData, RequiredLength, &RequiredLength,
            &DeviceInfoData ) )
        {
            if( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
            {
                LocalFreeIf( pDeviceInterfaceDetailData );
                pDeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)LocalAlloc(LMEM_FIXED, RequiredLength );
                pDeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
            } else {
                OutFormatMsg(_T("SetupDiGetDeviceInterfaceDetail"));
                continue;
            }
        }
 
        RequiredLength = 0;
 
        while ( !SetupDiGetDeviceRegistryProperty(hDevInfo, 
            &DeviceInfoData, SPDRP_ENUMERATOR_NAME, NULL, 
            (PBYTE)lpBuffer, RequiredLength, &RequiredLength) )
        {
            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) 
            {
                LocalFreeIf(lpBuffer);
                lpBuffer = (TCHAR*)LocalAlloc(LPTR, (RequiredLength + 1) * sizeof(TCHAR));
            } else {
                OutFormatMsg(_T("SetupDiGetDeviceRegistryProperty"));
                break;
            }
        }
 
        if( !_tcscmp(lpBuffer, _T("USBSTOR")) ) 
        {
            // Точно USB накопитель...
            _tprintf(_T("%s\n"), pDeviceInterfaceDetailData->DevicePath);
            /* \\?\usbstor#disk&ven_generic&prod_usb_flash_disk&rev_0.00#000000000000ec&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b} */
 
            RequiredLength = 0;
 
            while ( !SetupDiGetDeviceRegistryProperty(hDevInfo, 
                &DeviceInfoData, SPDRP_FRIENDLYNAME, NULL, 
                (PBYTE)lpBuffer, RequiredLength, &RequiredLength) )
            {
                if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) 
                {
                    LocalFreeIf(lpBuffer);
                    lpBuffer = (TCHAR*)LocalAlloc(LPTR, (RequiredLength + 1) * sizeof(TCHAR));
                } else {
                    OutFormatMsg(_T("SetupDiGetDeviceRegistryProperty2"));
                    break;
                }
            }
 
            _tprintf(_T("%s\n"),lpBuffer);
 
        }
        
 
        LocalFreeIf(lpBuffer);
        LocalFreeIf(pDeviceInterfaceDetailData);
    }
    SetupDiDestroyDeviceInfoList(hDevInfo);
 
    return 0;
}
Теперь мне нужно как то получить нормальный путь к этим устройствам, в виде (G:\ .. ), но как это сделать? Кто знает натолкните на мысль.
0
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
13.05.2011, 23:42
Ответы с готовыми решениями:

Как получить пути к профилям пользователей?
Здравствуйте! Интересует способ не через реестр. Взял пример с MSDN по NetUserEnum, в...

Получить дескриптор устройства USB
Как получить дескриптор устройства USB? Я пока только пытаюсь разобраться с API функциями. Пытаюсь...

Получить список USB устройств
Нужно получить список устройсст по классу гуида . Добавлено через 37 минут что бы в дальшейшем...

Получить имя USB устройства
Как получить имя подключенного девайса? //USB HDEVINFO hInfo =...

проблема с USB накопителям !
когда пытаюсь зайти на usb вылетает окошко фаил повржден или чтение не возможно ! ну пробовал...

5
blazonic
Videor venisse
127 / 108 / 6
Регистрация: 19.02.2010
Сообщений: 221
14.05.2011, 22:26 2
ISergey
Вот пример применения получения путей к устройствам и наименований устройств:
http://msdn.microsoft.com/en-us/library/cc542456%28v=VS.85%29.aspx
Пример интересный и рабочий.
Речь идёт о совсем другом наборе функций для достижения поставленной вами задачи. Чтобы получить путь к устройству типа "E:\" необходимо применить последовательно набор функций:
FindFirstVolumeW
QueryDosDeviceW
GetVolumePathNamesForVolumeNameW
FindNextVolumeW
FindVolumeClose

Этот набор необходимо включить в вашу программу.
2
ISergey
Maniac
Эксперт С++
1427 / 933 / 154
Регистрация: 02.01.2009
Сообщений: 2,779
Записей в блоге: 1
15.05.2011, 19:55  [ТС] 3
Лучший ответ Сообщение было отмечено как решение

Решение

Все таки мне показали как можно это сделать и через SetupAPI..
Вот набросал небольшую библиотеку. Может кому то пригодится
USBHelper.h
C++
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
#ifndef USBHelper_h__
#define USBHelper_h__
 
#include <windows.h>
 
 
#define USB_STORE_NO_ERROR                                      0L
#define USB_STORE_ERROR_SETUP_DI_GET_CLASS_DEVS                 1L
#define USB_STORE_ERROR_SETUP_DI_GET_DEVICE_INTERFACE_DETAIL    2L 
#define USB_STORE_ERROR_GET_VOLUME_PATH_NAME_FOR_VOLUME_NAME    3L 
#define USB_STORE_ERROR_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINT  4L 
#define USB_STORE_ERROR_INVALID_PARAMETRS                       5L
#define USB_STORE_ERROR_INSUFFICIENT_BUFFER                     6L
#define USB_STORE_ERROR_SETUP_DI_GET_DEVICE_REGISTRY_PROPERTY   7L
 
 
typedef struct _USB_DEVICE_STRORE_A {
    CHAR *DevicePhysicalName;
    CHAR *DeviceInterfacePath;
    CHAR *DeviceVolumeName;
    CHAR *DeviceVolumePath;
} USB_DEVICE_STRORE_A, *PUSB_DEVICE_STRORE_A;
 
typedef struct _USB_DEVICE_STRORE_W {
    WCHAR *DevicePhysicalName;
    WCHAR *DeviceInterfacePath;
    WCHAR *DeviceVolumeName;
    WCHAR *DeviceVolumePath;
} USB_DEVICE_STRORE_W, *PUSB_DEVICE_STRORE_W;
 
 
#ifdef UNICODE
    typedef USB_DEVICE_STRORE_W USB_DEVICE_STRORE;
    typedef PUSB_DEVICE_STRORE_W PUSB_DEVICE_STRORE;
#else
    typedef USB_DEVICE_STRORE_A USB_DEVICE_STRORE;
    typedef PUSB_DEVICE_STRORE_A PUSB_DEVICE_STRORE;
#endif
 
BOOL WINAPI GetUSBStoreDevicesListA(
    __out_bcount_opt(USBDeviceListDataSize)PUSB_DEVICE_STRORE_A USBDeviceList, 
    __in DWORD USBDeviceListDataSize,
    __out_opt PDWORD RequiredSize
    );
 
BOOL WINAPI GetUSBStoreDevicesListW(
    __out_bcount_opt(USBDeviceListDataSize)PUSB_DEVICE_STRORE_W USBDeviceList,
    __in DWORD USBDeviceListDataSize,
    __out_opt PDWORD RequiredSize
    );
 
 
#ifdef UNICODE
    #define GetUSBStoreDevicesList GetUSBStoreDevicesListW
#else
    #define GetUSBStoreDevicesList GetUSBStoreDevicesListA
#endif
 
VOID WINAPI ReleaseUSBStroreA(
    __in_ecount(USBDeviceListDataSize)PUSB_DEVICE_STRORE_A USBDeviceList,
    __in DWORD USBDeviceListDataSize
    );
 
VOID WINAPI ReleaseUSBStroreW(
    __in_ecount(USBDeviceListDataSize)PUSB_DEVICE_STRORE_W USBDeviceList,
    __in DWORD USBDeviceListDataSize
    );
 
#ifdef UNICODE
    #define ReleaseUSBStrore ReleaseUSBStroreW
#else
    #define ReleaseUSBStrore ReleaseUSBStroreA
#endif
 
DWORD WINAPI GetLastErrorUSBStore();
 
#endif // USBHelper_h__

USBHelper.cpp

C++
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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
#include "USBHelper.h"
#include <Setupapi.h>
 
 
#if defined (_MSC_VER) && (_MSC_VER >= 1200)
#pragma warning(push)
#pragma warning(disable:4996) 
#endif
 
// #define USB_STORE_NO_ERROR                                       0L
// #define USB_STORE_ERROR_SETUP_DI_GET_CLASS_DEVS                  1L
// #define USB_STORE_ERROR_SETUP_DI_GET_DEVICE_INTERFACE_DETAIL     2L 
// #define USB_STORE_ERROR_GET_VOLUME_PATH_NAME_FOR_VOLUME_NAME     3L 
// #define USB_STORE_ERROR_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINT   4L 
// #define USB_STORE_ERROR_INVALID_PARAMETRS                        5L
// #define USB_STORE_ERROR_INSUFFICIENT_BUFFER                      6L
// 
// 
// typedef struct _USB_DEVICE_STRORE {
//  TCHAR *DeviceName;
//  TCHAR *DeviceInstanceID;
//  TCHAR *DevicePhysicalName;
//  TCHAR *DeviceInterfacePath;
//  TCHAR *DeviceVolumeName;
//  TCHAR *DeviceVolumePath;
// } USB_DEVICE_STRORE, *PUSB_DEVICE_STRORE;
 
DWORD ErrorCode = USB_STORE_NO_ERROR;
#define LocalFreeIf(Pointer) if(Pointer) { LocalFree(Pointer); Pointer = NULL; }
 
BOOL WINAPI GetUSBStoreDevicesListA( 
    __out_bcount_opt(USBDeviceListDataSize)PUSB_DEVICE_STRORE_A USBDeviceList, 
    __in DWORD USBDeviceListDataSize, 
    __out_opt PDWORD RequiredSize )
{
 
    if( USBDeviceList == NULL && RequiredSize == NULL ) {
        ErrorCode = USB_STORE_ERROR_INVALID_PARAMETRS;
        return FALSE;
    }
 
    PSP_DEVICE_INTERFACE_DETAIL_DATA_A pDeviceInterfaceDetailData = NULL;
    SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
    SP_DEVINFO_DATA DeviceInfoData;
 
    HDEVINFO hDevInfo;
    CHAR *lpBuffer = NULL;
 
    DWORD len   = 0;
    DWORD Index = 0;
 
    const GUID InterfaceGuid = { 0x53f5630dL, 0xb6bf, 0x11d0, {0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b} };
 
    hDevInfo = SetupDiGetClassDevsA( &InterfaceGuid,0, 0, DIGCF_PRESENT  | DIGCF_DEVICEINTERFACE  );
 
    if (hDevInfo == INVALID_HANDLE_VALUE) {
        ErrorCode = USB_STORE_ERROR_SETUP_DI_GET_CLASS_DEVS;
        return FALSE;
    }
 
    DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
    DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
    for(DWORD i = 0; SetupDiEnumDeviceInterfaces(hDevInfo, 0, &InterfaceGuid, i, &DeviceInterfaceData); ++i)
    {
        ULONG RequiredLength = 0;
 
        while ( !SetupDiGetDeviceInterfaceDetailA( hDevInfo, 
            &DeviceInterfaceData, pDeviceInterfaceDetailData, RequiredLength, &RequiredLength, &DeviceInfoData ) )
        {
            if( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
            {
                LocalFreeIf( pDeviceInterfaceDetailData );
                pDeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_A)LocalAlloc(LMEM_FIXED, (RequiredLength + 2));
                pDeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
            } 
            else 
            {
                ErrorCode = USB_STORE_ERROR_SETUP_DI_GET_DEVICE_INTERFACE_DETAIL;
                SetupDiDestroyDeviceInfoList(hDevInfo);
                return FALSE;
            }
        }
 
        if( strstr(pDeviceInterfaceDetailData->DevicePath, "usbstor") ) 
        {
            if( USBDeviceList == NULL )         { ++Index; LocalFreeIf(pDeviceInterfaceDetailData); continue; }
            if( USBDeviceListDataSize == 0 )    { ++Index; LocalFreeIf(pDeviceInterfaceDetailData); continue; }
            if( USBDeviceListDataSize < Index ) { ++Index; LocalFreeIf(pDeviceInterfaceDetailData); continue; }
 
            CHAR Volume[256] = { 0 };
            CHAR Letter[256] = { 0 };
 
            len = strlen( pDeviceInterfaceDetailData->DevicePath );
 
            USBDeviceList[Index].DeviceInterfacePath = (CHAR*)LocalAlloc(LPTR, len + 1);
            strcpy(USBDeviceList[Index].DeviceInterfacePath, pDeviceInterfaceDetailData->DevicePath);
 
            pDeviceInterfaceDetailData->DevicePath[len]     = '\\';
            pDeviceInterfaceDetailData->DevicePath[len + 1] = '\0';
 
 
            if( GetVolumeNameForVolumeMountPointA(pDeviceInterfaceDetailData->DevicePath, Volume, 255) )
            {
                len = strlen( Volume );
                USBDeviceList[Index].DeviceVolumeName = (CHAR*)LocalAlloc(LPTR, len + 1);
                strcpy(USBDeviceList[Index].DeviceVolumeName, Volume);
 
                if (GetVolumePathNamesForVolumeNameA(Volume, Letter, 255, &RequiredLength))
                {
                    len = strlen( Letter );
                    USBDeviceList[Index].DeviceVolumePath = (CHAR*)LocalAlloc(LPTR, len + 1);
                    strcpy(USBDeviceList[Index].DeviceVolumePath, Letter);                          
 
                } 
                else 
                {
                    LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
                    LocalFreeIf(USBDeviceList[Index].DeviceVolumeName);
                    ReleaseUSBStroreA(USBDeviceList, Index);
 
                    ErrorCode = USB_STORE_ERROR_GET_VOLUME_PATH_NAME_FOR_VOLUME_NAME;
                    LocalFreeIf(pDeviceInterfaceDetailData);
                    SetupDiDestroyDeviceInfoList(hDevInfo);
 
                    return FALSE;
                }
 
            } 
            else 
            {
                LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
                ReleaseUSBStroreA(USBDeviceList, Index);
 
                ErrorCode = USB_STORE_ERROR_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINT;
                LocalFreeIf(pDeviceInterfaceDetailData);
                SetupDiDestroyDeviceInfoList(hDevInfo);
 
                return FALSE;
            }
 
            RequiredLength = 0;
            while ( !SetupDiGetDeviceRegistryPropertyA(hDevInfo, 
                &DeviceInfoData, SPDRP_PHYSICAL_DEVICE_OBJECT_NAME, NULL, 
                (PBYTE)lpBuffer, RequiredLength, &RequiredLength) )
            {
                if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) 
                {
                    LocalFreeIf(lpBuffer);
                    lpBuffer = (CHAR*)LocalAlloc(LPTR, RequiredLength + 1);
                } 
                else 
                {
                    LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
                    LocalFreeIf(USBDeviceList[Index].DeviceVolumePath);
                    LocalFreeIf(USBDeviceList[Index].DeviceVolumeName);
                    ReleaseUSBStroreA(USBDeviceList, Index);
 
                    ErrorCode = USB_STORE_ERROR_SETUP_DI_GET_DEVICE_REGISTRY_PROPERTY;
                    LocalFreeIf(pDeviceInterfaceDetailData);
                    SetupDiDestroyDeviceInfoList(hDevInfo);
                    return FALSE;
                }
            }
 
            len = strlen( lpBuffer );
            USBDeviceList[Index].DevicePhysicalName = (CHAR*)LocalAlloc(LPTR, len + 1);
            strcpy(USBDeviceList[Index].DevicePhysicalName, lpBuffer);  
 
            ++Index;
        }
 
 
        LocalFreeIf(lpBuffer);
        LocalFreeIf(pDeviceInterfaceDetailData);
    }
 
    SetupDiDestroyDeviceInfoList(hDevInfo);
 
    if(RequiredSize != NULL)
        *RequiredSize = Index;
 
    if( USBDeviceListDataSize == 0 || USBDeviceListDataSize < Index || USBDeviceList == NULL)
    {
        ErrorCode = USB_STORE_ERROR_INSUFFICIENT_BUFFER;
        return FALSE;
    }
 
    ErrorCode = USB_STORE_NO_ERROR;
    return TRUE;
}
 
BOOL WINAPI GetUSBStoreDevicesListW(
    __out_bcount_opt(USBDeviceListDataSize)PUSB_DEVICE_STRORE_W USBDeviceList, 
    __in DWORD USBDeviceListDataSize, 
    __out_opt PDWORD RequiredSize )
{
    if( USBDeviceList == NULL && RequiredSize == NULL ) {
        ErrorCode = USB_STORE_ERROR_INVALID_PARAMETRS;
        return FALSE;
    }
 
    PSP_DEVICE_INTERFACE_DETAIL_DATA_W pDeviceInterfaceDetailData = NULL;
    SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
    SP_DEVINFO_DATA DeviceInfoData;
 
    HDEVINFO hDevInfo;
    WCHAR *lpBuffer = NULL;
 
    DWORD len   = 0;
    DWORD Index = 0;
 
    const GUID InterfaceGuid = { 0x53f5630dL, 0xb6bf, 0x11d0, {0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b} };
 
    hDevInfo = SetupDiGetClassDevsW( &InterfaceGuid,0, 0, DIGCF_PRESENT  | DIGCF_DEVICEINTERFACE  );
 
    if (hDevInfo == INVALID_HANDLE_VALUE) {
        ErrorCode = USB_STORE_ERROR_SETUP_DI_GET_CLASS_DEVS;
        return FALSE;
    }
 
    DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
    DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
    for(DWORD i = 0; SetupDiEnumDeviceInterfaces(hDevInfo, 0, &InterfaceGuid, i, &DeviceInterfaceData); ++i)
    {
        ULONG RequiredLength = 0;
 
        while ( !SetupDiGetDeviceInterfaceDetailW( hDevInfo, 
            &DeviceInterfaceData, pDeviceInterfaceDetailData, RequiredLength, &RequiredLength, &DeviceInfoData ) )
        {
            if( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
            {
                LocalFreeIf( pDeviceInterfaceDetailData );
                pDeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)LocalAlloc(LMEM_FIXED, (RequiredLength + 2) * sizeof(WCHAR));
                pDeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
            } 
            else 
            {
                ErrorCode = USB_STORE_ERROR_SETUP_DI_GET_DEVICE_INTERFACE_DETAIL;
                SetupDiDestroyDeviceInfoList(hDevInfo);
                return FALSE;
            }
        }
 
        if( wcsstr(pDeviceInterfaceDetailData->DevicePath, L"usbstor") ) 
        {
            if( USBDeviceList == NULL )         { ++Index; LocalFreeIf(pDeviceInterfaceDetailData); continue; }
            if( USBDeviceListDataSize == 0 )    { ++Index; LocalFreeIf(pDeviceInterfaceDetailData); continue; }
            if( USBDeviceListDataSize < Index ) { ++Index; LocalFreeIf(pDeviceInterfaceDetailData); continue; }
 
            WCHAR Volume[256] = { 0 };
            WCHAR Letter[256] = { 0 };
 
            len = wcslen( pDeviceInterfaceDetailData->DevicePath );
 
            USBDeviceList[Index].DeviceInterfacePath = (WCHAR*)LocalAlloc(LPTR, (len + 1) * sizeof(WCHAR));
            wcscpy(USBDeviceList[Index].DeviceInterfacePath, pDeviceInterfaceDetailData->DevicePath);
 
            pDeviceInterfaceDetailData->DevicePath[len]     = L'\\';
            pDeviceInterfaceDetailData->DevicePath[len + 1] = L'\0';
 
 
            if( GetVolumeNameForVolumeMountPointW(pDeviceInterfaceDetailData->DevicePath, Volume, 255) )
            {
                len = wcslen( Volume );
                USBDeviceList[Index].DeviceVolumeName = (WCHAR*)LocalAlloc(LPTR, (len + 1) * sizeof(WCHAR));
                wcscpy(USBDeviceList[Index].DeviceVolumeName, Volume);
 
                if (GetVolumePathNamesForVolumeNameW(Volume, Letter, 255, &RequiredLength))
                {
                    len = wcslen( Letter );
                    USBDeviceList[Index].DeviceVolumePath = (WCHAR*)LocalAlloc(LPTR, (len + 1) * sizeof(WCHAR));
                    wcscpy(USBDeviceList[Index].DeviceVolumePath, Letter);                          
                } 
                else 
                {
                    LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
                    LocalFreeIf(USBDeviceList[Index].DeviceVolumeName);
                    ReleaseUSBStroreW(USBDeviceList, Index);
 
                    ErrorCode = USB_STORE_ERROR_GET_VOLUME_PATH_NAME_FOR_VOLUME_NAME;
                    LocalFreeIf(pDeviceInterfaceDetailData);
                    SetupDiDestroyDeviceInfoList(hDevInfo);
                    return FALSE;
                }
 
            } 
            else 
            {
                LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
                ReleaseUSBStroreW(USBDeviceList, Index);
 
                ErrorCode = USB_STORE_ERROR_GET_VOLUME_NAME_FOR_VOLUME_MOUNT_POINT;
                LocalFreeIf(pDeviceInterfaceDetailData);
                SetupDiDestroyDeviceInfoList(hDevInfo);
                return FALSE;
            }
 
            RequiredLength = 0;
            while ( !SetupDiGetDeviceRegistryPropertyW(hDevInfo, 
                &DeviceInfoData, SPDRP_PHYSICAL_DEVICE_OBJECT_NAME, NULL, 
                (PBYTE)lpBuffer, RequiredLength, &RequiredLength) )
            {
                if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) 
                {
                    LocalFreeIf(lpBuffer);
                    lpBuffer = (WCHAR*)LocalAlloc(LPTR, (RequiredLength + 1) * sizeof(WCHAR));
                } 
                else 
                {
                    LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
                    LocalFreeIf(USBDeviceList[Index].DeviceVolumePath);
                    LocalFreeIf(USBDeviceList[Index].DeviceVolumeName);
                    ReleaseUSBStroreW(USBDeviceList, Index);
                    ErrorCode = USB_STORE_ERROR_SETUP_DI_GET_DEVICE_REGISTRY_PROPERTY;
                    LocalFreeIf(pDeviceInterfaceDetailData);
                    SetupDiDestroyDeviceInfoList(hDevInfo);
                    return FALSE;
                }
            }
 
            len = wcslen( lpBuffer );
            USBDeviceList[Index].DevicePhysicalName = (WCHAR*)LocalAlloc(LPTR, (len + 1) * sizeof(WCHAR));
            wcscpy(USBDeviceList[Index].DevicePhysicalName, lpBuffer);  
 
            ++Index;
        }
 
        
        LocalFreeIf(lpBuffer);
        LocalFreeIf(pDeviceInterfaceDetailData);
    }
 
    SetupDiDestroyDeviceInfoList(hDevInfo);
 
    if(RequiredSize != NULL)
        *RequiredSize = Index;
 
    if( USBDeviceListDataSize == 0 || USBDeviceListDataSize < Index || USBDeviceList == NULL)
    {
        ErrorCode = USB_STORE_ERROR_INSUFFICIENT_BUFFER;
        return FALSE;
    }
 
    ErrorCode = USB_STORE_NO_ERROR;
    return TRUE;
}
 
VOID WINAPI ReleaseUSBStroreA( 
    __in_ecount(USBDeviceListDataSize)PUSB_DEVICE_STRORE_A USBDeviceList, 
    __in DWORD USBDeviceListDataSize
    )
{
    if(USBDeviceList == NULL) return;
 
    for(DWORD Index = 0; Index < USBDeviceListDataSize; ++Index)
    {
        LocalFreeIf(USBDeviceList[Index].DeviceVolumePath);
        LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
        LocalFreeIf(USBDeviceList[Index].DevicePhysicalName);
        LocalFreeIf(USBDeviceList[Index].DeviceVolumeName);
    }
}
 
VOID WINAPI ReleaseUSBStroreW( 
    __in_ecount(USBDeviceListDataSize)PUSB_DEVICE_STRORE_W USBDeviceList, 
    __in DWORD USBDeviceListDataSize
    )
{
    if(USBDeviceList == NULL) return;
 
    for(DWORD Index = 0; Index < USBDeviceListDataSize; ++Index)
    {
        LocalFreeIf(USBDeviceList[Index].DeviceVolumePath);
        LocalFreeIf(USBDeviceList[Index].DeviceInterfacePath);
        LocalFreeIf(USBDeviceList[Index].DevicePhysicalName);
        LocalFreeIf(USBDeviceList[Index].DeviceVolumeName);
    }
}
 
DWORD WINAPI GetLastErrorUSBStore()
{
    return ErrorCode;
}
 
 
#if defined (_MSC_VER) && (_MSC_VER >= 1200)
#pragma warning(pop)
#endif

Пример использования..
C++
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
#include <windows.h>
#include <tchar.h>
 
#include <stdio.h>
 
#include "USBHelper.h"
 
 
int main()
{
 
    DWORD RequiredSize = 0;
    USB_DEVICE_STRORE *uDevice = NULL;
 
    while( !GetUSBStoreDevicesList(uDevice, RequiredSize, &RequiredSize) )
    {
        if( GetLastErrorUSBStore() == USB_STORE_ERROR_INSUFFICIENT_BUFFER )
        {
            uDevice = (USB_DEVICE_STRORE*)LocalAlloc(LPTR, RequiredSize * sizeof(USB_DEVICE_STRORE));
        } else {
            _tprintf(_T("ErrorCode %d"), GetLastErrorUSBStore() );
            return 1;
        }
    }
 
    for(DWORD i = 0; i < RequiredSize; ++i)
    {
        _tprintf(_T("DeviceVolumeName: %s\n"),      uDevice[i].DeviceVolumeName);
        _tprintf(_T("DeviceVolumePath: %s\n"),      uDevice[i].DeviceVolumePath);
        _tprintf(_T("DevicePhysicalName: %s\n"),    uDevice[i].DevicePhysicalName);
        _tprintf(_T("DeviceInterfacePath: %s\n\n"), uDevice[i].DeviceInterfacePath);
    }
    
    ReleaseUSBStrore(uDevice, RequiredSize);
    LocalFree(uDevice);
 
    return 0;
}
Результат

Код
DeviceVolumeName: \\?\Volume{9917eda9-4c73-11df-980a-00e04d22a2c4}\
DeviceVolumePath: H:\
DevicePhysicalName: \Device\HarddiskVolume4
DeviceInterfacePath: \\?\storage#volume#_??_usbstor#disk&ven_generic&prod_usb_fl
ash_disk&rev_0.00#000000000000ec&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}#{53f56
30d-b6bf-11d0-94f2-00a0c91efb8b}

DeviceVolumeName: \\?\Volume{bce0b220-51de-11df-9d4a-00e04d22a2c4}\
DeviceVolumePath: J:\
DevicePhysicalName: \Device\HarddiskVolume7
DeviceInterfacePath: \\?\storage#volume#_??_usbstor#disk&ven_nokia&prod_nokia_31
20_class&rev_0000#353102024827559&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}#{53f5
630d-b6bf-11d0-94f2-00a0c91efb8b}
7
likevlz
0 / 0 / 0
Регистрация: 16.07.2015
01.03.2013, 09:00 4
У меня ваш код строка 15 while( !GetUSBStoreDevicesList(uDevice, RequiredSize, &RequiredSize) )
цикл уходит в бесконечность...
0
ISergey
Maniac
Эксперт С++
1427 / 933 / 154
Регистрация: 02.01.2009
Сообщений: 2,779
Записей в блоге: 1
01.03.2013, 15:02  [ТС] 5
Что в
C++
1
RequiredSize
при каждом заходе в цикл?

Добавлено через 22 минуты
Баг если нет флешек..

В файле USBHelper.h

Добавь строчку
C++
1
#define USB_STORE_NO_MORE_DEVICE                                8L
Потом в USBHelper.cpp
В функциях
C++
1
2
GetUSBStoreDevicesListW
GetUSBStoreDevicesListA
Вот это (180 и 337 строка)
C++
1
2
if(RequiredSize != NULL)
        *RequiredSize = Index;
Замени на
C++
1
2
3
4
5
6
7
8
    if(RequiredSize != NULL){
        if( Index == 0 ){
            ErrorCode = USB_STORE_NO_MORE_DEVICE;
            return FALSE;
        }
 
        *RequiredSize = Index;
    }
0
raxp
10190 / 6573 / 492
Регистрация: 28.12.2010
Сообщений: 21,166
Записей в блоге: 1
02.03.2013, 09:24 6
...можно вопрос: что делает сие c путем (массивом char) с "USBSTOR..." перед передачей его в GetVolumeNameForVolumeMountPointA():
C
1
2
 pDeviceInterfaceDetailData->DevicePath[len]     = '\\';
 pDeviceInterfaceDetailData->DevicePath[len + 1] = '\0';
первая заменяет косую черту, но на что заменяет? И вторая - удаляет. Т.е. как выглядит после этого путь?
0
02.03.2013, 09:24
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
02.03.2013, 09:24

Блокировка доступа к USB накопителям
На роботе необходимо закрить доступ к USB накопителям. Компютера находятса в домене. Такой...

USB устройство, проблемы и пути решения.
Народ, что делать с флешкой - сохраняю на ней файлы (форматы разные), после не могу их открыть,...

C пути получить имя файла
Всем здрасте, у меня есть путь точнее много путей к каждому файлу в цыкле, выгледят так :\ ...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
6
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.
Рейтинг@Mail.ru