archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/com/ole32/stg/exp/api.cxx

607 lines
18 KiB
Raw Blame History

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: api.cxx
//
// Contents: API entry points
//
// History: 30-Jun-93 DrewB Created
//
//----------------------------------------------------------------------------
#include "exphead.cxx"
#pragma hdrstop
#include <propapi.h>
#include <hntfsstg.hxx>
#include <dfentry.hxx>
#include <winefs.h> // for DuplicateEncryptionInfoFile
SCODE ValidateGrfMode( DWORD grfMode, BOOL fCreateAPI );
HRESULT GetNFFTempName (const WCHAR *pwcsFileName, WCHAR *awcsTmpName);
SCODE ValidateStgOptions (STGOPTIONS * pStgOptions, DWORD stgfmt, BOOL fCreate);
inline SCODE ValidateGrfAttrs (DWORD grfAttrs, DWORD stgfmt)
{
if (stgfmt != STGFMT_DOCFILE)
{
if (grfAttrs != 0)
return STG_E_INVALIDFLAG;
}
else
{
if ((grfAttrs & ~FILE_FLAG_NO_BUFFERING) != 0)
return STG_E_INVALIDFLAG;
}
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Function: DfOpenStorageEx
//
// Synopsis: Open storage and stream objects
//
// Arguments: [pwcsUsersName] - pathanme of the file
// [fCreateAPI] - create or open
// [grfMode] - open mode flags
// [grfAttrs] - reserved
// [stgfmt] - storage format
// [pSecurity] - reserved
// [pTransaction] - reserved
// [riid] - GUID of interface pointer to return
// [ppObjectOpen] - interface pointer to return
// Returns: Appropriate status code
//
// History: 12-Jul-95 HenryLee Created
//
//----------------------------------------------------------------------------
STDAPI DfOpenStorageEx (
const WCHAR* pwcsUsersName,
BOOL fCreateAPI, // create vs open
DWORD grfMode,
DWORD stgfmt, // enum
DWORD grfAttrs, // reserved
STGOPTIONS *pStgOptions,
void * reserved,
REFIID riid,
void ** ppObjectOpen)
{
HRESULT sc = S_OK;
CSmAllocator *pMalloc = NULL;
ULONG_PTR uHeapBase;
DWORD dwFullPathLen;
WCHAR awcsFullName[_MAX_PATH], *pwcsFile;
WCHAR awcsTmpPath[_MAX_PATH], *pwcsNameSnapshot = NULL;
//
// The ANY and STORAGE formats recursivly call back through here
// for the correct real format (DOCFILE, NATIVE or FILE). We only call
// GetFullPathName on real formats, to avoid redundant calls as we
// recurse.
// This then *requires* that the ANY and STORAGE must recurse (i.e. can't
// call NFFOpen or NSS directly) because the filename has not been
// properly prepared.
//
// For STGFMT_DOCFILE, let the docfile layer handle name checking
//
if(STGFMT_ANY != stgfmt &&
STGFMT_STORAGE != stgfmt &&
STGFMT_DOCFILE != stgfmt)
{
dwFullPathLen = GetFullPathNameW(pwcsUsersName, _MAX_PATH,
awcsFullName,&pwcsFile);
if (dwFullPathLen == 0)
{
DWORD dwErr = GetLastError();
// In some circumstances (name == " ", for instance),
// GetFullPathNameW can return 0 and GetLastError returns 0.
// We want to return STG_E_INVALIDNAME for these.
if (dwErr != NOERROR)
{
olErr(EH_Err, Win32ErrorToScode(dwErr));
}
else
{
olErr(EH_Err, STG_E_INVALIDNAME);
}
}
else if (dwFullPathLen > _MAX_PATH)
olErr(EH_Err, STG_E_PATHNOTFOUND);
}
//-----------------------------------------
// Switch on STGFMT_
// STORAGE, NATIVE, DOCFILE, FILE, ANY
//
switch(stgfmt)
{
case STGFMT_FILE:
{
olChk( NFFOpen( awcsFullName, grfMode, NFFOPEN_NORMAL,
fCreateAPI, riid, ppObjectOpen) );
} // case STGFMT_FILE
break;
case STGFMT_ANY:
{
DWORD stgfmt=STGFMT_STORAGE;
//
// Attempting to CREATE a Storage with STGFMT_ANY is ambiguous,
// On NTFS either STGFMT_NATIVE or STGFMT_FILE could be appropriate,
// and is therefore invalid.
//
if (fCreateAPI)
olChk (STG_E_INVALIDPARAMETER);
//
// If IsNffAppropriate() returns S_OK use STGFMT_FILE
// If it returns STG_E_INVALIDFUNCTION try storage (FAT-FS or Docfile).
// Any other Error, bubble back to the user
//
sc = CNtfsStorage::IsNffAppropriate( pwcsUsersName );
if( SUCCEEDED( sc ) )
{
stgfmt = STGFMT_FILE;
}
else
{
if( STG_E_INVALIDFUNCTION == sc )
stgfmt = STGFMT_STORAGE;
else
olChk( sc );
}
sc = DfOpenStorageEx (pwcsUsersName, fCreateAPI, grfMode, stgfmt,
grfAttrs, pStgOptions, reserved,
riid, ppObjectOpen);
olChk(sc);
} // case STGFMT_ANY;
break;
case STGFMT_STORAGE:
case STGFMT_DOCFILE: // GetFullPathName has not yet been called.
{
IStorage *pstg = NULL;
ULONG ulSectorSize;
if( fCreateAPI )
{
if (grfAttrs & FILE_ATTRIBUTE_TEMPORARY) // create temp file
pwcsUsersName = NULL;
olChk( DfCreateDocfile (pwcsUsersName,
NULL, grfMode, NULL,
pStgOptions ? pStgOptions->ulSectorSize : 512,
grfAttrs, &pstg));
}
else
olChk( DfOpenDocfile (pwcsUsersName,
NULL,
NULL,
grfMode,
NULL,
0,
&ulSectorSize,
grfAttrs,
&pstg));
if( IID_IStorage != riid )
{
sc = pstg->QueryInterface( riid, ppObjectOpen );
pstg->Release();
if (fCreateAPI && !SUCCEEDED(sc) && pwcsUsersName != NULL)
{
DeleteFileW (pwcsUsersName); //delete newly create file
}
}
else
{
*ppObjectOpen = pstg;
if (pStgOptions != NULL && !fCreateAPI)
pStgOptions->ulSectorSize = ulSectorSize;
}
olChk(sc);
} // case STGFMT_DOCFILE
break;
case STGFMT_NATIVE:
default:
olErr (EH_Err, STG_E_INVALIDPARAMETER);
break;
}
EH_Err:
return sc;
};
//+---------------------------------------------------------------------------
//
// Function: StgCreateStorageEx, public
//
// Synopsis: Creates a storage or stream object
//
// Arguments: [pwcsName] - pathname of file
// [grfMode] - open mode flags
// [stgfmt] - storage format
// [grfAttrs] - reserved
// [pSecurity] - reserved
// [pTransaction] - reserved
// [riid] - GUID of interface pointer to return
// [ppObjectOpen] - interface pointer to return
//
// Returns: Appropriate status code
//
// History: 12-Jul-95 HenryLee Created
//
//----------------------------------------------------------------------------
STDAPI StgCreateStorageEx (const WCHAR* pwcsName,
DWORD grfMode,
DWORD stgfmt, // enum
DWORD grfAttrs, // reserved
STGOPTIONS * pStgOptions,
void * reserved,
REFIID riid,
void ** ppObjectOpen)
{
HRESULT sc = S_OK;
WCHAR awcsTmpPath[_MAX_PATH];
olDebugOut((DEB_TRACE, "In StgCreateStorageEx(%ws, %p, %p, %p, %p)\n",
pwcsName, grfMode, stgfmt, riid, ppObjectOpen));
olChk(ValidatePtrBuffer(ppObjectOpen));
*ppObjectOpen = NULL;
if (reserved != NULL)
olErr (EH_Err, STG_E_INVALIDPARAMETER);
olChk( ValidateGrfAttrs (grfAttrs, stgfmt));
olChk( ValidateGrfMode( grfMode, TRUE ) );
olChk( VerifyPerms( grfMode, TRUE ) );
if (pStgOptions != NULL)
olChk( ValidateStgOptions(pStgOptions, stgfmt, TRUE));
if (stgfmt == STGFMT_FILE)
{
if (pwcsName != NULL)
{
olChk (ValidateNameW (pwcsName, _MAX_PATH));
}
else
{
olChk (GetNFFTempName (pwcsName, awcsTmpPath));
pwcsName = awcsTmpPath;
//Add the STGM_CREATE flag so we don't fail with
//STG_E_FILEALREADYEXISTS when we see that the file already exists
//later.
grfMode |= STGM_CREATE;
grfAttrs |= FILE_ATTRIBUTE_TEMPORARY;
}
}
if (stgfmt == STGFMT_DOCFILE &&
pStgOptions != NULL &&
pStgOptions->usVersion >= 2 &&
pStgOptions->pwcsTemplateFile != NULL)
{
DWORD dwAttrs = GetFileAttributes (pStgOptions->pwcsTemplateFile);
if (dwAttrs == 0xFFFFFFFF)
olChk (WIN32_SCODE (GetLastError()));
if (dwAttrs & FILE_ATTRIBUTE_ENCRYPTED)
{
DWORD dwErr = DuplicateEncryptionInfoFile(
pStgOptions->pwcsTemplateFile,
pwcsName,
grfMode & STGM_CREATE ? CREATE_ALWAYS : CREATE_NEW,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (dwErr != ERROR_SUCCESS)
olChk (WIN32_SCODE(dwErr));
grfAttrs |= FILE_ATTRIBUTE_ENCRYPTED;
}
}
olChk (DfOpenStorageEx (pwcsName, TRUE, grfMode, stgfmt, grfAttrs,
pStgOptions, reserved, riid, ppObjectOpen));
olDebugOut((DEB_TRACE, "Out StgCreateStorageEx => %p\n", *ppObjectOpen));
EH_Err:
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: StgOpenStorageEx
//
// Synopsis: Open storage and stream objects
//
// Arguments: [pwcsName] - pathanme of the file
// [grfMode] - open mode flags
// [grfAttrs] - reserved
// [stgfmt] - storage format
// [pSecurity] - reserved
// [pTransaction] - reserved
// [riid] - GUID of interface pointer to return
// [ppObjectOpen] - interface pointer to return
// Returns: Appropriate status code
//
// History: 12-Jul-95 HenryLee Created
//
//----------------------------------------------------------------------------
STDAPI StgOpenStorageEx (const WCHAR *pwcsName,
DWORD grfMode,
DWORD stgfmt, // enum
DWORD grfAttrs, // reserved
STGOPTIONS * pStgOptions,
void * reserved,
REFIID riid,
void ** ppObjectOpen)
{
HRESULT sc = S_OK;
olDebugOut((DEB_TRACE, "In StgOpenStorageEx(%ws, %p, %p, %p, %p)\n",
pwcsName, grfMode, stgfmt, riid, ppObjectOpen));
olChk(ValidatePtrBuffer(ppObjectOpen));
*ppObjectOpen = NULL;
if (reserved != NULL)
olErr (EH_Err, STG_E_INVALIDPARAMETER);
olChk (ValidateNameW (pwcsName, _MAX_PATH));
olChk( ValidateGrfAttrs (grfAttrs, stgfmt));
olChk( ValidateGrfMode( grfMode, FALSE ) );
olChk( VerifyPerms( grfMode, TRUE ) );
if (pStgOptions != NULL)
olChk( ValidateStgOptions(pStgOptions, stgfmt, FALSE));
olChk (DfOpenStorageEx (pwcsName, FALSE, grfMode, stgfmt, grfAttrs,
pStgOptions, reserved, riid, ppObjectOpen));
olDebugOut((DEB_TRACE, "Out StgOpenStorageEx => %p\n", *ppObjectOpen));
EH_Err:
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: ValidateGrfMode
//
// Synopsis: Sanity checking for the grfMode. (all implementations)
//
// Arguments: [grfMode] -- grfMode to check
// [fCreateAPI] -- Called from CreateStorage vs. OpenStorage.
//
// Returns: Appropriate status code
//
// History: 30-Mar-98 BChapman Created
//
//----------------------------------------------------------------------------
SCODE ValidateGrfMode( DWORD grfMode, BOOL fCreateAPI )
{
HRESULT sc=S_OK;
// If there are any invalid bits set (error)
if( 0 != ( grfMode & ~( STGM_DIRECT | // 0
STGM_TRANSACTED | // 1 0000
STGM_SIMPLE | // 800 0000
STGM_READ | // 0
STGM_WRITE | // 1
STGM_READWRITE | // 2
STGM_SHARE_DENY_NONE | // 40
STGM_SHARE_DENY_READ | // 30
STGM_SHARE_DENY_WRITE | // 20
STGM_SHARE_EXCLUSIVE | // 10
STGM_PRIORITY | // 4 0000
STGM_DELETEONRELEASE | // 400 0000
STGM_NOSCRATCH | // 10 0000
STGM_CREATE | // 1000
STGM_CONVERT | // 2 0000
STGM_FAILIFTHERE | // 0
STGM_DIRECT_SWMR |
STGM_NOSNAPSHOT ) ) ) // 20 0000
{
olErr( EH_Err, STG_E_INVALIDFLAG );
}
// If you Create for ReadOnly (error)
if( fCreateAPI && ( ( grfMode & STGM_RDWR ) == STGM_READ ) )
olErr( EH_Err, STG_E_INVALIDFLAG );
// if you Open/Create for Convert And DeleteOnRelease (error)
if( ( grfMode & ( STGM_DELETEONRELEASE | STGM_CONVERT ) )
== ( STGM_DELETEONRELEASE | STGM_CONVERT ) )
{
olErr(EH_Err, STG_E_INVALIDFLAG);
}
if( grfMode & STGM_SIMPLE )
{
if( fCreateAPI )
{
// If you Create Simple it must be exactly this way.
if( grfMode != ( STGM_SIMPLE | STGM_READWRITE |
STGM_SHARE_EXCLUSIVE | STGM_CREATE ) )
olErr( EH_Err, STG_E_INVALIDFLAG );
}
else
{
// If you Open Simple it must be one of these two ways.
if( grfMode != (STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE )
&& grfMode != (STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READ ) )
olErr( EH_Err, STG_E_INVALIDFLAG );
}
}
if( !fCreateAPI )
{
if (grfMode & STGM_DELETEONRELEASE)
olErr(EH_Err, STG_E_INVALIDFUNCTION);
if (grfMode & (STGM_CREATE | STGM_CONVERT))
olErr (EH_Err, STG_E_INVALIDPARAMETER);
}
EH_Err:
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: ValidateStgOptions
//
// Synopsis: Sanity checking for the StgOptions
//
// Arguments: [pStgOptions] -- options to check
// [stgfmt] -- intended storage format
//
// Returns: Appropriate status code
//
// History: 30-Mar-98 HenryLee Created
//
//----------------------------------------------------------------------------
SCODE ValidateStgOptions (STGOPTIONS * pStgOptions, DWORD stgfmt, BOOL fCreate)
{
#ifdef LARGE_DOCFILE
HRESULT sc = S_OK;
olChk(ValidatePtrBuffer(pStgOptions));
if (pStgOptions->usVersion > STGOPTIONS_VERSION ||
pStgOptions->usVersion == 0 ||
pStgOptions->reserved != 0)
{
olErr (EH_Err, STG_E_INVALIDPARAMETER);
}
if (fCreate)
{
// enable large sector support only for docfiles
if (pStgOptions->ulSectorSize != 512 && stgfmt != STGFMT_DOCFILE)
{
olErr (EH_Err, STG_E_INVALIDPARAMETER);
}
if (pStgOptions->ulSectorSize != 512 &&
pStgOptions->ulSectorSize != 4096)
/* pStgOptions->ulSectorSize != 8192 && */
/* pStgOptions->ulSectorSize != 16384 && */
/* pStgOptions->ulSectorSize != 32768) */
{
olErr (EH_Err, STG_E_INVALIDPARAMETER);
}
if (pStgOptions->usVersion >= 2)
{
if (stgfmt != STGFMT_DOCFILE)
{
olErr (EH_Err, STG_E_INVALIDPARAMETER);
}
else if (pStgOptions->pwcsTemplateFile != NULL)
olChk (ValidatePtrBuffer (pStgOptions->pwcsTemplateFile));
}
}
else
{
if (stgfmt != STGFMT_DOCFILE)
olErr (EH_Err, STG_E_INVALIDPARAMETER);
if (pStgOptions->usVersion >= 2 && pStgOptions->pwcsTemplateFile !=NULL)
olErr (EH_Err, STG_E_INVALIDPARAMETER);
}
EH_Err:
#else
HRESULT sc = STG_E_INVALIDPARAMETER;
#endif
return sc;
}
//+---------------------------------------------------------------------------
//
// Member: GetNFFTempName, public
//
// Synopsis: returns a filename for temporary NSS files
//
// Arguments: [pwcsFileName] - original file name
// [ppwcsTmpName] - output temporary name
//
// Returns: Appropriate status code
//
// History: 01-Jul-97 HenryLee Created
//
//----------------------------------------------------------------------------
HRESULT GetNFFTempName (const WCHAR *pwcsFileName, WCHAR *awcsTmpName)
{
HRESULT sc = S_OK;
WCHAR awcsDir[_MAX_PATH];
WCHAR *pwcsFile = NULL;
//
// Create a temp file in pwcsFileName's directory
//
if (pwcsFileName != NULL)
{
if (GetFullPathNameW (pwcsFileName, _MAX_PATH, awcsDir, &pwcsFile) == 0)
{
const DWORD dwErr = GetLastError();
//In some circumstances (name == " ", for instance),
// GetFullPathNameW can return 0 and GetLastError returns 0.
// We want to return STG_E_INVALIDNAME for these.
olErr(EH_Err, (dwErr != NOERROR) ? Win32ErrorToScode(dwErr) :
STG_E_INVALIDNAME);
}
else if (pwcsFile) *pwcsFile = L'\0';
}
else
{
// Create a temp file for StgCreateDocfile (NULL name)
//
// try %temp%
if(0 == GetTempPath(_MAX_PATH, awcsDir))
{
// next try %windir%
if(0 == GetWindowsDirectory(awcsDir, _MAX_PATH))
{
// finally use current directory
lstrcpyW (awcsDir, L".");
}
}
}
if (GetTempFileNameW (awcsDir, TEMPFILE_PREFIX, 0, awcsTmpName)==FALSE)
olErr (EH_Err, Win32ErrorToScode(GetLastError()));
EH_Err:
return sc;
}