Resolve Windows device path to drive letter

Question

How do you resolve an NT style device path, e.g. \Device\CdRom0, to its logical drive letter, e.g. G:\ ?

Edit: A Volume Name isn't the same as a Device Path so unfortunately GetVolumePathNamesForVolumeName() won't work.

score 6 · Accepted Answer · answered Sep 25 '08 at 08:02

Hopefully the following piece of code will give you enough to solve this - after you've initialised it, you just need to iterate through the collection to find your match. You may want to convert everything to upper/lower case before you insert into the collection to help with lookup performance.

typedef basic_string<TCHAR> tstring;
typedef map<tstring, tstring> HardDiskCollection;

void Initialise( HardDiskCollection &_hardDiskCollection )
{
    TCHAR tszLinkName[MAX_PATH] = { 0 };
    TCHAR tszDevName[MAX_PATH] = { 0 };
    TCHAR tcDrive = 0;

    _tcscpy_s( tszLinkName, MAX_PATH, _T("a:") );
    for ( tcDrive = _T('a'); tcDrive < _T('z'); ++tcDrive )
    {
        tszLinkName[0] = tcDrive;
        if ( QueryDosDevice( tszLinkName, tszDevName, MAX_PATH ) )
        {
            _hardDiskCollection.insert( pair<tstring, tstring>( tszLinkName, tszDevName ) );
        }
    }
}

If you need to handle removable drives, you can use GetLogicalDeviceStrings to get the existent devices dynamically. You'll need to truncate the device strings so that the trailing "\" is not passed to QueryDosDevice. — Kevin Condon, Mar 24 '11 at 17:55
This may not work if a device removed after initialize(eg. a usb storage device). — VictorV, Jul 17 '18 at 02:45
Here is a refactored version https://stackoverflow.com/a/59908355/964478 — Alex P., Jan 25 '20 at 10:26

score 1 · Answer 2 · answered Sep 24 '08 at 13:35

1

Maybe you could use GetVolumeNameForMountPoint and iterate through all mount points A:\ through Z:\, breaking when you find a match?

http://msdn.microsoft.com/en-us/library/aa364994(VS.85).aspx

