usb_dll.cpp

枚举删除USB设备,获取USB移动盘的盘符

// USB_DLL.cpp : 定义 DLL 的初始化例程。
//

#include "stdafx.h"
#include "USB_DLL.h"
#include <tchar.h>
#include <stdio.h>
#include <windows.h>
#include <devguid.h>
#include <winioctl.h>
#define DWORD_PTR DWORD
#define ULONG_PTR DWORD

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

extern "C" { 
#include "hidsdi.h" 
}
#include <setupapi.h>
// 需加入setupapi.lib

#include <regstr.h>
#include <winbase.h>

#include <cfgmgr32.h>
// 需要加入cfgmgr32.lib

#include <initguid.h>
//#include <usbiodef.h>
DEFINE_GUID(GUID_DEVINTERFACE_USB_DEVICE,
  0xA5DCBF10L, 0x6530, 0x11D2, 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED);
#define GUID_CLASS_USB_DEVICE           GUID_DEVINTERFACE_USB_DEVICE
//
//	注意！
//
//		如果此 DLL 动态链接到 MFC
//		DLL，从此 DLL 导出并
//		调入 MFC 的任何函数在函数的最前面
//		都必须添加 AFX_MANAGE_STATE 宏。
//
//		例如:
//
//		extern "C" BOOL PASCAL EXPORT ExportedFunction()
//		{
//			AFX_MANAGE_STATE(AfxGetStaticModuleState());
//			// 此处为普通函数体
//		}
//
//		此宏先于任何 MFC 调用
//		出现在每个函数中十分重要。这意味着
//		它必须作为函数中的第一个语句
//		出现，甚至先于所有对象变量声明，
//		这是因为它们的构造函数可能生成 MFC
//		DLL 调用。
//
//		有关其他详细信息，
//		请参阅 MFC 技术说明 33 和 58。
//

// CUSB_DLLApp

BEGIN_MESSAGE_MAP(CUSB_DLLApp, CWinApp)
END_MESSAGE_MAP()


// CUSB_DLLApp 构造

CUSB_DLLApp::CUSB_DLLApp()
{
	// TODO: 在此处添加构造代码，
	// 将所有重要的初始化放置在 InitInstance 中
}


// 唯一的一个 CUSB_DLLApp 对象

CUSB_DLLApp theApp;


// CUSB_DLLApp 初始化

BOOL CUSB_DLLApp::InitInstance()
{
	CWinApp::InitInstance();

	return TRUE;
}
BOOL FindDriv(DWORD p[16])
{
	HDEVINFO hDevInfo;
   
   SP_DEVINFO_DATA DeviceInfoData;
   DWORD i;

   //--------------------------------------------------------------------------
   // 获取设备信息
   hDevInfo = SetupDiGetClassDevs((LPGUID)&GUID_CLASS_USB_DEVICE,
       0, // Enumerator
       0,
       DIGCF_PRESENT | DIGCF_DEVICEINTERFACE );
   if (hDevInfo == INVALID_HANDLE_VALUE) {
       // 查询信息失败
       printf("ERROR - SetupDiGetClassDevs()");
       return 0;
   }
   //--------------------------------------------------------------------------

   // 枚举每个USB设备
   DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
   for (i=0;SetupDiEnumDeviceInfo(hDevInfo, i, &DeviceInfoData);i++)
   {
        LPTSTR buffer = NULL;
        PVOID buffer2 = NULL;
        DWORD buffersize = 0;
        //ULONG len;
        CONFIGRET   cr;
        //PNP_VETO_TYPE pnpvietotype;
        //CHAR vetoname[MAX_PATH];
        ULONG ulStatus;
        ULONG ulProblemNumber;

        cr = CM_Get_DevNode_Status( &ulStatus,
                                    &ulProblemNumber,
                                    DeviceInfoData.DevInst,
                                    0);
        if ( CR_SUCCESS == cr ) {
            printf("OK - CM_Get_DevNode_Status()[%d]\n", cr);
            printf("OK - CM_Get_DevNode_Status() sts [%x]\n", ulStatus);
            printf("OK - CM_Get_DevNode_Status() pro [%x]\n", ulProblemNumber);
        } else {
            printf("ERROR - CM_Get_DevNode_Status()[%d]\n", cr);
            printf("ERROR - CM_Get_DevNode_Status()[%d]\n", GetLastError());
        }
        // DN_DISABLEABLE or DN_REMOVABLE
        p[i]=DeviceInfoData.DevInst;
       //p++;
   }   
       
   if ( GetLastError()!=NO_ERROR &&
        GetLastError()!=ERROR_NO_MORE_ITEMS )
   {
       // Insert error handling here.
       return 0;
   }
       
   //  Cleanup
   SetupDiDestroyDeviceInfoList(hDevInfo);

   return 1;
			 }

