NT4/private/ole32/stg/fsstg/ntsupp.cxx

1244 lines
37 KiB
C++
Raw Normal View History

2001-01-01 00:00:00 +01:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: ntsupp.cxx
//
// Contents: NT support routines
//
// History: 28-Jun-93 DrewB Created
//
//----------------------------------------------------------------------------
#include "headers.cxx"
#pragma hdrstop
#include <iofs.h>
#include <stgutil.hxx>
#include <ntdddfs.h>
//+---------------------------------------------------------------------------
//
// Function: MakeStreamName
//
// Synopsis: Prepend a L':' to a string and return a new string.
// The old string is untouched.
//
// Arguments:
//
// Returns: New string, or NULL if out of memory.
//
// Modifies:
//
// History: 18-Feb-94 DrewB Created
//
// Notes:
//
//----------------------------------------------------------------------------
WCHAR * MakeStreamName(const WCHAR *pwcsName)
{
WCHAR *pwcsNewName;
ssDebugOut((DEB_ITRACE, "In MakeStreamName(%ws)\n",pwcsName));
USHORT uLen = lstrlenW(pwcsName);
pwcsNewName = new WCHAR[uLen + 2];
if (pwcsNewName)
{
pwcsNewName[0] = L':';
lstrcpyW(pwcsNewName + 1, pwcsName);
}
ssDebugOut((DEB_ITRACE, "Out MakeStreamName\n"));
return pwcsNewName;
}
//+---------------------------------------------------------------------------
//
// Function: CheckFdName, public
//
// Synopsis: Checks for illegal characters in an element name
//
// Arguments: [pwcs] - Name
//
// Returns: Appropriate status code
//
// History: 29-Jul-93 DrewB Created
//
// Notes: Doesn't check for length because that will vary by
// file system and will be enforced by the FS itself
//
// Kept separate from CheckName since we may want to
// allow different rules for file system elements
//
//----------------------------------------------------------------------------
SCODE CheckFdName(WCHAR const *pwcs)
{
static WCHAR const wcsInvalid[] = {'\\','/','\0'};
SCODE sc;
ssDebugOut((DEB_ITRACE, "In CheckFdName(%ws)\n", pwcs));
ssAssert (pwcs != NULL);
sc = S_OK;
for (; *pwcs; pwcs++)
if (wcschr(wcsInvalid, *pwcs))
{
sc = STG_E_INVALIDNAME;
break;
}
ssDebugOut((DEB_ITRACE, "Out CheckFdName => %lX\n", sc));
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: ModeToNtFlags, public
//
// Synopsis: Converts a grfMode to a set of NtCreateFile flags
//
// Arguments: [grfMode] - Mode
// [co] - Create or open request
// [fd] - File or directory
// [pam] - ACCESS_MASK return
// [pulAttributes] - Object attributes return
// [pulSharing] - Sharing return
// [pulCreateDisposition] - Create/open flags return
// [pulCreateOptions] - Create type return
//
// Returns: Appropriate status code
//
// Modifies: [pam]
// [pulAttributes]
// [pulSharing]
// [pulCreateDisposition]
// [pulCreateOptions]
//
// History: 24-Jun-93 DrewB Created
//
//----------------------------------------------------------------------------
SCODE ModeToNtFlags(DWORD grfMode,
CREATEOPEN co,
FILEDIR fd,
ACCESS_MASK *pam,
ULONG *pulAttributes,
ULONG *pulSharing,
ULONG *pulCreateDisposition,
ULONG *pulCreateOptions)
{
SCODE sc;
ssDebugOut((DEB_ITRACE, "In ModeToNtFlags("
"%lX, %d, %d, %p, %p, %p, %p, %p)\n",
grfMode, co, fd, pam, pulAttributes, pulSharing,
pulCreateDisposition, pulCreateOptions));
// Note: Although you may think permissions like FILE_ADD_FILE,
// FILE_ADD_SUBDIRECTORY and FILE_TRAVERSE are good permissions
// to have for a directory, they are only used for ACL checks and
// are not supposed to be specified in DesiredAccess.
// That's the word from DarrylH
// BUGBUG: [mikese] of course, the consequence of that it that there is no
// way that this routine can generate a desired access mask which is
// sufficiently polymorphic so as to be acceptable regardless of the
// type of thing being opened. Therefore, we give it our best shot and
// retry for certain distinguishable error cases. The tricky cases are
// those where fd == FD_DEFAULT, since for that case must assume the
// most general case, nameky that of a structured storage, which behaves
// like both a directory and a file.
switch(grfMode & (STGM_READ | STGM_WRITE | STGM_READWRITE))
{
case STGM_READ:
*pam = FILE_GENERIC_READ;
break;
case STGM_WRITE:
if ((fd == FD_FILE) || (fd == FD_STREAM))
*pam = FILE_GENERIC_WRITE;
else if ( fd == FD_DIR )
{
*pam = STANDARD_RIGHTS_WRITE |
FILE_WRITE_EA |
SYNCHRONIZE |
FILE_WRITE_ATTRIBUTES;
}
else
*pam = FILE_GENERIC_WRITE;
break;
case STGM_READWRITE:
if ((fd == FD_FILE) || (fd == FD_STREAM))
*pam = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
else if ( fd == FD_DIR )
*pam = FILE_GENERIC_READ
| STANDARD_RIGHTS_WRITE
| FILE_WRITE_EA | SYNCHRONIZE
| FILE_WRITE_ATTRIBUTES;
else
*pam = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
break;
default:
ssErr(EH_Err, STG_E_INVALIDFLAG);
break;
}
if (grfMode & STGM_EDIT_ACCESS_RIGHTS)
{
*pam |= WRITE_DAC | READ_CONTROL;
}
// If we're opening something for deletion, throw on the DELETE permission
if (co == CO_OPEN && (grfMode & STGM_CREATE))
*pam |= DELETE;
switch(grfMode & (STGM_SHARE_DENY_NONE | STGM_SHARE_DENY_READ |
STGM_SHARE_DENY_WRITE | STGM_SHARE_EXCLUSIVE))
{
case STGM_SHARE_DENY_READ:
*pulSharing = FILE_SHARE_WRITE | FILE_SHARE_DELETE;
break;
case STGM_SHARE_DENY_WRITE:
*pulSharing = FILE_SHARE_READ | FILE_SHARE_DELETE;
break;
case STGM_SHARE_EXCLUSIVE:
*pulSharing = FILE_SHARE_DELETE;
break;
case STGM_SHARE_DENY_NONE:
case 0:
*pulSharing = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
break;
default:
ssErr(EH_Err, STG_E_INVALIDFLAG);
break;
}
switch(grfMode & (STGM_CREATE | STGM_FAILIFTHERE | STGM_CONVERT))
{
case STGM_CREATE:
if (co == CO_CREATE)
if ((fd == FD_FILE) || (fd == FD_STREAM) || (fd == FD_STORAGE) ||
(fd == FD_CATALOG))
*pulCreateDisposition = FILE_SUPERSEDE;
else if (fd == FD_DIR)
*pulCreateDisposition = FILE_OPEN_IF;
else
{
ssErr(EH_Err, STG_E_INVALIDFLAG);
}
else
*pulCreateDisposition = FILE_OPEN;
break;
case STGM_FAILIFTHERE:
if (co == CO_CREATE)
*pulCreateDisposition = FILE_CREATE;
else
*pulCreateDisposition = FILE_OPEN;
break;
case STGM_CONVERT:
default:
ssErr(EH_Err, STG_E_INVALIDFLAG);
break;
}
*pulAttributes |= FILE_ATTRIBUTE_NORMAL;
// FILE_FLAG_OVERLAPPED is a valid Win32 flag, but invalid NT flag
// so we translate it into ~FILE_SYNCHRONOUS_IO_NONALERT
// and mask out FILE_FLAG_OVERLAPPED before calling NtCreateFile
if ((*pulAttributes & FILE_FLAG_OVERLAPPED) == 0 &&
(grfMode & STGM_OVERLAPPED) == 0)
*pulCreateOptions = FILE_SYNCHRONOUS_IO_NONALERT;
else
*pulAttributes &= ~FILE_FLAG_OVERLAPPED;
switch (fd)
{
case FD_DEFAULT:
break;
//case FD_EMBEDDING: // no longer supported
// *pulCreateOptions |= FILE_STORAGE_TYPE_SPECIFIED | FILE_STORAGE_TYPE_EMBEDDING;
// break;
case FD_STORAGE:
*pulCreateOptions |= FILE_STORAGE_TYPE_SPECIFIED | FILE_STORAGE_TYPE_STRUCTURED_STORAGE;
break;
case FD_STREAM:
*pulCreateOptions |= FILE_STORAGE_TYPE_SPECIFIED | FILE_STORAGE_TYPE_STREAM;
break;
case FD_DIR:
*pulCreateOptions |= FILE_DIRECTORY_FILE;
break;
case FD_FILE:
*pulCreateOptions |= FILE_NON_DIRECTORY_FILE;
break;
case FD_CATALOG:
*pulCreateOptions |= FILE_STORAGE_TYPE_SPECIFIED | FILE_STORAGE_TYPE_CATALOG;
break;
case FD_JUNCTION:
*pulCreateOptions |= FILE_STORAGE_TYPE_SPECIFIED | FILE_STORAGE_TYPE_JUNCTION_POINT;
break;
default:
ssErr (EH_Err, STG_E_INVALIDFLAG);
}
#ifdef TRANSACT_OLE
if (grfMode & STGM_TRANSACTED)
{
*pulCreateOptions |= FILE_TRANSACTED_MODE;
}
#endif
// Set up delete-on-release flags
if (grfMode & STGM_DELETEONRELEASE)
{
// We cannot use the DELETE_ON_CLOSE bits in OFS since this
// causes the file to become invalid for relative opens.
*pam |= DELETE;
}
sc = S_OK;
ssDebugOut((DEB_ITRACE, "Out ModeToNtFlags\n"));
EH_Err:
return sc;
}
SAFE_HEAP_PTR(SafeFeai, FILE_FULL_EA_INFORMATION);
//+---------------------------------------------------------------------------
//
// Function: GetNtHandle, public
//
// Synopsis: Opens or create a file or directory using NtCreateFile
//
// Arguments: [hParent] - Parent handle or NULL
// [pwcsName] - Child name or full path
// [grfMode] - Access mode
// [co] - Create or open
// [fd] - File or directory
// [pssSecurity] - Security or NULL
// [ph] - Handle return
//
// Returns: Appropriate status code
//
// Modifies: [ph]
//
// History: 24-Jun-93 DrewB Created
//
// Notes: If [hParent] is NULL, [pwcsName] should be a full path
// [ph] should only be set on success
//
//----------------------------------------------------------------------------
SCODE GetNtHandle(HANDLE hParent,
WCHAR const *pwcsName,
DWORD grfMode,
DWORD grfAttrs,
CREATEOPEN co,
FILEDIR fd,
LPSECURITY_ATTRIBUTES pssSecurity,
HANDLE *ph)
{
SCODE sc;
NTSTATUS nts;
OBJECT_ATTRIBUTES oa;
IO_STATUS_BLOCK iosb;
UNICODE_STRING us;
HANDLE h;
ACCESS_MASK am;
ULONG ulAttrs = grfAttrs;
ULONG ulSharing;
ULONG ulCreateDisp;
ULONG ulCreateOpt = 0;
ULONG ulEaLength = 0;
SafeFeai pfeai = NULL;
ssDebugOut((DEB_ITRACE, "In GetNtHandle(%p, %ws, %lX, %d, %d, %p, %p)\n",
hParent, pwcsName, grfMode, co, fd, pssSecurity, ph));
if (hParent == NULL)
{
if (pwcsName == NULL)
ssErr(EH_Err, STG_E_INVALIDNAME);
if (!RtlDosPathNameToNtPathName_U(pwcsName, &us, NULL, NULL))
ssErr(EH_Err, STG_E_UNKNOWN);
}
else
{
ssChk(CheckFdName(pwcsName));
us.Length = lstrlenW(pwcsName)*sizeof(WCHAR);
us.MaximumLength = us.Length+sizeof(WCHAR);
us.Buffer = (PWSTR)pwcsName;
}
InitializeObjectAttributes(&oa, &us, OBJ_CASE_INSENSITIVE, hParent, NULL);
if (pssSecurity)
{
if (pssSecurity->nLength != sizeof(SECURITY_ATTRIBUTES))
ssErr(EH_us, STG_E_INVALIDPARAMETER);
oa.SecurityDescriptor = pssSecurity->lpSecurityDescriptor;
}
ssChkTo(EH_us,
ModeToNtFlags(grfMode, co, fd, &am, &ulAttrs, &ulSharing,
&ulCreateDisp, &ulCreateOpt));
if (fd == FD_JUNCTION || (grfMode & STGM_NOCROSSJP))
{
ulEaLength=sizeof(FILE_FULL_EA_INFORMATION)+strlen(EA_NAME_OPENIFJP)+1;
pfeai.Attach((FILE_FULL_EA_INFORMATION *) new BYTE[ulEaLength]);
ssMem((FILE_FULL_EA_INFORMATION *) pfeai);
pfeai->NextEntryOffset = 0;
pfeai->Flags = 0;
pfeai->EaNameLength = strlen(EA_NAME_OPENIFJP);
pfeai->EaValueLength = 0;
strcpy (pfeai->EaName, EA_NAME_OPENIFJP);
}
nts = NtCreateFile(&h, am, &oa, &iosb, NULL,
ulAttrs, ulSharing, ulCreateDisp,
ulCreateOpt, pfeai, ulEaLength);
// BUGBUG: thise is a hack to get around inflexibilities in the file system.
// if the operation failed with STATUS_INVALID_PARAMETER, it probably
// means we tried to open a directory using modes only valid for a file
// (Not sure if this can ever really happen)
if ( nts == STATUS_INVALID_PARAMETER )
{
nts = NtCreateFile(&h, am & ~(FILE_ADD_SUBDIRECTORY|FILE_ADD_FILE), &oa,
&iosb, NULL, ulAttrs, ulSharing, ulCreateDisp,
ulCreateOpt, pfeai, ulEaLength);
}
if (NT_SUCCESS(nts))
{
*ph = h;
sc = S_OK;
}
else
sc = NtStatusToScode(nts);
ssDebugOut((DEB_ITRACE, "Out GetNtHandle => %p\n", *ph));
EH_us:
if (hParent == NULL)
RtlFreeHeap(RtlProcessHeap(), 0, us.Buffer);
EH_Err:
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: ReopenNtHandle, public
//
// Synopsis: Duplicates an NT handle with new permissions
//
// Arguments: [h] - Handle to dup
// [grfMode] - Desired access for duplicate
// [fd] - File or directory handle
// [ph] - Handle return
//
// Returns: Appropriate status code
//
// Modifies: [ph]
//
// History: 29-Jun-93 DrewB Created
//
// Notes: Reopen can only change the read/write access to the
// file; sharing cannot be changed
//
//----------------------------------------------------------------------------
SCODE ReopenNtHandle(HANDLE h, DWORD grfMode, FILEDIR fd, HANDLE *ph)
{
ACCESS_MASK am;
ULONG ulAttrs = 0;
ULONG ulSharing;
ULONG ulCreateDisp;
ULONG ulCreateOpt;
SCODE sc;
NTSTATUS nts;
HANDLE th;
ssDebugOut((DEB_ITRACE, "In ReopenNtHandle(%p, %lX, %d, %p)\n",
h, grfMode, fd, ph));
ssChk(ModeToNtFlags(grfMode & (STGM_READ | STGM_WRITE | STGM_READWRITE),
CO_OPEN, fd, &am, &ulAttrs, &ulSharing, &ulCreateDisp,
&ulCreateOpt));
nts = NtDuplicateObject(NtCurrentProcess(), h, NtCurrentProcess(), &th, am,
0, DUPLICATE_SAME_ATTRIBUTES);
if (!NT_SUCCESS(nts))
{
sc = NtStatusToScode(nts);
}
else
{
*ph = th;
sc = S_OK;
}
ssDebugOut((DEB_ITRACE, "Out ReopenNtHandle => %p, 0x%lX\n", *ph, sc));
EH_Err:
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: DupNtHandle, public
//
// Synopsis: Duplicates an NT handle
//
// Arguments: [h] - Handle
// [ph] - Return
//
// Returns: Appropriate status code
//
// Modifies: [ph]
//
// History: 09-Jul-93 DrewB Created
//
//----------------------------------------------------------------------------
SCODE DupNtHandle(HANDLE h, HANDLE *ph)
{
SCODE sc;
NTSTATUS nts;
HANDLE th;
ssDebugOut((DEB_ITRACE, "In DupNtHandle(%p, %p)\n", h, ph));
nts = NtDuplicateObject(NtCurrentProcess(), h, NtCurrentProcess(), &th, 0,
0, DUPLICATE_SAME_ATTRIBUTES |
DUPLICATE_SAME_ACCESS);
if (!NT_SUCCESS(nts))
{
sc = NtStatusToScode(nts);
}
else
{
sc = S_OK;
*ph = th;
}
ssDebugOut((DEB_ITRACE, "Out DupNtHandle => %p, 0x%lX\n", *ph, sc));
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: StorageTypeToFileDir, public
//
// Synopsis: converts a NT StorageType into a FileDir type
//
// Arguments: [storageType] - returned from NtQueryOleAllInformation
// [pfd] - FILEDIR used by storage layer
//
// Returns: Appropriate status code
//
// History: 26-Jul-1995 HenryLee created
//
// Notes:
//
//----------------------------------------------------------------------------
SCODE StorageTypeToFileDir (ULONG storageType, FILEDIR *pfd)
{
SCODE sc = S_OK;
switch (storageType)
{
case StorageTypeDirectory:
*pfd = FD_DIR;
break;
case StorageTypeFile:
*pfd = FD_FILE;
break;
case StorageTypeStructuredStorage:
case StorageTypeEmbedding:
*pfd = FD_STORAGE;
break;
case StorageTypeStream:
*pfd = FD_STREAM;
break;
case StorageTypeCatalog:
*pfd = FD_CATALOG;
break;
case StorageTypeJunctionPoint:
*pfd = FD_JUNCTION;
break;
default:
sc = STG_E_INVALIDPARAMETER;
ssAssert (!"Unhandled storage type");
break;
}
return sc;
};
//+---------------------------------------------------------------------------
//
// Function: template<class T> FillSTATSTG, public
//
// Synopsis: Fills out a STATSTG by retrieving information from NT handle
// FillSTATSTG<FILE_ALL_INFORMATION*> is instantiated for
// non-OFS volumes, and FillSTATSTG<FILE_OLE_ALL_INFORMATION*>
// is instantiated for OFS volumes
//
// Arguments: [h] - Handle
// [grfStatFlag] - Stat flags
// [cbExtra] - Extra space to allocate for name,
// used for faking \CONTENTS on file contents stream
// [pstat] - STATSTG to fill in
// [pwcsName] - Name to fill in or NULL
// [pfd] - Return dir/file
//
// Returns: Appropriate status code
//
// BUGBUG: This call should retrieve the storage type from the info class
// in order to set the PFD field.
//
// Modifies: [pstat]
// [pwcsName]
// [pfDir]
//
// History: 14-Jul-1995 HenryLee created
//
// Notes: Doesn't fill in grfMode because full information
// can't be retrieved
//
//----------------------------------------------------------------------------
SCODE FillSTATSTG (FILE_ALL_INFORMATION *pfai,
DWORD grfStatFlag,
ULONG cbExtra,
STATSTG *pstat,
WCHAR *pwcsName,
DWORD *pdwAttrs,
FILEDIR *pfd)
{
SCODE sc = S_OK;
WCHAR awcName[MAX_PATH];
WCHAR *pwcs = NULL;
if (grfStatFlag != STATFLAG_NONAME || pwcsName != NULL)
{
memcpy(awcName, pfai->NameInformation.FileName,
pfai->NameInformation.FileNameLength);
*(WCHAR *)((BYTE *)awcName+pfai->NameInformation.FileNameLength)=L'\0';
}
if (grfStatFlag != STATFLAG_NONAME)
{ // add 3 characters for drive letter and trailing wide NULL
sc = GetScode(CoMemAlloc((lstrlenW(awcName)+3)*sizeof(WCHAR)+
cbExtra+sizeof(WCHAR), (void **)&pwcs));
}
else
sc = S_OK;
if (SUCCEEDED(sc))
{
if (pwcs)
lstrcpyW(pwcs, awcName);
if (pwcsName)
lstrcpyW(pwcsName, awcName);
pstat->pwcsName = pwcs;
pstat->type = STGTY_STORAGE;
pstat->cbSize = *(ULARGE_INTEGER *)&pfai->StandardInformation.
EndOfFile;
LARGE_INTEGER_TO_FILETIME(&pfai->BasicInformation.LastWriteTime,
&pstat->mtime);
LARGE_INTEGER_TO_FILETIME(&pfai->BasicInformation.CreationTime,
&pstat->ctime);
LARGE_INTEGER_TO_FILETIME(&pfai->BasicInformation.LastAccessTime,
&pstat->atime);
pstat->grfMode = 0;
pstat->grfLocksSupported = 0;
if (pdwAttrs) *pdwAttrs = pfai->BasicInformation.FileAttributes;
if (pfai->StandardInformation.Directory)
{
pstat->STATSTG_dwStgFmt = STGFMT_DIRECTORY;
*pfd = FD_DIR;
}
else
{
pstat->STATSTG_dwStgFmt = STGFMT_DOCUMENT;
*pfd = FD_STORAGE;
}
}
return sc;
}
SCODE FillOleSTATSTG (FILE_OLE_ALL_INFORMATION *pfai,
DWORD grfStatFlag,
ULONG cbExtra,
STATSTG *pstat,
WCHAR *pwcsName,
DWORD *pdwAttrs,
FILEDIR *pfd)
{
SCODE sc = S_OK;
WCHAR awcName[MAX_PATH];
WCHAR *pwcs = NULL;
if (grfStatFlag != STATFLAG_NONAME || pwcsName != NULL)
{
memcpy(awcName, pfai->NameInformation.FileName,
pfai->NameInformation.FileNameLength);
*(WCHAR *)((BYTE *)awcName+pfai->NameInformation.FileNameLength)=L'\0';
}
if (grfStatFlag != STATFLAG_NONAME)
{ // add 3 characters for drive letter and trailing wide NULL
sc = GetScode(CoMemAlloc((lstrlenW(awcName)+3)*sizeof(WCHAR)+
cbExtra+sizeof(WCHAR), (void **)&pwcs));
}
else
sc = S_OK;
if (SUCCEEDED(sc))
{
if (pwcs)
lstrcpyW(pwcs, awcName);
if (pwcsName)
lstrcpyW(pwcsName, awcName);
pstat->pwcsName = pwcs;
pstat->type = STGTY_STORAGE;
pstat->cbSize = *(ULARGE_INTEGER *)&pfai->StandardInformation.
EndOfFile;
LARGE_INTEGER_TO_FILETIME(&pfai->BasicInformation.LastWriteTime,
&pstat->mtime);
LARGE_INTEGER_TO_FILETIME(&pfai->BasicInformation.CreationTime,
&pstat->ctime);
LARGE_INTEGER_TO_FILETIME(&pfai->BasicInformation.LastAccessTime,
&pstat->atime);
pstat->grfMode = 0;
pstat->grfLocksSupported = 0;
if (pdwAttrs) *pdwAttrs = pfai->BasicInformation.FileAttributes;
if (pfai->StandardInformation.Directory)
{
pstat->STATSTG_dwStgFmt = STGFMT_DIRECTORY;
*pfd = FD_DIR;
}
else if (pfai->StorageType == StorageTypeStream)
{
if ((pfai->BasicInformation.FileAttributes &
FILE_ATTRIBUTE_PROPERTY_SET) == 0)
{
pstat->mtime.dwHighDateTime = pstat->mtime.dwLowDateTime = 0;
}
pstat->ctime.dwHighDateTime = pstat->ctime.dwLowDateTime = 0;
pstat->atime.dwHighDateTime = pstat->atime.dwLowDateTime = 0;
pstat->STATSTG_dwStgFmt = STGFMT_DOCUMENT;
*pfd = FD_STREAM;
}
else
{
pstat->STATSTG_dwStgFmt = STGFMT_DOCUMENT;
*pfd = FD_STORAGE;
}
}
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: StatNtHandle, public
//
// Synopsis: Fills out a STATSTG by retrieving information for an NT handle
//
// Arguments: [h] - Handle
// [grfStatFlag] - Stat flags
// [cbExtra] - Extra space to allocate for name,
// used for faking \CONTENTS on file contents stream
// [pstat] - STATSTG to fill in
// [pwcsName] - Name to fill in or NULL
// [pfd] - Return dir/file
//
// Returns: Appropriate status code
//
// BUGBUG: This call should retrieve the storage type from the info class
// in order to set the PFD field.
//
// Modifies: [pstat]
// [pwcsName]
// [pfDir]
//
// History: 09-Jul-93 DrewB Created
// 24-Mar-95 HenryLee remove GetFullPathName, use stored drive
//
// Notes: Doesn't fill in grfMode because full information
// can't be retrieved
//
//----------------------------------------------------------------------------
SAFE_HEAP_PTR(SafeFai, FILE_ALL_INFORMATION);
SAFE_HEAP_PTR(SafeFoai, FILE_OLE_ALL_INFORMATION);
SCODE StatNtHandle(HANDLE h,
DWORD grfStatFlag,
ULONG cbExtra,
STATSTG *pstat,
WCHAR *pwcsName,
DWORD *pdwAttrs,
FILEDIR *pfd)
{
NTSTATUS nts;
SCODE sc;
IO_STATUS_BLOCK iosb;
SafeFai pfai;
SafeFoai pfoai;
ULONG cbFai;
BOOL fOfs = TRUE;
ssDebugOut((DEB_ITRACE, "In StatNtHandle(%p, 0x%lX, %lu, %p, %p, %p)\n",
h, grfStatFlag, cbExtra, pstat, pwcsName, pfd));
cbFai = sizeof(FILE_OLE_ALL_INFORMATION) +
MAXIMUM_FILENAME_LENGTH*sizeof(WCHAR);
pfoai.Attach((FILE_OLE_ALL_INFORMATION *)new BYTE[cbFai]);
ssMem((FILE_OLE_ALL_INFORMATION *)pfoai);
nts = NtQueryInformationFile(h, &iosb, pfoai, cbFai, FileOleAllInformation);
if (!NT_SUCCESS(nts))
{
fOfs = FALSE;
cbFai = sizeof(FILE_ALL_INFORMATION)+
MAXIMUM_FILENAME_LENGTH*sizeof(WCHAR);
pfai.Attach((FILE_ALL_INFORMATION *)new BYTE[cbFai]);
ssMem((FILE_ALL_INFORMATION *)pfai);
nts = NtQueryInformationFile(h, &iosb, pfai, cbFai, FileAllInformation);
if (!NT_SUCCESS(nts))
ssErr(EH_Err, NtStatusToScode(nts));
sc = FillSTATSTG ((FILE_ALL_INFORMATION *) pfai,
grfStatFlag, cbExtra, pstat, pwcsName, pdwAttrs, pfd);
if (SUCCEEDED(sc))
{
pstat->clsid = CLSID_NULL;
pstat->grfStateBits = 0;
}
}
else
{
sc = FillOleSTATSTG ((FILE_OLE_ALL_INFORMATION *)pfoai,
grfStatFlag, cbExtra, pstat, pwcsName, pdwAttrs, pfd);
if (SUCCEEDED(sc))
{
pstat->clsid = pfoai->OleClassIdInformation.ClassId;
pstat->grfStateBits = pfoai->OleStateBits;
DWORD dwStgfmt;
if (SUCCEEDED(sc = StorageTypeToFileDir (pfoai->StorageType,pfd)) &&
SUCCEEDED(sc = DetermineHandleStgType (h,*pfd,&dwStgfmt)))
{
pstat->STATSTG_dwStgFmt = dwStgfmt;
}
}
}
EH_Err:
ssDebugOut((DEB_ITRACE, "Out StatNtHandle => 0x%lX\n", sc));
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: HandleRefersToOfsVolume, public
//
// Synopsis: Determines whether the given handle refers to an OFS volume
//
// Arguments: [h] - Handle
//
// Returns: Appropriate status code
//
// History: 21-Sep-93 DrewB Created
//
//----------------------------------------------------------------------------
SCODE HandleRefersToOfsVolume(HANDLE h)
{
NTSTATUS nts;
SCODE sc;
ssDebugOut((DEB_ITRACE, "In HandleRefersToOfsVolume(%p)\n", h));
nts = OFSGetVersion(h, NULL);
if (!NT_SUCCESS(nts))
{
// BUGBUG - It would be nice to be able to distinguish
// failure from unsupported but there doesn't seem to
// be any way to do it
// For the moment, simply return S_FALSE. This will cause
// all failures to be retried as non-OFS operations which
// should fail also
sc = S_FALSE;
}
else
{
sc = S_OK;
}
ssDebugOut((DEB_ITRACE, "Out HandleRefersToOfsVolume => %lX\n", sc));
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: RefersToOfsVolume, public
//
// Synopsis: Determines whether the given path refers to something
// on an OFS volume
//
// Arguments: [pwcsPath] - Path
// [co] - create or open case
//
// Returns: Appropriate status code
//
// History: 15-Jul-93 DrewB Created
//
// Algorithm: Attempt to open the parent and return HandleRTOV
//
// Notes: The path doesn't have to refer to an existing object
//
//----------------------------------------------------------------------------
SCODE RefersToOfsVolume(WCHAR const *pwcsPath, CREATEOPEN co)
{
SCODE sc;
WCHAR awcFullPath[_MAX_PATH];
HANDLE h;
ssDebugOut((DEB_ITRACE, "In RefersToOfsVolume(%ws)\n", pwcsPath));
// Temporary files are always treated as non-OFS
if (pwcsPath == NULL)
ssErr(EH_Err, S_FALSE);
if (GetFullPathName(pwcsPath, _MAX_PATH, awcFullPath, NULL) == 0)
sc = LAST_STG_SCODE;
else
{
if (co == CO_CREATE)
{
WCHAR *pwc;
// Locate last separator
pwc = wcsrchr(awcFullPath, L'\\');
// A fully qualified path is guaranteed to have at least one '\'
ssAssert(pwc != NULL);
// Is this a UNC path or a device path?
if (lstrlenW(awcFullPath) >= 2 &&
memcmp(awcFullPath, L"\\\\", 2*sizeof(WCHAR)) == 0)
{
WCHAR *pwcMach, *pwcShare;
// Find separator between machine and share
pwcMach = wcschr(awcFullPath+2, L'\\');
ssAssert(pwcMach != NULL);
// Find separator after share
pwcShare = wcschr(pwcMach+1, L'\\');
// If there isn't a separator after the share, add one
// The path must be of the form \\mach\share so we can
// just stick a \ on the end
if (pwcShare == NULL)
{
pwcShare = awcFullPath+lstrlenW(awcFullPath);
*pwcShare = L'\\';
pwc = pwcShare;
}
else
{
// If we're not at the root (share separator), back up one
// so awcFullPath refers to the parent
if (pwc != pwcShare)
pwc--;
}
}
else
{
// If we're not at the root, back up one so awcFullPath refers
// to the parent
if (pwc != wcschr(awcFullPath, L'\\'))
pwc--;
}
// Terminate after parent name
*++pwc = 0;
} // endif (co == CO_CREATE)
else
{
ssAssert (co == CO_OPEN);
lstrcpyW (awcFullPath, pwcsPath);
}
ssChk(GetNtHandle(NULL, awcFullPath, STGM_READ, 0, CO_OPEN,
(co == CO_CREATE ? FD_DIR : FD_DEFAULT), NULL, &h));
sc = HandleRefersToOfsVolume(h);
dbgNtVerSucc(NtClose(h));
}
ssDebugOut((DEB_ITRACE, "Out RefersToOfsVolume => %x\n", sc));
EH_Err:
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: SetTimes, public
//
// Synopsis: Sets the times for a handle
//
// Arguments: [h] - Handle
// [pctime] - Creation time or NULL
// [patime] - Modification time or NULL
// [pmtime] - Access time or NULL
//
// Returns: Appropriate status code
//
// History: 22-Jul-93 DrewB Created
//
//----------------------------------------------------------------------------
SCODE SetTimes(HANDLE h,
FILETIME const *pctime,
FILETIME const *patime,
FILETIME const *pmtime)
{
IO_STATUS_BLOCK iosb;
NTSTATUS nts;
FILE_BASIC_INFORMATION fbi;
SCODE sc;
ssDebugOut((DEB_ITRACE, "In SetTimes(%p, %p, %p, %p)\n",
h, pctime, patime, pmtime));
if (pctime)
FILETIME_TO_LARGE_INTEGER(pctime, &fbi.CreationTime);
else
fbi.CreationTime.LowPart = fbi.CreationTime.HighPart = 0;
if (patime)
FILETIME_TO_LARGE_INTEGER(patime, &fbi.LastAccessTime);
else
fbi.LastAccessTime.LowPart = fbi.LastAccessTime.HighPart = 0;
if (pmtime)
FILETIME_TO_LARGE_INTEGER(pmtime, &fbi.LastWriteTime);
else
fbi.LastWriteTime.LowPart = fbi.LastWriteTime.HighPart = 0;
fbi.ChangeTime.LowPart = fbi.ChangeTime.HighPart = 0;
fbi.FileAttributes = 0;
nts = NtSetInformationFile(h, &iosb, &fbi,
sizeof(FILE_BASIC_INFORMATION),
FileBasicInformation);
if (!NT_SUCCESS(nts))
sc = NtStatusToScode(nts);
else
sc = S_OK;
ssDebugOut((DEB_ITRACE, "Out SetTimes => %lX\n", sc));
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: SetNtFileAttributes, public
//
// Synopsis: Sets the times for a handle
//
// Arguments: [h] - Handle
// [grfAttr] - File Attributes
//
// Returns: Appropriate status code
//
// History: 12-Jul-95 HenryLee Created
//
//----------------------------------------------------------------------------
SCODE SetNtFileAttributes(HANDLE h, ULONG grfAttr)
{
IO_STATUS_BLOCK iosb;
NTSTATUS nts;
FILE_BASIC_INFORMATION fbi = {{0,0},{0,0},{0,0},{0,0},0};
SCODE sc;
ssDebugOut((DEB_ITRACE, "In SetNtFileAttributes(%p, %x)\n", h, grfAttr));
fbi.FileAttributes = grfAttr;
nts = NtSetInformationFile(h, &iosb, &fbi,
sizeof(FILE_BASIC_INFORMATION),
FileBasicInformation);
if (!NT_SUCCESS(nts))
sc = NtStatusToScode(nts);
else
sc = S_OK;
ssDebugOut((DEB_ITRACE, "Out SetNtFileAttributes => %lX\n", sc));
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: GetFileOrDirHandle, public
//
// Synopsis: Opens either a file or directory and returns the handle
//
// Arguments: [hParent] - Parent handle or NULL
// [pwcsName] - Child name or full path
// [grfMode] - Mode
// [ph] - Handle return
// [pfd] - FILEDIR return or NULL
//
// Returns: Appropriate status code
//
// Modifies: [ph]
// [pfd]
//
// History: 22-Jul-93 DrewB Created
//
//----------------------------------------------------------------------------
SCODE GetFileOrDirHandle(HANDLE hParent,
WCHAR const *pwcsName,
DWORD grfMode,
HANDLE *ph,
CLSID *pclsid,
BOOL *pfOfs,
FILEDIR *pfd)
{
SCODE sc;
FILEDIR fd;
if (pfd == NULL)
pfd = &fd;
ssDebugOut((DEB_ITRACE, "In GetFileOrDirHandle("
"%p, %ws, %lX, %p, %p)\n", hParent, pwcsName, grfMode, ph,
pfd));
sc = GetNtHandle (hParent,pwcsName,grfMode,0,CO_OPEN,FD_DEFAULT,NULL, ph);
if (!FAILED (sc))
{
NTSTATUS Status;
IO_STATUS_BLOCK iosb;
FILE_OLE_ALL_INFORMATION foai;
Status = NtQueryInformationFile(
*ph,
&iosb,
&foai,
sizeof(foai),
FileOleAllInformation);
if (NT_SUCCESS(Status) ||
(Status == STATUS_BUFFER_OVERFLOW &&
iosb.Information == sizeof(foai)))
{
StorageTypeToFileDir (foai.StorageType, pfd);
if (pclsid != NULL) *pclsid = foai.OleClassIdInformation.ClassId;
if (pfOfs != NULL)
if (foai.LastChangeUsn != 0)
*pfOfs = TRUE; // real OFS implementation
else
*pfOfs = FALSE; // FAT or NTFS supporting FileOleAllInfo
}
else
{
// Since the operation failed, we are probably dealing with
// a non-OFS partition. We need to disinguish a file from a directory
// BUGBUG: [mikese] eventually, maybe all file systems will support
// FileAllOleInfo and we won't need this part.
FILE_BASIC_INFORMATION fbi;
Status = NtQueryInformationFile (
*ph,
&iosb,
&fbi,
sizeof(fbi),
FileBasicInformation );
if ( NT_SUCCESS(Status) &&
(fbi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
{
*pfd = FD_DIR;
}
else
{
// assume we have a docfile in a file
*pfd = FD_FILE;
}
if (pclsid != NULL) *pclsid = CLSID_NULL;
if (pfOfs != NULL) *pfOfs = FALSE;
}
}
ssDebugOut((DEB_ITRACE, "Out GetFileOrDirHandle => %p\n", *ph));
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: NameNtHandle, public
//
// Synopsis: Obtains the full path name from a file handle
//
// Arguments: [handle] - file handle
// [wcDrive] - drive letter
// [wcBuffer] - output result
// [wcFile] - append optional filename
//
// Returns: Appropriate status code
//
// History: 02-Jun-1995 HenryLee created
//
// Notes:
//
//----------------------------------------------------------------------------
SAFE_HEAP_PTR(SafeFni, FILE_NAME_INFORMATION);
SCODE NameNtHandle (HANDLE h, WCHAR wcDrive, WCHAR *wcBuffer,
const WCHAR *wcFile)
{
NTSTATUS nts;
SCODE sc = S_OK;
IO_STATUS_BLOCK iosb;
SafeFni pfni;
ULONG cbFni;
cbFni=sizeof(FILE_NAME_INFORMATION)+MAXIMUM_FILENAME_LENGTH*sizeof(WCHAR);
pfni.Attach((FILE_NAME_INFORMATION *)new BYTE[cbFni]);
ssMem((FILE_NAME_INFORMATION *)pfni);
nts=NtQueryInformationFile(h,&iosb,pfni,cbFni,FileNameInformation);
if (!NT_SUCCESS(nts))
ssErr(EH_Err, NtStatusToScode(nts));
memcpy (wcBuffer, pfni->FileName, pfni->FileNameLength);
*(WCHAR *)((BYTE *)wcBuffer+pfni->FileNameLength) = L'\0';
SetDriveLetter (wcBuffer, wcDrive);
if (wcFile != NULL)
{
lstrcatW (wcBuffer, L"\\");
lstrcatW (wcBuffer, wcFile);
}
EH_Err:
return sc;
}