|
|
/* demlfn.c - SVC handler for calls that use lfns
* * * Modification History: * * VadimB 10-Sep-1996 Created * VadimB Sep-Oct 1996 Functionality added * */
#include "dem.h"
#include "demmsg.h"
#include "winbasep.h"
#include <vdm.h>
#include <softpc.h>
#include <mvdm.h>
#include <memory.h>
#include <nt_vdd.h>
#include "demlfn.h"
//
// locally used function
//
DWORD dempLFNCheckDirectory(PUNICODE_STRING pPath);
//
// Global Variables
// (initialized in dempInitLFNSupport)
//
//
UNICODE_STRING DosDevicePrefix;UNICODE_STRING DosDeviceUNCPrefix;UNICODE_STRING SlashSlashDotSlash;UNICODE_STRING ColonSlashSlash;
// this is zero-time for dos in terms of convertability
FILETIME gFileTimeDos0;
//
// Search handle table (see demlfn.h for definitions)
//
DemSearchHandleTable gSearchHandleTable;
//
// Dos/WOW variables (curdir&drive mostly)
//
DOSWOWDATA DosWowData; // this is same exactly as used by wow in wdos.c
#ifdef DBG
/* Function:
* dempLFNLog * * */
DWORD gdwLog;
VOID __cdecl dempLFNLog( PCHAR pFormat, ...){ va_list va; CHAR LogStr[512];
if (gdwLog) { va_start(va, pFormat); wvsprintf(LogStr, pFormat, va); OutputDebugStringOem(LogStr); }}
#else
#define dempLFNLog //
#endif
//
// String Convertion
//
// Define OEM/Ansi->Unicode and Unicode->OEM/Ansi translation functions
//
//
PFNUNICODESTRINGTODESTSTRING pfnUnicodeStringToDestString;PFNSRCSTRINGTOUNICODESTRING pfnSrcStringToUnicodeString;
#define ENABLE_CONDITIONAL_TRANSLATION
/*
* These two macros establish a dependency on oem/ansi api translation * WOW32 calls into us and tells us to be ansi. all support is totally * transparent. * */
#define DemSourceStringToUnicodeString(pUnicodeString, pSourceString, fAllocate) \
(*pfnSrcStringToUnicodeString)(pUnicodeString, pSourceString, fAllocate)
#define DemUnicodeStringToDestinationString(pDestString, pUnicodeString, fAllocate, fVerify) \
(*pfnUnicodeStringToDestString)(pDestString, pUnicodeString, fAllocate, fVerify)
/* Function:
* DemUnicodeStringToOemString * Convert Unicode counted string to Oem counted string with verification for * bad characters. Verification is provided by RtlUnicodeStringToCountedOemString. * At the same time the aforementioned api does not 0-terminate the dest string. * This function does 0-termination (given the dest string has enough space). * * If Translation does not need to be verified then speedier version of the * convertion api is called * * Parameters * pOemString - points to a destination oem counted string structure * pUnicodeString - points to a source unicode counted string * fAllocateResult - if TRUE, then storage for the resulting string will * be allocated * fVerifyTranslation - if TRUE, then converted string will be verified for * correctness (and appropriate status will be returned) */
NTSTATUSDemUnicodeStringToOemString( POEM_STRING pOemString, PUNICODE_STRING pUnicodeString, BOOLEAN fAllocateResult, BOOLEAN fVerifyTranslation){ NTSTATUS dwStatus;
if (fVerifyTranslation) { PUCHAR pchBuffer = NULL;
if (!fAllocateResult && pOemString->MaximumLength > 0) { pchBuffer = pOemString->Buffer; }
dwStatus = RtlUnicodeStringToCountedOemString(pOemString, pUnicodeString, fAllocateResult); if (NT_SUCCESS(dwStatus)) { if (pOemString->Length < pOemString->MaximumLength) { pOemString->Buffer[pOemString->Length] = '\0'; } else { if (NULL == pOemString->Buffer) { // source string was empty
if (NULL != pchBuffer) { *pchBuffer = '\0'; // terminate if there was a buffer
} } else { return(STATUS_BUFFER_OVERFLOW); } } } } else { dwStatus = RtlUnicodeStringToOemString(pOemString, pUnicodeString, fAllocateResult); }
return(dwStatus);}
/* Function:
* DemUnicodeStringToAnsiString * Convert Unicode counted string to Ansi counted string with verification for * bad characters. Note, that verification IS NOT provided by the corresponding * Rtl* api, thus is it never performed(!!!) * * Parameters * pOemString - points to a destination oem counted string structure * pUnicodeString - points to a source unicode counted string * fAllocateResult - if TRUE, then storage for the resulting string will * be allocated * fVerifyTranslation - if TRUE, then converted string will be verified for * correctness (and appropriate status will be returned) * * Note * This function does not provide verification. */
NTSTATUSDemUnicodeStringToAnsiString( PANSI_STRING pAnsiString, PUNICODE_STRING pUnicodeString, BOOLEAN fAllocateResult, BOOLEAN fVerifyTranslation){ return(RtlUnicodeStringToAnsiString(pAnsiString, pUnicodeString, fAllocateResult));}
/* Function:
* demSetLFNApiTranslation * Sets api translation to be Oem or Ansi. Windows seems to want apis to be * Ansi while dos apps require Oem translation. This function allows WOW to * set the appropriate translation at startup * * Parameters * fIsAnsi - if TRUE, all LFN apis will provide Ansi translation * * * */
VOIDdemSetLFNApiTranslation(BOOL fIsAnsi){ if (fIsAnsi) { pfnUnicodeStringToDestString = (PFNUNICODESTRINGTODESTSTRING) DemUnicodeStringToAnsiString; pfnSrcStringToUnicodeString = (PFNSRCSTRINGTOUNICODESTRING) DemAnsiStringToUnicodeString; } else { pfnUnicodeStringToDestString = (PFNUNICODESTRINGTODESTSTRING) DemUnicodeStringToOemString; pfnSrcStringToUnicodeString = (PFNSRCSTRINGTOUNICODESTRING) DemOemStringToUnicodeString; }}
/*
* Function: * dempGetDosUserEnvironment * Retrieves user stack top from the current process's pdb * see msdisp.asm for details, * ss is at psp:0x30 and sp is at psp:0x2e * Registers are at offsets represented by enumDemUserRegisterOffset * * Parameters: * fProtectedMode - TRUE if emulator is in 386 protected mode * Uses pusCurrentPDB * * Return: * Flat pointer to the user stack top * * */
PVOIDdempGetDosUserEnvironment(VOID){ USHORT wPSP; PBYTE pPDB;
wPSP = *pusCurrentPDB; pPDB = (PBYTE)GetVDMAddr(wPSP, 0); return((PVOID)GetVDMAddr(*(PUSHORT)(pPDB+0x30), *(PUSHORT)(pPDB+0x2e)));}
/* NOTES:
* * - On caution when using UNICODE_STRING * A lot of the functions here rely upon Rtl* functions including some * that provide UNICODE_STRING functionality. These functions, unlike one * would have to expect use notion of Length - it is measured in * BYTES not characters. * * - On return values from worker fns * Throughout this code we use Win32 error codes and nt status codes * Having both aroung can be fun, thus we generally return error codes in * a status code format, making all the return values consistent * * - On naming convention: * All functions that are internal and are not called directly from within * api dispatching code (such as real working functions for all the apis) * have prefix 'demp' (dem private), other functions that are callable from * within fast thunks (such as for wow32.dll - protected mode windows app) * have the usual prefix 'dem' */
/*
Functions:
Dos Extentions
i21h 4302 - GetCompressedFileSize i21h 440d 48 - LockUnlockRemovableMedia i21h 440d 49 - EjectRemovableMedia i21h 440d 6f - GetDriveMapInformation i21h 440d 71 - GetFirstCluster - should not be implemented
LFN
i21h *5704 - GetFileTimeLastAccess *5705 - SetFileTimeLastAccess *5706 - GetFileTimeCreation *5707 - SetFileTimeCreation *7139 - CreateDirectory *713a - RemoveDirectory *713b - SetCurrentDirectory *7141 - DeleteFile *7143 - SetGetFileAttributes *7147 - GetCurrentDirectory *714e - FindFirstFile *714f - FindNextFile *7156 - MoveFile *7160 0 - GetFullPathName *7160 1 - GetShortPathName *7160 2 - GetLongPathName *716c - CreateOpenFile *71a0 - GetVolumeInformation *71a1 - FindClose *71a6 - GetFileInformationByHandle *71a7 0 - FileTimeToDosDateTime *71a7 1 - DOSDateTimeToFileTime 71a8 - GenerateShortFileName *** no impl 71a9 - ServerCreateOpenFile *71aa 0 - CreateSubst *71aa 1 - TerminateSubst *71aa 2 - QuerySubst
*/
#if 0
typedef struct tagCLOSEAPPSTATE { DWORD dwFlags; FILETIME CloseCmdTime;} CLOSEAPPSTATE;
#define CLOSESTATE_QUERYCALLED 0x00000001UL // app has called QueryClose at least once
#define CLOSESTATE_CLOSECMD 0x00010000UL // close command was chosen
#define CLOSESTATE_APPGOTCLOSE 0x00020000UL // app received close notify
#define CLOSESTATE_CLOSEACK 0x01000000UL // close cmd
CLOSEAPPSTATE GlobalCloseState;
// handle variour close apis
VOID dempLFNHandleClose( VOID){ switch(getDX()) { case 1: // query close
GlobalCloseState.dwFlags |= CLOSESTATE_QUERYCALLED; if (GlobalCloseState.dwFlags & CLOSESTATE_CLOSECMD) { // bummer
} break;
case 2: // ack close
GlobalCloseState.dwFlags |= CLOSESTATE_CLOSEACK; break;
case 3: // cancel close
GlobalCloseState.dwFlags |= CLOSESTATE_CLOSECANCEL; break;}
BOOL dempCompareTimeInterval( FILETIME* pTimeStart, FILETIME* pTimeEnd, DWORD dwIntervalMilliseconds){ LARGE_INTEGER TimeStart; LARGE_INTEGER TimeEnd;
TimeStart.LowPart = pTimeStart->dwLowDateTime; TimeStart.HighPart = pTimeStart->dwHighDateTime;
TimeEnd.LowPart = pTimeEnd->dwLowDateTime; TimeEnd.HighPart = pTimeEnd->dwHighDateTime;
return(((TimeEnd.QuadPart - TimeStart.QuadPart) * 1000 * 10) < (LONGLONG)dwIntervalMilliseconds);}
#define DOS_APP_CLOSE_TIMEOUT 5000 // 5s
//
// This is how we handle query close calls
//
// Upon receiving a ctrl_close_event we set the global flag and wait
// when pinged by app with query close
//
//
BOOL dempLFNConsoleCtrlHandler( DWORD dwCtrlType){ FILETIME SysTime;
switch(dwCtrlType) { case CTRL_CLOSE_EVENT:
// -- set the flag
// -- return true
// this is the only event we are interested in
if (GlobalCloseState.dwFlags & CLOSESTATE_CLOSECMD) {
if (GlobalCloseState.dwFlags & CLOSESTATE_CLOSEACK) { // allow 1 sec from close ack to either close or die
}
!(GlobalCloseState.dwFlags & CLOSESTATE_APPRECEIVEDCLOSE))
// another close event - after the first one -
// and in these 5sec app has not called queryclose -
// then handle by default
GetSystemTimeAsFileTime(&SysTime); if (dempCompareTimeInterval(&GlobalCloseState.CloseCmdTime, &SysTime, DOS_APP_CLOSE_TIMEOUT)) return(
}
}
// set the flag so we can signal the app
if (GlobalCloseState.dwFlags & CLOSESTATE_QUERYCALLED) { GlobalCloseState.dwFlags |= CLOSESTATE_CLOSECMD
}
}
}
// if the handler is not installed, then we don't care ...
VOIDdemLFNInstallCtrlHandler(VOID){ if (!VDMForWOW) { SetConsoleCtrlHandler(dempLFNConsoleCtrlHandler, TRUE); }}
#endif
/*
* Function: * dempInitLFNSupport * Initializes LFN (Long File Names) support for NT DOS emulation * (global vars). Called from demInit in dem.c * * This function sets api translation to OEM. * */
VOIDdempInitLFNSupport( VOID){ TIME_FIELDS TimeFields; LARGE_INTEGER ft0;
RtlInitUnicodeString(&DosDevicePrefix, L"\\??\\"); RtlInitUnicodeString(&DosDeviceUNCPrefix, L"\\??\\UNC\\"); RtlInitUnicodeString(&SlashSlashDotSlash, L"\\\\.\\"); RtlInitUnicodeString(&ColonSlashSlash, L":\\\\");
demSetLFNApiTranslation(FALSE); // set api to oem mode
// init important time conversion constants
RtlZeroMemory(&TimeFields, sizeof(TimeFields)); TimeFields.Year = (USHORT)1980; TimeFields.Month = 1; TimeFields.Day = 1; RtlTimeFieldsToTime(&TimeFields, &ft0); gFileTimeDos0.dwLowDateTime = ft0.LowPart; gFileTimeDos0.dwHighDateTime = ft0.HighPart;
// now initialize our control handler api
// we are watching for a 'close' call with an assumption
// app will be doing QueryClose calls
#if 0
demLFNInstallCtrlHandler();#endif
}
/*
* Function: * dempStringInitZeroUnicode * Initializes an empty Unicode counted string given the pointer * to the character buffer * * Parameters: * IN OUT pStr - unicode counted string * IN pwsz - pointer to the string buffer * IN nMaximumLength - size (in BYTES) of the buffer pointed to by pwsz * * Returns: * NOTHING * */
VOIDdempStringInitZeroUnicode( PUNICODE_STRING pStr, PWSTR pwsz, USHORT nMaximumLength){ pStr->Length = 0; pStr->MaximumLength = nMaximumLength; pStr->Buffer = pwsz; if (NULL != pwsz) { pwsz[0] = UNICODE_NULL; }}
/*
* Function: * dempStringPrefixUnicode * Verifies if a string is a prefix in another unicode counted string * Equivalent to RtlStringPrefix * * Parameters: * IN StrPrefix - unicode counted string - prefix * IN String - unicode counted string to check for prefix * IN CaseInSensitive - whether the comparison should be case insensitive * TRUE - case insensitive * FALSE- case sensitive * * Returns: * TRUE - String contains StrPrefix at it's start * */
BOOLdempStringPrefixUnicode( PUNICODE_STRING pStrPrefix, PUNICODE_STRING pString, BOOL CaseInSensitive){ PWSTR ps1, ps2; UINT n; WCHAR c1, c2;
n = pStrPrefix->Length; if (pString->Length < n) { return(FALSE); }
n /= sizeof(WCHAR); // convert to char count
ps1 = pStrPrefix->Buffer; ps2 = pString->Buffer;
if (CaseInSensitive) { while (n--) { c1 = *ps1++; c2 = *ps2++;
if (c1 != c2) { c1 = RtlUpcaseUnicodeChar(c1); c2 = RtlUpcaseUnicodeChar(c2); if (c1 != c2) { return(FALSE); } } } } else { while (n--) { if (*ps1++ != *ps2++) { return(FALSE); } }
}
return(TRUE);}
/*
* Function: * dempStringDeleteCharsUnicode * Removes specified number of characters from a unicode counted string * starting at specified position (including starting character) * * Parameters: * IN OUT pStringDest - unicode counted string to operate on * IN nIndexStart - starting byte for deletion * IN nLength - number of bytes to be removed * * Returns: * TRUE - characters were removed * FALSE- starting position exceeds string length * */
BOOLdempStringDeleteCharsUnicode( PUNICODE_STRING pStringDest, USHORT nIndexStart, USHORT nLength){ if (nIndexStart > pStringDest->Length) { // start past length
return(FALSE); }
if (nLength >= (pStringDest->Length - nIndexStart)) { pStringDest->Length = nIndexStart; *(PWCHAR)((PUCHAR)pStringDest->Buffer + nIndexStart) = UNICODE_NULL; } else { USHORT nNewLength;
nNewLength = pStringDest->Length - nLength;
RtlMoveMemory((PUCHAR)pStringDest->Buffer + nIndexStart, (PUCHAR)pStringDest->Buffer + nIndexStart + nLength, nNewLength - nIndexStart);
pStringDest->Length = nNewLength; *(PWCHAR)((PUCHAR)pStringDest->Buffer + nNewLength) = UNICODE_NULL; }
return(TRUE);}
/*
* Function: * dempStringFindLastChar * implements strrchr - finds the last occurence of a character in * unicode counted string * * Parameters * pString - target string to search * wch - Unicode character to look for * CaseInSensitive - if TRUE, search is case insensitive * * Returns * Index of the character in the string or -1 if char * could not be found. Index is (as always with counted strings) is bytes, * not characters * */
LONGdempStringFindLastChar( PUNICODE_STRING pString, WCHAR wch, BOOL CaseInSensitive){ INT Index = (INT)UNICODESTRLENGTH(pString); PWCHAR pBuffer = (PWCHAR)((PUCHAR)pString->Buffer + pString->Length); WCHAR c2;
if (CaseInSensitive) { wch = RtlUpcaseUnicodeChar(wch);
while (--Index >= 0) { c2 = *--pBuffer;
c2 = RtlUpcaseUnicodeChar(c2); if (wch == c2) { return((LONG)(Index << 1)); } } } else { while (--Index >= 0) { if (wch == (*--pBuffer)) { return((LONG)(Index << 1)); } } }
return(-1);}
/*
* Function: * This function checks LFN path for abnormalities, such as a presence of * a drive letter followed by a :\\ such as in d:\\mycomputer\myshare\foo.txt * subsequently d: is removed * * Parameters: * IN OUT pPath - unicode path * * Returns: * NOTHING * */VOID dempLFNNormalizePath( PUNICODE_STRING pPath){ UNICODE_STRING PathNormal;
if (pPath->Length > 8) { // 8 as in "d:\\"
RtlInitUnicodeString(&PathNormal, pPath->Buffer + 1); if (dempStringPrefixUnicode(&ColonSlashSlash, &PathNormal, TRUE)) { dempStringDeleteCharsUnicode(pPath, 0, 2 * sizeof(WCHAR)); }
}
}
/*
* Function: * dempQuerySubst * Verify if drive is a subst (sym link) and return the base path * for this drive. * Uses QueryDosDeviceW api which does exactly what we need * Checks against substed UNC devices and forms correct unc path * Function works on Unicode counted strings * * Parameters: * IN wcDrive - Drive Letter to be checked * OUT pSubstPath - Buffer that will receive mapping if the drive is substed * should contain sufficient buffer * * Returns: * The status value (maybe Win32 error wrapped in) * STATUS_SUCCESS - Drive is substed and mapping was put into SubstPath * ERROR_NOT_SUBSTED - Drive is not substed * or the error code * */
NTSTATUSdempQuerySubst( WCHAR wcDrive, // dos drive letter to inquire
PUNICODE_STRING pSubstPath){ WCHAR wszDriveStr[3]; DWORD dwStatus;
wszDriveStr[0] = wcDrive; wszDriveStr[1] = L':'; wszDriveStr[2] = UNICODE_NULL;
dwStatus = QueryDosDeviceW(wszDriveStr, pSubstPath->Buffer, pSubstPath->MaximumLength/sizeof(WCHAR)); if (dwStatus) {
// fix the length (in BYTES) - QueryDosDeviceW returns 2 chars more then
// the length of the string
pSubstPath->Length = (USHORT)(dwStatus - 2) * sizeof(WCHAR);
// see if we hit a unc string there
if (dempStringPrefixUnicode(&DosDeviceUNCPrefix, pSubstPath, TRUE)) {
// This is a unc name - convert to \\<uncname>
// if we hit this code - potential trouble, as win95
// does not allow for subst'ing unc names
dempStringDeleteCharsUnicode(pSubstPath, (USHORT)0, (USHORT)(DosDeviceUNCPrefix.Length - 2 * sizeof(WCHAR)));
pSubstPath->Buffer[0] = L'\\'; dwStatus = STATUS_SUCCESS;
} // string is not prefixed by <UNC\>
else if (dempStringPrefixUnicode(&DosDevicePrefix, pSubstPath, TRUE)) {
dempStringDeleteCharsUnicode(pSubstPath, 0, DosDevicePrefix.Length); dwStatus = STATUS_SUCCESS;
} // string is not prefixed by <\??\>
else { dwStatus = NT_STATUS_FROM_WIN32(ERROR_NOT_SUBSTED); }
} else { dwStatus = GET_LAST_STATUS(); }
return(dwStatus);}
/*
* Function: * dempExpandSubst * Verify if the full path that is passed in relates to a substed drive * and expands the substed drive mapping * Optionally converts subst mapping to a short form * Win95 always removes the terminating backslash from the resulting path * after the expansion hence this function should do it as well * * Parameters: * IN OUT pPath - Full path to be verified/expanded * IN fShortPathName - expand path in a short form * * Returns: * ERROR_SUCCESS - Drive is substed and mapping was put into SubstPath * ERROR_NOT_SUBSTED - Drive is not substed * ERROR_BUFFER_OVERFLOW - Either subst mapping or the resulting path is too long * or the error code if invalid path/etc * */
NTSTATUSdempExpandSubst( PUNICODE_STRING pPath, BOOL fShortPathName){ UNICODE_STRING SubstPath; DWORD dwStatus; WCHAR wszSubstPath[MAX_PATH]; WORD wCharType;
PWSTR pwszPath = pPath->Buffer;
// check if we have a canonical dos path in Path
// to do so we
// - check that the first char is alpha
// - check that the second char is ':'
if ( !GetStringTypeW(CT_CTYPE1, pwszPath, 1, &wCharType)) { // Couldn't get string type
// assuming Drive is not substed
return(NT_STATUS_FROM_WIN32(GetLastError())); }
if (!(C1_ALPHA & wCharType) || L':' != pwszPath[1]) { // this could have been a unc name
// or something weird
return(NT_STATUS_FROM_WIN32(ERROR_NOT_SUBSTED)); }
dempStringInitZeroUnicode(&SubstPath, wszSubstPath, sizeof(wszSubstPath));
dwStatus = dempQuerySubst(*pwszPath, &SubstPath); if (NT_SUCCESS(dwStatus)) { USHORT nSubstLength = SubstPath.Length;
// see if we need a short path
if (fShortPathName) { dwStatus = GetShortPathNameW(wszSubstPath, // this is SubstPath counted string
wszSubstPath, ARRAYCOUNT(wszSubstPath));
CHECK_LENGTH_RESULT(dwStatus, ARRAYCOUNT(wszSubstPath), nSubstLength);
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
// nSubstLength is set to the length of a string
}
// okay - we have a subst there
// replace now a <devletter><:> with a subst
if (L'\\' == *(PWCHAR)((PUCHAR)wszSubstPath + nSubstLength - sizeof(WCHAR))) { nSubstLength -= sizeof(WCHAR); }
// see if we might overflow the destination string
if (pPath->Length + nSubstLength - 2 * sizeof(WCHAR) > pPath->MaximumLength) { return(NT_STATUS_FROM_WIN32(ERROR_BUFFER_OVERFLOW)); }
// now we have to insert the right subst path in
// move stuff to the right in the path department
RtlMoveMemory((PUCHAR)pwszPath + nSubstLength - 2 * sizeof(WCHAR), // to the right, less 2 chars
(PUCHAR)pwszPath, // from the beginning
pPath->Length);
// after this is done we will insert the chars from subst expansion
// at the starting position of the path
RtlCopyMemory(pwszPath, wszSubstPath, nSubstLength);
// at this point we fix the length of the path
pPath->Length += nSubstLength - 2 * sizeof(WCHAR);
dwStatus = STATUS_SUCCESS; }
return(dwStatus);}
/* Function 7160
* * * Implements fn 0 - GetFullPathName * * Parameters * ax = 0x7160 - fn major code * cl = 0 - minor code * ch = SubstExpand * 0x00 - expand subst drive * 0x80 - do not expand subst drive * ds:si = Source Path * es:di = Destination Path * * The base path as in GetFullPathName will be given in a short form and * in a long form sometimes * * c:\foo bar\john dow\ * will return * c:\foobar~1\john dow * from GetFullPathName "john dow", c:\foo bar being the current dir * and * c:\foobar~1\johndo~1 * from GetFullPathName "johndo~1" * * Return * Success - * carry not set, ax modified(?) * Failure - * carry set, ax = error value * */
NTSTATUSdempGetFullPathName( PUNICODE_STRING pSourcePath, PUNICODE_STRING pDestinationPath, BOOL fExpandSubst)
{ DWORD dwStatus;
// maps to GetFullPathName
dwStatus = RtlGetFullPathName_U(pSourcePath->Buffer, pDestinationPath->MaximumLength, pDestinationPath->Buffer, NULL);
// check result, fix string length
// dwStatus will be set to error if buffer overflow
CHECK_LENGTH_RESULT_RTL_USTR(dwStatus, pDestinationPath);
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
// now check for dos device names being passed in
if (dempStringPrefixUnicode(&SlashSlashDotSlash, pDestinationPath, TRUE)) {
// this is a bit strange though this is what Win95 returns
return(NT_STATUS_FROM_WIN32(ERROR_FILE_NOT_FOUND)); }
// now see if we need to expand the subst
// note that this implementation is exactly what win95 does - the subst
// path is always expanded as short unless the long filename is being
// requested
if (fExpandSubst) { dwStatus = dempExpandSubst(pDestinationPath, FALSE); if (!NT_SUCCESS(dwStatus)) { if (WIN32_ERROR_FROM_NT_STATUS(dwStatus) != ERROR_NOT_SUBSTED) { return(dwStatus); } } }
return(STATUS_SUCCESS);}
/* Function
* dempGetShortPathName * Retrieves short path name for the given path * * Parameters * ax = 0x7160 - fn major code * cl = 1 - minor code * ch = SubstExpand * 0x00 - expand subst drive * 0x80 - do not expand subst drive * ds:si = Source Path * es:di = Destination Path * * The base path as in GetFullPathName will be given in a short form and * in a long form sometimes * * c:\foo bar\john dow\ * will return * c:\foobar~1\john dow * from GetFullPathName "john dow", c:\foo bar being the current dir * and * c:\foobar~1\johndo~1 * from GetFullPathName "johndo~1" * * Return * Success - * carry not set, ax modified(?) * Failure - * carry set, ax = error value * */
NTSTATUSdempGetShortPathName( PUNICODE_STRING pSourcePath, PUNICODE_STRING pDestinationPath, BOOL fExpandSubst){ DWORD dwStatus;
dwStatus = dempGetFullPathName(pSourcePath, pDestinationPath, fExpandSubst); if (NT_SUCCESS(dwStatus)) { dwStatus = GetShortPathNameW(pDestinationPath->Buffer, pDestinationPath->Buffer, pDestinationPath->MaximumLength / sizeof(WCHAR));
CHECK_LENGTH_RESULT_USTR(dwStatus, pDestinationPath); }
return(dwStatus);}
// the code below was mostly partially ripped from base/client/vdm.c
DWORD rgdwIllegalMask[] ={ // code 0x00 - 0x1F --> all illegal
0xFFFFFFFF, // code 0x20 - 0x3f --> 0x20,0x22,0x2A-0x2C,0x2F and 0x3A-0x3F are illegal
0xFC009C05, // code 0x40 - 0x5F --> 0x5B-0x5D are illegal
0x38000000, // code 0x60 - 0x7F --> 0x7C is illegal
0x10000000};
BOOLdempIsShortNameW( LPCWSTR Name, int Length, BOOL fAllowWildCard ){ int Index; BOOL ExtensionFound; DWORD dwStatus; UNICODE_STRING unicodeName; OEM_STRING oemString; UCHAR oemBuffer[MAX_PATH]; UCHAR Char;
ASSERT(Name);
// total length must less than 13(8.3 = 8 + 1 + 3 = 12)
if (Length > 12) return FALSE; // "" or "." or ".."
if (!Length) return TRUE; if (L'.' == *Name) { // "." or ".."
if (1 == Length || (2 == Length && L'.' == Name[1])) return TRUE; else // '.' can not be the first char(base name length is 0)
return FALSE; }
unicodeName.Buffer = (LPWSTR)Name; unicodeName.Length = unicodeName.MaximumLength = Length * sizeof(WCHAR);
oemString.Buffer = oemBuffer; oemString.Length = 0; oemString.MaximumLength = MAX_PATH; // make a dangerous assumption
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemUnicodeStringToDestinationString(&oemString, &unicodeName, FALSE, FALSE);#else
dwStatus = RtlUnicodeStringToOemString(&oemString, &unicodeName, FALSE);#endif
if (! NT_SUCCESS(dwStatus)) { return(FALSE); }
// all trivial cases are tested, now we have to walk through the name
ExtensionFound = FALSE; for (Index = 0; Index < oemString.Length; Index++) { Char = oemString.Buffer[Index];
// Skip over and Dbcs characters
if (IsDBCSLeadByte(Char)) { //
// 1) if we're looking at base part ( !ExtensionPresent ) and the 8th byte
// is in the dbcs leading byte range, it's error ( Index == 7 ). If the
// length of base part is more than 8 ( Index > 7 ), it's definitely error.
//
// 2) if the last byte ( Index == DbcsName.Length - 1 ) is in the dbcs leading
// byte range, it's error
//
if ((!ExtensionFound && (Index >= 7)) || (Index == oemString.Length - 1)) { return FALSE; } Index += 1; continue; }
// make sure the char is legal
if ((Char < 0x80) && (rgdwIllegalMask[Char / 32] & (1 << (Char % 32)))) { if (!fAllowWildCard || ('?' != Char && '*' != Char)) { return(FALSE); } } if ('.' == Char) { // (1) can have only one '.'
// (2) can not have more than 3 chars following.
if (ExtensionFound || Length - (Index + 1) > 3) { return FALSE; } ExtensionFound = TRUE; } // base length > 8 chars
if (Index >= 8 && !ExtensionFound) return FALSE; } return TRUE;
}
/* Function:
* demIsShortPathName * Returns true is the path name passed in is a short path name * * * * */
// this function was ripped from windows\base\client\vdm.c
LPCWSTRdempSkipPathTypeIndicatorW( LPCWSTR Path ){ RTL_PATH_TYPE RtlPathType; LPCWSTR pFirst; DWORD Count;
RtlPathType = RtlDetermineDosPathNameType_U(Path); switch (RtlPathType) { // form: "\\server_name\share_name\rest_of_the_path"
case RtlPathTypeUncAbsolute: pFirst = Path + 2; Count = 2; // guard for UNICODE_NULL is necessary because
// RtlDetermineDosPathNameType_U doesn't really
// verify an UNC name.
while (Count && *pFirst != UNICODE_NULL) { if (*pFirst == L'\\' || *pFirst == L'/') Count--; pFirst++; } break;
// form: "\\.\rest_of_the_path"
case RtlPathTypeLocalDevice: pFirst = Path + 4; break;
// form: "\\."
case RtlPathTypeRootLocalDevice: pFirst = NULL; break;
// form: "D:\rest_of_the_path"
case RtlPathTypeDriveAbsolute: pFirst = Path + 3; break;
// form: "D:rest_of_the_path"
case RtlPathTypeDriveRelative: pFirst = Path + 2; break;
// form: "\rest_of_the_path"
case RtlPathTypeRooted: pFirst = Path + 1; break;
// form: "rest_of_the_path"
case RtlPathTypeRelative: pFirst = Path; break;
default: pFirst = NULL; break; } return pFirst;}
// this function is rather "permissive" if it errs and can't find
// out for sure -- we then hope that the failure will occur later...
BOOLdemIsShortPathName( LPSTR pszPath, BOOL fAllowWildCardName){ NTSTATUS dwStatus; PUNICODE_STRING pUnicodeStaticFileName; OEM_STRING oemFileName; LPWSTR lpwszPath; LPWSTR pFirst, pLast; BOOL fWild = FALSE;
//
// convert parameters to unicode - we use a static string here
//
RtlInitOemString(&oemFileName, pszPath);
pUnicodeStaticFileName = GET_STATIC_UNICODE_STRING_PTR();
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStaticFileName, &oemFileName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStaticFileName, &oemFileName, FALSE);#endif
if (!NT_SUCCESS(dwStatus)) { return(TRUE); }
// now we have a unicode string to mess with
lpwszPath = pUnicodeStaticFileName->Buffer;
// chop off the intro part first
lpwszPath = (LPWSTR)dempSkipPathTypeIndicatorW((LPCWSTR)pUnicodeStaticFileName->Buffer); if (NULL == lpwszPath) { // some weird path type ? just let it go
return(TRUE); // we assume findfirst will hopefully choke on it too
}
pFirst = lpwszPath;
// we go through the name now
while (TRUE) { while (UNICODE_NULL != *pFirst && (L'\\' == *pFirst || L'/' == *pFirst)) { ++pFirst; // this is legal -- to have multiple separators!
}
if (UNICODE_NULL == *pFirst) { // meaning -- just separators found or end of string
break; }
// now see that we find the end of this name
pLast = pFirst + 1; while (UNICODE_NULL != *pLast && (L'\\' != *pLast && L'/' != *pLast)) { ++pLast; }
fWild = fAllowWildCardName && UNICODE_NULL == *pLast;
// now pLast points to the UNICODE_NULL or the very next backslash
if (!dempIsShortNameW(pFirst, (int)(pLast-pFirst), fWild)) { return(FALSE); // this means long path name found in the middle
}
// now we continue
if (UNICODE_NULL == *pLast) { break; } pFirst = pLast + 1; }
return(TRUE);}
/* Function:
* dempGetLongPathName * Retrieves long version of a path name given it's short form * * * Parameters * IN pSourcePath - unicode counted string representing short path * OUT pDestinationPath - unicode counted string - output long path * IN fExpandSubst - flag indicating whether to perform subst expansion * * Return * NT Error code * * * * */
NTSTATUSdempGetLongPathName( PUNICODE_STRING pSourcePath, PUNICODE_STRING pDestinationPath, BOOL fExpandSubst){ UNICODE_STRING NtPathName; RTL_PATH_TYPE RtlPathType; // path type
PWCHAR pchStart, pchEnd; PWCHAR pchDest, pchLast; UINT nCount, // temp counter
nLength = 0; // final string length
WCHAR wchSave; // save char during path parsing
DWORD dwStatus;
UNICODE_STRING FullPathName; UNICODE_STRING FileName; BOOL fVerify = FALSE; // flag indicating that only verification
// is performed on a path and no long path
// retrieval is necessary
struct tagDirectoryInformationBuffer { // directory information (see ntioapi.h)
FILE_DIRECTORY_INFORMATION DirInfo; WCHAR name[MAX_PATH]; } DirectoryInformationBuf; PFILE_DIRECTORY_INFORMATION pDirInfo = &DirectoryInformationBuf.DirInfo;
OBJECT_ATTRIBUTES FileObjectAttributes; // used for querying name info
HANDLE FileHandle; IO_STATUS_BLOCK IoStatusBlock;
// algorithm here:
// 1. call getfullpathname
// 2. verify(on each part of the name) and retrieve lfn version of the name
// first we need a buffer for our full expanded path
// allocate this buffer from the heap -- * local ? *
RtlInitUnicodeString(&NtPathName, NULL);
pchStart = RtlAllocateHeap(RtlProcessHeap(), 0, MAX_PATH * sizeof(WCHAR)); if (NULL == pchStart) { return(NT_STATUS_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY)); }
dempStringInitZeroUnicode(&FullPathName, pchStart, MAX_PATH * sizeof(WCHAR));
dwStatus = RtlGetFullPathName_U(pSourcePath->Buffer, FullPathName.MaximumLength, FullPathName.Buffer, NULL);
CHECK_LENGTH_RESULT_RTL_USTR(dwStatus, &FullPathName);
if (!NT_SUCCESS(dwStatus)) { goto glpExit; }
// optionally expand the subst
// to whatever it should have been
if (fExpandSubst) { dwStatus = dempExpandSubst(&FullPathName, FALSE); if (!NT_SUCCESS(dwStatus)) { if (WIN32_ERROR_FROM_NT_STATUS(dwStatus) != ERROR_NOT_SUBSTED) { goto glpExit; } } }
// at this point recycle the input source path -- we will know that
// this modification took place
RtlPathType = RtlDetermineDosPathNameType_U(FullPathName.Buffer);
switch(RtlPathType) {
case RtlPathTypeUncAbsolute:
// this is a unc name
pchStart = FullPathName.Buffer + 2; // beyond initial "\\"
// drive ahead looking past second backslash -- this is really
// bogus approach as unc name should be cared for by redirector
// yet I do same as base
nCount = 2; while (UNICODE_NULL != *pchStart && nCount > 0) { if (L'\\' == *pchStart || L'/' == *pchStart) { --nCount; } ++pchStart; } break;
case RtlPathTypeDriveAbsolute: pchStart = FullPathName.Buffer + 3; // includes <drive><:><\\>
break;
default: // this error will never occur, yet to be safe we are aware of this...
// case ... we will keep it here as a safeguard
dwStatus = NT_STATUS_FROM_WIN32(ERROR_BAD_PATHNAME); goto glpExit; }
// prepare destination
pchDest = pDestinationPath->Buffer; // current pointer to destination buffer
pchLast = FullPathName.Buffer; // last piece of the source path
pchEnd = pchStart; // current end-of-scan portion
// we are going to walk the filename assembling it's various pieces
//
while (TRUE) { // copy the already-assembled part into the dest buffer
// this is rather dubious part as all it copies are prefix and backslashes
nCount = (PUCHAR)pchEnd - (PUCHAR)pchLast; if (nCount > 0) { // copy this portion
nLength += nCount; // dest length-to-be
if (nLength >= pDestinationPath->MaximumLength) { dwStatus = NT_STATUS_FROM_WIN32(ERROR_BUFFER_OVERFLOW); break; }
// copy the memory
RtlMoveMemory(pchDest, pchLast, nCount); pchDest += nCount / sizeof(WCHAR); }
// if we are at the end here, then there is nothing left
// we should be running a verification pass only
if (UNICODE_NULL == *pchEnd) { fVerify = TRUE; } else { // look for the next backslash
while (UNICODE_NULL != *pchEnd && L'\\' != *pchEnd && L'/' != *pchEnd) { ++pchEnd; } }
// found backslash or end here
// temporary null-terminate the string and research it's full name
wchSave = *pchEnd; *pchEnd = UNICODE_NULL;
dwStatus = RtlDosPathNameToNtPathName_U(FullPathName.Buffer, &NtPathName, &FileName.Buffer, NULL); if (!dwStatus) { // could also be a memory problem here
dwStatus = NT_STATUS_FROM_WIN32(ERROR_FILE_NOT_FOUND); break; }
if (fVerify || NULL == FileName.Buffer) { // no filename portion there - panic ? or this is just a
// directory (root)
// this also may signal that our job is done as there is nothing
// to query about - we are at the root of things
// let us open this stuff then and if it exists - just exit,
// else return error
fVerify = TRUE; FileName.Length = 0; } else {
USHORT nPathLength;
nPathLength = (USHORT)((ULONG)FileName.Buffer - (ULONG)NtPathName.Buffer);
FileName.Length = NtPathName.Length - nPathLength;
// chop the backslash off if this is not the last one only
NtPathName.Length = nPathLength; if (L':' != *(PWCHAR)((PUCHAR)NtPathName.Buffer+nPathLength-2*sizeof(WCHAR))) { NtPathName.Length -= sizeof(WCHAR); } }
FileName.MaximumLength = FileName.Length; NtPathName.MaximumLength = NtPathName.Length;
// now we should have a full nt path sitting right in NtPathName
// restore saved char
*pchEnd = wchSave;
// initialize info obj
InitializeObjectAttributes(&FileObjectAttributes, &NtPathName, OBJ_CASE_INSENSITIVE, NULL, NULL);
dwStatus = NtOpenFile(&FileHandle, FILE_LIST_DIRECTORY | SYNCHRONIZE, &FileObjectAttributes, &IoStatusBlock, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT);
if (!NT_SUCCESS(dwStatus)) { break; }
dwStatus = NtQueryDirectoryFile(FileHandle, NULL, NULL, NULL, &IoStatusBlock, pDirInfo, sizeof(DirectoryInformationBuf), FileDirectoryInformation, TRUE, &FileName, FALSE);
NtClose(FileHandle);
// we need NtPathName no more - release it here
RtlFreeUnicodeString(&NtPathName); NtPathName.Buffer = NULL;
if (!NT_SUCCESS(dwStatus)) { break; }
if (fVerify) { dwStatus = STATUS_SUCCESS; break; }
nLength += pDirInfo->FileNameLength; if (nLength >= pDestinationPath->MaximumLength) { dwStatus = NT_STATUS_FROM_WIN32(ERROR_BUFFER_OVERFLOW); break; }
RtlMoveMemory(pchDest, pDirInfo->FileName, pDirInfo->FileNameLength);
// update dest pointer
pchDest += pDirInfo->FileNameLength / sizeof(WCHAR);
if (UNICODE_NULL == *pchEnd) { dwStatus = STATUS_SUCCESS; break; }
pchLast = pchEnd++; // this is set to copy backslash
} // end while
// only on success condition we touch dest buffer here
if (NT_SUCCESS(dwStatus)) { *pchDest = UNICODE_NULL; pDestinationPath->Length = (USHORT)nLength; }
glpExit:
if (NULL != FullPathName.Buffer) { RtlFreeHeap(RtlProcessHeap(), 0, FullPathName.Buffer); } if (NULL != NtPathName.Buffer) { RtlFreeUnicodeString(&NtPathName); }
return(dwStatus);}
/* Function:
* demGetPathName * completely handles function 7160 with three minor subfunctions * exported function that could be called from wow32 for fast handling * of a 0x7160 thunk * * Parameters * IN lpSourcePath - source path to query for full/long/short path name * OUT lpDestinationPath - result produced by this function * IN uiMinorCode - minor code see enumFullPathNameMinorCode - which * function to execute - * fullpathname/shortpathname/longpathname * IN fExpandSubst - flag whether to expand substituted drive letter * * Return * NT Error code * * Known implementation differences [with Win95] * * All these apis will return error on win95 if path does not exist * only GetLongPathName currently returns error in such a case * * if a local path does not exist win95 fn0 returns fine while * fns 1 and 2 return error 3 (path not found) * * we return the name with a terminating backslash when expanding the * subst e.g.: * z:\ -> substed for c:\foo\bar * we return "c:\foo\bar\" while win95 returns "c:\foo\bar" * * if win95 running on \\vadimb9 any of these calls with \\vadimb9\foo * where share foo does not exist - we get a doserror generated with * abort/retry/fail - and code is 46 (bogus) * * error codes may differ a bit * * win95 does not allow for subst on a unc name, win nt does and fns correctly * process these cases(with long or short filenames) * */
NTSTATUSdemLFNGetPathName( LPSTR lpSourcePath, LPSTR lpDestinationPath, UINT uiMinorCode, BOOL fExpandSubst )
{ // convert input parameter to unicode
//
UNICODE_STRING unicodeSourcePath; UNICODE_STRING unicodeDestinationPath; OEM_STRING oemString; WCHAR wszDestinationPath[MAX_PATH]; DWORD dwStatus;
// Validate input parameters
if (NULL == lpSourcePath || NULL == lpDestinationPath) { return(NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER)); }
RtlInitOemString(&oemString, lpSourcePath);
// convert source path from ansi to unicode and allocate result
// this rtl function returns status code, not the winerror code
//
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(&unicodeSourcePath, &oemString, TRUE);
#else
dwStatus = RtlOemStringToUnicodeString(&unicodeSourcePath, &oemString, TRUE);
#endif
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
dempStringInitZeroUnicode(&unicodeDestinationPath, wszDestinationPath, sizeof(wszDestinationPath));
// now call api and get appropriate result back
switch(uiMinorCode) { case fnGetFullPathName:
dwStatus = dempGetFullPathName(&unicodeSourcePath, &unicodeDestinationPath, fExpandSubst);
break;
case fnGetShortPathName: dwStatus = dempGetShortPathName(&unicodeSourcePath, &unicodeDestinationPath, fExpandSubst); break;
case fnGetLongPathName: dwStatus = dempGetLongPathName(&unicodeSourcePath, &unicodeDestinationPath, fExpandSubst); break;
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION); }
if (NT_SUCCESS(dwStatus)) { // convert to ansi and we are done
oemString.Buffer = lpDestinationPath; oemString.Length = 0; oemString.MaximumLength = MAX_PATH; // make a dangerous assumption
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemUnicodeStringToDestinationString(&oemString, &unicodeDestinationPath, FALSE, FALSE);#else
dwStatus = RtlUnicodeStringToOemString(&oemString, &unicodeDestinationPath, FALSE);#endif
}
RtlFreeUnicodeString(&unicodeSourcePath);
return(dwStatus);}
// Create a subst for this particular drive
// using path name
//
// same as used by subst command
// check to see if specified path exists
/* Function:
* dempLFNCheckDirectory * Verifies that a supplied path is indeed an existing directory * * Parameters * IN pPath - pointer to unicode Path String * * Return * NT Error code * * */
DWORDdempLFNCheckDirectory( PUNICODE_STRING pPath){ // we just read file's attributes
DWORD dwAttributes;
dwAttributes = GetFileAttributesW(pPath->Buffer);
if ((DWORD)-1 == dwAttributes) { return(GET_LAST_STATUS()); }
// now see if this is a directory
if (dwAttributes & FILE_ATTRIBUTE_DIRECTORY) { return(STATUS_SUCCESS); }
return(NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND));
}
/* Function:
* dempLFNCreateSubst * Creates, if possible, new mapping for the supplied dos drive number, * mapping it to the supplied path * * Parameters * IN uDriveNum - dos drive number (current-0, a-1, b-2, etc) * IN pPathName - pointer to unicode Path String * * Return * NT Error code * * Note: * Win95 never works properly with the current drive, we essentially * ignore this case * */
DWORDdempLFNCreateSubst( UINT uiDriveNum, PUNICODE_STRING pPathName){ // first, make a dos drive name
WCHAR wszDriveStr[3]; DWORD dwStatus; WCHAR wszSubstPath[MAX_PATH];
wszDriveStr[0] = L'@' + uiDriveNum; wszDriveStr[1] = L':'; wszDriveStr[2] = UNICODE_NULL;
if (!QueryDosDeviceW(wszDriveStr, wszSubstPath, ARRAYCOUNT(wszSubstPath))) { dwStatus = GetLastError();
if (ERROR_FILE_NOT_FOUND == dwStatus) {
// check for the input path validity - it better be valid
// or else...
dwStatus = dempLFNCheckDirectory(pPathName); if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
if (DefineDosDeviceW(0, wszDriveStr, pPathName->Buffer)) { // patch in cds for this device
// BUGBUG
return(STATUS_SUCCESS); }
dwStatus = GetLastError(); }
}
return (NT_STATUS_FROM_WIN32(dwStatus));}
/* Function:
* dempLFNRemoveSubst * Removes mapping for the supplied dos drive number * * Parameters * IN uDriveNum - dos drive number (current-0, a-1, b-2, etc) * * Return * NT Error code * * Note: * Win95 never works properly with the current drive, we essentially * ignore this case * */
DWORDdempLFNRemoveSubst( UINT uiDriveNum){ // for this one query for real subst
WCHAR wszDriveStr[3]; PUNICODE_STRING pUnicodeStatic; DWORD dwStatus;
wszDriveStr[0] = L'@' + uiDriveNum; wszDriveStr[1] = L':'; wszDriveStr[2] = UNICODE_NULL;
pUnicodeStatic = &NtCurrentTeb()->StaticUnicodeString; // query
dwStatus = dempQuerySubst(wszDriveStr[0], pUnicodeStatic);
if (NT_SUCCESS(dwStatus)) { if (DefineDosDeviceW(DDD_REMOVE_DEFINITION, wszDriveStr, pUnicodeStatic->Buffer)) { // BUGBUG -- patch in cds for this device
return(STATUS_SUCCESS); }
dwStatus = GET_LAST_STATUS(); }
return(dwStatus);}
/* Function:
* dempLFNQuerySubst * Queries the supplied dos drive number for being a substitute drive, * retrieves dos drive mapping if so * * Parameters * IN uDriveNum - dos drive number (current-0, a-1, b-2, etc) * OUT pSubstPath - receives drive mapping if drive is a subst * * Return * NT Error code * * Note: * Win95 never works properly with the current drive, we essentially * ignore this case -- This is BUGBUG for this api * */
DWORDdempLFNQuerySubst( UINT uiDriveNum, PUNICODE_STRING pSubstPath){ DWORD dwStatus;
dwStatus = dempQuerySubst((WCHAR)(L'@' + uiDriveNum), pSubstPath); return(dwStatus);}
/* Function:
* demLFNSubstControl * Implements Subst APIs for any valid minor code * * Parameters * IN uiMinorCode - function to perform (see enumSubstMinorCode below) * IN uDriveNum - dos drive number (current-0, a-1, b-2, etc) * IN OUT pSubstPath - receives/supplies drive mapping if drive is a subst * * Return * NT Error code * * Note: * */
DWORDdemLFNSubstControl( UINT uiMinorCode, UINT uiDriveNum, LPSTR lpPathName){ DWORD dwStatus; OEM_STRING oemPathName; PUNICODE_STRING pUnicodeStatic = NULL;
switch(uiMinorCode) { case fnCreateSubst:
RtlInitOemString(&oemPathName, lpPathName); pUnicodeStatic = GET_STATIC_UNICODE_STRING_PTR();
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStatic, &oemPathName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStatic, &oemPathName, FALSE); // allocate result
#endif
if (NT_SUCCESS(dwStatus)) { dwStatus = dempLFNCreateSubst(uiDriveNum, pUnicodeStatic); } break;
case fnRemoveSubst: dwStatus = dempLFNRemoveSubst(uiDriveNum); break;
case fnQuerySubst: // query lfn stuff
pUnicodeStatic = GET_STATIC_UNICODE_STRING_PTR();
dwStatus = dempLFNQuerySubst(uiDriveNum, pUnicodeStatic); if (NT_SUCCESS(dwStatus)) { oemPathName.Length = 0; oemPathName.MaximumLength = MAX_PATH; oemPathName.Buffer = lpPathName;
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemUnicodeStringToDestinationString(&oemPathName, pUnicodeStatic, FALSE, FALSE);#else
dwStatus = RtlUnicodeStringToOemString(&oemPathName, pUnicodeStatic, FALSE);#endif
} break; default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION); }
//
// the only thing this ever returns on Win95 is
// 0x1 - error/invalid function
// 0xf - error/invalid drive (invalid drive)
// 0x3 - error/path not found (if bad path is given)
return(dwStatus);}
/* Function
* dempLFNMatchFile * Matches the given search hit with attributes provided by a search call * * Parameters * pFindDataW - Unicode WIN32_FIND_DATA structure as returned by FindFirstFile * or FindNextFile apis * * wMustMatchAttributes - attribs that given file must match * wSearchAttributes - search attribs for the file * * Returns * TRUE if the file matches the search criteria * * */
BOOLdempLFNMatchFile( PWIN32_FIND_DATAW pFindDataW, USHORT wMustMatchAttributes, USHORT wSearchAttributes){ DWORD dwAttributes = pFindDataW->dwFileAttributes;
// now clear out a volume id flag - it is not matched here
dwAttributes &= ~DEM_FILE_ATTRIBUTE_VOLUME_ID;
return ( ((dwAttributes & (DWORD)wMustMatchAttributes) == (DWORD)wMustMatchAttributes) && (((dwAttributes & (~(DWORD)wSearchAttributes)) & 0x1e) == 0));}
DWORDdempLFNFindFirstFile( HANDLE* pFindHandle, PUNICODE_STRING pFileName, PWIN32_FIND_DATAW pFindDataW, USHORT wMustMatchAttributes, USHORT wSearchAttributes){ HANDLE hFindFile; DWORD dwStatus;
// match the volume file name first
hFindFile = FindFirstFileW(pFileName->Buffer, pFindDataW); if (INVALID_HANDLE_VALUE != hFindFile) { BOOL fContinue = TRUE;
while (!dempLFNMatchFile(pFindDataW, wMustMatchAttributes, wSearchAttributes) && fContinue) { fContinue = FindNextFileW(hFindFile, pFindDataW); }
if (fContinue) { // we found some
*pFindHandle = hFindFile; return(STATUS_SUCCESS); } else { // ; return file not found error
SetLastError(ERROR_FILE_NOT_FOUND); }
}
dwStatus = GET_LAST_STATUS(); if (INVALID_HANDLE_VALUE != hFindFile) { FindClose(hFindFile); }
return(dwStatus);}
DWORDdempLFNFindNextFile( HANDLE hFindFile, PWIN32_FIND_DATAW pFindDataW, USHORT wMustMatchAttributes, USHORT wSearchAttributes){ BOOL fFindNext;
do {
fFindNext = FindNextFileW(hFindFile, pFindDataW); if (fFindNext && dempLFNMatchFile(pFindDataW, wMustMatchAttributes, wSearchAttributes)) { // found a match!
return(STATUS_SUCCESS); } } while (fFindNext);
return(GET_LAST_STATUS());}
// the handle we return is a number of the entry into this table below
// with high bit turned on (to be different then any other handle in dos)
DWORDdempLFNAllocateHandleEntry( PUSHORT pDosHandle, PLFN_SEARCH_HANDLE_ENTRY* ppHandleEntry){ PLFN_SEARCH_HANDLE_ENTRY pHandleEntry = gSearchHandleTable.pHandleTable;
if (NULL == pHandleEntry) { pHandleEntry = RtlAllocateHeap(RtlProcessHeap(), 0, LFN_SEARCH_HANDLE_INITIAL_SIZE * sizeof(LFN_SEARCH_HANDLE_ENTRY)); if (NULL == pHandleEntry) { return(NT_STATUS_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY)); // not enough memory
} gSearchHandleTable.pHandleTable = pHandleEntry; gSearchHandleTable.nTableSize = LFN_SEARCH_HANDLE_INITIAL_SIZE; gSearchHandleTable.nHandleCount = 0; gSearchHandleTable.nFreeEntry = LFN_SEARCH_HANDLE_LIST_END; }
// walk the free list if available....
if (LFN_SEARCH_HANDLE_LIST_END != gSearchHandleTable.nFreeEntry) { pHandleEntry += gSearchHandleTable.nFreeEntry; gSearchHandleTable.nFreeEntry = pHandleEntry->nNextFreeEntry; } else { // no free entries, should we grow ?
UINT nHandleCount = gSearchHandleTable.nHandleCount; if (nHandleCount >= gSearchHandleTable.nTableSize) { // oops - need to grow.
UINT nTableSize = gSearchHandleTable.nTableSize + LFN_SEARCH_HANDLE_INCREMENT;
if (nTableSize >= LFN_DOS_HANDLE_LIMIT) { // handle as error - we cannot have that many handles
}
pHandleEntry = RtlReAllocateHeap(RtlProcessHeap(), 0, pHandleEntry, nTableSize * sizeof(LFN_SEARCH_HANDLE_ENTRY)); if (NULL != pHandleEntry) { gSearchHandleTable.pHandleTable = pHandleEntry; gSearchHandleTable.nTableSize = nTableSize; } else { // error - out of memory
return(NT_STATUS_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY)); }
}
// now set the new entry
pHandleEntry += nHandleCount; gSearchHandleTable.nHandleCount = nHandleCount + 1; }
*pDosHandle = (USHORT)(pHandleEntry - gSearchHandleTable.pHandleTable) | LFN_DOS_HANDLE_MASK; *ppHandleEntry = pHandleEntry; return(STATUS_SUCCESS);
}
/*
* The list of free entries is sorted in the last-to-first order * * */
VOIDdempLFNFreeHandleEntry( PLFN_SEARCH_HANDLE_ENTRY pHandleEntry){ UINT nHandleCount = gSearchHandleTable.nHandleCount - 1; UINT DosHandle = (UINT)(pHandleEntry - gSearchHandleTable.pHandleTable);
// this is the entry - is this the last one ?
if (DosHandle == nHandleCount) { // if so, chop it off
UINT nCurHandle = gSearchHandleTable.nFreeEntry;
// if this handle was the last one and is gone, maybe
// shrink the list by checking free entry list
// this is rather simple as the list is sorted in high-to-low
// numerical order
while (LFN_SEARCH_HANDLE_LIST_END != nCurHandle && nCurHandle == (nHandleCount-1)) { --nHandleCount; nCurHandle = gSearchHandleTable.pHandleTable[nCurHandle].nNextFreeEntry; }
// now update free list entry and handle count
gSearchHandleTable.nFreeEntry = nCurHandle; gSearchHandleTable.nHandleCount = nHandleCount;
} else { // mark as free and include in the free list
// find an in-order spot for it
// this means that the first free handle in the list has the biggest
// numerical value, thus facilitating shrinking of the table if needed
UINT nCurHandle = gSearchHandleTable.nFreeEntry; UINT nPrevHandle = LFN_SEARCH_HANDLE_LIST_END; PLFN_SEARCH_HANDLE_ENTRY pHandlePrev;
while (LFN_SEARCH_HANDLE_LIST_END != nCurHandle && nCurHandle > DosHandle) { nPrevHandle = nCurHandle; nCurHandle = gSearchHandleTable.pHandleTable[nCurHandle].nNextFreeEntry; }
// at this point nCurHandle == -1 or nCurHandle < DosHandle
// insert DosHandle in between nPrevHandle and nCurHandle
if (LFN_SEARCH_HANDLE_LIST_END == nPrevHandle) { // becomes the first item
pHandleEntry->nNextFreeEntry = gSearchHandleTable.nFreeEntry; gSearchHandleTable.nFreeEntry = DosHandle; } else { pHandlePrev = gSearchHandleTable.pHandleTable + nPrevHandle;
pHandleEntry->nNextFreeEntry = pHandlePrev->nNextFreeEntry; pHandlePrev->nNextFreeEntry = DosHandle; }
pHandleEntry->wProcessPDB = 0; // no pdb there
}}
PLFN_SEARCH_HANDLE_ENTRYdempLFNGetHandleEntry( USHORT DosHandle){ PLFN_SEARCH_HANDLE_ENTRY pHandleEntry = NULL;
if (DosHandle & LFN_DOS_HANDLE_MASK) {
DosHandle &= ~LFN_DOS_HANDLE_MASK; // this is to filter real offset
if (NULL != gSearchHandleTable.pHandleTable) { UINT nHandleCount = gSearchHandleTable.nHandleCount; if (DosHandle < nHandleCount) { pHandleEntry = gSearchHandleTable.pHandleTable + DosHandle; if (pHandleEntry->wProcessPDB != FETCHWORD(*pusCurrentPDB)) { return(NULL); } } } }
return(pHandleEntry);}
VOIDdempLFNCloseSearchHandles( VOID){ INT DosHandle;
for (DosHandle = (int)gSearchHandleTable.nHandleCount-1; DosHandle >= 0; --DosHandle) { PLFN_SEARCH_HANDLE_ENTRY pHandleEntry;
pHandleEntry = dempLFNGetHandleEntry((USHORT)(DosHandle|LFN_DOS_HANDLE_MASK)); if (NULL != pHandleEntry) { if (INVALID_HANDLE_VALUE != pHandleEntry->hFindHandle) { FindClose(pHandleEntry->hFindHandle); } dempLFNFreeHandleEntry(pHandleEntry); } }}
DWORD dempLFNConvertFileTime( FILETIME* pDosFileTime, FILETIME* pNTFileTime, UINT uDateTimeFormat){ DWORD dwStatus = STATUS_SUCCESS;
// before we do that assume pNTFileTime is a UTC time
switch (uDateTimeFormat) { case dtfDos: { WORD wDosDate, wDosTime; BOOL fResult; LARGE_INTEGER ftNT = { pNTFileTime->dwLowDateTime, pNTFileTime->dwHighDateTime }; LARGE_INTEGER ftDos0 = { gFileTimeDos0.dwLowDateTime, gFileTimeDos0.dwHighDateTime };
//
// before we start frolicking with local file time, check to see
// if the nt filetime refers to 01-01-80 and if so, keep it this way
//
if (ftNT.QuadPart <= ftDos0.QuadPart) { *pDosFileTime = gFileTimeDos0; fResult = TRUE; } else { fResult = FileTimeToLocalFileTime(pNTFileTime, pDosFileTime); }
if (fResult) { fResult = FileTimeToDosDateTime(pDosFileTime, &wDosDate, &wDosTime); }
if (fResult) { // date is in high-order word low dword
// time is in low-order word of a low dword
pDosFileTime->dwLowDateTime = (DWORD)MAKELONG(wDosTime, wDosDate); pDosFileTime->dwHighDateTime = 0; } else { dwStatus = GET_LAST_STATUS(); } } break;
case dtfWin32: *pDosFileTime = *pNTFileTime; break;
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER); break; }
return(dwStatus);}
// please note that the date time format in case of 32-bit is not returned
// local but the original 32-bit
//
// Note that if we pass lpFileName
// and lpAltFileName
// than this is what will be used for these fields...
//
NTSTATUSdempLFNConvertFindDataUnicodeToOem( LPWIN32_FIND_DATA lpFindDataOem, LPWIN32_FIND_DATAW lpFindDataW, UINT uDateTimeFormat, PUSHORT pConversionCode, LPSTR lpFileName, LPSTR lpAltFileName )
{ OEM_STRING oemString; UNICODE_STRING unicodeString; NTSTATUS dwStatus; WORD wConversionCode = 0;
dwStatus = dempLFNConvertFileTime(&lpFindDataOem->ftLastWriteTime, &lpFindDataW->ftLastWriteTime, uDateTimeFormat); if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
if (0 == lpFindDataW->ftCreationTime.dwLowDateTime && 0 == lpFindDataW->ftCreationTime.dwHighDateTime) { lpFindDataW->ftCreationTime = lpFindDataW->ftLastWriteTime; }
dwStatus = dempLFNConvertFileTime(&lpFindDataOem->ftCreationTime, &lpFindDataW->ftCreationTime, uDateTimeFormat); if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
if (0 == lpFindDataW->ftLastAccessTime.dwLowDateTime && 0 == lpFindDataW->ftLastAccessTime.dwHighDateTime) { lpFindDataW->ftLastAccessTime = lpFindDataW->ftLastWriteTime; }
dwStatus = dempLFNConvertFileTime(&lpFindDataOem->ftLastAccessTime, &lpFindDataW->ftLastAccessTime, uDateTimeFormat); if (!NT_SUCCESS(dwStatus)) { // could be a bogus last access date time as provided to us by win32
// don't bail out! Just give same as creation time
return(dwStatus); }
// convert both the name and the alternative name
oemString.Buffer = (NULL == lpFileName) ? lpFindDataOem->cFileName : lpFileName; oemString.MaximumLength = ARRAYCOUNT(lpFindDataOem->cFileName); oemString.Length = 0;
RtlInitUnicodeString(&unicodeString, lpFindDataW->cFileName);
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemUnicodeStringToDestinationString(&oemString, &unicodeString, FALSE, TRUE); // verify result
if (!NT_SUCCESS(dwStatus)) { if (STATUS_UNMAPPABLE_CHARACTER == dwStatus) { wConversionCode |= 0x01; // mask we have unmappable chars in file name
} else { return(dwStatus); // failed
} }
#else
dwStatus = RtlUnicodeStringToCountedOemString(&oemString, &unicodeString, FALSE); if (!NT_SUCCESS(dwStatus)) { if (STATUS_UNMAPPABLE_CHARACTER == dwStatus) { wConversionCode |= 0x01; } else { return(dwStatus); } }
if (oemString.Length < oemString.MaximumLength) { oemString.Buffer[oemString.Length] = '\0'; } else { if (NULL == oemString.Buffer) { // string is empty
*lpFindDataOem->cFileName = '\0'; } else { return(STATUS_BUFFER_OVERFLOW); } }
#endif
oemString.Buffer = (NULL == lpAltFileName) ? lpFindDataOem->cAlternateFileName : lpAltFileName; oemString.MaximumLength = ARRAYCOUNT(lpFindDataOem->cAlternateFileName); oemString.Length = 0;
RtlInitUnicodeString(&unicodeString, lpFindDataW->cAlternateFileName);
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemUnicodeStringToDestinationString(&oemString, &unicodeString, FALSE, TRUE); // verify result
if (!NT_SUCCESS(dwStatus)) { if (STATUS_UNMAPPABLE_CHARACTER == dwStatus) { wConversionCode |= 0x02; // mask we have unmappable chars in file name
} else { return(dwStatus); // failed
} }
#else
dwStatus = RtlUnicodeStringToCountedOemString(&oemString, &unicodeString, FALSE); if (!NT_SUCCESS(dwStatus)) { if (STATUS_UNMAPPABLE_CHARACTER == dwStatus) { wConversionCode |= 0x02; } else { return(dwStatus); } }
if (oemString.Length < oemString.MaximumLength) { oemString.Buffer[oemString.Length] = '\0'; } else { if (NULL == oemString.Buffer) { // 0-length string
*lpFindDataOem->cAlternateFileName = '\0'; } else { return(STATUS_BUFFER_OVERFLOW); } }
#endif
// attributes - these are not touched at the moment
lpFindDataOem->dwFileAttributes = lpFindDataW->dwFileAttributes;
// file size
lpFindDataOem->nFileSizeHigh = lpFindDataW->nFileSizeHigh; lpFindDataOem->nFileSizeLow = lpFindDataW->nFileSizeLow;
// set the conversion code here
*pConversionCode = wConversionCode;
return(STATUS_SUCCESS);}
NTSTATUSdemLFNFindFirstFile( LPSTR lpFileName, // file name to look for
LPWIN32_FIND_DATA lpFindData, USHORT wDateTimeFormat, USHORT wMustMatchAttributes, USHORT wSearchAttributes, PUSHORT pConversionCode, // points to conversion code -- out
PUSHORT pDosHandle, // points to dos handle -- out
LPSTR lpDstFileName, // points to a destination for a file name
LPSTR lpAltFileName // points to a destination for a short name
) // hibyte == MustMatchAttrs, lobyte == SearchAttrs
{ HANDLE hFindFile; WIN32_FIND_DATAW FindDataW; PLFN_SEARCH_HANDLE_ENTRY pHandleEntry; NTSTATUS dwStatus; PUNICODE_STRING pUnicodeStaticFileName; OEM_STRING oemFileName;
//
// convert parameters to unicode - we use a static string here
//
RtlInitOemString(&oemFileName, lpFileName);
pUnicodeStaticFileName = GET_STATIC_UNICODE_STRING_PTR();
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStaticFileName, &oemFileName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStaticFileName, &oemFileName, FALSE);#endif
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
// match volume label here
if (DEM_FILE_ATTRIBUTE_VOLUME_ID == wMustMatchAttributes && DEM_FILE_ATTRIBUTE_VOLUME_ID == wSearchAttributes) {
// this is a query for the volume information file
// actually this is what documented, yet ifsmgr source tells a different
// story. We adhere to documentation here as it is much simpler to do it
// this way, see fastfat source in Win95 for more fun with matching
// attrs and files
// match the volume label and if we do have a match then
// call RtlCreateDestinationString( ); to create a string that is stored
// inside the HandleEntry
return(0); }
// normalize path
dempLFNNormalizePath(pUnicodeStaticFileName);
// call worker api
dwStatus = dempLFNFindFirstFile(&hFindFile, pUnicodeStaticFileName, &FindDataW, wMustMatchAttributes, wSearchAttributes);
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
//
// convert from unicode to oem
//
dwStatus = dempLFNConvertFindDataUnicodeToOem(lpFindData, &FindDataW, (UINT)wDateTimeFormat, pConversionCode, lpDstFileName, lpAltFileName); if (!NT_SUCCESS(dwStatus)) { if (INVALID_HANDLE_VALUE != hFindFile) { FindClose(hFindFile); } return(dwStatus); }
// allocate dos handle if needed
dwStatus = dempLFNAllocateHandleEntry(pDosHandle, &pHandleEntry); if (NT_SUCCESS(dwStatus)) { pHandleEntry->hFindHandle = hFindFile; pHandleEntry->wMustMatchAttributes = wMustMatchAttributes; pHandleEntry->wSearchAttributes = wSearchAttributes; pHandleEntry->wProcessPDB = *pusCurrentPDB; } else { // could not allocate dos handle
if (NULL != hFindFile) { FindClose(hFindFile); }
}
return(dwStatus);}
VOIDdemLFNCleanup( VOID){ // this fn will cleanup after unclosed lfn searches
dempLFNCloseSearchHandles();
// also -- close the clipboard if this api has been used by the application
// in question. How do we know ???
}
DWORDdemLFNFindNextFile( USHORT DosHandle, LPWIN32_FIND_DATAA lpFindData, USHORT wDateTimeFormat, PUSHORT pConversionCode, LPSTR lpFileName, LPSTR lpAltFileName)
{ // unpack parameters
WIN32_FIND_DATAW FindDataW; PLFN_SEARCH_HANDLE_ENTRY pHandleEntry; DWORD dwStatus; USHORT ConversionStatus;
// this call never has to deal with volume labels
//
pHandleEntry = dempLFNGetHandleEntry(DosHandle); if (NULL != pHandleEntry) {
// possible we had a volume-label match the last time around
// so we should then deploy dempLFNFindFirstFile if this the case
//
if (INVALID_HANDLE_VALUE == pHandleEntry->hFindHandle) { dwStatus = dempLFNFindFirstFile(&pHandleEntry->hFindHandle, &pHandleEntry->unicodeFileName, &FindDataW, pHandleEntry->wMustMatchAttributes, pHandleEntry->wSearchAttributes);
RtlFreeUnicodeString(&pHandleEntry->unicodeFileName); } else { dwStatus = dempLFNFindNextFile(pHandleEntry->hFindHandle, &FindDataW, pHandleEntry->wMustMatchAttributes, pHandleEntry->wSearchAttributes); } if (NT_SUCCESS(dwStatus)) { // this is ok
dwStatus = dempLFNConvertFindDataUnicodeToOem(lpFindData, &FindDataW, wDateTimeFormat, pConversionCode, lpFileName, lpAltFileName); }
} else { dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_HANDLE); }
return(dwStatus);}
DWORDdemLFNFindClose( USHORT DosHandle){ PLFN_SEARCH_HANDLE_ENTRY pHandleEntry; DWORD dwStatus = STATUS_SUCCESS;
pHandleEntry = dempLFNGetHandleEntry(DosHandle); if (NULL != pHandleEntry) { if (INVALID_HANDLE_VALUE != pHandleEntry->hFindHandle) { dwStatus = FindClose(pHandleEntry->hFindHandle); }
dempLFNFreeHandleEntry(pHandleEntry); } else { // invalid handle
dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_HANDLE); }
return(dwStatus);
}
////////////////////////////////////////////////////////////////////////////
//
// The current directory wrath
//
//
//
// Rules:
// - we keep the directory in question in SHORT form
// - if the length of it exceeds what's in CDS -- then we
// keep it in LCDS
// current directory is stored:
// TDB -- \foo\blah
// cds -- c:\foo\blah
// getcurrentdirectory apis return foo\blah
//
#define MAX_DOS_DRIVES 26
// we need flags to mark when our current directory is out of sync
// so that we could provide for it's long version when necessary
//
#define LCDS_VALID 0x00000001 // curdir on the drive is valid
#define LCDS_SYNC 0x00000002 // curdir on the drive has to be synced
typedef struct tagLCDSEntry { CHAR szCurDir[MAX_PATH]; DWORD dwFlags;} LCDSENTRY, *PLCDSENTRY;
// this is stored here, so we can have our current directories per
// drive in their long form
PLCDSENTRY rgCurDirs[MAX_DOS_DRIVES] = {NULL};
#define CD_NOTDB 0x00010000 // ignore tdb
#define CD_NOCDS 0x00020000 // ignore cds
#define CD_DIRNAMEMASK 0x0000FFFF
#define CD_SHORTDIRNAME 0x00000001
#define CD_LONGDIRNAME 0x00000002
#define CD_CDSDIRNAME 0x00000003
typedef enum tagDirType { dtLFNDirName = CD_LONGDIRNAME, dtShortDirName = CD_SHORTDIRNAME, dtCDSDirName = CD_CDSDIRNAME} enumDirType;
// drive here is 0-25
// check whether we received this ptr from wow
BOOL (*DosWowGetTDBDir)(UCHAR Drive, LPSTR pCurrentDirectory);VOID (*DosWowUpdateTDBDir)(UCHAR Drive, LPSTR pCurrentDirectory);BOOL (*DosWowDoDirectHDPopup)(VOID);
// makes sure cds directory is valid
BOOL dempValidateDirectory (PCDS pcds, UCHAR Drive){ DWORD dw; CHAR chDrive; static CHAR pPath[]="?:\\"; static CHAR EnvVar[] = "=?:";
// validate media
chDrive = Drive + 'A'; pPath[0] = chDrive; dw = GetFileAttributesOem(pPath); if (dw == 0xFFFFFFFF || !(dw & FILE_ATTRIBUTE_DIRECTORY)) { return (FALSE); }
// if invalid path, set path to the root
// reset CDS, and win32 env for win32
dw = GetFileAttributesOem(pcds->CurDir_Text); if (dw == 0xFFFFFFFF || !(dw & FILE_ATTRIBUTE_DIRECTORY)) { strcpy(pcds->CurDir_Text, pPath); pcds->CurDir_End = 2; EnvVar[1] = chDrive; SetEnvironmentVariableOem(EnvVar,pPath); }
return (TRUE);}
// drive here is 0-25
// returns: pointer to cds entry
PCDS dempGetCDSPtr(USHORT Drive){ PCDS pCDS = NULL; static CHAR Path[] = "?:\\";
if (Drive >= (USHORT)*(PUCHAR)DosWowData.lpCDSCount) { // so it's more than fixed
if (Drive <= (MAX_DOS_DRIVES-1)) { Path[0] = 'A' + Drive; if ((USHORT)*(PUCHAR)DosWowData.lpCurDrv == Drive || GetDriveType(Path) > DRIVE_NO_ROOT_DIR) { pCDS = (PCDS)DosWowData.lpCDSBuffer; } } } else { Path[0] = 'A' + Drive; if (1 != Drive || (DRIVE_REMOVABLE == GetDriveType(Path))) { pCDS = (PCDS)DosWowData.lpCDSFixedTable;#ifdef FE_SB
if (GetSystemDefaultLangID() == MAKELANGID(LANG_JAPANESE,SUBLANG_DEFAULT)) { pCDS = (PCDS)((ULONG)pCDS + (Drive*sizeof(CDS_JPN))); } else pCDS = (PCDS)((ULONG)pCDS + (Drive*sizeof(CDS)));#else
pCDS = (PCDS)((ULONG)pCDS + (Drive*sizeof(CDS)));#endif
} } return pCDS;}
#define MAXIMUM_VDM_CURRENT_DIR 64
BOOLdempUpdateCDS(USHORT Drive, PCDS pcds){ // update cds with the current directory as specified in env variable
// please note that it only happens upon a flag being reset in cds
static CHAR EnvVar[] = "=?:"; DWORD EnvVarLen; BOOL bStatus = TRUE; UCHAR FixedCount; int i; PCDS pcdstemp;
FixedCount = *(PUCHAR) DosWowData.lpCDSCount; //
// from Macro.Asm in DOS:
// ; Sudeepb 20-Dec-1991 ; Added for redirected drives
// ; We always sync the redirected drives. Local drives are sync
// ; as per the curdir_tosync flag and SCS_ToSync
//
if (*(PUCHAR)DosWowData.lpSCS_ToSync) {
#ifdef FE_SB
if (GetSystemDefaultLangID() == MAKELANGID(LANG_JAPANESE,SUBLANG_DEFAULT)) { PCDS_JPN pcdstemp_jpn;
pcdstemp_jpn = (PCDS_JPN) DosWowData.lpCDSFixedTable; for (i=0;i < (int)FixedCount; i++, pcdstemp_jpn++) pcdstemp_jpn->CurDirJPN_Flags |= CURDIR_TOSYNC; } else { pcdstemp = (PCDS) DosWowData.lpCDSFixedTable; for (i=0;i < (int)FixedCount; i++, pcdstemp++) pcdstemp->CurDir_Flags |= CURDIR_TOSYNC; }#else
pcdstemp = (PCDS) DosWowData.lpCDSFixedTable; for (i=0;i < (int)FixedCount; i++, pcdstemp++) pcdstemp->CurDir_Flags |= CURDIR_TOSYNC;#endif
// Mark tosync in network drive as well
pcdstemp = (PCDS)DosWowData.lpCDSBuffer; pcdstemp->CurDir_Flags |= CURDIR_TOSYNC;
*(PUCHAR)DosWowData.lpSCS_ToSync = 0; }
// If CDS needs to be synched or if the requested drive is different
// then the the drive being used by NetCDS go refresh the CDS.
if ((pcds->CurDir_Flags & CURDIR_TOSYNC) || ((Drive >= FixedCount) && (pcds->CurDir_Text[0] != (Drive + 'A') && pcds->CurDir_Text[0] != (Drive + 'a')))) { // validate media
EnvVar[1] = Drive + 'A'; if((EnvVarLen = GetEnvironmentVariableOem (EnvVar, (LPSTR)pcds, MAXIMUM_VDM_CURRENT_DIR+3)) == 0){
// if its not in env then and drive exist then we have'nt
// yet touched it.
pcds->CurDir_Text[0] = EnvVar[1]; pcds->CurDir_Text[1] = ':'; pcds->CurDir_Text[2] = '\\'; pcds->CurDir_Text[3] = 0; SetEnvironmentVariableOem ((LPSTR)EnvVar,(LPSTR)pcds); }
if (EnvVarLen > MAXIMUM_VDM_CURRENT_DIR+3) { //
// The current directory on this drive is too long to fit in the
// cds. That's ok for a win16 app in general, since it won't be
// using the cds in this case. But just to be more robust, put
// a valid directory in the cds instead of just truncating it on
// the off chance that it gets used.
//
pcds->CurDir_Text[0] = EnvVar[1]; pcds->CurDir_Text[1] = ':'; pcds->CurDir_Text[2] = '\\'; pcds->CurDir_Text[3] = 0; }
pcds->CurDir_Flags &= 0xFFFF - CURDIR_TOSYNC; pcds->CurDir_End = 2;
}
if (!bStatus) {
*(PUCHAR)DosWowData.lpDrvErr = ERROR_INVALID_DRIVE; }
return (bStatus);}
// takes:
// Drive 0-25
// returns:
// fully-qualified current directory if success
//
NTSTATUSdempGetCurrentDirectoryTDB(UCHAR Drive, LPSTR pCurDir){ NTSTATUS Status;
// see if we're wow-bound
if (NULL != DosWowGetTDBDir) { if (DosWowGetTDBDir(Drive, &pCurDir[3])) { pCurDir[0] = 'A' + Drive; pCurDir[1] = ':'; pCurDir[2] = '\\'; return(STATUS_SUCCESS); } }
return(NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND));}
VOIDdempSetCurrentDirectoryTDB(UCHAR Drive, LPSTR pCurDir){ if (NULL != DosWowUpdateTDBDir) { DosWowUpdateTDBDir(Drive, pCurDir); }}
NTSTATUSdempGetCurrentDirectoryCDS(UCHAR Drive, LPSTR pCurDir){ PCDS pCDS; NTSTATUS Status = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND);
if (NULL != (pCDS = dempGetCDSPtr(Drive))) { if (dempUpdateCDS(Drive, pCDS)) { // now we can get cds data
// DOS. sudeepb 30-Dec-1993
if (!(pCDS->CurDir_Flags & CURDIR_NT_FIX)) { // that means -- re-query the drive
if (!dempValidateDirectory(pCDS, Drive)) { return(Status); } }
strcpy(pCurDir, &pCDS->CurDir_Text[0]); Status = STATUS_SUCCESS; }
} return(Status);}
BOOLdempValidateDirectoryCDS(PCDS pCDS, UCHAR Drive){ BOOL fValid = TRUE;
if (NULL == pCDS) { pCDS = dempGetCDSPtr(Drive); } if (NULL != pCDS) { if (!(pCDS->CurDir_Flags & CURDIR_NT_FIX)) { fValid = dempValidateDirectory(pCDS, Drive); } } return(fValid);}
// we assume that drive here is 0-based drive number and
// pszDir is a full-formed path
NTSTATUSdempSetCurrentDirectoryCDS(UCHAR Drive, LPSTR pszDir){ PCDS pCDS; NTSTATUS Status = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND);
if (NULL != (pCDS = dempGetCDSPtr(Drive))) { // cds retrieved successfully
// now for this drive -- validate
if (strlen(pszDir) > MAXIMUM_VDM_CURRENT_DIR+3) { // put a valid directory in cds just for robustness' sake
strncpy(&pCDS->CurDir_Text[0], pszDir, 3); pCDS->CurDir_Text[3] = '\0'; Status = STATUS_SUCCESS; } else { strcpy(&pCDS->CurDir_Text[0], pszDir); Status = STATUS_SUCCESS; } } return(Status);}
// just manipulate curdir caches
NTSTATUSdemSetCurrentDirectoryLCDS(UCHAR Drive, LPSTR pCurDir){ PLCDSENTRY pCurDirCache;
pCurDirCache = rgCurDirs[Drive]; if (NULL == pCurDir) { if (NULL != pCurDirCache) { RtlFreeHeap(RtlProcessHeap(), 0, pCurDirCache); rgCurDirs[Drive] = NULL; return(STATUS_SUCCESS); } } else { if (NULL == pCurDirCache) { pCurDirCache = RtlAllocateHeap(RtlProcessHeap(), 0, sizeof(LCDSENTRY));
if (NULL == pCurDirCache) { return(NT_STATUS_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY)); } } }
strcpy(pCurDirCache->szCurDir, pCurDir);
return(STATUS_SUCCESS);}
// pCurDir is valid to be NULL -- meaning -- just checking if the dir
// for this drive is cached
NTSTATUSdemGetCurrentDirectoryLCDS(UCHAR Drive, LPSTR pCurDir){ PLCDSENTRY pCurDirCache; NTSTATUS Status = STATUS_SUCCESS;
pCurDirCache = rgCurDirs[Drive]; if (NULL != pCurDirCache) { if (NULL != pCurDir) { strcpy(pCurDir, pCurDirCache->szCurDir); } } else { Status = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND); }
return(Status);}
NTSTATUSdempGetCurrentDirectoryWin32(UCHAR Drive, LPSTR pCurDir){ // we do a getenvironment blah instead
static CHAR EnvVar[] = "=?:\\"; DWORD EnvVarLen; DWORD dwAttributes; NTSTATUS Status = STATUS_SUCCESS;
EnvVar[1] = 'A' + Drive; EnvVarLen = GetEnvironmentVariableOem (EnvVar, pCurDir, MAX_PATH); if (0 == EnvVarLen) { // that was not touched before
pCurDir[0] = EnvVar[1]; pCurDir[1] = ':'; pCurDir[2] = '\\'; pCurDir[3] = '\0'; SetEnvironmentVariableOem ((LPSTR)EnvVar,(LPSTR)pCurDir); } else { if (EnvVarLen > MAX_PATH) { Status = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND); return(Status); } // if we're doing it here -- validate dir
dwAttributes = GetFileAttributesOem(pCurDir); if (0xffffffff == dwAttributes) { Status = GET_LAST_STATUS(); } else { // now see if this is a directory
if (!(dwAttributes & FILE_ATTRIBUTE_DIRECTORY)) { Status = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND); } } }
return(Status);}
// lifted from wdos.c
NTSTATUSdempSetCurrentDirectoryWin32(UCHAR Drive, LPSTR pCurDir){ static CHAR EnvVar[] = "=?:"; CHAR chDrive = Drive + 'A'; BOOL bRet; NTSTATUS Status = STATUS_SUCCESS;
// ok -- we are setting the current directory ONLY if the drive
// is the current drive for the app
if (*(PUCHAR)DosWowData.lpCurDrv == Drive) { // if on the current drive--go win32
bRet = SetCurrentDirectoryOem(pCurDir); if (!bRet) { Status = GET_LAST_STATUS(); } } else { // verify it's a valid dir
DWORD dwAttributes;
dwAttributes = GetFileAttributesOem(pCurDir); bRet = (0xffffffff != dwAttributes) && (dwAttributes & FILE_ATTRIBUTE_DIRECTORY); if (!bRet) { Status = STATUS_INVALID_HANDLE; } }
if (!bRet) { return(Status); }
EnvVar[1] = chDrive; bRet = SetEnvironmentVariableOem((LPSTR)EnvVar, pCurDir); if (!bRet) { Status = GET_LAST_STATUS(); }
return (Status);}
NTSTATUSdemGetCurrentDirectoryLong(UCHAR Drive, LPSTR pCurDir, DWORD LongDir){ PLCDSENTRY pCurDirCache = NULL; NTSTATUS Status = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND); CHAR szCurrentDirectory[MAX_PATH];
// first -- attempt to get the dir from tdb in WOW (if this is wow)
// unless off course it's been blocked
if (!(LongDir & CD_NOTDB)) { Status = dempGetCurrentDirectoryTDB(Drive, szCurrentDirectory); }
// now try to get the dir off our cache
if (!NT_SUCCESS(Status)) { // we don't have the dir from TDB
Status = demGetCurrentDirectoryLCDS(Drive, szCurrentDirectory); }
if (!NT_SUCCESS(Status) && !(LongDir & CD_NOCDS)) { // so neither TDB nor LCDS -- try CDS
Status = dempGetCurrentDirectoryCDS(Drive, szCurrentDirectory); }
// so at this point if we've failed -- that means our directory is not
// good at all. Hence return error -- all means have failed
// we do the very last in all the things
if (!NT_SUCCESS(Status)) { // this one could be lfn !
Status = dempGetCurrentDirectoryWin32(Drive, szCurrentDirectory); }
// so we have gone through all the stages --
if (!NT_SUCCESS(Status)) { return(NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND)); }
// now see that we convert the dir we have in a proper manner
switch(LongDir & CD_DIRNAMEMASK) { case dtLFNDirName: Status = demLFNGetPathName(szCurrentDirectory, pCurDir, fnGetLongPathName, FALSE); break; case dtCDSDirName: if (strlen(szCurrentDirectory) > MAXIMUM_VDM_CURRENT_DIR+3) { Status = NT_STATUS_FROM_WIN32(ERROR_BUFFER_OVERFLOW); break; } // intentional fall-through
case dtShortDirName: strcpy(pCurDir, szCurrentDirectory); break; }
return Status;}
// remember -- this should be called with a full-formed path -- short or long
NTSTATUSdemSetCurrentDirectoryLong(UCHAR Drive, LPSTR pCurDir, DWORD LongDir){ NTSTATUS Status; CHAR szCurrentDirectory[MAX_PATH];
// first convert to a short path
Status = demLFNGetPathName(pCurDir, szCurrentDirectory, fnGetShortPathName, FALSE); if (!NT_SUCCESS(Status)) { return(Status); }
Status = dempSetCurrentDirectoryWin32(Drive, szCurrentDirectory); if (!NT_SUCCESS(Status)) { return(Status); }
Status = demSetCurrentDirectoryLCDS(Drive, szCurrentDirectory); if (!NT_SUCCESS(Status)) { return(Status); // memory ?
}
// first we have to see if we have to poke through
if (!(LongDir & CD_NOCDS)) { // set it in cds
Status = dempSetCurrentDirectoryCDS(Drive, szCurrentDirectory); if (!NT_SUCCESS(Status)) { return(Status); } }
if (!(LongDir & CD_NOTDB)) { dempSetCurrentDirectoryTDB(Drive, szCurrentDirectory); }
return(Status);}
/* Rules of engagement:
* * - the env variable -- which ?:= is not useful as it's max length is * limited to 64+3 chars. * - the cds entry is also limited in length * - we have our own entry in the * * - jarbats bug 207913 * demLFNGetCurrentDirectory, returns an empty string, if the current directory is the root * RtlGetFullPathName_U fails when the first parameter (CurrentDirectory) is an empty string * dempLFNSetCurrentDirectory fails * fix by changing empty string to \ * */
NTSTATUSdempLFNSetCurrentDirectory( PUNICODE_STRING pCurrentDirectory, PUINT pDriveNum // optional
){ UNICODE_STRING FullPathName; DWORD dwStatus; RTL_PATH_TYPE RtlPathType; UCHAR Drive; BOOL fCurrentDrive; OEM_STRING OemDirectoryName; CHAR szFullPathOem[MAX_PATH]; WCHAR szFullPathUnicode[MAX_PATH]; LPWSTR lpCurrentDir=L"\\";
if ( pCurrentDirectory->Buffer && pCurrentDirectory->Buffer[0] != L'\0' ) { lpCurrentDir = pCurrentDirectory->Buffer; }
RtlPathType = RtlDetermineDosPathNameType_U(lpCurrentDir); // now --
switch(RtlPathType) { case RtlPathTypeDriveAbsolute:
// this is a chdir on a specific drive -- is this a current drive ?
CharUpperBuffW(lpCurrentDir, 1); Drive = (UCHAR)(lpCurrentDir[0] - L'A'); fCurrentDrive = (Drive == *(PUCHAR)DosWowData.lpCurDrv); break;
case RtlPathTypeDriveRelative: case RtlPathTypeRelative: case RtlPathTypeRooted:
// this is a chdir on a current drive
Drive = *(PUCHAR)DosWowData.lpCurDrv; fCurrentDrive = TRUE; break;
default: // invalid call -- goodbye
dwStatus = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND); goto scdExit; break; }
// please remember that we should have set the current dir
// when curdrive gets selected -- hence we can rely upon win32
// for path expansion...
// actually this is only true for the current drives. In case of this
// particular api it may not be true.
// so -- uncash the current setting here -- bugbug ??
// now get the full path name
FullPathName.Buffer = szFullPathUnicode; FullPathName.MaximumLength = sizeof(szFullPathUnicode);
dwStatus = RtlGetFullPathName_U(lpCurrentDir, FullPathName.MaximumLength, FullPathName.Buffer, NULL); // check length and set status
CHECK_LENGTH_RESULT_RTL_USTR(dwStatus, &FullPathName);
if (!NT_SUCCESS(dwStatus)) { goto scdExit; // exit with status code
}
OemDirectoryName.Buffer = szFullPathOem; OemDirectoryName.MaximumLength = sizeof(szFullPathOem);
// convert this stuff (fullpath) to oem
dwStatus = DemUnicodeStringToDestinationString(&OemDirectoryName, &FullPathName, FALSE, FALSE); if (!NT_SUCCESS(dwStatus)) { goto scdExit; }
dwStatus = demSetCurrentDirectoryLong(Drive, OemDirectoryName.Buffer, 0); if (NULL != pDriveNum) { *pDriveNum = Drive; }
scdExit:
return(dwStatus);}
// this is a compound api that sets both current drive and current directory
// according to what has been specified in a parameter
// the return value is also for the drive number
DWORDdemSetCurrentDirectoryGetDrive(LPSTR lpDirectoryName, PUINT pDriveNum){ PUNICODE_STRING pUnicodeStaticDirectoryName; OEM_STRING OemDirectoryName; DWORD dwStatus; UINT Drive;
// this is external api callable from wow ONLY -- it depends on
// deminitcdsptr having been initialized!!! which happens if:
// -- call has been made through lfn api
// -- app running on wow (windows app)
// convert to uni
pUnicodeStaticDirectoryName = GET_STATIC_UNICODE_STRING_PTR();
// preamble - convert input parameter/validate
// init oem counted string
RtlInitOemString(&OemDirectoryName, lpDirectoryName);
// convert oem->unicode
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStaticDirectoryName, &OemDirectoryName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStaticDirectoryName, &OemDirectoryName, FALSE);#endif
// first we extract the drive
dwStatus = dempLFNSetCurrentDirectory(pUnicodeStaticDirectoryName, pDriveNum);
return(dwStatus);}
// each of these functions could have used OEM thunk in oemuni
// for efficiency purpose we basically do what they did
#if 1
DWORDdemLFNDirectoryControl( UINT uiFunctionCode, LPSTR lpDirectoryName){ DWORD dwStatus = STATUS_SUCCESS; PUNICODE_STRING pUnicodeStaticDirectoryName; OEM_STRING OemDirectoryName; BOOL fResult;
// we use a temp static unicode string
pUnicodeStaticDirectoryName = GET_STATIC_UNICODE_STRING_PTR();
// preamble - convert input parameter/validate
// init oem counted string
RtlInitOemString(&OemDirectoryName, lpDirectoryName);
// convert oem->unicode
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStaticDirectoryName, &OemDirectoryName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStaticDirectoryName, &OemDirectoryName, FALSE);#endif
if (!NT_SUCCESS(dwStatus)) { //
// fix bizarre behavior of win95 apis
//
if (dwStatus == STATUS_BUFFER_OVERFLOW) { dwStatus = NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND); }
return(dwStatus); }
switch (uiFunctionCode) { case fnLFNCreateDirectory:
fResult = CreateDirectoryW(pUnicodeStaticDirectoryName->Buffer,NULL); if (!fResult) { dwStatus = GET_LAST_STATUS(); if (NT_STATUS_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) == dwStatus || NT_STATUS_FROM_WIN32(ERROR_ALREADY_EXISTS) == dwStatus) { dwStatus = NT_STATUS_FROM_WIN32(ERROR_ACCESS_DENIED); } } break;
case fnLFNRemoveDirectory:
fResult = RemoveDirectoryW(pUnicodeStaticDirectoryName->Buffer); if (!fResult) { dwStatus = GET_LAST_STATUS(); } break;
case fnLFNSetCurrentDirectory:
// as it appears, this implementation is not good enough
// dos does a lot more fun things than just call to an api
dwStatus = dempLFNSetCurrentDirectory(pUnicodeStaticDirectoryName, NULL); break; }
return(dwStatus);}
#else
DWORDdemLFNDirectoryControl( UINT uiFunctionCode, LPSTR lpDirectoryName){ BOOL fResult;
switch(uiFunctionCode) { case fnLFNCreateDirectory: fResult = CreateDirectoryOem(lpDirectoryName, NULL); break;
case fnLFNRemoveDirectory: fResult = RemoveDirectoryOem(lpDirectoryName); break;
case fnLFNSetCurrentDirectory: fResult = SetCurrentDirectoryOem(lpDirectoryName); break;
default: return(NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION)); }
return(fResult ? STATUS_SUCCESS : GET_LAST_STATUS());
}
#endif
/*
* With this api win95 returns : * - int24's are generated * - 0x0f if drive is invalid * - 0x03 on set to invalid * * * * */
DWORDdemLFNGetCurrentDirectory( UINT DriveNum, LPSTR lpDirectoryName){ // unfortunately, this fn is not present in win nt so we emulate
DWORD dwStatus; CHAR szCurrentDirectory[MAX_PATH];
if (0 == DriveNum) { DriveNum = (UINT)*(PUCHAR)DosWowData.lpCurDrv; } else { --DriveNum; }
dwStatus = demGetCurrentDirectoryLong((UCHAR)DriveNum, szCurrentDirectory, dtLFNDirName); if (NT_SUCCESS(dwStatus)) { strcpy(lpDirectoryName, &szCurrentDirectory[3]); } // done
return(dwStatus);}
DWORDdemLFNMoveFile( LPSTR lpOldName, LPSTR lpNewName){ DWORD dwStatus = STATUS_SUCCESS; UNICODE_STRING unicodeOldName; UNICODE_STRING unicodeNewName; OEM_STRING oemString;
RtlInitOemString(&oemString, lpOldName);
// convert source path from ansi to unicode and allocate result
// this rtl function returns status code, not the winerror code
//
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(&unicodeOldName, &oemString, TRUE);
#else
dwStatus = RtlOemStringToUnicodeString(&unicodeOldName, &oemString, TRUE);
#endif
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
dempLFNNormalizePath(&unicodeOldName);
RtlInitOemString(&oemString, lpNewName);
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(&unicodeNewName, &oemString, TRUE);
#else
dwStatus = RtlOemStringToUnicodeString(&unicodeNewName, &oemString, TRUE);
#endif
if (!NT_SUCCESS(dwStatus)) { RtlFreeUnicodeString(&unicodeOldName); return(dwStatus); }
dempLFNNormalizePath(&unicodeNewName);
if (!MoveFileW(unicodeOldName.Buffer, unicodeNewName.Buffer)) { dwStatus = GET_LAST_STATUS(); }
RtlFreeUnicodeString(&unicodeOldName); RtlFreeUnicodeString(&unicodeNewName); return(dwStatus);}
DWORDdemLFNGetVolumeInformation( LPSTR lpRootName, LPLFNVOLUMEINFO lpVolumeInfo){ DWORD dwStatus = STATUS_SUCCESS; DWORD dwFSFlags;
#if 0
if (_stricmp(lpRootName, "\\:\\")) { // special case of edit.com calling us to see if we support LFN when
// started from a unc path
}
#endif
if (!GetVolumeInformationOem(lpRootName, NULL, // name buffer
0, NULL, // volume serial num
&lpVolumeInfo->dwMaximumFileNameLength, &dwFSFlags, lpVolumeInfo->lpFSNameBuffer, lpVolumeInfo->dwFSNameBufferSize)) { dwStatus = GET_LAST_STATUS(); } else {
dwFSFlags &= LFN_FS_ALLOWED_FLAGS; // clear out anything that is not Win95
dwFSFlags |= FS_LFN_APIS; // say we support lfn apis always
lpVolumeInfo->dwFSFlags = dwFSFlags;
// this is shaky yet who'd really use it ?
// 4 = <driveletter><:><\><FileName><\0>
lpVolumeInfo->dwMaximumPathNameLength = lpVolumeInfo->dwMaximumFileNameLength + 5; }
return(dwStatus);}
// assume the pFileTime being a UTC format always
// uiMinorCode is enumFileTimeControlMinorCode type
#define AlmostTwoSeconds (2*1000*1000*10 - 1)
DWORDdemLFNFileTimeControl( UINT uiMinorCode, FILETIME* pFileTime, PLFNFILETIMEINFO pFileTimeInfo){ DWORD dwStatus = STATUS_SUCCESS; TIME_FIELDS TimeFields; LARGE_INTEGER Time; USHORT u; FILETIME ftLocal; BOOL fResult;
switch(uiMinorCode & FTCTL_CODEMASK) { case fnFileTimeToDosDateTime:
if (!(uiMinorCode & FTCTL_UTCTIME)) { if (!FileTimeToLocalFileTime(pFileTime, &ftLocal)) { dwStatus = GET_LAST_STATUS(); break; // break out as the conv error occured
} } else { ftLocal = *pFileTime; // just utc file time
}
Time.LowPart = ftLocal.dwLowDateTime; Time.HighPart = ftLocal.dwHighDateTime; Time.QuadPart += (LONGLONG)AlmostTwoSeconds;
RtlTimeToTimeFields(&Time, &TimeFields);
if (TimeFields.Year < (USHORT)1980 || TimeFields.Year > (USHORT)2107) { pFileTimeInfo->uDosDate = (1 << 5) | 1; // January, 1st, 1980
pFileTimeInfo->uDosTime = 0; pFileTimeInfo->uMilliseconds = 0; dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_DATA); } else { pFileTimeInfo->uDosDate = (USHORT)( ((USHORT)(TimeFields.Year-(USHORT)1980) << 9) | ((USHORT)TimeFields.Month << 5) | (USHORT)TimeFields.Day );
pFileTimeInfo->uDosTime = (USHORT)( ((USHORT)TimeFields.Hour << 11) | ((USHORT)TimeFields.Minute << 5) | ((USHORT)TimeFields.Second >> 1) );
// set the spillover so we can correctly retrieve the seconds
// we are talking of milliseconds in units of 10
// so the max value here is 199
pFileTimeInfo->uMilliseconds = ((TimeFields.Second & 0x1) * 1000 + TimeFields.Milliseconds) / 10; } break;
case fnDosDateTimeToFileTime: // here the process is backwards
u = pFileTimeInfo->uDosDate;
TimeFields.Year = ((u & 0xFE00) >> 9) + (USHORT)1980; TimeFields.Month = ((u & 0x01E0) >> 5); TimeFields.Day = (u & 0x001F);
u = pFileTimeInfo->uDosTime;
TimeFields.Hour = (u & 0xF800) >> 11; TimeFields.Minute = (u & 0x07E0) >> 5; TimeFields.Second = (u & 0x001F) << 1; // seconds as multiplied...
// correction
u = pFileTimeInfo->uMilliseconds * 10; // approx millisecs
TimeFields.Second += u / 1000; TimeFields.Milliseconds = u % 1000;
if (RtlTimeFieldsToTime(&TimeFields, &Time)) {
// now convert to global time
ftLocal.dwLowDateTime = Time.LowPart; ftLocal.dwHighDateTime = Time.HighPart; if (!LocalFileTimeToFileTime(&ftLocal, pFileTime)) { dwStatus = GET_LAST_STATUS(); } } else { dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_DATA); }
break;
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION); break; }
return(dwStatus);
}
NTSTATUSdempLFNSetFileTime( UINT uMinorCode, PUNICODE_STRING pFileName, PLFNFILETIMEINFO pTimeInfo){ OBJECT_ATTRIBUTES ObjAttributes; HANDLE hFile; UNICODE_STRING FileName; RTL_RELATIVE_NAME RelativeName; BOOL TranslationStatus; PVOID FreeBuffer; FILE_BASIC_INFORMATION FileBasicInfo; IO_STATUS_BLOCK IoStatusBlock; LPFILETIME pFileTime; NTSTATUS dwStatus;
//
// Prepare info
//
RtlZeroMemory(&FileBasicInfo, sizeof(FileBasicInfo)); switch(uMinorCode) { case fnSetCreationDateTime: pFileTime = (LPFILETIME)&FileBasicInfo.CreationTime; break;
case fnSetLastAccessDateTime: pFileTime = (LPFILETIME)&FileBasicInfo.LastAccessTime; break;
case fnSetLastWriteDateTime: pFileTime = (LPFILETIME)&FileBasicInfo.LastWriteTime; break; }
dwStatus = demLFNFileTimeControl(fnDosDateTimeToFileTime, pFileTime, pTimeInfo);
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
TranslationStatus = RtlDosPathNameToNtPathName_U(pFileName->Buffer, &FileName, NULL, &RelativeName);
if (!TranslationStatus) { return(NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND)); }
FreeBuffer = FileName.Buffer;
// this is relative-path optimization stolen from filehops.c in base/client
if (0 != RelativeName.RelativeName.Length) { FileName = *(PUNICODE_STRING)&RelativeName.RelativeName; } else { RelativeName.ContainingDirectory = NULL; }
InitializeObjectAttributes( &ObjAttributes, &FileName, OBJ_CASE_INSENSITIVE, RelativeName.ContainingDirectory, NULL );
//
// Open the file
//
dwStatus = NtOpenFile( &hFile, FILE_WRITE_ATTRIBUTES | SYNCHRONIZE, &ObjAttributes, &IoStatusBlock, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT );
RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer);
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
//
// Set file basic info.
//
dwStatus = NtSetInformationFile( hFile, &IoStatusBlock, &FileBasicInfo, sizeof(FileBasicInfo), FileBasicInformation );
NtClose(hFile);
return(dwStatus);}
NTSTATUSdempLFNGetFileTime( UINT uMinorCode, PUNICODE_STRING pFileName, PLFNFILETIMEINFO pTimeInfo){
OBJECT_ATTRIBUTES ObjAttributes; UNICODE_STRING FileName; RTL_RELATIVE_NAME RelativeName; BOOL TranslationStatus; PVOID FreeBuffer; LPFILETIME pFileTime; NTSTATUS dwStatus; FILE_NETWORK_OPEN_INFORMATION NetworkInfo;
TranslationStatus = RtlDosPathNameToNtPathName_U(pFileName->Buffer, &FileName, NULL, &RelativeName);
if (!TranslationStatus) { return(NT_STATUS_FROM_WIN32(ERROR_PATH_NOT_FOUND)); }
FreeBuffer = FileName.Buffer;
// this is relative-path optimization stolen from filehops.c in base/client
if (0 != RelativeName.RelativeName.Length) { FileName = *(PUNICODE_STRING)&RelativeName.RelativeName; } else { RelativeName.ContainingDirectory = NULL; }
InitializeObjectAttributes( &ObjAttributes, &FileName, OBJ_CASE_INSENSITIVE, RelativeName.ContainingDirectory, NULL );
dwStatus = NtQueryFullAttributesFile( &ObjAttributes, &NetworkInfo); RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer);
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
switch (uMinorCode) { case fnGetCreationDateTime: pFileTime = (LPFILETIME)&NetworkInfo.CreationTime; break;
case fnGetLastAccessDateTime: pFileTime = (LPFILETIME)&NetworkInfo.LastAccessTime; break;
case fnGetLastWriteDateTime: pFileTime = (LPFILETIME)&NetworkInfo.LastWriteTime; break; }
// assert here against pFileTime
// convert to dos style
dwStatus = demLFNFileTimeControl(fnFileTimeToDosDateTime | (dempUseUTCTimeByName(pFileName) ? FTCTL_UTCTIME : 0), pFileTime, pTimeInfo); if (!NT_SUCCESS(dwStatus) && NT_STATUS_FROM_WIN32(ERROR_INVALID_DATA) == dwStatus && fnGetLastWriteDateTime == uMinorCode) { dwStatus = STATUS_SUCCESS; }
return(dwStatus);}
NTSTATUSdemLFNGetSetFileAttributes( UINT uMinorCode, LPSTR lpFileName, PLFNFILEATTRIBUTES pLFNFileAttributes){ PUNICODE_STRING pUnicodeStaticFileName; OEM_STRING oemFileName; NTSTATUS dwStatus = STATUS_SUCCESS;
pUnicodeStaticFileName = GET_STATIC_UNICODE_STRING_PTR();
RtlInitOemString(&oemFileName, lpFileName);
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStaticFileName, &oemFileName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStaticFileName, &oemFileName, FALSE);#endif
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
dempLFNNormalizePath(pUnicodeStaticFileName);
switch(uMinorCode) { case fnGetFileAttributes: { DWORD dwAttributes;
// attention! BUGBUG
// need to check for volume id here - if the name actually matches...
dwAttributes = GetFileAttributesW(pUnicodeStaticFileName->Buffer); if ((DWORD)-1 == dwAttributes) { dwStatus = GET_LAST_STATUS(); } else { pLFNFileAttributes->wFileAttributes = (WORD)(dwAttributes & DEM_FILE_ATTRIBUTE_VALID); } } break;
case fnSetFileAttributes: { DWORD dwAttributes;
// this is how win95 handles this api:
// the volume bit is valid but ignored, setting everything else but
// DEM_FILE_ATTRIBUTE_SET_VALID is causing error 0x5 (access denied)
//
dwAttributes = (DWORD)pLFNFileAttributes->wFileAttributes;
if (dwAttributes & (~(DEM_FILE_ATTRIBUTE_SET_VALID | DEM_FILE_ATTRIBUTE_VOLUME_ID))) { dwStatus = NT_STATUS_FROM_WIN32(ERROR_ACCESS_DENIED); } else {
dwAttributes &= DEM_FILE_ATTRIBUTE_SET_VALID; // clear possible volume id
if (!SetFileAttributesW(pUnicodeStaticFileName->Buffer, dwAttributes)) { dwStatus = GET_LAST_STATUS(); } } } break;
case fnGetCompressedFileSize: { DWORD dwFileSize;
dwFileSize = GetCompressedFileSizeW(pUnicodeStaticFileName->Buffer, NULL); // for dos we have no high part
if ((DWORD)-1 == dwFileSize) { dwStatus = GET_LAST_STATUS(); } else { pLFNFileAttributes->dwFileSize = dwFileSize; } } break;
case fnSetLastWriteDateTime: case fnSetCreationDateTime: case fnSetLastAccessDateTime: dwStatus = dempLFNSetFileTime(uMinorCode, pUnicodeStaticFileName, &pLFNFileAttributes->TimeInfo); break;
case fnGetLastAccessDateTime: case fnGetCreationDateTime: case fnGetLastWriteDateTime: dwStatus = dempLFNGetFileTime(uMinorCode, pUnicodeStaticFileName, &pLFNFileAttributes->TimeInfo); break;
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION); break; }
return(dwStatus);}
BOOLdempUseUTCTimeByHandle( HANDLE hFile){ // if file is on a cdrom -- then we use utc time as opposed to other
// local time
NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock; FILE_FS_DEVICE_INFORMATION DeviceInfo; BOOL fUseUTCTime = FALSE;
Status = NtQueryVolumeInformationFile(hFile, &IoStatusBlock, &DeviceInfo, sizeof(DeviceInfo), FileFsDeviceInformation); if (NT_SUCCESS(Status)) { // we look at the characteristics of this particular device --
// if the media is cdrom -- then we DO NOT need to convert to local time
fUseUTCTime = (DeviceInfo.Characteristics & FILE_REMOVABLE_MEDIA) && (DeviceInfo.DeviceType == FILE_DEVICE_CD_ROM || DeviceInfo.DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM); }
return(fUseUTCTime);}
BOOLdempUseUTCTimeByName( PUNICODE_STRING pFileName){ DWORD Status; UNICODE_STRING UnicodeFullPath; WCHAR wszFullPath[MAX_PATH]; RTL_PATH_TYPE RtlPathType; BOOL fUseUTCTime = FALSE;
dempStringInitZeroUnicode(&UnicodeFullPath, wszFullPath, sizeof(wszFullPath)/sizeof(wszFullPath[0]));
Status = RtlGetFullPathName_U(pFileName->Buffer, UnicodeFullPath.MaximumLength, UnicodeFullPath.Buffer, NULL);
CHECK_LENGTH_RESULT_RTL_USTR(Status, &UnicodeFullPath); if (NT_SUCCESS(Status)) { RtlPathType = RtlDetermineDosPathNameType_U(UnicodeFullPath.Buffer); if (RtlPathTypeDriveAbsolute == RtlPathType) { // see that we have a valid root dir
wszFullPath[3] = L'\0'; fUseUTCTime = (DRIVE_CDROM == GetDriveTypeW(wszFullPath)); }
} return(fUseUTCTime);}
/*
* Handle a file handle - based time apis * * * * * * * * * * * */
NTSTATUSdempGetFileTimeByHandle( UINT uFunctionCode, HANDLE hFile, PLFNFILETIMEINFO pTimeInfo){ NTSTATUS dwStatus; FILETIME* pCreationTime = NULL; FILETIME* pLastAccessTime = NULL; FILETIME* pLastWriteTime = NULL; FILETIME FileTime;
switch (uFunctionCode) { case fnFTGetLastWriteDateTime: pLastWriteTime = &FileTime; break;
case fnFTGetLastAccessDateTime: pLastAccessTime = &FileTime; break;
case fnFTGetCreationDateTime: pCreationTime = &FileTime; break; }
if (GetFileTime(hFile, pCreationTime, pLastAccessTime, pLastWriteTime)) { // now convert the result
dwStatus = demLFNFileTimeControl(fnFileTimeToDosDateTime | (dempUseUTCTimeByHandle(hFile) ? FTCTL_UTCTIME : 0), &FileTime, pTimeInfo); if (!NT_SUCCESS(dwStatus) && NT_STATUS_FROM_WIN32(ERROR_INVALID_DATA) == dwStatus && fnFTGetLastWriteDateTime == uFunctionCode) { dwStatus = STATUS_SUCCESS; }
} else { dwStatus = GET_LAST_STATUS(); }
return(dwStatus);}
/*
* This is a special wow32 - callable function for getting file time by handle * from wow. We have not done any extensive checking (like in demFileTimes * but rather provided for the behavior consistent with wow * * * */
ULONG demGetFileTimeByHandle_WOW( HANDLE hFile){ LFNFILETIMEINFO fti; NTSTATUS Status;
Status = dempGetFileTimeByHandle(fnFTGetLastWriteDateTime, hFile, &fti); if (NT_SUCCESS(Status)) { return (fti.uDosTime | ((ULONG)fti.uDosDate << 16)); }
return(0xFFFF);}
NTSTATUSdempSetFileTimeByHandle( UINT uFunctionCode, HANDLE hFile, PLFNFILETIMEINFO pTimeInfo){
NTSTATUS dwStatus; FILETIME* pCreationTime = NULL; FILETIME* pLastAccessTime = NULL; FILETIME* pLastWriteTime = NULL; FILETIME FileTime;
//
// see which time we are setting and fixup parameters
//
switch (uFunctionCode) { case fnFTSetLastWriteDateTime: pLastWriteTime = &FileTime; pTimeInfo->uMilliseconds = 0; // not supported
break;
case fnFTSetLastAccessDateTime: pLastAccessTime = &FileTime; pTimeInfo->uMilliseconds = 0; // not supported
// time is also not supported in this function and should be somehow
// ignored, but Win95 resets the time to 0 every time this fn is
// executed - we monkey
//
pTimeInfo->uDosTime = 0;
break;
case fnFTSetCreationDateTime: pCreationTime = &FileTime; break; }
dwStatus = demLFNFileTimeControl(fnDosDateTimeToFileTime, &FileTime, pTimeInfo); if (NT_SUCCESS(dwStatus)) { // set the file time
if (!SetFileTime(hFile, pCreationTime, pLastAccessTime, pLastWriteTime)) { dwStatus = GET_LAST_STATUS(); } }
return(dwStatus);}
/* Function
* demFileTimes * works for all handle-based file time apis * * Parameters * None * * Returns * Nothing * * Note * This function is for handling real-mode cases only * reason: using getXX macros instead of frame-based getUserXX macros * * */
VOIDdemFileTimes(VOID){ UINT uFunctionCode; LFNFILETIMEINFO TimeInfo; NTSTATUS dwStatus = STATUS_SUCCESS; PVOID pUserEnvironment; PDOSSFT pSFT = NULL; HANDLE hFile;
uFunctionCode = (UINT)getAL();
hFile = VDDRetrieveNtHandle((ULONG)NULL, // uses current pdb
getBX(), // dos handle
(PVOID*)&pSFT, // retrieve sft ptr
NULL); // no jft pleast
//
// it is possible to have NULL nt handle for the particular file -
// e.g. stdaux, stdprn devices
//
// We are catching only the case of bad dos handle here
//
if (NULL == pSFT && NULL == hFile) { //
// invalid handle value here
//
// We know that dos handles it in the same way, so we just
// put error code in, set carry and return
//
setAX((USHORT)ERROR_INVALID_HANDLE); setCF(1); return; }
switch(uFunctionCode) { case fnFTGetCreationDateTime: case fnFTGetLastWriteDateTime: case fnFTGetLastAccessDateTime: if (pSFT->SFT_Flags & SFTFLAG_DEVICE_ID) {
SYSTEMTIME stCurrentTime; FILETIME FileTime;
//
// for a local device return current time
//
GetSystemTime(&stCurrentTime); SystemTimeToFileTime(&stCurrentTime, &FileTime); // now make a dos file time
dwStatus = demLFNFileTimeControl(fnFileTimeToDosDateTime, &FileTime, &TimeInfo); } else { dwStatus = dempGetFileTimeByHandle(uFunctionCode, hFile, &TimeInfo); }
if (NT_SUCCESS(dwStatus)) { // set the regs
pUserEnvironment = dempGetDosUserEnvironment();
setUserDX(TimeInfo.uDosDate, pUserEnvironment); setUserCX(TimeInfo.uDosTime, pUserEnvironment);
// if this was a creation date/time then set msecs
if (fnGetCreationDateTime != uFunctionCode) { TimeInfo.uMilliseconds = 0; }
// Note that this is valid only for new (LFN) functions
// and not for the old functionality (get/set last write)
// -- BUGBUG (what do other cases amount to on Win95)
if (fnFTGetLastWriteDateTime != uFunctionCode) { setUserSI(TimeInfo.uMilliseconds, pUserEnvironment); }
} break;
case fnFTSetCreationDateTime: case fnFTSetLastWriteDateTime: case fnFTSetLastAccessDateTime: if (!(pSFT->SFT_Flags & SFTFLAG_DEVICE_ID)) {
// if this is a local device and a request to set time
// then as dos code does it, we just return ok
// we set times here for all other stuff
TimeInfo.uDosDate = getDX(); TimeInfo.uDosTime = getCX(); // for one of those it is 0 (!!!)
//
// we just retrieve value that will be ignored later
// for some of the functions
//
TimeInfo.uMilliseconds = getSI();
dwStatus = dempSetFileTimeByHandle(uFunctionCode, hFile, &TimeInfo); }
break;
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION); break; }
if (NT_SUCCESS(dwStatus)) { setCF(0); } else {
//
// demClientError sets cf and appropriate registers
//
SetLastError(WIN32_ERROR_FROM_NT_STATUS(dwStatus)); demClientError(hFile, (CHAR)-1); }}
/*
* Open file (analogous to 6c) * This actually calls into CreateFile and is quite similar in * behaviour (with appropriate restrictions) * * uModeAndFlags * Combination of OPEN_* stuff * * uAttributes * See DEM_FILE_ATTRIBUTES_VALID * * * * * */
NTSTATUSdemLFNOpenFile( LPSTR lpFileName, USHORT uModeAndFlags, USHORT uAttributes, USHORT uAction, USHORT uAliasHint, // ignored
PUSHORT puDosHandle, PUSHORT puActionTaken){
// convert the filename please
PUNICODE_STRING pUnicodeStaticFileName; OEM_STRING OemFileName; NTSTATUS dwStatus; DWORD dwCreateDistribution; DWORD dwDesiredAccess; DWORD dwShareMode; DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; HANDLE hFile; USHORT uDosHandle; PDOSSFT pSFT; BOOL fFileExists; USHORT uActionTaken = ACTION_OPENED;
// convert the filename in question
pUnicodeStaticFileName = GET_STATIC_UNICODE_STRING_PTR();
RtlInitOemString(&OemFileName, lpFileName);
// convert oem->unicode
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStaticFileName, &OemFileName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStaticFileName, &OemFileName, FALSE);#endif
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
if (uModeAndFlags & DEM_FILE_ATTRIBUTE_VOLUME_ID) { // process this completely separately
; return(NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION)); }
// we are calling into CreateFile with it's flags
// so find out what we are set to do first
// as determined by MSDN
// FILE_CREATE (0010h) Creates a new file if it does not
// already exist. The function fails if
// the file already exists.
// FILE_OPEN (0001h) Opens the file. The function fails if
// the file does not exist.
// FILE_TRUNCATE (0002h) Opens the file and truncates it to zero
// length (replaces the existing file).
// The function fails if the file does not exist.
//
// The only valid combinations are FILE_CREATE combined with FILE_OPEN
// or FILE_CREATE combined with FILE_TRUNCATE.
switch(uAction & 0x0f) { case DEM_OPEN_ACTION_FILE_OPEN: if (uAction & DEM_OPEN_ACTION_FILE_CREATE) { dwCreateDistribution = OPEN_ALWAYS; } else { dwCreateDistribution = OPEN_EXISTING; } break;
case DEM_OPEN_ACTION_FILE_TRUNCATE: if (uAction & DEM_OPEN_ACTION_FILE_CREATE) { // this is an unmappable situation
//
dwCreateDistribution = OPEN_ALWAYS; // we truncate ourselves
// note that we need access mode to permit this !!!
} else { dwCreateDistribution = TRUNCATE_EXISTING; } break;
case 0: // this is the case that could only be file_create call
if (uAction == DEM_OPEN_ACTION_FILE_CREATE) { dwCreateDistribution = CREATE_NEW; break; } // else we fall through to the bad param return
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER); return(dwStatus); break; }
// now see what sort of sharing mode we can inflict upon ourselves
switch(uModeAndFlags & DEM_OPEN_SHARE_MASK) { case DEM_OPEN_SHARE_COMPATIBLE: // the reason we see share_delete here is to emulate compat mode
// behaviour requiring to fail if any other (than compat) mode was
// used to open the file
dwShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE; break;
case DEM_OPEN_SHARE_DENYREADWRITE: dwShareMode = 0; break;
case DEM_OPEN_SHARE_DENYWRITE: dwShareMode = FILE_SHARE_READ; break;
case DEM_OPEN_SHARE_DENYREAD: dwShareMode = FILE_SHARE_WRITE; break;
case DEM_OPEN_SHARE_DENYNONE: dwShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE; break;
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER); return(dwStatus); break; }
// now crack the access mode to fill in dwDesiredAccess
switch(uModeAndFlags & DEM_OPEN_ACCESS_MASK) {
case DEM_OPEN_ACCESS_READONLY: dwDesiredAccess = GENERIC_READ; break;
case DEM_OPEN_ACCESS_WRITEONLY: dwDesiredAccess = GENERIC_WRITE; break;
case DEM_OPEN_ACCESS_READWRITE: dwDesiredAccess = GENERIC_READ|GENERIC_WRITE; break;
case DEM_OPEN_ACCESS_RO_NOMODLASTACCESS: // although this is a weird mode - we care not for the last
// access time - proper implementation would have been to
// provide for a last access time retrieval and reset upon
// closing the file
// Put a message up here and a breakpoint
dwDesiredAccess = GENERIC_READ; break;
case DEM_OPEN_ACCESS_RESERVED: default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER); return(dwStatus); break;
}
// and now crack the flags used -
// fill in the flags portion of dwFlagsAndAttributes
if ((uModeAndFlags & DEM_OPEN_FLAGS_MASK) & (~DEM_OPEN_FLAGS_VALID)) { dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER); return(dwStatus); }
if (uModeAndFlags & DEM_OPEN_FLAGS_NO_BUFFERING) { // if unbuffered mode is used then the buffer is to be aligned on
// a volume sector size boundary. This is not necessarily true for
// win95 or is it ?
dwFlagsAndAttributes |= FILE_FLAG_NO_BUFFERING; }
if (uModeAndFlags & DEM_OPEN_FLAGS_COMMIT) { dwFlagsAndAttributes |= FILE_FLAG_WRITE_THROUGH; }
if (uModeAndFlags & DEM_OPEN_FLAGS_ALIAS_HINT) { // print a message, ignore the hint
; }
if (uModeAndFlags & DEM_OPEN_FLAGS_NO_COMPRESS) { // what the heck we do with this one ?
; }
// set the attributes
dwFlagsAndAttributes |= ((DWORD)uAttributes & DEM_FILE_ATTRIBUTE_SET_VALID);
dempLFNNormalizePath(pUnicodeStaticFileName);
// out we go
{ //
// Need to create this because if we don't, any process we cause to be launched will not
// be able to inherit handles (ie: launch FINDSTR.EXE via 21h/4bh to pipe to a file
// ala NT Bug 199416 - bjm)
//
SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
hFile = CreateFileW(pUnicodeStaticFileName->Buffer, dwDesiredAccess, dwShareMode, &sa, /// NULL, // no security attr here
dwCreateDistribution, dwFlagsAndAttributes, NULL); }
// now see what the return should be
dwStatus = GetLastError();
fFileExists = ERROR_ALREADY_EXISTS == dwStatus;
if (INVALID_HANDLE_VALUE == hFile) { return(NT_STATUS_FROM_WIN32(dwStatus)); }
if (fFileExists) { if ((DEM_OPEN_ACTION_FILE_TRUNCATE|DEM_OPEN_ACTION_FILE_CREATE) == uAction) { if (FILE_TYPE_DISK == GetFileType(hFile) ) { // truncate the file here please
if (!SetEndOfFile(hFile)) { dwStatus = GET_LAST_STATUS(); CloseHandle(hFile); return (dwStatus); }
uActionTaken = ACTION_REPLACED_OPENED; } else { uActionTaken = ACTION_CREATED_OPENED; } } } else { if (DEM_OPEN_ACTION_FILE_CREATE & uAction) { uActionTaken = ACTION_CREATED_OPENED; } }
// now we insert the handle and allocate a dos handle
uDosHandle = VDDAllocateDosHandle(0L, (PVOID*)&pSFT, NULL);
if ((SHORT)uDosHandle < 0) { CloseHandle(hFile); return(NT_STATUS_FROM_WIN32((DWORD)(-(SHORT)uDosHandle))); } else {
// we have obtained a good handle here
// so place the nt handle into sft
pSFT->SFT_Mode = uModeAndFlags & 0x7f; // up to no_inherit bit
pSFT->SFT_Attr = 0; // Not used.
pSFT->SFT_Flags = (uModeAndFlags & DEM_OPEN_FLAGS_NOINHERIT) ? 0x1000 : 0; // copy no_inherit bit.
pSFT->SFT_Devptr = (ULONG) -1; pSFT->SFT_NTHandle = (ULONG) hFile;
*puActionTaken = uActionTaken; *puDosHandle = uDosHandle; }
return(STATUS_SUCCESS);}
NTSTATUSdemLFNDeleteFile( LPSTR lpFileName, USHORT wMustMatchAttributes, USHORT wSearchAttributes, BOOL fUseWildCard){ // this is how we deal with this rather harsh function:
//
HANDLE hFind; NTSTATUS dwStatus; WIN32_FIND_DATAW FindData; PUNICODE_STRING pUnicodeStaticFileName; OEM_STRING OemFileName; UNICODE_STRING UnicodeFileName; // for deletion
// convert file name / pattern to uni
pUnicodeStaticFileName = GET_STATIC_UNICODE_STRING_PTR();
RtlInitOemString(&OemFileName, lpFileName);
// convert oem->unicode
#ifdef ENABLE_CONDITIONAL_TRANSLATION
dwStatus = DemSourceStringToUnicodeString(pUnicodeStaticFileName, &OemFileName, FALSE);#else
dwStatus = RtlOemStringToUnicodeString(pUnicodeStaticFileName, &OemFileName, FALSE);#endif
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
// check for the deletion of a volume label - this hurts
// BUGBUG
dempLFNNormalizePath(pUnicodeStaticFileName);
if (fUseWildCard) {
// make a template for a file name by backtracking the last backslash
LONG Index; BOOL fSuccess = FALSE;
dwStatus = dempLFNFindFirstFile(&hFind, pUnicodeStaticFileName, &FindData, wMustMatchAttributes, wSearchAttributes);
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); // this is safe as dempLFNFindFirstFile closed the handle
}
// cut the filename part off
// index is (-1) if not found or 0-based index of a char
Index = dempStringFindLastChar(pUnicodeStaticFileName, L'\\', FALSE) + 1;
while (NT_SUCCESS(dwStatus)) { // construct a filename
RtlInitUnicodeString(&UnicodeFileName, FindData.cFileName); if (UnicodeFileName.Length < 3 && (L'.' == UnicodeFileName.Buffer[0] && (UnicodeFileName.Length < 2 || L'.' == UnicodeFileName.Buffer[1]))) {
// this is deletion of '.' or '..'
; // assert ?
}
pUnicodeStaticFileName->Length = (USHORT)Index;
dwStatus = RtlAppendUnicodeStringToString(pUnicodeStaticFileName, &UnicodeFileName);
if (!NT_SUCCESS(dwStatus)) { break; }
// now delete the file in question given it's not '.' or '..'
// (although I have no idea what '95 would have done)
if (!DeleteFileW(pUnicodeStaticFileName->Buffer)) {
dwStatus = GET_LAST_STATUS(); break;
} else {
fSuccess = TRUE;
}
dwStatus = dempLFNFindNextFile(hFind, &FindData, wMustMatchAttributes, wSearchAttributes);
}
FindClose(hFind);
// note success if at least one file nuked
if (fSuccess) { dwStatus = STATUS_SUCCESS; } } else { // wilds are not used here
// scan for wild card chars using our fn
LONG Index;
Index = dempStringFindLastChar(pUnicodeStaticFileName, L'*', FALSE); if (Index >= 0) { return(NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER)); }
Index = dempStringFindLastChar(pUnicodeStaticFileName, L'?', FALSE); if (Index >= 0) { return(NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER)); }
if (DeleteFileW(pUnicodeStaticFileName->Buffer)) { dwStatus = STATUS_SUCCESS; } else {
dwStatus = GET_LAST_STATUS(); } }
return(dwStatus);}
NTSTATUSdemLFNGetFileInformationByHandle( USHORT wDosHandle, LPBY_HANDLE_FILE_INFORMATION pFileInformation){ HANDLE hFile;
hFile = VDDRetrieveNtHandle((ULONG)NULL, // uses current pdb
wDosHandle, NULL, // no sft
NULL); // no jft
if (NULL == hFile) { return(NT_STATUS_FROM_WIN32(ERROR_INVALID_HANDLE)); }
if (!GetFileInformationByHandle(hFile, pFileInformation)) { return(GET_LAST_STATUS()); }
return(STATUS_SUCCESS);}
#define BCS_SRC_WANSI 0x0
#define BCS_SRC_OEM 0x01
#define BCS_SRC_UNICODE 0x02
#define BCS_DST_WANSI 0x00
#define BCS_DST_OEM 0x10
#define BCS_DST_UNICODE 0x20
/* Function:
* demLFNGenerateShortFileName * Produces surrogate short file name given the long file name * Note, that win'95 implementation seems to be quite bogus. * They do not bother to adhere to docs, and return whatever * is on their mind. * * This implementation corresponds to name-generating habits of NT * thus allowing 16-bit apps seemless interaction with lfn apis * * */
NTSTATUSdemLFNGenerateShortFileName( LPSTR lpShortFileName, LPSTR lpLongFileName, USHORT wShortNameFormat, USHORT wCharSet){
UNICODE_STRING UnicodeShortName; WCHAR szShortNameBuffer[13]; OEM_STRING OemFileName; GENERATE_NAME_CONTEXT GenNameContext; LONG Index; DWORD dwStatus;
PUNICODE_STRING pUnicodeLongName = GET_STATIC_UNICODE_STRING_PTR();
// convert to unicode
switch(wCharSet & 0x0f) { case BCS_SRC_WANSI: // BCS_WANSI - windows ansi
RtlInitAnsiString(&OemFileName, lpLongFileName); dwStatus = RtlAnsiStringToUnicodeString(pUnicodeLongName, &OemFileName, FALSE); break;
case BCS_SRC_OEM: // oem
RtlInitOemString(&OemFileName, lpLongFileName); dwStatus = RtlOemStringToUnicodeString(pUnicodeLongName, &OemFileName, FALSE); break;
case BCS_SRC_UNICODE: // unicode (what ?)
// copy unicode str into our buf
RtlInitUnicodeString(pUnicodeLongName, (PWCHAR)lpLongFileName); dwStatus = STATUS_SUCCESS; break;
default: return(NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER)); }
if (!NT_SUCCESS(dwStatus)) { return(dwStatus); }
wCharSet &= 0xf0; // filter out the dest
dempStringInitZeroUnicode(&UnicodeShortName, (BCS_DST_UNICODE == wCharSet) ? (LPWSTR)lpShortFileName : (LPWSTR)szShortNameBuffer, 13 * sizeof(WCHAR));
RtlZeroMemory(&GenNameContext, sizeof(GenNameContext));
// generate name
RtlGenerate8dot3Name(pUnicodeLongName, FALSE, // allowed ext chars ? and why not ?
&GenNameContext, &UnicodeShortName);
// chop off the part starting with ~
Index = dempStringFindLastChar(&UnicodeShortName, L'~', FALSE); if (Index >= 0) { // remove ~<Number>
//
dempStringDeleteCharsUnicode(&UnicodeShortName, (USHORT)Index, 2 * sizeof(WCHAR)); }
if (0 == wShortNameFormat) { // directory entry - 11 chars format
// just remove the darn '.' from the name
Index = dempStringFindLastChar(&UnicodeShortName, L'.', TRUE); if (Index >= 0) { dempStringDeleteCharsUnicode(&UnicodeShortName, (USHORT)Index, 1 * sizeof(WCHAR)); } }
if (BCS_DST_UNICODE == wCharSet) { // if result is uni, we are done
return(STATUS_SUCCESS); }
OemFileName.Buffer = lpShortFileName; OemFileName.Length = 0; OemFileName.MaximumLength = 13 * sizeof(WCHAR);
switch(wCharSet) { case BCS_DST_WANSI: // windows ansi
dwStatus = RtlUnicodeStringToAnsiString(&OemFileName, &UnicodeShortName, FALSE); break;
case BCS_DST_OEM: // oem
dwStatus = RtlUnicodeStringToOemString(&OemFileName, &UnicodeShortName, FALSE); break;
default: return(NT_STATUS_FROM_WIN32(ERROR_INVALID_PARAMETER)); }
return(dwStatus);}
/*
* This function dispatches lfn calls * * ATTN: All the pointers coming from 16-bit code could be unaligned!!! * * danger: dependency on relative location of things in pdb * * * */
BOOL gfInitCDSPtr = FALSE;VOID demInitCDSPtr(VOID);
NTSTATUSdemLFNDispatch( PVOID pUserEnvironment, BOOL fProtectedMode, PUSHORT pUserAX){ DWORD dwStatus; USHORT wUserAX;
if (!gfInitCDSPtr) { demInitCDSPtr(); }
if (NULL == pUserEnvironment) { pUserEnvironment = dempGetDosUserEnvironment(); }
wUserAX = getUserAX(pUserEnvironment); *pUserAX = wUserAX; // initialize to initial value
if (fnLFNMajorFunction == HIB(wUserAX)) { dempLFNLog("LFN Function: 0x%x \r\n", (DWORD)wUserAX);
switch(LOB(wUserAX)) { case fnLFNFileTime: { LFNFILETIMEINFO TimeInfo; UINT uMinorFunction = (UINT)getUserBL(pUserEnvironment);
switch(uMinorFunction) { case fnFileTimeToDosDateTime: dwStatus = demLFNFileTimeControl(uMinorFunction, (FILETIME*)getUserDSSI(pUserEnvironment, fProtectedMode), &TimeInfo); if (NT_SUCCESS(dwStatus)) {
// set registers
setUserDX(TimeInfo.uDosDate, pUserEnvironment); setUserCX(TimeInfo.uDosTime, pUserEnvironment); setUserBH((BYTE)TimeInfo.uMilliseconds, pUserEnvironment); } break;
case fnDosDateTimeToFileTime: TimeInfo.uDosDate = (USHORT)getUserDX(pUserEnvironment); TimeInfo.uDosTime = (USHORT)getUserCX(pUserEnvironment); TimeInfo.uMilliseconds = (USHORT)getUserBH(pUserEnvironment);
dwStatus = demLFNFileTimeControl((UINT)getBL(), (FILETIME*)getUserESDI(pUserEnvironment, fProtectedMode), &TimeInfo); break; default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION); break; } } break;
case fnLFNGetVolumeInformation: { LFNVOLUMEINFO vi;
vi.dwFSNameBufferSize = (DWORD)getUserCX(pUserEnvironment); vi.lpFSNameBuffer = (LPSTR)getUserESDI(pUserEnvironment, fProtectedMode);
dwStatus = demLFNGetVolumeInformation((LPSTR)getUserDSDX(pUserEnvironment, fProtectedMode), &vi); if (NT_SUCCESS(dwStatus)) {
setUserBX((USHORT)vi.dwFSFlags, pUserEnvironment); setUserCX((USHORT)vi.dwMaximumFileNameLength, pUserEnvironment); setUserDX((USHORT)vi.dwMaximumPathNameLength, pUserEnvironment); } } break;
case fnLFNMoveFile: dwStatus = demLFNMoveFile((LPSTR)getUserDSDX(pUserEnvironment, fProtectedMode), (LPSTR)getUserESDI(pUserEnvironment, fProtectedMode)); break;
case fnLFNGetCurrentDirectory: dwStatus = demLFNGetCurrentDirectory((UINT)getUserDL(pUserEnvironment), // drive no
(LPSTR)getUserDSSI(pUserEnvironment, fProtectedMode)); // ptr to buf
break;
case fnLFNSetCurrentDirectory: case fnLFNRemoveDirectory: case fnLFNCreateDirectory: dwStatus = demLFNDirectoryControl((UINT)getUserAL(pUserEnvironment), (LPSTR)getUserDSDX(pUserEnvironment, fProtectedMode)); break;
case fnLFNGetPathName:
dwStatus = demLFNGetPathName((LPSTR)getUserDSSI(pUserEnvironment, fProtectedMode), // SourcePath
(LPSTR)getUserESDI(pUserEnvironment, fProtectedMode), // Destination Path
(UINT)getUserCL(pUserEnvironment), // minor code
(BOOL)!(getUserCH(pUserEnvironment) & 0x80)); // expand subst flag
if (NT_SUCCESS(dwStatus)) { // doc says modify ax
*pUserAX = 0; } break;
case fnLFNSubst: dwStatus = demLFNSubstControl((UINT)getUserBH(pUserEnvironment), (UINT)getUserBL(pUserEnvironment), (LPSTR)getUserDSDX(pUserEnvironment, fProtectedMode)); break; case fnLFNFindFirstFile: { USHORT wConversionCode; USHORT wDosHandle; WIN32_FIND_DATAA FindData; // used to enforce alignment
LPWIN32_FIND_DATAA lpFindDataDest; // resulting ptr
lpFindDataDest = (LPWIN32_FIND_DATAA)getUserESDI(pUserEnvironment, fProtectedMode); ASSERT(NULL != lpFindDataDest);
dwStatus = demLFNFindFirstFile((LPSTR)getUserDSDX(pUserEnvironment, fProtectedMode), &FindData, (USHORT)getUserSI(pUserEnvironment), // date/time format
(USHORT)getUserCH(pUserEnvironment), // must match attrs
(USHORT)getUserCL(pUserEnvironment), // search attrs
&wConversionCode, &wDosHandle, lpFindDataDest->cFileName, lpFindDataDest->cAlternateFileName ); if (NT_SUCCESS(dwStatus)) { // now copy the data
//
// WARNING: THIS CODE DEPENDS ON THE LAYOUT OF THE WIN32_FIND_DATA
// STRUCTURE IN THE ASSUMPTION THAT cFileName and CAlternateFileName
// ARE THE VERY LAST MEMBERS OF IT!!!
//
RtlMoveMemory((PUCHAR)lpFindDataDest, (PUCHAR)&FindData,
// warning -- this will move more data
// than we ever wanted to -- so break into pieces
sizeof(FindData.dwFileAttributes)+ sizeof(FindData.ftCreationTime)+ sizeof(FindData.ftLastAccessTime)+ sizeof(FindData.ftLastWriteTime)+ sizeof(FindData.nFileSizeHigh)+ sizeof(FindData.nFileSizeLow)+ sizeof(FindData.dwReserved0)+ sizeof(FindData.dwReserved1));
*pUserAX = wDosHandle; setUserCX(wConversionCode, pUserEnvironment); } } break;
case fnLFNFindNextFile: { USHORT wConversionCode; WIN32_FIND_DATAA FindData; LPWIN32_FIND_DATAA lpFindDataDest;
lpFindDataDest = (LPWIN32_FIND_DATAA)getUserESDI(pUserEnvironment, fProtectedMode); ASSERT(NULL != lpFindDataDest);
dwStatus = demLFNFindNextFile((USHORT)getUserBX(pUserEnvironment), // handle
&FindData, (USHORT)getUserSI(pUserEnvironment), // date/time format
&wConversionCode, lpFindDataDest->cFileName, lpFindDataDest->cAlternateFileName );
if (NT_SUCCESS(dwStatus)) { RtlMoveMemory((PUCHAR)lpFindDataDest, (PUCHAR)&FindData,
sizeof(FindData.dwFileAttributes)+ sizeof(FindData.ftCreationTime)+ sizeof(FindData.ftLastAccessTime)+ sizeof(FindData.ftLastWriteTime)+ sizeof(FindData.nFileSizeHigh)+ sizeof(FindData.nFileSizeLow)+ sizeof(FindData.dwReserved0)+ sizeof(FindData.dwReserved1));
setUserCX(wConversionCode, pUserEnvironment); } } break;
case fnLFNFindClose: { dwStatus = demLFNFindClose((USHORT)getUserBX(pUserEnvironment)); } break;
case fnLFNDeleteFile: { dwStatus = demLFNDeleteFile((LPSTR) getUserDSDX(pUserEnvironment, fProtectedMode), (USHORT)getUserCH(pUserEnvironment), // must match
(USHORT)getUserCL(pUserEnvironment), // search
(BOOL) getUserSI(pUserEnvironment)); } break;
case fnLFNGetSetFileAttributes: { USHORT wAction = (USHORT)getUserBL(pUserEnvironment);
LFNFILEATTRIBUTES FileAttributes;
RtlZeroMemory(&FileAttributes, sizeof(FileAttributes));
switch (wAction) { case fnSetFileAttributes: FileAttributes.wFileAttributes = getUserCX(pUserEnvironment); break;
case fnSetCreationDateTime: FileAttributes.TimeInfo.uMilliseconds = (USHORT)getUserSI(pUserEnvironment); // fall through
case fnSetLastAccessDateTime: case fnSetLastWriteDateTime: FileAttributes.TimeInfo.uDosDate = (USHORT)getUserDI(pUserEnvironment); FileAttributes.TimeInfo.uDosTime = (USHORT)getUserCX(pUserEnvironment); break; }
dwStatus = demLFNGetSetFileAttributes(wAction, // action
(LPSTR)getUserDSDX(pUserEnvironment, fProtectedMode), &FileAttributes); // filename
if (NT_SUCCESS(dwStatus)) {
// return stuff
switch (wAction) { case fnGetFileAttributes: setUserCX(FileAttributes.wFileAttributes, pUserEnvironment); *pUserAX = FileAttributes.wFileAttributes; break;
case fnGetCreationDateTime: case fnGetLastAccessDateTime: case fnGetLastWriteDateTime: setUserSI(FileAttributes.TimeInfo.uMilliseconds, pUserEnvironment); setUserCX(FileAttributes.TimeInfo.uDosTime, pUserEnvironment); setUserDI(FileAttributes.TimeInfo.uDosDate, pUserEnvironment); break;
case fnGetCompressedFileSize: setUserDX(HIWORD(FileAttributes.dwFileSize), pUserEnvironment); *pUserAX = LOWORD(FileAttributes.dwFileSize); break; }
} } break;
case fnLFNOpenFile: { USHORT uDosHandle; USHORT uActionTaken;
dwStatus = demLFNOpenFile((LPSTR)getUserDSSI(pUserEnvironment, fProtectedMode), // filename
getUserBX(pUserEnvironment), // mode and flags
getUserCX(pUserEnvironment), // attribs
getUserDX(pUserEnvironment), // action
getUserDI(pUserEnvironment), // alias hint - unused
&uDosHandle, &uActionTaken);
if (NT_SUCCESS(dwStatus)) { *pUserAX = uDosHandle; setUserCX(uActionTaken, pUserEnvironment); } } break;
case fnLFNGetFileInformationByHandle: { BY_HANDLE_FILE_INFORMATION FileInfo;
dwStatus = demLFNGetFileInformationByHandle(getUserBX(pUserEnvironment), // handle
&FileInfo); if (NT_SUCCESS(dwStatus)) { RtlMoveMemory((PUCHAR)getUserDSDX(pUserEnvironment, fProtectedMode), (PUCHAR)&FileInfo, sizeof(FileInfo)); } }
break;
case fnLFNGenerateShortFileName:
// using rtl function, off course
dwStatus = demLFNGenerateShortFileName((LPSTR)getUserESDI(pUserEnvironment, fProtectedMode), (LPSTR)getUserDSSI(pUserEnvironment, fProtectedMode), (USHORT)getUserDH(pUserEnvironment), (USHORT)getUserDL(pUserEnvironment)); break;
default: dwStatus = NT_STATUS_FROM_WIN32(ERROR_INVALID_FUNCTION); break; }
// we handle here any case that sets ax to error and cf to 1 if error
if (!NT_SUCCESS(dwStatus)) { *pUserAX = (USHORT)WIN32_ERROR_FROM_NT_STATUS(dwStatus); } } else { // this is a service call such as cleanup
demLFNCleanup(); dwStatus = STATUS_SUCCESS; }
dempLFNLog("LFN returns: 0x%x\r\n", dwStatus); return(dwStatus);}
ULONGdempWOWLFNReturn( NTSTATUS dwStatus){ DWORD dwError = WIN32_ERROR_FROM_NT_STATUS(dwStatus); USHORT wErrorCode = (USHORT)ERROR_CODE_FROM_NT_STATUS(dwError);
if (wErrorCode < ERROR_WRITE_PROTECT || wErrorCode > ERROR_GEN_FAILURE && wErrorCode != ERROR_WRONG_DISK) {
// this is not hard error
return((ULONG)wErrorCode); }
return((ULONG)MAKELONG(wErrorCode, 0xFFFF));}
VOIDdemLFNEntry(VOID){ NTSTATUS dwStatus; USHORT UserAX;
// second parm is a ptr to the value of an ax register
dwStatus = demLFNDispatch(NULL, FALSE, &UserAX);
// in any case set ax
setAX(UserAX);
//
// in case of a failure we do not necessarily mess with user registers
//
// as ax set on the user side will be over-written by dos
if (NT_SUCCESS(dwStatus)) { // ok, we are ok
setCF(0); // not the user cf
} else { // we are in error
setCF(1);
// see if we need to fire int24....
// set error code
// set error flag
}
}
/* Function
* demWOWLFNEntry * The main entry point for protected-mode calls (e.g. from kernel31) * It provides all the dispatching and, unlike the dos entry point, * does not modify any x86 processor registers, instead, it operates * on "User" Registers on the stack. * * * Parameters * pUserEnvironment - pointer to user stack frame. Registers should be * pushed on stack according to dos (see DEMUSERFRAME) * * Returns * ULONG containing error code in the low word and 0xffff in the high word * if the error is "hard error" and int24 should have been generated * * It also modifies (in case of success) registers on the user's stack * and patches flags into the processor flags word on the stack * No flags - no error * Carry Set - error * Carry & Zero set - hard error */
ULONGdemWOWLFNEntry( PVOID pUserEnvironment){ NTSTATUS dwStatus; USHORT UserAX; USHORT Flags;
// protected-mode entry
dwStatus = demLFNDispatch(pUserEnvironment, TRUE, &UserAX);
// now set up for return
Flags = getUserPModeFlags(pUserEnvironment) & ~(FLG_ZERO|FLG_CARRY);
if (NT_SUCCESS(dwStatus)) { //
// this is set only when we succeed!!!
//
setUserAX(UserAX, pUserEnvironment); // success - no flags necessary
} else { // set carry flag ... meaning error
Flags |= FLG_CARRY;
// possibly set zero flag indicating hard error
dwStatus = (NTSTATUS)dempWOWLFNReturn(dwStatus);
if (dwStatus & 0xFFFF0000UL) { // we are harderr
Flags |= FLG_ZERO; } }
//
// in any event set user flags
//
setUserPModeFlags(Flags, pUserEnvironment);
return(dwStatus);}
/////////////////////////////////////////////////////////////////////////
//
// Retrieve important dos/wow variables
//
//
#define FETCHVDMADDR(varTo, varFrom) \
{ DWORD __dwTemp; \ __dwTemp = FETCHDWORD(varFrom); \ varTo = (DWORD)GetVDMAddr(HIWORD(__dwTemp), LOWORD(__dwTemp)); \}
VOIDdemInitCDSPtr(VOID){
DWORD dwTemp; PULONG pTemp;
if (!gfInitCDSPtr) { gfInitCDSPtr = TRUE; pTemp = (PULONG)DosWowData.lpCDSFixedTable; dwTemp = FETCHDWORD(*pTemp); DosWowData.lpCDSFixedTable = (DWORD)GetVDMAddr(HIWORD(dwTemp), LOWORD(dwTemp)); }}
VOIDdemSetDosVarLocation(VOID){ PDOSWOWDATA pDosWowData; DWORD dwTemp; PULONG pTemp;
pDosWowData = (PDOSWOWDATA)GetVDMAddr (getDS(),getSI());
FETCHVDMADDR(DosWowData.lpCDSCount, pDosWowData->lpCDSCount);
// the real pointer should be obtained through double-indirection
// but we opt to do it later through deminitcdsptr
dwTemp = FETCHDWORD(pDosWowData->lpCDSFixedTable); pTemp = (PULONG)GetVDMAddr(HIWORD(dwTemp), LOWORD(dwTemp)); DosWowData.lpCDSFixedTable = (DWORD)pTemp;
FETCHVDMADDR(DosWowData.lpCDSBuffer, pDosWowData->lpCDSBuffer); FETCHVDMADDR(DosWowData.lpCurDrv, pDosWowData->lpCurDrv); FETCHVDMADDR(DosWowData.lpCurPDB, pDosWowData->lpCurPDB); FETCHVDMADDR(DosWowData.lpDrvErr, pDosWowData->lpDrvErr); FETCHVDMADDR(DosWowData.lpExterrLocus, pDosWowData->lpExterrLocus); FETCHVDMADDR(DosWowData.lpSCS_ToSync, pDosWowData->lpSCS_ToSync); FETCHVDMADDR(DosWowData.lpSftAddr, pDosWowData->lpSftAddr);}
///////////////////////////////////////////////////////////////////////////
//
// Initialization for this module and temp environment variables
//
//
///////////////////////////////////////////////////////////////////////////
//
// these functions could be found in cmd
//
extern VOID cmdCheckTempInit(VOID);extern LPSTR cmdCheckTemp(LPSTR lpszzEnv);
VOIDdempCheckTempEnvironmentVariables(VOID){ LPSTR rgszTempVars[] = { "TEMP", "TMP" }; int i; DWORD len; DWORD EnvVarLen; CHAR szBuf[MAX_PATH+6]; LPSTR pszVar;
cmdCheckTempInit();
// this code below depends on the fact that none of the vars listed in
// rgszTempVars are longer than 5 chars!
for (i = 0; i < sizeof(rgszTempVars)/sizeof(rgszTempVars[0]); ++i) { strcpy(szBuf, rgszTempVars[i]); len = strlen(szBuf); EnvVarLen = GetEnvironmentVariable(szBuf, szBuf+len+1, sizeof(szBuf)-6); if (EnvVarLen > 0 && EnvVarLen < sizeof(szBuf)-6) { *(szBuf+len) = '='; pszVar = cmdCheckTemp(szBuf); if (NULL != pszVar) { *(pszVar+len) = '\0'; dempLFNLog("%s: substituted for %s\r\n", pszVar, pszVar+len+1); SetEnvironmentVariable(pszVar, pszVar+len+1); } } }
}
VOIDdemWOWLFNInit( PWOWLFNINIT pLFNInit ){ DosWowUpdateTDBDir = pLFNInit->pDosWowUpdateTDBDir; DosWowGetTDBDir = pLFNInit->pDosWowGetTDBDir; DosWowDoDirectHDPopup = pLFNInit->pDosWowDoDirectHDPopup;
// this api also sets temp variables to their needded values -- for ntvdm
// process itself that is. These environment variables come to us from
// cmd
dempCheckTempEnvironmentVariables(); demInitCDSPtr();}
ULONG demWOWLFNAllocateSearchHandle(HANDLE hFind){ DWORD dwStatus; PLFN_SEARCH_HANDLE_ENTRY pHandleEntry; USHORT DosHandle = 0;
dwStatus = dempLFNAllocateHandleEntry(&DosHandle, &pHandleEntry); if (NT_SUCCESS(dwStatus)) { pHandleEntry->hFindHandle = hFind; pHandleEntry->wMustMatchAttributes = 0; pHandleEntry->wSearchAttributes = 0; pHandleEntry->wProcessPDB = *pusCurrentPDB; return((ULONG)MAKELONG(DosHandle, 0)); }
// we have an error
return((ULONG)INVALID_HANDLE_VALUE);}
HANDLE demWOWLFNGetSearchHandle(USHORT DosHandle){ PLFN_SEARCH_HANDLE_ENTRY pHandleEntry;
pHandleEntry = dempLFNGetHandleEntry(DosHandle);
return(NULL == pHandleEntry ? INVALID_HANDLE_VALUE : pHandleEntry->hFindHandle);}
BOOL demWOWLFNCloseSearchHandle(USHORT DosHandle){ PLFN_SEARCH_HANDLE_ENTRY pHandleEntry; HANDLE hFind = INVALID_HANDLE_VALUE;
pHandleEntry = dempLFNGetHandleEntry(DosHandle); if (NULL != pHandleEntry) { hFind = pHandleEntry->hFindHandle; dempLFNFreeHandleEntry(pHandleEntry); }
return(FindClose(hFind));}
#if 0
///////////////////////////////////////////////////////
//
//
// Clipboard dispatch api
typedef enum tagClipbrdFunctionNumber { fnIdentifyClipboard = 0x00, fnOpenClipboard = 0x01, fnEmptyClipboard = 0x02, fnSetClipboardData = 0x03, fnGetClipboardDataSize = 0x04, fnGetClipboardData = 0x05, fnInvalidFunction6 = 0x06, fnInvalidFunction7 = 0x07, fnCloseClipboard = 0x08, fnCompactClipboard = 0x09, fnGetDeviceCaps = 0x0a} enumClipbrdFunctionNumber;
#define CLIPBOARD_VERSION 0x0200
#define SWAPBYTES(w) \
((((USHORT)w & 0x0ff) << 8) | ((USHORT)w >> 8))
#pragma pack(1)
typedef struct tagBITMAPDOS { WORD bmdType; WORD bmdWidth; WORD bmdHeight; WORD bmdWidthBytes; BYTE bmdPlanes; BYTE bmdBitsPixel; DWORD bmdBits; DWORD bmdJunk; WORD bmdWidthUm; WORD bmdHeightUm;} BITMAPDOS, UNALIGNED*PBITMAPDOS;
typedef struct tagMETAFILEPICTDOS { WORD mfpd_mm; WORD mfpd_xExt; WORD mfpd_yExt;} METAFILEPICTDOS, UNALIGNED* PMETAFILEPICTDOS;
#pragma pack()
BOOLdemSetClipboardData( VOID ){ WORD wType = getDX(); LONG lSize = ((ULONG)getSI() << 16) | getCX();
if (wType == CF_METAFILEPICT || wType == CF_DSPMETAFILEPICT) { if (lSize < sizeof(METAFILEPICTDOS)) { return(FALSE); }
hMeta = GlobalAlloc(); if (NULL == hMeta) { return(FALSE); }
}
}
BOOL dempGetClipboardDataSize( WORD wFormat, LPDWORD lpdwSize; ){ HANDLE hData; DWORD dwSize = 0;
hData = GetClipboardData(wFormat); if (NULL != hData) { switch(wFormat) { case CF_BITMAP: case CF_DSPBITMAP: { BITMAP bm; int sizeBM;
sizeBM = GetObject((HGDIOBJ)hData, sizeof(bm), &bm); if (sizeBM > 0) { dwSize = bm.bmWidthBytes * bm.bmHeight * bm.bmPlanes; dwSize += sizeof(BITMAPDOS); } } break;
case CF_METAFILEPICT: case CF_DSPMETAFILEPICT: dwSize = GlobalSize(hData); if (dwSize) { dwSize += sizeof(METAFILEPICTDOS); } break;
default: dwSize = GlobalSize(hData); break; } }
*lpdwSize = dwSize; return(0 != dwSize);}
extern HANDLE GetConsoleWindow(VOID);
BOOL demClipbrdDispatch( VOID){ BOOL fHandled = TRUE; HWND hWndConsole;
switch(getAL()) { case fnIdentifyClipboard: // identify call just checks for installation
setAX(SWAPBYTES(CLIPBOARD_VERSION)); setDX(0); break;
case fnOpenClipboard: // open clipboard -- opens a clipboard on behalf of console app
//
hWndConsole = GetConsoleWindow(); if (OpenClipboard(hWndConsole)) { setDX(0); setAX(1); } else { setDX(0); setAX(0); } break;
case fnEmptyClipboard: if (EmptyClipboard()) { setDX(0); setAX(1); } else { setDX(0); setAX(0); } break;
case fnSetClipboardData:// if (dempSetClipboardData()) {
//
// }
break; case fnGetClipboardDataSize:// if (dempGetClipboardDataSize(getDX())) {
// then we have it
//
// }
break; case fnGetClipboardData:// if (dempGetClipboardData( )) {
// }
break; case fnCloseClipboard: if (CloseClipboard()) { setDX(0); setAX(1); } else { setDX(0); setAX(0); } break;
case fnCompactClipboard: // this should really mess with GlobalCompact but we don't have any
// idea of how to handle these things. The only valid case could be
// made for Windows apps that call this api for some reason
// while they have a "real" GlobalCompact avaliable...
break; case fnGetDeviceCaps: { HWND hWndConsole; HDC hDC; DWORD dwCaps = 0; hWndConsole = GetConsoleWindow(); hDC = GetDC(hWndConsole); dwCaps = (DWORD)GetDeviceCaps(hDC, getDX()); if (NULL != hDC) { ReleaseDC(hWndConsole, hDC); } setDX(HIWORD(dwCaps)); setAX(LOWORD(dwCaps)); } break; default: fHandled = FALSE; break; }
return(fHandled);}
#endif
BOOL demClipbrdDispatch( VOID){ return(FALSE);}
|