//BOOL GetDriv(DWORD *k[16])

BOOL DelDriA(DWORD tt,char mm[256])
			 {
	HDEVINFO hDevInfo;
   
   SP_DEVINFO_DATA DeviceInfoData;
   DWORD i;

   //--------------------------------------------------------------------------
   // 获取设备信息
   hDevInfo = SetupDiGetClassDevs((LPGUID)&GUID_CLASS_USB_DEVICE,
       0, // Enumerator
       0,
       DIGCF_PRESENT | DIGCF_DEVICEINTERFACE );
   if (hDevInfo == INVALID_HANDLE_VALUE) {
       // 查询信息失败
       printf("ERROR - SetupDiGetClassDevs()");
       return 0;
   }
   //--------------------------------------------------------------------------

   // 枚举每个USB设备
   DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
   for (i=0;SetupDiEnumDeviceInfo(hDevInfo, i, &DeviceInfoData);i++)
   {
        LPTSTR buffer = NULL;
        PVOID buffer2 = NULL;
        DWORD buffersize = 0;
        ULONG len;
        CONFIGRET   cr;
        PNP_VETO_TYPE pnpvietotype;
        CHAR vetoname[MAX_PATH];
        ULONG ulStatus;
        ULONG ulProblemNumber;

        cr = CM_Get_DevNode_Status( &ulStatus,
                                    &ulProblemNumber,
                                    DeviceInfoData.DevInst,
                                    0);
        if ( CR_SUCCESS == cr ) {
            printf("OK - CM_Get_DevNode_Status()[%d]\n", cr);
            printf("OK - CM_Get_DevNode_Status() sts [%x]\n", ulStatus);
            printf("OK - CM_Get_DevNode_Status() pro [%x]\n", ulProblemNumber);
        } else {
            printf("ERROR - CM_Get_DevNode_Status()[%d]\n", cr);
            printf("ERROR - CM_Get_DevNode_Status()[%d]\n", GetLastError());
        }
        // DN_DISABLEABLE or DN_REMOVABLE
    if (tt==DeviceInfoData.DevInst){
        if ((DN_DISABLEABLE & ulStatus ) != 0 ) {
            printf("HAS - DN_DISABLEABLE()[%x]\n", DN_DISABLEABLE & ulStatus);
        } else {
           continue;
        }
        if ((DN_REMOVABLE & ulStatus ) != 0 ) {
            printf("HAS - DN_REMOVABLE()[%x]\n", DN_REMOVABLE & ulStatus);
        } else {
           continue;
        }
       
        len = MAX_PATH;
        // pnpvietotype = PNP_VetoDevice; 删除当前的USB设备
        cr = CM_Request_Device_Eject(
                            DeviceInfoData.DevInst,
                            &pnpvietotype,
                            vetoname,
                            len,
                            0
                            );
        if ( CR_SUCCESS == cr ) {
            printf("OK - CM_Request_Device_Eject()[%d]\n", cr);
        } else {
            printf("ERROR - CM_Request_Device_Eject()[%d]\n", cr);
            printf("ERROR - CM_Request_Device_Eject()[%d]\n", GetLastError());
            strcpy(mm,"NOT_Del_SUCCESS");
        }
        break;
       }
    else
        {
            strcpy(mm,"NOT_Find_Same_Hdc");
        }
   }
       
       
   if ( GetLastError()!=NO_ERROR &&
        GetLastError()!=ERROR_NO_MORE_ITEMS )
   {
       // Insert error handling here.
       return 0;
   }
       
   //  Cleanup
   SetupDiDestroyDeviceInfoList(hDevInfo);
    strcpy(mm,"Del_Hdc_OK");
   return 1;
			 }


