Launching an APP from volume ID

Question

I'm trying to launch an .exe file in windows using and a volume ID. The volume do not have a letter. Here is what I've tryed.

ShellExecute

When I call ShellExecute with the volume ID, Windows' explorer open the correct directory. Same thing if I try to open a folder inside the volume. However, if I try to open an exe file, nothing happen.

This is the way I call ShellExecute, which is part of windows.h :

char path[MAX_PATH] = R"(\\?\Volume{0dc7f9cc-d3ea-11e4-824b-806e6f6e6963}\App.exe)";    
LONG_PTR returnValue = (LONG_PTR) ShellExecute(GetDesktopWindow(),NULL, path,NULL,NULL,SW_SHOW);

The error code returned is 2 :

The system cannot find the file specified.

CreateProcessW

After following the comments, I am now using . My new code look like this :

char path[MAX_PATH] = R"(\\?\Volume{0dc7f9cc-d3ea-11e4-824b-806e6f6e6963}\launcher.exe)";

STARTUPINFO info = {sizeof(info)};
PROCESS_INFORMATION processInfo;
if (CreateProcessW(path, NULL, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &info, &processInfo))
{
    WaitForSingleObject(processInfo.hProcess, INFINITE);
    CloseHandle(processInfo.hProcess);
    CloseHandle(processInfo.hThread);
}
else {
    DWORD dw = GetLastError();
    printf("ERROR CODE: %d", dw);
}

But it still doesn't work. Error is the same (2).

Changing the path notation

From "\\?\Volume{ID}" to "\\.\Volume{ID}". The strange thing is that I can list the drive's files or start a console process but I cannot launch any GUI EXE files. Error code remains 2.

Is the anythink I am missing here ? Any help are welcome. Thank you.

---

Answer

I've got confuse with the comments, using "\\.\Volume{ID}\myApp.exe" worked well if used with CreateProcess, not CreateProcessW.

