How to link hard drive numbers and drive letters

Example below that uses WMI to handle both the logical -> physical as well as the physical ->  logical mapping (the second being the more difficult). This was done using D5, so let me know if you run into problems if using a later version of the compiler.

Sample usage, then supporting code.

Russell

---

var  dwDrive:       Integer;
     dwIndex:       Integer;
     szDrives:      String;
begin

  // Get the physical disk that the logical drive C is located on
  if (WMIGetDriveNumber('c', dwDrive) = S_OK) then
  begin
     // Show the drive
     ShowMessage(Format('Drive C: is located on physical disk %d', [dwDrive]));
     // Now get all logical drives on disk
     if (WMIGetLogicalDrives(dwDrive, szDrives) = S_OK) then
     begin
        // Walk the drive letters that were found
        for dwIndex:=1 to Length(szDrives) do
        begin
           // Display
           ShowMessage(Format('Found drive %s: on physical disk %d', [szDrives[dwIndex], dwDrive]));
        end;
     end;
  end;

end;

---

unit WmiDisk;
////////////////////////////////////////////////////////////////////////////////
//
//   Unit        :  WmiDisk
//   Author      :  rllibby
//   Date        :  02.17.2009
//   Description :  Disk handling functions through WMI
//
////////////////////////////////////////////////////////////////////////////////
interface

////////////////////////////////////////////////////////////////////////////////
//   Compiler defines
////////////////////////////////////////////////////////////////////////////////

{$IFDEF VER80}
  {$DEFINE DELPHI_V1}
{$ELSE}
  {$IFDEF VER90}
     {$DEFINE DELPHI_V2}
  {$ELSE}
     {$IFDEF VER100}
        {$DEFINE DELPHI_V3}
     {$ELSE}
        {$IFDEF VER120}
           {$DEFINE DELPHI_V4}
        {$ELSE}
           {$IFDEF VER130}
              {$DEFINE DELPHI_V5}
           {$ELSE}
              {$DEFINE DELPHI_V6_UP}
           {$ENDIF}
        {$ENDIF}
     {$ENDIF}
  {$ENDIF}
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////
//   Include units
////////////////////////////////////////////////////////////////////////////////
uses
  Windows, SysUtils, Classes, ComObj, ActiveX {$IFDEF DELPHI_V6_UP}, Variants {$ENDIF};

////////////////////////////////////////////////////////////////////////////////
//   Interface types
////////////////////////////////////////////////////////////////////////////////
type
  IEnumerator       =  interface
     function       ForEach(out Obj: OleVariant): Boolean;
     function       ForEachObject(const IID: TGUID; out Obj): Boolean;
     function       Reset: Boolean;
     function       Skip(Count: LongWord): Boolean;
     function       Clone: IEnumerator;
  end;

////////////////////////////////////////////////////////////////////////////////
//   IEnumVariant wrapper
////////////////////////////////////////////////////////////////////////////////
type
  TEnumerator       =  class(TInterfacedObject, IEnumerator)
  private
     // Private declarations
     FEnumVariant:  IEnumVariant;
     procedure      GetEnumVariant(Dispatch: IDispatch);
  protected
     // Protected declarations
     function       ForEach(out Obj: OleVariant): Boolean;
     function       ForEachObject(const IID: TGUID; out Obj): Boolean;
     function       Reset: Boolean;
     function       Skip(Count: LongWord): Boolean;
     function       Clone: IEnumerator;
  public
     // Public declarations
     constructor    Create(Dispatch: IDispatch);
     constructor    CreateWrapper(EnumVariant: IEnumVariant);
     destructor     Destroy; override;
  end;

////////////////////////////////////////////////////////////////////////////////
//   Constants
////////////////////////////////////////////////////////////////////////////////
const
  WMI_SERVICE       =  'winmgmts:{impersonationLevel=Impersonate}!//.';
  WMI_QRY_DRIVES    =  'SELECT DeviceID, Index FROM Win32_DiskDrive';
  WMI_QRY_DISKPARTS =  'ASSOCIATORS OF {Win32_DiskDrive.DeviceID=''%s''} WHERE AssocClass = Win32_DiskDriveToDiskPartition';
  WMI_QRY_DISKS     =  'ASSOCIATORS OF {Win32_DiskPartition.DeviceID=''%s''} WHERE AssocClass = Win32_LogicalDiskToPartition';

////////////////////////////////////////////////////////////////////////////////
//   Utility routines
////////////////////////////////////////////////////////////////////////////////
function   GetEnumerator(Dispatch: IDispatch): IEnumerator;
function   GetObject(ObjectName: String; out Obj: OleVariant): HResult;
function   SetCheckSucceed(Value: HResult; var Return: HResult): Boolean;