char chFirstDriveFromMask (ULONG unitmask)
{

      char i;
      for (i = 0; i < 26; ++i)  
      {
           if (unitmask & 0x1) 
				break;
            unitmask = unitmask >> 1;
      }
    return (i + 'A');
}
//获取磁盘参数（类别）
BOOL GetDisksProperty(HANDLE hDevice, PSTORAGE_DEVICE_DESCRIPTOR pDevDesc)
{
	STORAGE_PROPERTY_QUERY	Query;	// input param for query
	DWORD dwOutBytes;				// IOCTL output length
	BOOL bResult;					// IOCTL return val

	// specify the query type
	Query.PropertyId = StorageDeviceProperty;
	Query.QueryType = PropertyStandardQuery;

	// Query using IOCTL_STORAGE_QUERY_PROPERTY 
	bResult = ::DeviceIoControl(hDevice,			// 设备句柄
			IOCTL_STORAGE_QUERY_PROPERTY,			// 取磁盘参数
			&Query, sizeof(STORAGE_PROPERTY_QUERY),	// 输入数据
			pDevDesc, pDevDesc->Size,				// 输出数据缓冲区
			&dwOutBytes,							// 输出数据长度
			(LPOVERLAPPED)NULL);					

	return bResult;
}

BOOL LLFormatDisk(DWORD drive)
{
    DWORD dwOutBytes;
    BOOL bResult;
    HANDLE hDisk;
    TCHAR filename[256]="";
    DISK_GEOMETRY Geometry;
    sprintf(filename, "\\\\?\\%c:",drive);
    // 打开设备
    hDisk = ::CreateFile(filename,           // 文件名
        GENERIC_READ | GENERIC_WRITE,        // 读写方式
        FILE_SHARE_READ | FILE_SHARE_WRITE,  // 共享方式
        NULL,                                // 默认的安全描述符
        OPEN_EXISTING,                       // 创建方式
        0,                                   // 不需设置文件属性
        NULL);                               // 不需参照模板文件
 
    // 用IOCTL_DISK_GET_DRIVE_GEOMETRY取磁盘参数
   if (!(GetDiskGeometry(hDisk,&Geometry))) return false;
       
                for(DWORD dwCylinder=0; dwCylinder<Geometry.Cylinders.LowPart; dwCylinder++)
				{
                    if (!(LowLevelFormatTracks(hDisk, &Geometry, dwCylinder, 1)))
				      break;
				}
    CloseHandle(hDisk);
    return bResult;
}