There is the fully functional code (Don't forget to include windows.h).

char path[MAX_PATH] = R"(\\.\Volume{0dc7f9cc-d3ea-11e4-824b-806e6f6e6963}\App.exe)";

STARTUPINFO info = {sizeof(info)};
PROCESS_INFORMATION processInfo;
if (CreateProcess(path, NULL, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &info, &processInfo))
{
    CloseHandle(processInfo.hProcess);
    CloseHandle(processInfo.hThread);
}
else 
{
    DWORD dw = GetLastError();
    printf("ERROR CODE WHILE STARTING: %d", dw);
}

Answer 1

problem in win32 subsystem - it not use native for windows NT Paths, but Win32 Paths which first must be converted to NT Paths before passing to kernel.

also some functions, like ShellExecuteEx or CreateProcessW accept not any valid win32 path, but only restricted subset - so called Drive Letter form. if pass path in form \\?\Volume{guid}\* - ShellExecuteEx and CreateProcessW always fail with this path (so called volume path) even if path correct (CreateFileW open this path). funny that CreateProcessW will be work with path \\.\Volume{guid}\* (if replace ? to . at [2] position) but ShellExecuteEx not worked with this path too.

only one reliable solution here - convert this volume form path to Drive Letter form. this can be done with help IOCTL_MOUNTMGR_QUERY_POINTS - need get list of all MOUNTMGR_MOUNT_POINT in system and do 2 loops by this list - first found device name by existing volume symlink. then in loop #2 - by already known device name found - dos-device name and got it drive letter

#include <mountmgr.h>

ULONG NtVolumePathToDosPath(PUNICODE_STRING VolumePath)
{
    if (!MOUNTMGR_IS_NT_VOLUME_NAME(VolumePath))
    {
        return ERROR_PATH_NOT_FOUND;
    }

    static volatile UCHAR guz;
    PVOID stack = alloca(guz);
    ULONG cb = 0, rcb = 0x400;

    union {
        PVOID buf;
        PMOUNTMGR_MOUNT_POINTS pmmp;
    };

    HANDLE hFile = CreateFile(MOUNTMGR_DOS_DEVICE_NAME, FILE_GENERIC_READ, FILE_SHARE_VALID_FLAGS, 0, OPEN_EXISTING, 0, 0);

    if (hFile == INVALID_HANDLE_VALUE)
    {
        return GetLastError();
    }

    static MOUNTMGR_MOUNT_POINT mmp;

    ULONG dwError = NOERROR;
    do 
    {
        if (cb < rcb) cb = RtlPointerToOffset(buf = alloca(rcb - cb), stack);

        if (!DeviceIoControl(hFile, IOCTL_MOUNTMGR_QUERY_POINTS, &mmp, sizeof(mmp), buf, cb, &rcb, 0))
        {
            dwError = GetLastError();
            rcb = pmmp->Size;
            continue;
        }

        dwError = ERROR_PATH_NOT_FOUND;

        if (ULONG NumberOfMountPoints = pmmp->NumberOfMountPoints)
        {
            PMOUNTMGR_MOUNT_POINT MountPoints = pmmp->MountPoints;

            //loop #1: search for DeviceName linked to VolumePath
            do 
            {
                UNICODE_STRING SymbolicLinkName = {
                    MountPoints->SymbolicLinkNameLength,
                    SymbolicLinkName.Length,
                    (PWSTR)RtlOffsetToPointer(pmmp, MountPoints->SymbolicLinkNameOffset)
                };

                if (MOUNTMGR_IS_VOLUME_NAME(&SymbolicLinkName))
                {
                    if (RtlEqualUnicodeString(&SymbolicLinkName, VolumePath, TRUE))
                    {
                        // found DeviceName
                        UNICODE_STRING _DeviceName = {
                            MountPoints->DeviceNameLength,
                            _DeviceName.Length,
                            (PWSTR)RtlOffsetToPointer(pmmp, MountPoints->DeviceNameOffset)
                        };

                        NumberOfMountPoints = pmmp->NumberOfMountPoints;
                        MountPoints = pmmp->MountPoints;

                        // loop #2: search for "drive letter" linked to DeviceName
                        do 
                        {
                            UNICODE_STRING DeviceName = {
                                MountPoints->DeviceNameLength,
                                DeviceName.Length,
                                (PWSTR)RtlOffsetToPointer(pmmp, MountPoints->DeviceNameOffset)
                            };

                            if (RtlEqualUnicodeString(&_DeviceName, &DeviceName, FALSE))
                            {
                                SymbolicLinkName.MaximumLength = SymbolicLinkName.Length = MountPoints->SymbolicLinkNameLength;
                                SymbolicLinkName.Buffer = (PWSTR)RtlOffsetToPointer(pmmp, MountPoints->SymbolicLinkNameOffset);

                                if (MOUNTMGR_IS_DRIVE_LETTER(&SymbolicLinkName))
                                {
                                    PWSTR szVolumePath = VolumePath->Buffer + 48;
                                    *--szVolumePath = ':';
                                    *--szVolumePath = SymbolicLinkName.Buffer[12];
                                    *--szVolumePath = '\\';
                                    *--szVolumePath = '?';
                                    *--szVolumePath = '\\';
                                    *--szVolumePath = '\\';
                                    VolumePath->Buffer = szVolumePath;
                                    dwError = NOERROR;
                                    break;
                                }
                            }

                        } while (MountPoints++, --NumberOfMountPoints);

                        break;
                    }
                }

            } while (MountPoints++, --NumberOfMountPoints);
        }
        break;

    } while (dwError == ERROR_MORE_DATA);

    CloseHandle(hFile);

    return dwError;
}

ULONG TestExecByVolumePath(PCWSTR szVolumePath)
{
    size_t size = wcslen(szVolumePath) * sizeof(WCHAR);

    if (size >= MAXUSHORT || size < 98)
    {
        return ERROR_PATH_NOT_FOUND;
    }

    UNICODE_STRING VolumePath;

    VolumePath.Length = 96;
    VolumePath.MaximumLength = (USHORT)size + sizeof(WCHAR);
    memcpy(VolumePath.Buffer = (PWSTR)alloca(VolumePath.MaximumLength), szVolumePath, VolumePath.MaximumLength);

    if (!MOUNTMGR_IS_DOS_VOLUME_NAME(&VolumePath))
    {
        return ERROR_PATH_NOT_FOUND;
    }

    VolumePath.Buffer[1] = '?';

    ULONG dwErr = NtVolumePathToDosPath(&VolumePath);

    if (dwErr == NOERROR)
    {
        SHELLEXECUTEINFOW sei = {sizeof(sei), 0, 0, L"open", VolumePath.Buffer, 0, 0, SW_SHOWDEFAULT };
        if (!ShellExecuteExW(&sei))
        {
            dwErr = GetLastError();
        }
    }

    return dwErr;
}

    TestExecByVolumePath(L"\\\\?\\Volume{***}\\Windows\\System32\\notepad.exe");