////////////////////////////////////////////////////////////////////////////////
//   WMI handling routines
////////////////////////////////////////////////////////////////////////////////
function   WMIGetDriveNumber(const DriveLetter: AnsiChar; out DriveNumber: Integer): HResult;
function   WMIGetLogicalDrives(const DriveNumber: Integer; out DriveLetters: String): HResult;

implementation

//// WMI handling routines /////////////////////////////////////////////////////
function WMIGetLogicalDrives(const DriveNumber: Integer; out DriveLetters: String): HResult;
var  enumDrives:    IEnumerator;
     enumDiskParts: IEnumerator;
     enumDisks:     IEnumerator;
     ovService:     OleVariant;
     ovDrive:       OleVariant;
     ovDiskPart:    OleVariant;
     ovDisk:        OleVariant;
     dwDrives:      Integer;
     szDisk:        String;
begin

  // Set count of drives found
  dwDrives:=0;

  // Resource protection
  try
     // Set worst case buffer for drive letters
     SetLength(DriveLetters, 26);
     // Get service
     if SetCheckSucceed(GetObject(WMI_SERVICE, ovService), result) then
     begin
        // Set default result
        result:=S_FALSE;
        // Resource protection
        try
           // Get physical disk drives
           enumDrives:=GetEnumerator(ovService.ExecQuery(WMI_QRY_DRIVES));
           // Resource protection
           try
              // Enumerate the drives
              while (result = S_FALSE) and enumDrives.ForEach(ovDrive) do
              begin
                 // Resource protection
                 try
                    // Check drive index against specified drive number
                    if (ovDrive.Index = DriveNumber) then
                    begin
                       // Query for the disk partitions
                       enumDiskParts:=GetEnumerator(ovService.ExecQuery(Format(WMI_QRY_DISKPARTS, [ovDrive.DeviceID])));
                       // Resource protection
                       try
                          // Enumerate the disk partitions
                          while enumDiskParts.ForEach(ovDiskPart) do
                          begin
                             // Resource protection
                             try
                                // Query for the logical disks
                                enumDisks:=GetEnumerator(ovService.ExecQuery(Format(WMI_QRY_DISKS, [ovDiskPart.DeviceID])));
                                // Resource protection
                                try
                                   // Enumerate the logical disks
                                   while enumDisks.ForEach(ovDisk) do
                                   begin
                                      // Update count of drives found
                                      Inc(dwDrives);
                                      // Resource protection
                                      try
                                         // Get the disk id
                                         szDisk:=ovDisk.DeviceID;
                                         // Add to result buffer
                                         DriveLetters[dwDrives]:=UpCase(szDisk[1]);
                                      finally
                                         // Release interface
                                         ovDisk:=Unassigned;
                                      end;
                                   end;
                                finally
                                   // Release interface
                                   enumDisks:=nil;
                                end;
                             finally
                                // Release interface
                                ovDiskPart:=Unassigned;
                             end;
                          end;
                       finally
                          // Release the interface
                          enumDisks:=nil;
                       end;
                       // Done processing
                       result:=S_OK;
                    end;
                 finally
                    // Release interface
                    ovDrive:=Unassigned;
                 end;
              end;
           finally
              // Release interface
              enumDrives:=nil;
           end;
        finally
           // Release interface
           ovService:=Unassigned;
        end;
     end;
  finally
     // Reset buffer with actual size
     SetLength(DriveLetters, dwDrives);
  end;

end;

function WMIGetDriveNumber(const DriveLetter: AnsiChar; out DriveNumber: Integer): HResult;
var  enumDrives:    IEnumerator;
     enumDiskParts: IEnumerator;
     enumDisks:     IEnumerator;
     ovService:     OleVariant;
     ovDrive:       OleVariant;
     ovDiskPart:    OleVariant;
     ovDisk:        OleVariant;
     szDisk:        String;