//获取磁盘参数（大小）
BOOL GetDiskGeometry(HANDLE hDisk, PDISK_GEOMETRY lpGeometry)
{
    DWORD dwOutBytes;
	BOOL bResult;

	// 用IOCTL_DISK_GET_DRIVE_GEOMETRY取磁盘参数
	bResult = ::DeviceIoControl(hDisk,				// 设备句柄
			IOCTL_DISK_GET_DRIVE_GEOMETRY,			// 取磁盘参数
			NULL, 0,								// 不需要输入数据
			lpGeometry, sizeof(DISK_GEOMETRY),		// 输出数据缓冲区
			&dwOutBytes,							// 输出数据长度
			(LPOVERLAPPED)NULL);					// 用同步I/O

	return bResult;
}
bool LowLevelFormatTracks(HANDLE hDisk, PDISK_GEOMETRY lpGeometry, DWORD dwStartCylinder, DWORD dwCylinderNumber)
{
    FORMAT_PARAMETERS FormatParameters;
    PBAD_TRACK_NUMBER lpBadTrack;
    DWORD dwOutBytes;
	DWORD dwBufSize;
    BOOL bResult;

    FormatParameters.MediaType = lpGeometry->MediaType;
    FormatParameters.StartCylinderNumber = dwStartCylinder;
    FormatParameters.EndCylinderNumber = dwStartCylinder + dwCylinderNumber - 1;
    FormatParameters.StartHeadNumber = 0;
    FormatParameters.EndHeadNumber = lpGeometry->TracksPerCylinder - 1;

	dwBufSize = lpGeometry->TracksPerCylinder * sizeof(BAD_TRACK_NUMBER);

    lpBadTrack = (PBAD_TRACK_NUMBER) new BYTE[dwBufSize];
                
	// 用IOCTL_DISK_FORMAT_TRACKS对连续磁道进行低级格式化
	bResult = ::DeviceIoControl(hDisk,				// 设备句柄
			IOCTL_DISK_FORMAT_TRACKS,				// 低级格式化
			&FormatParameters, sizeof(FormatParameters),	// 输入数据缓冲区
			lpBadTrack, dwBufSize,					// 输出数据缓冲区
			&dwOutBytes,							// 输出数据长度
			(LPOVERLAPPED)NULL);					// 用同步I/O

    delete lpBadTrack;

    return bResult;
}

BOOL Find_USBDisk(int d[26])
{
    int s =0;
	int k = 0;
	DWORD			MaxDriveSet, CurDriveSet;
	DWORD			drive, drivetype;
	TCHAR			szBuf[300];
	HANDLE			hDevice;
	PSTORAGE_DEVICE_DESCRIPTOR pDevDesc;

	for(k=0; k<26; k++)
		szMoveDiskName[k] = '\0';	
	k = 0;		
	// Get available drives we can monitor
	MaxDriveSet = CurDriveSet = 0;

	MaxDriveSet = GetLogicalDrives();
	CurDriveSet = MaxDriveSet;
	for ( drive = 0; drive < 32; ++drive )  
	{
		if ( MaxDriveSet & (1 << drive) )  
		{
			DWORD temp = 1<<drive;
			_stprintf( szDrvName, _T("%c:\\"), 'A'+drive );
			
            switch ( GetDriveType( szDrvName ) )  
			{
				case DRIVE_REMOVABLE:	// The drive can be removed from the drive.
					drivetype = DRVREMOVE;
                   					
					d[k] = int(chFirstDriveFromMask(temp));
					k++;
					break;
     //           case DRIVE_REMOTE:		// The drive is a remote (network) drive.
					//drivetype = DRVREMOTE;
					//d[k] = int(chFirstDriveFromMask(temp));
					//k++;
					//break;
                case DRIVE_FIXED:		// The disk cannot be removed from the drive.
					drivetype = DRVFIXED;
					sprintf(szBuf, "\\\\?\\%c:", 'A'+drive);
					hDevice = CreateFile(szBuf, GENERIC_READ,
							FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, NULL);

					if (hDevice != INVALID_HANDLE_VALUE)
					{

						pDevDesc = (PSTORAGE_DEVICE_DESCRIPTOR)new BYTE[sizeof(STORAGE_DEVICE_DESCRIPTOR) + 512 - 1];
						pDevDesc->Size = sizeof(STORAGE_DEVICE_DESCRIPTOR) + 512 - 1;
						
                        if(GetDisksProperty(hDevice, pDevDesc))
						{
                            /*d[k] = int(chFirstDriveFromMask(temp)) ;*/
							if(pDevDesc->BusType == BusTypeUsb)
							{
								d[k] = int(chFirstDriveFromMask(temp)) ;
								k++;
							}
                        
						}
           
						delete pDevDesc;
						CloseHandle(hDevice);
					}
					break;
			}
		}
	}
        return 1;
}