struct tagDrives

{

  WCHAR letter;

  WCHAR volume[ BUFFER_SIZE ];

} g_drives[  ];

//

WCHAR GetUSBDrive( )

{

  LPTSTR lpDevID;

  WCHAR cDrive;

  DWORD dwSize = BUFFER_SIZE;

  // Get all removable disks on user laptop.

  if ( !GetAllRemovableDisks( ) )

  {

    WRITELOG( "Error - GetAllRemovableDisks failed\n" );

    return ;

  }

  // Alocate memory to device ID

  lpDevID = (LPTSTR) AllocMem( BUFFER_SIZE );

  // Get device ID corresponding to USBFM from registry.

  if ( !GetRegValue( lpDevID, DEVICE_ID, dwSize ) )

  {

    WRITELOG( "Error - Registry - USBFMDevID failed\n" );

    FreeMem( lpDevID );

    return ;

  }

  // Get drive corresponding to the registry entry.

  cDrive = GetSpecificDrive( lpDevID );

  FreeMem( lpDevID );

  // return the drive letter.

  return cDrive;

}

/******************************************************************************

 * GetAllRemovableDisks - This function retrieves volume information for all

 removable disks

 *

 * In:        None

 *

 * Out:  TRUE        - Success

 *                FALSE        - Failure

 *

 *******************************************************************************/

BOOL GetAllRemovableDisks( )

{

  WCHAR caDrive[  ];

  WCHAR volume[ BUFFER_SIZE ];

  int nLoopIndex;

  DWORD dwDriveMask;

  caDrive[  ] = 'A';

  caDrive[  ] = ':';

  caDrive[  ] = '\\';

  caDrive[  ] = ;

  g_count = ;

  // Get all drives in the system.

  dwDriveMask = GetLogicalDrives( );

  if ( dwDriveMask ==  )

  {

    WRITELOG( "Error - GetLogicalDrives failed\n" );

    return FALSE;

  }

  // Loop for all drives (MAX_DRIVES = 26)

  for ( nLoopIndex = ; nLoopIndex < MAX_DRIVES; nLoopIndex++ )

  {

    // if a drive is present,

    if ( dwDriveMask &  )

    {

      caDrive[  ] = 'A' + nLoopIndex;

      // If a drive is removable

      if ( GetDriveType( caDrive ) == DRIVE_REMOVABLE )

      {

        //Get its volume info and store it in the global variable.

        if ( GetVolumeNameForVolumeMountPoint( caDrive, volume, BUFFER_SIZE ) )

        {

          g_drives[ g_count ].letter = caDrive[  ];

          wcscpy( g_drives[ g_count ].volume, volume );

          g_count++;

        }

      }

    }

    dwDriveMask >>= ;

  }

  // success if atleast one removable drive is found.

  if ( g_count ==  )

  {

    return FALSE;

  }

  else

  {

    return TRUE;

  }

}

/******************************************************************************

 * GetSpecificDrive - This function returns the drive corresponding to the

 given device ID

 *

 * In        :        lpDevID        - Device ID

 *

 * Return:        Drive letter corresponding to the given device ID.

 *

 *******************************************************************************/

WCHAR GetSpecificDrive( LPTSTR lpDevID )

{

  HDEVINFO hDevInfo;

  GUID guid;

  BYTE buffer[ BUFFER_SIZE ];

  DWORD dwRequiredSize;

  WCHAR buf[ BUFFER_SIZE ];

  DEVINST devInstParent;

  DWORD dwIndex;

  WCHAR volume[ BUFFER_SIZE ];

  int nLength, nLoopIndex;

  SP_DEVICE_INTERFACE_DATA devInterfaceData;

  SP_DEVINFO_DATA devInfoData;

  PSP_DEVICE_INTERFACE_DETAIL_DATA pDevDetail;

  if ( !lpDevID )

  {

    return ;

  }

  // GUID_DEVINTERFACE_VOLUME is interface Guid for Volume class devices.

  guid = GUID_DEVINTERFACE_VOLUME;

  // Get device Information handle for Volume interface

  hDevInfo = SetupDiGetClassDevs( &guid, NULL, NULL,

    DIGCF_DEVICEINTERFACE | DIGCF_PRESENT );

  if ( hDevInfo == INVALID_HANDLE_VALUE )

  {

    WRITELOG( "Error - SetupDiGetClassDevs failed\n" );

    return ;

  }

  // Loop until device interfaces are found.

  for ( dwIndex = ;; dwIndex++ )

  {

    ZeroMemory( &devInterfaceData, sizeof( devInterfaceData ) );

    devInterfaceData.cbSize = sizeof( devInterfaceData );

    // Get device Interface data.

    if ( !SetupDiEnumDeviceInterfaces( hDevInfo, NULL, &guid, dwIndex,

      &devInterfaceData ) )

    {

      break;

    }

    ZeroMemory( &devInfoData, sizeof( devInfoData ) );

    devInfoData.cbSize = sizeof( devInfoData );

    pDevDetail = (PSP_DEVICE_INTERFACE_DETAIL_DATA) buffer;

    pDevDetail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

    // Get device interface detail data to get

    //        Device Instance from SP_DEVINFO_DATA and

    //  Device Path from SP_DEVICE_INTERFACE_DETAIL_DATA

    SetupDiGetDeviceInterfaceDetail( hDevInfo, &devInterfaceData, pDevDetail, // SP_DEVICE_INTERFACE_DETAIL_DATA

      BUFFER_SIZE, &dwRequiredSize, &devInfoData );           // SP_DEVINFO_DATA

    // Get the device instance of parent. This points to USBSTOR.

    CM_Get_Parent( &devInstParent, devInfoData.DevInst,  );

    // Get the device instance of grand parent. This points to USB root.

    CM_Get_Parent( &devInstParent, devInstParent,  );

    // Get the device ID of the USB root.

    CM_Get_Device_ID( devInstParent, buf, BUFFER_SIZE,  );

    // If USB root device matches with the input device ID, it is the target  device.

    if ( buf != NULL && wcscmp( lpDevID, buf ) ==  )

    {

      // Append \ to the DevicePath of SP_DEVICE_INTERFACE_DETAIL_DATA

      nLength = wcslen( pDevDetail->DevicePath );

      pDevDetail->DevicePath[ nLength ] = '\\';

      pDevDetail->DevicePath[ nLength +  ] = ;

      // Get Volume mount point for the device path.

      if ( GetVolumeNameForVolumeMountPoint( pDevDetail->DevicePath, volume,

        BUFFER_SIZE ) )

      {

        for ( nLoopIndex = ; nLoopIndex < g_count; nLoopIndex++ )

        {

          // Compare volume mount point with the one stored earlier.

          // If both match, return the corresponding drive letter.

          if ( wcscmp( g_drives[ nLoopIndex ].volume, volume ) ==  )

          {

            SetupDiDestroyDeviceInfoList( hDevInfo );

            return g_drives[ nLoopIndex ].letter;

          }

        }

      }

    }

  }

  SetupDiDestroyDeviceInfoList( hDevInfo );

  WRITELOG( "Error - No drives found in GetSpecificDrives\n" );

  return ;

}