begin

  // Get service
  if SetCheckSucceed(GetObject(WMI_SERVICE, ovService), result) then
  begin
     // Set default result
     result:=S_FALSE;
     // Resource protection
     try
        // Get physical disk drives
        enumDrives:=GetEnumerator(ovService.ExecQuery(WMI_QRY_DRIVES));
        // Resource protection
        try
           // Enumerate the drives
           while (result = S_FALSE) and enumDrives.ForEach(ovDrive) do
           begin
              // Resource protection
              try
                 // Query for the disk partitions
                 enumDiskParts:=GetEnumerator(ovService.ExecQuery(Format(WMI_QRY_DISKPARTS, [ovDrive.DeviceID])));
                 // Resource protection
                 try
                    // Enumerate the disk partitions
                    while (result = S_FALSE) and enumDiskParts.ForEach(ovDiskPart) do
                    begin
                       // Resource protection
                       try
                          // Query for the logical disks
                          enumDisks:=GetEnumerator(ovService.ExecQuery(Format(WMI_QRY_DISKS, [ovDiskPart.DeviceID])));
                          // Resource protection
                          try
                             // Enumerate the logical disks
                             while (result = S_FALSE) and enumDisks.ForEach(ovDisk) do
                             begin
                                // Resource protection
                                try
                                   // Get the disk id
                                   szDisk:=ovDisk.DeviceID;
                                   // Check against the specififed drive letter
                                   if (Length(szDisk) > 0) and (UpCase(DriveLetter) = UpCase(szDisk[1])) then
                                   begin
                                      // Found the correct disk
                                      DriveNumber:=ovDrive.Index;
                                      // Set result
                                      result:=S_OK;
                                   end;
                                finally
                                   // Release interface
                                   ovDisk:=Unassigned;
                                end;
                             end;
                          finally
                             // Release interface
                             enumDisks:=nil;
                          end;
                       finally
                          // Release interface
                          ovDiskPart:=Unassigned;
                       end;
                    end;
                 finally
                    // Release the interface
                    enumDisks:=nil;
                 end;
              finally
                 // Release interface
                 ovDrive:=Unassigned;
              end;
           end;
        finally
           // Release interface
           enumDrives:=nil;
        end;
     finally
        // Release interface
        ovService:=Unassigned;
     end;
  end;

end;

//// TEnumerator ///////////////////////////////////////////////////////////////
procedure TEnumerator.GetEnumVariant(Dispatch: IDispatch);
var  pdParams:      TDispParams;
     ovEnum:        OleVariant;
begin

  // Check interface
  if Assigned(Dispatch) then
  begin
     // Clear disp params
     FillChar(pdParams, SizeOf(TDispParams), 0);
     // Get enumerator
     OleCheck(Dispatch.Invoke(DISPID_NEWENUM, GUID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET or DISPATCH_METHOD, pdParams, @ovEnum, nil, nil));
     // Resource protection
     try
        // Check returned interface
        if (TVariantArg(ovEnum).vt = VT_UNKNOWN) then
           // Query interface for the IEnumVariant
           OleCheck(IUnknown(ovEnum).QueryInterface(IEnumVariant, FEnumVariant))
        else
           // Throw error
           OleError(E_NOINTERFACE);
     finally
        // Clear interface
        ovEnum:=Unassigned;
     end;
  end
  else
     // Throw error
     OleError(E_NOINTERFACE);

end;

function TEnumerator.ForEach(out Obj: OleVariant): Boolean;
var  dwFetch:       Cardinal;
begin

  // Get the next item
  result:=(FEnumVariant.Next(1, Obj, dwFetch) = S_OK) and (dwFetch = 1);

end;

function TEnumerator.ForEachObject(const IID: TGUID; out Obj): Boolean;
var  ovItem:        OleVariant;
begin

  // Get next item as OleVariant
  if ForEach(ovItem) then
  begin
     // Resource protection
     try
        // Check interface for IUknown
        if (TVariantArg(ovItem).vt = VT_UNKNOWN) then
           // Query interface for the desired interface
           result:=(IUnknown(ovItem).QueryInterface(IID, Obj) = S_OK)
        // Check interface for IDispatch
        else if (TVariantArg(ovItem).vt = VT_DISPATCH) then
           // Query interface for the desired interface
           result:=(IDispatch(ovItem).QueryInterface(IID, Obj) = S_OK)
        else
        begin
           // Pacify the compiler
           result:=False;
           // Throw error
           OleError(E_NOINTERFACE);
        end;
     finally
        // Clear obtained item
        ovItem:=Unassigned;
     end;
  end
  else
     // Failed to get item
     result:=False;

end;

function TEnumerator.Reset: Boolean;
begin

  // Reset enumerator
  result:=(FEnumVariant.Reset = S_OK);

end;

function TEnumerator.Skip(Count: LongWord): Boolean;
begin

  // Skip items in enumerator
  result:=(FEnumVariant.Skip(Count) = S_OK);

end;

function TEnumerator.Clone: IEnumerator;
var  pvEnum:        IEnumVariant;
begin

  // Clone
  if (FEnumVariant.Clone(pvEnum) = S_OK) then
  begin
     // Resource protection
     try
        // Return wrapper
        result:=TEnumerator.CreateWrapper(pvEnum);
     finally
        // Release interface
        pvEnum:=nil;
     end
  end
  else
     // Return nil
     result:=nil;