(I haven't tried this)

answered Sep 24 '08 at 13:35

Nick

13,238
17
64
100

score 1 · Answer 3 · answered Jul 06 '16 at 19:14

Following function does the job using C only

BOOL GetWin32FileName(const TCHAR* pszNativeFileName, TCHAR *pszWin32FileName)
{
    BOOL bFound = FALSE;

    // Translate path with device name to drive letters.
    TCHAR szTemp[MAX_PATH];
    szTemp[0] = '\0';

    if (GetLogicalDriveStrings(MAX_PATH - 1, szTemp))
    {
        TCHAR szName[MAX_PATH];
        TCHAR szDrive[3] = TEXT(" :");
        TCHAR* p = szTemp;

        do
        {
            // Copy the drive letter to the template string
            *szDrive = *p;

            // Look up each device name
            if (QueryDosDevice(szDrive, szName, MAX_PATH))
            {
                size_t uNameLen = _tcslen(szName);

                if (uNameLen < MAX_PATH)
                {
                    bFound = _tcsnicmp(pszNativeFileName, szName, uNameLen) == 0
                        && *(pszNativeFileName + uNameLen) == _T('\\');

                    if (bFound)
                    {
                        // Replace device path with DOS path
                        StringCchPrintf(pszWin32FileName,
                            MAX_PATH,
                            TEXT("%s%s"),
                            szDrive,
                            pszNativeFileName + uNameLen);
                    }
                }
            }
            // Go to the next NULL character.
            while (*p++);
        } while (!bFound && *p);
    }

    return(bFound);
}

score 1 · Answer 4 · answered Jul 17 '18 at 02:38

You can lookup all volumes' name to match a device name and get drive letter.Here is a sample:

int DeviceNameToVolumePathName(WCHAR *filepath) {
    WCHAR fileDevName[MAX_PATH];
    WCHAR devName[MAX_PATH];
    WCHAR fileName[MAX_PATH];
    HANDLE FindHandle = INVALID_HANDLE_VALUE;
    WCHAR  VolumeName[MAX_PATH];
    DWORD  Error = ERROR_SUCCESS;
    size_t Index = 0;
    DWORD  CharCount = MAX_PATH + 1;

    int index = 0;
    // \Device\HarddiskVolume1\windows,locate \windows.
    for (int i = 0; i < lstrlenW(filepath); i++) {
        if (!memcmp(&filepath[i], L"\\", 2)) {
            index++;
            if (index == 3) {
                index = i;
                break;
            }
        }
    }
    filepath[index] = L'\0';

    memcpy(fileDevName, filepath, (index + 1) * sizeof(WCHAR));

    FindHandle = FindFirstVolumeW(VolumeName, ARRAYSIZE(VolumeName));

    if (FindHandle == INVALID_HANDLE_VALUE)
    {
        Error = GetLastError();
        wprintf(L"FindFirstVolumeW failed with error code %d\n", Error);
        return FALSE;
    }
    for (;;)
    {
        //  Skip the \\?\ prefix and remove the trailing backslash.
        Index = wcslen(VolumeName) - 1;

        if (VolumeName[0] != L'\\' ||
            VolumeName[1] != L'\\' ||
            VolumeName[2] != L'?' ||
            VolumeName[3] != L'\\' ||
            VolumeName[Index] != L'\\')
        {
            Error = ERROR_BAD_PATHNAME;
            wprintf(L"FindFirstVolumeW/FindNextVolumeW returned a bad path: %s\n", VolumeName);
            break;
        }
        VolumeName[Index] = L'\0';
        CharCount = QueryDosDeviceW(&VolumeName[4], devName, 100);
        if (CharCount == 0)
        {
            Error = GetLastError();
            wprintf(L"QueryDosDeviceW failed with error code %d\n", Error);
            break;
        }
        if (!lstrcmpW(devName, filepath)) {
            VolumeName[Index] = L'\\';
            Error = GetVolumePathNamesForVolumeNameW(VolumeName, fileName, CharCount, &CharCount);
            if (!Error) {
                Error = GetLastError();
                wprintf(L"GetVolumePathNamesForVolumeNameW failed with error code %d\n", Error);
                break;
            }

            // concat drive letter to path
            lstrcatW(fileName, &filepath[index + 1]);
            lstrcpyW(filepath, fileName);

            Error = ERROR_SUCCESS;
            break;
        }

        Error = FindNextVolumeW(FindHandle, VolumeName, ARRAYSIZE(VolumeName));

        if (!Error)
        {
            Error = GetLastError();

            if (Error != ERROR_NO_MORE_FILES)
            {
                wprintf(L"FindNextVolumeW failed with error code %d\n", Error);
                break;
            }

            //
            //  Finished iterating
            //  through all the volumes.
            Error = ERROR_BAD_PATHNAME;
            break;
        }
    }

    FindVolumeClose(FindHandle);
    if (Error != ERROR_SUCCESS)
        return FALSE;
    return TRUE;

}

If you want to resolve it in driver,you can check this link for reference.

Alex P. · Answer 5 · 2020-01-25T10:46:58.623

Here is refactored version of the solution.

I replaced TChAR with wchar_t because afaik it's not a good idea to use it in most projects.

std::map<std::wstring, std::wstring> GetDosPathDevicePathMap()
{
    // It's not really related to MAX_PATH, but I guess it should be enough.
    // Though the docs say "The first null-terminated string stored into the buffer is the current mapping for the device.
    //                      The other null-terminated strings represent undeleted prior mappings for the device."
    wchar_t devicePath[MAX_PATH] = { 0 };
    std::map<std::wstring, std::wstring> result;
    std::wstring dosPath = L"A:";

    for (wchar_t letter = L'A'; letter <= L'Z'; ++letter)
    {
        dosPath[0] = letter;
        if (QueryDosDeviceW(dosPath.c_str(), devicePath, MAX_PATH)) // may want to properly handle errors instead ... e.g. check ERROR_INSUFFICIENT_BUFFER
        {
            result[dosPath] = devicePath;
        }
    }
    return result;
}

Resolve Windows device path to drive letter

5 Answers5

Linked