This post will be code-heavy and the code will be ugly. This code is all sloppy about buffer sizes and string over-runs and such, so DO NOT copy-paste it into production unless you want security holes. (a particular nasty point to be wary of is that many of the APIs differ in whether they take a buffer size in bytes or chars, which with unicode is different)
We're gonna use these helpers to call into windows dlls :
template
<typename t_func_type>
t_func_type GetWindowsImport( t_func_type * pFunc , const char * funcName, const char * libName , bool dothrow)
{
if ( *pFunc == 0 )
{
HMODULE m = GetModuleHandle(libName);
if ( m == 0 ) m = LoadLibrary(libName); // adds extension for you
ASSERT_RELEASE( m != 0 );
t_func_type f = (t_func_type) GetProcAddress( m, funcName );
if ( f == 0 && dothrow )
{
throw funcName;
}
*pFunc = f;
}
return (*pFunc);
}
// GET_IMPORT can return NULL
#define GET_IMPORT(lib,name) (GetWindowsImport(&STRING_JOIN(fp_,name),STRINGIZE(name),lib,false))
// CALL_IMPORT throws if not found
#define CALL_IMPORT(lib,name) (*GetWindowsImport(&STRING_JOIN(fp_,name),STRINGIZE(name),lib,true))
#define CALL_KERNEL32(name) CALL_IMPORT("kernel32",name)
#define CALL_NT(name) CALL_IMPORT("ntdll",name)
I also make use of the cblib strlen, strcpy, etc. on wchars. Their implementation is obvious.
Also, for reference, to open a file handle just to read its attributes (to map its name) you use :
HANDLE f = CreateFile(from,
FILE_READ_ATTRIBUTES |
STANDARD_RIGHTS_READ
,FILE_SHARE_READ,0,OPEN_EXISTING,FILE_FLAG_BACKUP_SEMANTICS,0);
(also works on directories).
Okay now : How to get a final path name from a file handle :
1. On Vista+ , just use GetFinalPathNameByHandle.
GetFinalPathNameByHandle gives you back a "\\?\" prefixed path, or "\\?\UNC\" for network shares.
2. Pre-Vista, lots of people recommend mem-mapping the file and then using GetMappedFileName.
This is a bad suggestion. It doesn't work on directories. It requires that you actually have the file open for read, which is of course impossible in some scenarios. It's just generally a non-robust way to get a file name from a handle.
For the record, here is the code from MSDN to get a file name from handle using GetMappedFileName.
Note that GetMappedFileName gives you back an NT-namespace name, and I have factored out the
bit to convert that to Win32 into MapNtDriveName, which we'll come back to later.
BOOL GetFileNameFromHandleW_Map(HANDLE hFile,wchar_t * pszFilename,int pszFilenameSize)
{
BOOL bSuccess = FALSE;
HANDLE hFileMap;
pszFilename[0] = 0;
// Get the file size.
DWORD dwFileSizeHi = 0;
DWORD dwFileSizeLo = GetFileSize(hFile, &dwFileSizeHi);
if( dwFileSizeLo == 0 && dwFileSizeHi == 0 )
{
lprintf(("Cannot map a file with a length of zero.\n"));
return FALSE;
}
// Create a file mapping object.
hFileMap = CreateFileMapping(hFile,
NULL,
PAGE_READONLY,
0,
1,
NULL);
if (hFileMap)
{
// Create a file mapping to get the file name.
void* pMem = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 1);
if (pMem)
{
if (GetMappedFileNameW(GetCurrentProcess(),
pMem,
pszFilename,
MAX_PATH))
{
//pszFilename is an NT-space name :
//pszFilename = "\Device\HarddiskVolume4\devel\projects\oodle\z.bat"
wchar_t temp[2048];
strcpy(temp,pszFilename);
MapNtDriveName(temp,pszFilename);
}
bSuccess = TRUE;
UnmapViewOfFile(pMem);
}
CloseHandle(hFileMap);
}
else
{
return FALSE;
}
return(bSuccess);
}
3. There's a more direct way to get the name from file handle : NtQueryObject.
NtQueryObject gives you the name of any handle. If it's a file handle, you get the file name. This name is an NT namespace name, so you have to map it down of course.
The core code is :
typedef enum _OBJECT_INFORMATION_CLASS {
ObjectBasicInformation, ObjectNameInformation, ObjectTypeInformation, ObjectAllInformation, ObjectDataInformation
} OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
typedef struct _OBJECT_NAME_INFORMATION {
UNICODE_STRING Name;
WCHAR NameBuffer[1];
} OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION;
NTSTATUS
(NTAPI *
fp_NtQueryObject)(
IN HANDLE ObjectHandle, IN OBJECT_INFORMATION_CLASS ObjectInformationClass, OUT PVOID ObjectInformation, IN ULONG Length, OUT PULONG ResultLength )
= 0;
{
char infobuf[4096];
ULONG ResultLength = 0;
CALL_NT(NtQueryObject)(f,
ObjectNameInformation,
infobuf,
sizeof(infobuf),
&ResultLength);
OBJECT_NAME_INFORMATION * pinfo = (OBJECT_NAME_INFORMATION *) infobuf;
wchar_t * ps = pinfo->NameBuffer;
// info->Name.Length is in BYTES , not wchars
ps[ pinfo->Name.Length / 2 ] = 0;
lprintf("OBJECT_NAME_INFORMATION: (%S)\n",ps);
}
which will give you a name like :
OBJECT_NAME_INFORMATION: (\Device\HarddiskVolume1\devel\projects\oodle\examples\oodle_future.h)
and then you just have to pull off the drive part and call MapNtDriveName (mentioned previously but not
yet detailed).
Note that there's another call that looks appealing :
CALL_NT(NtQueryInformationFile)(f,
&block,
infobuf,
sizeof(infobuf),
FileNameInformation);
but NtQueryInformationFile seems to always give you just the file name without the drive. In fact
it seems possible to use NtQueryInformationFile and NtQueryObject to separate the drive part and path part.
That is, you get something like :
t: is substed to c:\trans
LogDosDrives prints :
T: : \??\C:\trans
we ask about :
fmName : t:\prefs.js
we get :
NtQueryInformationFile: "\trans\prefs.js"
NtQueryObject: "\Device\HarddiskVolume4\trans\prefs.js"
If there was a way to get the drive letter, then you could just use NtQueryInformationFile , but so far as I know there is no simple way, so we have to go through all this mess.
On network shares, it's similar but a little different :
y: is net used to \\charlesbpc\C$
LogDosDrives prints :
Y: : \Device\LanmanRedirector\;Y:0000000000034569\charlesbpc\C$
we ask about :
fmName : y:\xfer\path.txt
we get :
NtQueryInformationFile: "\charlesbpc\C$\xfer\path.txt"
NtQueryObject: "\Device\Mup\charlesbpc\C$\xfer\path.txt"
so in that case you could just prepend a "\" to NtQueryInformationFile , but again I'm not sure how
to know that what you got was a network share and not just a directory, so we'll go through all the
mess here to figure it out.
4. MapNtDriveName is needed to map an NT-namespace drive name to a Win32/DOS-namespace name.
I've found two different ways of doing this, and they seem to produce the same results in all the tests I've run, so it's unclear if one is better than the other.
4.A. MapNtDriveName by QueryDosDevice
QueryDosDevice gives you the NT name of a dos drive. This is the opposite of what we want, so we have to reverse the mapping. The way is to use GetLogicalDriveStrings which gives you all the dos drive letters, then you can look them up to get all the NT names, and thus create the reverse mapping.
Here's LogDosDrives :
void LogDosDrives()
{
#define BUFSIZE 2048
// Translate path with device name to drive letters.
wchar_t szTemp[BUFSIZE];
szTemp[0] = '\0';
// GetLogicalDriveStrings
// gives you the DOS drives on the system
// including substs and network drives
if (GetLogicalDriveStringsW(BUFSIZE-1, szTemp))
{
wchar_t szName[MAX_PATH];
wchar_t szDrive[3] = (L" :");
wchar_t * p = szTemp;
do
{
// Copy the drive letter to the template string
*szDrive = *p;
// Look up each device name
if (QueryDosDeviceW(szDrive, szName, MAX_PATH))
{
lprintf("%S : %S\n",szDrive,szName);
}
// Go to the next NULL character.
while (*p++);
} while ( *p); // double-null is end of drives list
}
return;
}
/**
LogDosDrives prints stuff like :
A: : \Device\Floppy0
C: : \Device\HarddiskVolume1
D: : \Device\HarddiskVolume2
E: : \Device\CdRom0
H: : \Device\CdRom1
I: : \Device\CdRom2
M: : \??\D:\misc
R: : \??\D:\ramdisk
S: : \??\D:\ramdisk
T: : \??\D:\trans
V: : \??\C:
W: : \Device\LanmanRedirector\;W:0000000000024326\radnet\raddevel
Y: : \Device\LanmanRedirector\;Y:0000000000024326\radnet\radmedia
Z: : \Device\LanmanRedirector\;Z:0000000000024326\charlesb-pc\c
**/
Recall from the last post that "\??\" is the NT-namespace way of mapping back to the win32 namespace.
Those are substed drives. The "net use" drives get the "Lanman" prefix.
MapNtDriveName using QueryDosDevice is :
bool MapNtDriveName_QueryDosDevice(const wchar_t * from,wchar_t * to)
{
#define BUFSIZE 2048
// Translate path with device name to drive letters.
wchar_t allDosDrives[BUFSIZE];
allDosDrives[0] = '\0';
// GetLogicalDriveStrings
// gives you the DOS drives on the system
// including substs and network drives
if (GetLogicalDriveStringsW(BUFSIZE-1, allDosDrives))
{
wchar_t * pDosDrives = allDosDrives;
do
{
// Copy the drive letter to the template string
wchar_t dosDrive[3] = (L" :");
*dosDrive = *pDosDrives;
// Look up each device name
wchar_t ntDriveName[BUFSIZE];
if ( QueryDosDeviceW(dosDrive, ntDriveName, ARRAY_SIZE(ntDriveName)) )
{
size_t ntDriveNameLen = strlen(ntDriveName);
if ( strnicmp(from, ntDriveName, ntDriveNameLen) == 0
&& ( from[ntDriveNameLen] == '\\' || from[ntDriveNameLen] == 0 ) )
{
strcpy(to,dosDrive);
strcat(to,from+ntDriveNameLen);
return true;
}
}
// Go to the next NULL character.
while (*pDosDrives++);
} while ( *pDosDrives); // double-null is end of drives list
}
return false;
}
4.B. MapNtDriveName by IOControl :
There's a more direct way using DeviceIoControl. You just send a message to the "MountPointManager"
which is the guy who controls these mappings. (this is from "Mehrdad" on Stackoverflow) :
struct MOUNTMGR_TARGET_NAME { USHORT DeviceNameLength; WCHAR DeviceName[1]; };
struct MOUNTMGR_VOLUME_PATHS { ULONG MultiSzLength; WCHAR MultiSz[1]; };
#define MOUNTMGRCONTROLTYPE ((ULONG) 'm')
#define IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH \
CTL_CODE(MOUNTMGRCONTROLTYPE, 12, METHOD_BUFFERED, FILE_ANY_ACCESS)
union ANY_BUFFER {
MOUNTMGR_TARGET_NAME TargetName;
MOUNTMGR_VOLUME_PATHS TargetPaths;
char Buffer[4096];
};
bool MapNtDriveName_IoControl(const wchar_t * from,wchar_t * to)
{
ANY_BUFFER nameMnt;
int fromLen = strlen(from);
// DeviceNameLength is in *bytes*
nameMnt.TargetName.DeviceNameLength = (USHORT) ( 2 * fromLen );
strcpy(nameMnt.TargetName.DeviceName, from );
HANDLE hMountPointMgr = CreateFile( ("\\\\.\\MountPointManager"),
0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL, OPEN_EXISTING, 0, NULL);
ASSERT_RELEASE( hMountPointMgr != 0 );
DWORD bytesReturned;
BOOL success = DeviceIoControl(hMountPointMgr,
IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH, &nameMnt,
sizeof(nameMnt), &nameMnt, sizeof(nameMnt),
&bytesReturned, NULL);
CloseHandle(hMountPointMgr);
if ( success && nameMnt.TargetPaths.MultiSzLength > 0 )
{
strcpy(to,nameMnt.TargetPaths.MultiSz);
return true;
}
else
{
return false;
}
}
5. Fix MapNtDriveName for network names.
I said that MapNtDriveName_IoControl and MapNtDriveName_QueryDosDevice produced the same results and both worked. Well, that's only true for local drives. For network drives they both fail, but in different ways. MapNtDriveName_QueryDosDevice just won't find network drives, while MapNtDriveName_IoControl will hang for a long time and eventually time out with a failure.
We can fix it easily though because the NT path for a network share contains the valid win32 path
as a suffix, so all we have to do is grab that suffix.
bool MapNtDriveName(const wchar_t * from,wchar_t * to)
{
// hard-code network drives :
if ( strisame(from,L"\\Device\\Mup") || strisame(from,L"\\Device\\LanmanRedirector") )
{
strcpy(to,L"\\");
return true;
}
// either one :
//return MapNtDriveName_IOControl(from,to);
return MapNtDriveName_QueryDosDevice(from,to);
}
This just takes the NT-namespace network paths, like :
"\Device\Mup\charlesbpc\C$\xfer\path.txt"
->
"\\charlesbpc\C$\xfer\path.txt"
And we're done.
No comments:
Post a Comment