char szDriveLetter[  ];

char * pszDrive;

STORAGE_DEVICE_NUMBER sdnDevNumber;

BOOL fResult;

fResult = GetBasicDiskDriveMapping( szDriveLetter, &sdnDevNumber );

// sdnDevNumber.DeviceNumber will contain the drive number you want

// sdnDevNumber.PartitionNumber will contain the partition for your reference 

BOOL GetBasicDiskDriveMapping( LPCSTR pszDrive, STORAGE_DEVICE_NUMBER *psdn )

{

  BOOL fResult;

  char szDriveName[  ];

  HANDLE hDrive;

  DWORD dwBytesReturned;

  __try

  {

    lstrcpy( szDriveName, "\\\\.\\" );

    lstrcat( szDriveName, pszDrive );

    // Open the volume to which the drive letter refers and get

    // the physical drive on which the volume resides. 

    hDrive = CreateFile( szDriveName, GENERIC_READ,

    FILE_SHARE_READ | FILE_SHARE_WRITE, ,

    OPEN_EXISTING, ,  );

    if ( INVALID_HANDLE_VALUE != hDrive )

      fResult = DeviceIoControl( hDrive,

      IOCTL_STORAGE_GET_DEVICE_NUMBER, , ,

      psdn, sizeof(STORAGE_DEVICE_NUMBER),

      &dwBytesReturned,  );

    else

      fResult = false;

  }

  __except( EXCEPTION_EXECUTE_HANDLER )

  {

    // if we get here, one of the arguments probably

    // points to not enough memory. 

    SetLastError( ERROR_INVALID_PARAMETER );

    fResult = false;

  }

  CloseHandle( hDrive );

  return ( fResult );

}

switch ( GetDriveType( szDrvName ) )

{

  case : // The drive type cannot be determined.

  case :// The root directory does not exist.

  drivetype = DRVUNKNOWN;

  break;

  case DRIVE_REMOVABLE:// The drive can be removed from the drive.

  drivetype = DRVREMOVE;

  break;

  case DRIVE_CDROM:// The drive is a CD-ROM drive.

  break;

  case DRIVE_FIXED:// The disk cannot be removed from the drive.

  drivetype = DRVFIXED;

  break;

  case DRIVE_REMOTE:// The drive is a remote (network) drive.

  drivetype = DRVREMOTE;

  break;

  case DRIVE_RAMDISK:// The drive is a RAM disk.

  drivetype = DRVRAM;

  break;

}

hDevice = CreateFile(szBuf,

  GENERIC_READ,

  FILE_SHARE_READ | FILE_SHARE_WRITE,

  NULL, OPEN_EXISTING, NULL, NULL);

if(GetDisksProperty(hDevice, pDevDesc))

{

 if(pDevDesc->BusType == BusTypeUsb) // This is the ‘Check Point’!!! ;-)

 {

  // We store the drive letter here

  szMoveDiskName[k] = chFirstDriveFromMask(temp);

  szMoveDiskName[]=k;

  k++;

 }

}

CloseHandle(hDevice);

/********************************************************

*

* FUNCTION: GetDisksProperty(HANDLE hDevice,

* PSTORAGE_DEVICE_DESCRIPTOR pDevDesc)

*

* PURPOSE: get the info of specified device

*

******************************************************/

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, // device handle

 IOCTL_STORAGE_QUERY_PROPERTY, // info of device property

  &Query, sizeof(STORAGE_PROPERTY_QUERY), // input data buffer

  pDevDesc, pDevDesc->Size, // output data buffer

  &dwOutBytes, // out's length

  (LPOVERLAPPED)NULL); 

 return bResult;

}

This article, along with any associated source code and files,
is licensed underThe Code Project Open License (CPOL)