end;

constructor TEnumerator.CreateWrapper(EnumVariant: IEnumVariant);
begin

  // Perform inherited
  inherited Create;

  // Check interface pointer
  if Assigned(EnumVariant) then
     // Bind to the passed interface
     FEnumVariant:=EnumVariant
  else
     // Throw error
     OleError(E_NOINTERFACE);

end;

constructor TEnumerator.Create(Dispatch: IDispatch);
begin

  // Perform inherited
  inherited Create;

  // Get enumerator interface
  GetEnumVariant(Dispatch);

end;

destructor TEnumerator.Destroy;
begin

  // Resource protection
  try
     // Release the interface
     FEnumVariant:=nil;
  finally
     // Perform inherited
     inherited Destroy;
  end;

end;

//// Utility routines //////////////////////////////////////////////////////////
function GetEnumerator(Dispatch: IDispatch): IEnumerator;
begin

  // Create class and return interface
  result:=TEnumerator.Create(Dispatch);

end;

function GetObject(ObjectName: String; out Obj: OleVariant): HResult;
var  lpwszMoniker:  PWideChar;
     pvUnknown:     IUnknown;
     pvMoniker:     IMoniker;
     pvContext:     IBindCtx;
     cbEaten:       LongInt;
     clsid:         TGUID;
begin

  // Clear outbound param
  Obj:=Unassigned;

  // Check object name
  if SetCheckSucceed(CLSIDFromProgID(PWideChar(WideString(ObjectName)), clsid), result) then
  begin
     // Check running object table
     if SetCheckSucceed(GetActiveObject(clsid, nil, pvUnknown), result) then
     begin
        // Resource protection
        try
           // QI for IDispatch
           if SetCheckSucceed(pvUnknown.QueryInterface(IDispatch, TVariantArg(Obj).dispVal), result) then
           begin
              // Set the vt type
              TVariantArg(Obj).vt:=VT_DISPATCH;
           end;
        finally
           // Clear interface
           pvUnknown:=nil;
        end;
     end;
  end
  // Try to access the object using a moniker
  else if SetCheckSucceed(CreateBindCtx(0, pvContext), result) then
  begin
     // Resousce protection
     try
        // Allocate bstr for moniker
        lpwszMoniker:=StringToOleStr(ObjectName);
        // Resource protection
        try
           // Parse the display name
           if SetCheckSucceed(MkParseDisplayName(pvContext, lpwszMoniker, cbEaten, pvMoniker), result) then
           begin
              // Resource protection
              try
                 // Attempt to bind the moniker
                 if SetCheckSucceed(BindMoniker(pvMoniker, 0, IUnknown, pvUnknown), result) then
                 begin
                    // Resource protection
                    try
                       // QI for IDispatch
                       if SetCheckSucceed(pvUnknown.QueryInterface(IDispatch, TVariantArg(Obj).dispVal), result) then
                       begin
                          // Set the vt type
                          TVariantArg(Obj).vt:=VT_DISPATCH;
                       end;
                    finally
                       // Clear interface
                       pvUnknown:=nil;
                    end;
                 end;
              finally
                 // Release interface
                 pvMoniker:=nil;
              end;
           end;
        finally
           // Free string memory
           SysFreeString(lpwszMoniker);
        end;
     finally
        // Release interface
        pvContext:=nil;
     end;
  end;

end;

function SetCheckSucceed(Value: HResult; var Return: HResult): Boolean;
begin

  // Resource protection
  try
     // Perform return set
     Return:=Value;
  finally
     // Check for success
     result:=(Value = S_OK);
  end;

end;

end.

To get the physical count:

function WMIGetPhysicalDriveCount(out Count: Integer): HResult;
var  ovService:     OleVariant;
     ovDrives:      OleVariant;
     ovDrive:       OleVariant;
begin

  // Set count of drives found
  Count:=0;

  // Get service
  if SetCheckSucceed(GetObject(WMI_SERVICE, ovService), result) then
  begin
     // Resource protection
     try
        // Get physical disk drives
        ovDrives:=ovService.ExecQuery(WMI_QRY_DRIVES);
        // Resource protection
        try
           // Return the count
           result:=ovDrives.Count;
        finally
           // Release interface
           ovDrives:=Unassigned;
        end;
     finally
        // Release interface
        ovService:=Unassigned;
     end;
  end;

end;

Note, the WMI routines I gave you won't return CD/DVD/Zip/Network drives. Only those that have a device ID of '\\.\PHYSICALDRIVEX' will be listed. (Usb drives do show up). And yeah, the WMI routines are a little slower, but they do operate correctly.

Point split is fine.

Russell