able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/svcs/nsepm/nsepm.cxx

2783 lines
58 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name :
nsepm.cxx
Abstract:
This module defines Name Space Extension for mapping
Author:
Philippe Choquier 29-Nov-1996
--*/
#define INITGUID
extern "C" {
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
}
#include <dbgutil.h>
#include <ole2.h>
#include <imd.h>
#include <windows.h>
#include <xbf.hxx>
#include "nsepimp.hxx"
#include "nsepm.hxx"
#include <stringau.hxx>
//#define TEST_ADMACL
#if defined(TEST_ADMACL)
#include <admacl.hxx>
#endif
#define NSEPM_NOISY 0 // set to 1 for really noisy debug output
#if NSEPM_NOISY
#define NOISYPRINTF(x) DBGPRINTF(x)
#else
#define NOISYPRINTF(x)
#endif
OPEN_CTX** OPEN_CTX::sm_pHandleTable;
CRITICAL_SECTION OPEN_CTX::sm_csHandleTableLock;
DWORD OPEN_CTX::sm_cHandleEntries;
DWORD OPEN_CTX::sm_cMaxHandleEntries;
DWORD
OPEN_CTX::InitializeHandleTable(
VOID
)
/*++
Routine Description:
Initialize Handle Table. This table maps DWORD handles to pointers to
OPEN_CTX objects. This is an Sundown-ism
Arguments:
None
Returns:
Returns ERROR_SUCCESS if successful, else Win32 Error
--*/
{
INITIALIZE_CRITICAL_SECTION( &sm_csHandleTableLock );
sm_cHandleEntries = 0;
sm_cMaxHandleEntries = INITIAL_HANDLE_TABLE_SIZE;
sm_pHandleTable = (POPEN_CTX*) LocalAlloc( LPTR,
sizeof( POPEN_CTX ) *
sm_cMaxHandleEntries );
if ( sm_pHandleTable == NULL )
{
return GetLastError();
}
return ERROR_SUCCESS;
}
DWORD
OPEN_CTX::TerminateHandleTable(
VOID
)
/*++
Routine Description:
Destroy Handle Table.
Arguments:
None
Returns:
Returns ERROR_SUCCESS if successful, else Win32 Error
--*/
{
EnterCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
sm_cHandleEntries = 0;
sm_cMaxHandleEntries = 0;
if ( sm_pHandleTable )
{
LocalFree( sm_pHandleTable );
sm_pHandleTable = NULL;
}
LeaveCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
DeleteCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
return ERROR_SUCCESS;
}
POPEN_CTX
OPEN_CTX::MapHandleToContext(
IN DWORD dwHandle
)
{
POPEN_CTX pOpenCtx = NULL;
EnterCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
if ( dwHandle &&
dwHandle <= OPEN_CTX::sm_cMaxHandleEntries )
{
pOpenCtx = OPEN_CTX::sm_pHandleTable[ dwHandle - 1 ];
}
LeaveCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
return pOpenCtx;
}
OPEN_CTX::OPEN_CTX( DWORD dwAccess )
: m_dwAccess( dwAccess ),
m_dwHandle( 0 )
/*++
Routine Description:
Constructor for OPEN_CTX objects. Responsible for generating a DWORD
handle to be passed back to caller of NSEPM.
Arguments:
dwAccess - Access required for NSEPM call
Returns:
None. Successful if GetHandle() selector returns non-zero handle
--*/
{
DWORD cNewCount;
DWORD iCounter;
EnterCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
cNewCount = sm_cHandleEntries + 1;
if ( cNewCount > sm_cMaxHandleEntries )
{
sm_cMaxHandleEntries += HANDLE_TABLE_REALLOC_JUMP;
sm_pHandleTable = (POPEN_CTX*) LocalReAlloc( sm_pHandleTable,
sm_cMaxHandleEntries *
sizeof( POPEN_CTX ),
LMEM_MOVEABLE );
if ( sm_pHandleTable == NULL )
{
LeaveCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
return;
}
}
sm_cHandleEntries = cNewCount;
for( iCounter = 0;
iCounter < sm_cMaxHandleEntries;
iCounter++ )
{
if ( sm_pHandleTable[ iCounter ] == NULL )
{
sm_pHandleTable[ iCounter ] = this;
// Handle is index+1, so that 0 can represent failure.
m_dwHandle = iCounter + 1;
break;
}
}
LeaveCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
}
OPEN_CTX::~OPEN_CTX()
/*++
Routine Description:
Destructor for OPEN_CTX object
Arguments:
Returns:
None
--*/
{
DWORD iCounter;
EnterCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
if ( m_dwHandle )
{
sm_pHandleTable[ m_dwHandle - 1 ] = NULL;
sm_cHandleEntries--;
}
LeaveCriticalSection( &OPEN_CTX::sm_csHandleTableLock );
}
//
// Local class
//
class CDirPath : public CAllocString {
public:
BOOL Append( LPSTR );
private:
} ;
CDirPath::Append(
LPSTR pszPath
)
{
LPSTR pCur = Get();
int ch;
if ( pCur && *pCur && (ch=pCur[strlen(pCur)-1])!='/' && ch!='\\' &&
pszPath && *pszPath && *pszPath != '/' && *pszPath != '\\' )
{
if ( !CAllocString::Append( "\\" ) )
{
return FALSE;
}
}
return CAllocString::Append( pszPath );
}
//
// Globals
//
#include <initguid.h>
DEFINE_GUID(IisNsepmGuid,
0x784d8916, 0xaa8c, 0x11d2, 0x92, 0x5e, 0x00, 0xc0, 0x4f, 0x72, 0xd9, 0x0e);
DECLARE_DEBUG_PRINTS_OBJECT();
IMDCOM* g_pMdIf = NULL;
DWORD g_dwInitialized = 0;
ULONG g_dwRefCount = 0;
ULONG g_dwLockCount = 0;
CRITICAL_SECTION g_csInitCritSec;
class CInitNsep {
public:
#ifndef _NO_TRACING_
CInitNsep() { CREATE_DEBUG_PRINT_OBJECT( "NSEPM", IisNsepmGuid ); INITIALIZE_CRITICAL_SECTION( &g_csInitCritSec ); }
#else
CInitNsep() { CREATE_DEBUG_PRINT_OBJECT( "NSEPM" ); INITIALIZE_CRITICAL_SECTION( &g_csInitCritSec ); }
#endif
~CInitNsep() { DELETE_DEBUG_PRINT_OBJECT(); DeleteCriticalSection( &g_csInitCritSec ); }
} g_cinitnsep;
//
// Class factory
//
class NSEPCOMSrvFactory : public IClassFactory {
public:
NSEPCOMSrvFactory();
~NSEPCOMSrvFactory();
HRESULT _stdcall
QueryInterface(REFIID riid, void** ppObject);
ULONG _stdcall
AddRef();
ULONG _stdcall
Release();
HRESULT _stdcall
CreateInstance(IUnknown *pUnkOuter, REFIID riid,
void ** pObject);
HRESULT _stdcall
LockServer(BOOL fLock);
private:
ULONG m_dwRefCount;
NSEPCOM m_mdcObject;
};
NSEPCOMSrvFactory::NSEPCOMSrvFactory(
)
:m_mdcObject()
/*++
Routine Description:
Class factory constructor
Arguments:
None
Returns:
Nothing
--*/
{
m_dwRefCount = 0;
}
NSEPCOMSrvFactory::~NSEPCOMSrvFactory(
)
/*++
Routine Description:
Class factory destructor
Arguments:
None
Returns:
Nothing
--*/
{
}
HRESULT
NSEPCOMSrvFactory::CreateInstance(
IUnknown * pUnkOuter,
REFIID riid,
void ** ppObject
)
/*++
Routine Description:
Create NSECOM instance
Arguments:
pUnkOuter - controlling unknown
riid - interface ID
ppObject - updated with interface ptr if success
Returns:
status
--*/
{
NOISYPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::CreateInstance]\n" ) );
NSEPCOM* pC = new NSEPCOM;
if ( pC == NULL )
{
return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
}
if (FAILED( pC->QueryInterface(riid, ppObject)))
{
DBGPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::CreateInstance] no I/F\n" ) );
delete pC;
return E_NOINTERFACE;
}
InterlockedIncrement((long *)&g_dwRefCount);
return NO_ERROR;
}
HRESULT
NSEPCOMSrvFactory::LockServer(
BOOL fLock
)
/*++
Routine Description:
Lock server
Arguments:
fLock - TRUE to lock server, FALSE to unlock it
Returns:
status
--*/
{
if (fLock)
{
InterlockedIncrement((long *)&g_dwLockCount);
}
else
{
InterlockedDecrement((long *)&g_dwLockCount);
}
return NO_ERROR;
}
HRESULT
NSEPCOMSrvFactory::QueryInterface(
REFIID riid,
void **ppObject
)
/*++
Routine Description:
Lock server
Arguments:
None
Returns:
status
--*/
{
NOISYPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::QueryInterface]\n" ) );
if (riid==IID_IUnknown || riid == IID_IClassFactory)
{
*ppObject = (IMDCOM *) this;
}
else
{
DBGPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::QueryInterface] no I/F\n") );
return E_NOINTERFACE;
}
AddRef();
return NO_ERROR;
}
ULONG
NSEPCOMSrvFactory::AddRef(
)
/*++
Routine Description:
Increment refcount to class factory
Arguments:
None
Returns:
>0 if new refcount >0, 0 if new refcount is 0, otherwise <0
--*/
{
DWORD dwRefCount;
dwRefCount = InterlockedIncrement((long *)&m_dwRefCount);
return dwRefCount;
}
ULONG
NSEPCOMSrvFactory::Release(
)
/*++
Routine Description:
Decrement refcount to class factory
Arguments:
None
Returns:
>0 if new refcount >0, 0 if new refcount is 0, otherwise <0
--*/
{
DWORD dwRefCount;
dwRefCount = InterlockedDecrement((long *)&m_dwRefCount);
if (dwRefCount == 0)
{
NOISYPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::Release] delete object\n" ) );
delete this;
}
return dwRefCount;
}
STDAPI
DllGetClassObject(
REFCLSID rclsid,
REFIID riid,
void** ppObject
)
/*++
Routine Description:
Create instance of class factory
Arguments:
rclsid - class ID
riid - interface ID
ppObject - updated with ptr to interface if success
Returns:
status
--*/
{
NOISYPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::DllGetClassObject]\n" ) );
if ( rclsid != CLSID_NSEPMCOM )
{
DBGPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::DllGetClassObject] bad class\n" ) );
return CLASS_E_CLASSNOTAVAILABLE;
}
NSEPCOMSrvFactory *pFactory = new NSEPCOMSrvFactory;
if (FAILED(pFactory->QueryInterface(riid, ppObject)))
{
delete pFactory;
*ppObject = NULL;
DBGPRINTF( (DBG_CONTEXT, "[NSEPCOMSrvFactory::DllGetClassObject] no I/F\n" ) );
return E_INVALIDARG;
}
return NO_ERROR;
}
HRESULT _stdcall
DllCanUnloadNow(
)
/*++
Routine Description:
return S_OK if dll can be unloaded
Arguments:
None
Returns:
S_OK if OK to unload, otherwise S_FALSE
--*/
{
if ( g_dwRefCount || g_dwLockCount )
{
return S_FALSE;
}
else
{
return S_OK;
}
}
STDAPI
DllRegisterServer(
void
)
/*++
Routine Description:
Register NSECOM class & interface in registry
Arguments:
None
Returns:
status
--*/
{
HKEY hKeyCLSID, hKeyInproc32;
HKEY hKeyIF, hKeyStub32;
DWORD dwDisposition;
HMODULE hModule;
if (RegCreateKeyEx(HKEY_CLASSES_ROOT,
TEXT("CLSID\\{05dc3bb0-4337-11d0-a5c8-00a0c922e752}"),
NULL, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&hKeyCLSID, &dwDisposition)!=ERROR_SUCCESS) {
return E_UNEXPECTED;
}
if (RegSetValueEx(hKeyCLSID, TEXT(""), NULL, REG_SZ, (BYTE*) TEXT("NSEPM COM Server"), sizeof(TEXT("NSEPM COM Server")))!=ERROR_SUCCESS) {
RegCloseKey(hKeyCLSID);
return E_UNEXPECTED;
}
if (RegCreateKeyEx(hKeyCLSID,
"InprocServer32",
NULL, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&hKeyInproc32, &dwDisposition)!=ERROR_SUCCESS) {
RegCloseKey(hKeyCLSID);
return E_UNEXPECTED;
}
hModule=GetModuleHandle("NSEPM.DLL");
if (!hModule) {
RegCloseKey(hKeyInproc32);
RegCloseKey(hKeyCLSID);
return E_UNEXPECTED;
}
TCHAR szName[MAX_PATH+1];
if (GetModuleFileName(hModule, szName, sizeof(szName))==0) {
RegCloseKey(hKeyInproc32);
RegCloseKey(hKeyCLSID);
return E_UNEXPECTED;
}
if (RegSetValueEx(hKeyInproc32, TEXT(""), NULL, REG_SZ, (BYTE*) szName, sizeof(TCHAR)*(lstrlen(szName)+1))!=ERROR_SUCCESS) {
RegCloseKey(hKeyInproc32);
RegCloseKey(hKeyCLSID);
return E_UNEXPECTED;
}
if (RegSetValueEx(hKeyInproc32, TEXT("ThreadingModel"), NULL, REG_SZ, (BYTE*) "Both", sizeof("Both")-1 )!=ERROR_SUCCESS) {
RegCloseKey(hKeyInproc32);
RegCloseKey(hKeyCLSID);
return E_UNEXPECTED;
}
RegCloseKey(hKeyInproc32);
RegCloseKey(hKeyCLSID);
//
// Register Interface, proxy is IMDCOM
//
if (RegCreateKeyEx(HKEY_CLASSES_ROOT,
TEXT("Interface\\{4810a750-4318-11d0-a5c8-00a0c922e752}"),
NULL, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&hKeyIF, &dwDisposition)!=ERROR_SUCCESS) {
return E_UNEXPECTED;
}
if (RegSetValueEx(hKeyIF, TEXT(""), NULL, REG_SZ, (BYTE*) TEXT("NSECOM"), sizeof(TEXT("NSECOM")))!=ERROR_SUCCESS) {
RegCloseKey(hKeyIF);
return E_UNEXPECTED;
}
if (RegCreateKeyEx(hKeyIF,
"ProxyStubClsid32",
NULL, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&hKeyStub32, &dwDisposition)!=ERROR_SUCCESS) {
RegCloseKey(hKeyIF);
return E_UNEXPECTED;
}
if (RegSetValueEx(hKeyStub32, TEXT(""), NULL, REG_SZ, (BYTE*)"{C1AA48C0-FACC-11cf-9D1A-00AA00A70D51}", sizeof("{C1AA48C0-FACC-11cf-9D1A-00AA00A70D51}") )!=ERROR_SUCCESS) {
RegCloseKey(hKeyStub32);
RegCloseKey(hKeyIF);
return E_UNEXPECTED;
}
RegCloseKey(hKeyStub32);
RegCloseKey(hKeyIF);
return NOERROR;
}
STDAPI
DllUnregisterServer(
void
)
/*++
Routine Description:
Unregister NSECOM class & interface from registry
Arguments:
None
Returns:
status
--*/
{
if (RegDeleteKey(HKEY_CLASSES_ROOT,
TEXT("CLSID\\{05dc3bb0-4337-11d0-a5c8-00a0c922e752}\\InprocServer32"))!=ERROR_SUCCESS)
{
return E_UNEXPECTED;
}
if (RegDeleteKey(HKEY_CLASSES_ROOT,
TEXT("CLSID\\{05dc3bb0-4337-11d0-a5c8-00a0c922e752}"))!=ERROR_SUCCESS)
{
return E_UNEXPECTED;
}
if (RegDeleteKey(HKEY_CLASSES_ROOT,
TEXT("Interface\\{4810a750-4318-11d0-a5c8-00a0c922e752}\\ProxyStubClsid32"))!=ERROR_SUCCESS)
{
return E_UNEXPECTED;
}
if (RegDeleteKey(HKEY_CLASSES_ROOT,
TEXT("Interface\\{4810a750-4318-11d0-a5c8-00a0c922e752}"))!=ERROR_SUCCESS)
{
return E_UNEXPECTED;
}
return NOERROR;
}
//
// NSEPCOM implementation
//
NSEPCOM::NSEPCOM(
)
/*++
Routine Description:
NSEPCOM constructor
Arguments:
None
Returns:
Nothing
--*/
{
m_dwRefCount = 0;
}
NSEPCOM::~NSEPCOM(
)
/*++
Routine Description:
NSEPCOM destructor
Arguments:
None
Returns:
Nothing
--*/
{
}
HRESULT
NSEPCOM::QueryInterface(
REFIID riid,
void **ppObject
)
/*++
Routine Description:
NSEPCOM query interface
recognize IID_IUnknown & IID_NSECOM
Arguments:
riid - interface ID
ppObject - updated with ptr to interface if success
Returns:
status
--*/
{
NOISYPRINTF( (DBG_CONTEXT, "[NSEPCOM::QueryInterface]\n" ) );
if (riid==IID_IUnknown || riid==IID_NSECOM)
{
*ppObject = (NSEPCOM *) this;
}
else
{
DBGPRINTF( (DBG_CONTEXT, "[NSEPCOM::QueryInterface] no I/F\n" ) );
return E_NOINTERFACE;
}
AddRef();
return NO_ERROR;
}
ULONG
NSEPCOM::AddRef(
)
/*++
Routine Description:
Add reference to NSECOM interface
Arguments:
None
Returns:
>0 if new refcount >0, 0 if new refcount is 0, otherwise <0
--*/
{
DWORD dwRefCount;
dwRefCount = InterlockedIncrement((long *)&m_dwRefCount);
return dwRefCount;
}
ULONG
NSEPCOM::Release(
)
/*++
Routine Description:
Remove reference to NSECOM interface
Arguments:
None
Returns:
>0 if new refcount >0, 0 if new refcount is 0, otherwise <0
--*/
{
DWORD dwRefCount;
dwRefCount = InterlockedDecrement((long *)&m_dwRefCount);
if ( !dwRefCount )
{
delete this;
InterlockedDecrement((long *)&g_dwRefCount);
}
return dwRefCount;
}
HRESULT
NSEPCOM::ComMDInitialize(
)
/*++
Routine Description:
Initialize access to NSE for mappings
Arguments:
None
Returns:
status
--*/
{
DWORD RetCode = ERROR_SUCCESS;
HRESULT hRes = S_OK;
EnterCriticalSection( &g_csInitCritSec );
if ( g_dwInitialized++ == 0 )
{
hRes = CoCreateInstance(CLSID_MDCOM, NULL, CLSCTX_INPROC_SERVER, IID_IMDCOM, (void**) &g_pMdIf);
if (FAILED(hRes))
{
g_pMdIf = NULL;
}
else
{
hRes = ReturnCodeToHresult( OPEN_CTX::InitializeHandleTable() );
if ( SUCCEEDED( hRes ) )
{
hRes = g_pMdIf->ComMDInitialize();
if ( SUCCEEDED( hRes ) )
{
hRes = NseMappingInitialize() ? S_OK : ReturnCodeToHresult( GetLastError() );
}
}
}
}
if ( FAILED( hRes ) )
{
--g_dwInitialized;
}
LeaveCriticalSection( &g_csInitCritSec );
return hRes;
}
HRESULT
NSEPCOM::ComMDTerminate(
IN BOOL bSaveData
)
/*++
Routine Description:
Terminate access to NSE for mappings
Arguments:
bSaveData - TRUE to save data on persistent storage
Returns:
status
--*/
{
DWORD RetCode = ERROR_SUCCESS;
HRESULT hRes = S_OK;
EnterCriticalSection( &g_csInitCritSec );
if ( g_dwInitialized && (--g_dwInitialized == 0) )
{
if ( bSaveData )
{
NseSaveObjs();
}
hRes = NseMappingTerminate() ? S_OK : ReturnCodeToHresult( GetLastError() );
if ( g_pMdIf )
{
g_pMdIf->ComMDTerminate(TRUE);
g_pMdIf->Release();
g_pMdIf = NULL;
}
DBG_REQUIRE( OPEN_CTX::TerminateHandleTable() == ERROR_SUCCESS );
}
LeaveCriticalSection( &g_csInitCritSec );
return hRes;
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDShutdown( void)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT
NSEPCOM::ComMDAddMetaObjectA(
IN METADATA_HANDLE hMDHandle,
IN PBYTE pszMDPath
)
/*++
Routine Description:
Add object
Arguments:
hMDHandle - open handle
pszMDPath - path of object to add
Returns:
status
--*/
{
DWORD RetCode;
CDirPath asPath;
POPEN_CTX pOpenCtx;
pOpenCtx = OPEN_CTX::MapHandleToContext( hMDHandle );
// BugFix: 117734 Whistler
// Prefix bug pOpenCtx being used when it could be null
// EBK 5/15/2000
if (pOpenCtx == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if (((LPSTR)pszMDPath == NULL) || (*(LPSTR)pszMDPath == (TCHAR)'\0'))
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if ( !(pOpenCtx->GetAccess() & METADATA_PERMISSION_WRITE) )
{
RetCode = ERROR_ACCESS_DENIED;
}
else
{
if ( asPath.Set( pOpenCtx->GetPath() ) &&
asPath.Append( (LPSTR)pszMDPath ) )
{
RetCode = NseAddObj( asPath.Get() ) ? ERROR_SUCCESS : GetLastError();
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDAddMetaObjectW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDAddMetaObjectA( hMDHandle, (LPBYTE)pszPathA );
}
HRESULT
NSEPCOM::ComMDDeleteMetaObjectA(
IN METADATA_HANDLE hMDHandle,
IN PBYTE pszMDPath
)
/*++
Routine Description:
Delete object
Arguments:
hMDHandle - open handle
pszMDPath - path of object to delete
Returns:
status
--*/
{
DWORD RetCode;
CDirPath asPath;
POPEN_CTX pOpenCtx;
pOpenCtx = OPEN_CTX::MapHandleToContext( hMDHandle );
// BugFix: 117747 Whistler
// Prefix bug pOpenCtx being used when it could be null
// EBK 5/15/2000
if (pOpenCtx == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if ((LPSTR)pszMDPath == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if ( !(pOpenCtx->GetAccess() & METADATA_PERMISSION_WRITE) )
{
RetCode = ERROR_ACCESS_DENIED;
}
else
{
if ( asPath.Set( pOpenCtx->GetPath() ) &&
asPath.Append( (LPSTR)pszMDPath ) )
{
RetCode = NseDeleteObj( asPath.Get() ) ? ERROR_SUCCESS : GetLastError();
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteMetaObjectW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDDeleteMetaObjectA( hMDHandle, (LPBYTE)pszPathA );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteChildMetaObjectsA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDPath
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteChildMetaObjectsW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDDeleteChildMetaObjectsA( hMDHandle, (LPBYTE)pszPathA );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDEnumMetaObjectsA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [size_is][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [size_is][out] */ unsigned char __RPC_FAR *pszMDName,
/* [in] */ DWORD dwMDEnumObjectIndex
)
/*++
Routine Description:
Enumerate objects in path
Arguments:
hMDHandle - open handle
pszMDPath - path where to enumerate objects
pszMDName - updated with object name
dwMDEnumObjectIndex - object index ( 0 based )
Returns:
status
--*/
{
DWORD RetCode;
LPSTR pszPath = (LPSTR)pszMDPath;
CDirPath asPath;
POPEN_CTX pOpenCtx;
pOpenCtx = OPEN_CTX::MapHandleToContext( hMDHandle );
// BugFix: 117725 Whistler
// Prefix bug pOpenCtx being used when it could be null
// EBK 5/15/2000
if (pOpenCtx == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if ((LPSTR)pszMDName == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
if ( asPath.Set( pOpenCtx->GetPath() ) &&
asPath.Append( (LPSTR)pszMDPath ) )
{
RetCode = NseEnumObj( asPath.Get(), pszMDName, dwMDEnumObjectIndex )
? ERROR_SUCCESS : GetLastError();
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDEnumMetaObjectsW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [size_is][out] */ LPWSTR pszMDName,
/* [in] */ DWORD dwMDEnumObjectIndex)
{
STRAU strauPath;
STRAU strauName;
LPSTR pszPathA = NULL;
CHAR achNameA[METADATA_MAX_NAME_LEN];
HRESULT hres;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
hres = ComMDEnumMetaObjectsA( hMDHandle, (LPBYTE)pszPathA, (LPBYTE)achNameA, dwMDEnumObjectIndex );
if ( SUCCEEDED(hres) )
{
if ( (!strauName.Copy( achNameA )) || (strauName.QueryStrW() == NULL))
{
hres = ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
else
{
memcpy( pszMDName, strauName.QueryStrW(), strauName.QueryCBW() + sizeof(WCHAR) );
}
}
return hres;
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDCopyMetaObjectA(
/* [in] */ METADATA_HANDLE hMDSourceHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDSourcePath,
/* [in] */ METADATA_HANDLE hMDDestHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDDestPath,
/* [in] */ BOOL bOverwriteFlag,
/* [in] */ BOOL bCopyFlag
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDCopyMetaObjectW(
/* [in] */ METADATA_HANDLE hMDSourceHandle,
/* [string][in][unique] */ LPCWSTR pszMDSourcePath,
/* [in] */ METADATA_HANDLE hMDDestHandle,
/* [string][in][unique] */ LPCWSTR pszMDDestPath,
/* [in] */ BOOL bMDOverwriteFlag,
/* [in] */ BOOL bMDCopyFlag)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDRenameMetaObjectA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDPath,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDNewName)
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDRenameMetaObjectW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [string][in][unique] */ LPCWSTR pszMDNewName)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDSetMetaDataA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [size_is][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [in] */ PMETADATA_RECORD pmdrMDData
)
/*++
Routine Description:
Set property of object
Arguments:
hMDHandle - open handle
pszMDPath - path to object
pmdrMDData - metadata descriptor
Returns:
status
--*/
{
DWORD RetCode;
LPSTR pszPath = (LPSTR)pszMDPath;
CDirPath asPath;
POPEN_CTX pOpenCtx;
pOpenCtx = OPEN_CTX::MapHandleToContext( hMDHandle );
// BugFix: 117743 Whistler
// Prefix bug pOpenCtx being used when it could be null
// EBK 5/15/2000
if (pOpenCtx == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if ( !( pOpenCtx->GetAccess() & METADATA_PERMISSION_WRITE) )
{
RetCode = ERROR_ACCESS_DENIED;
}
else
{
#if defined(TEST_ADMACL)
METADATA_HANDLE hMB;
HRESULT hRes;
hRes = g_pMdIf->ComMDOpenMetaObject( METADATA_MASTER_ROOT_HANDLE,
(BYTE *) "/LM/W3SVC/1",
METADATA_PERMISSION_READ,
5000,
&hMB );
AdminAclNotifyOpen( hMB, (LPBYTE)"/LM/W3SVC/1", FALSE );
if ( SUCCEEDED( hRes ) )
{
BOOL fSt = AdminAclAccessCheck(
hMB,
pszMDPath,
pmdrMDData->dwMDIdentifier,
METADATA_PERMISSION_WRITE
);
AdminAclNotifyClose( hMB );
g_pMdIf->ComMDCloseMetaObject( hMB );
if ( !fSt )
{
return ReturnCodeToHresult( ERROR_ACCESS_DENIED );
}
}
AdminAclNotifyOpen( hMDHandle, (LPBYTE)"/LM/W3SVC/1/<nsepm>/", TRUE );
AdminAclAccessCheck(
hMDHandle,
pszMDPath,
pmdrMDData->dwMDIdentifier,
METADATA_PERMISSION_WRITE
);
AdminAclNotifyClose( hMDHandle );
#endif
if ( asPath.Set( pOpenCtx->GetPath() ) &&
asPath.Append( (LPSTR)pszMDPath ) )
{
RetCode = NseSetProp( asPath.Get(), pmdrMDData )
? ERROR_SUCCESS : GetLastError();
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDSetMetaDataW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [in] */ PMETADATA_RECORD pmdrMDData)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDSetMetaDataA( hMDHandle, (LPBYTE)pszPathA, pmdrMDData );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetMetaDataA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [out][in] */ PMETADATA_RECORD pmdrMDData,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredDataLen
)
/*++
Routine Description:
Get property of object
Arguments:
hMDHandle - open handle
pszMDPath - path to object
pmdrMDData - metadata descriptor
pdwMDRequiredDataLen - updated with required length to get property
Returns:
status
--*/
{
DWORD RetCode;
CDirPath asPath;
LPSTR pszPath = (LPSTR)pszMDPath;
POPEN_CTX pOpenCtx;
pOpenCtx = OPEN_CTX::MapHandleToContext( hMDHandle );
// BugFix: 117745 Whistler
// Prefix bug pOpenCtx being used when it could be null
// EBK 5/15/2000
if (pOpenCtx == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if ((pmdrMDData == NULL) ||
((pmdrMDData->dwMDDataLen != 0) && (pmdrMDData->pbMDData == NULL)) ||
((pmdrMDData->dwMDAttributes & METADATA_PARTIAL_PATH) &&
!(pmdrMDData->dwMDAttributes & METADATA_INHERIT)))
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
if ( asPath.Set( hMDHandle ? pOpenCtx->GetPath() : "" ) &&
asPath.Append( pszMDPath ? (LPSTR)pszMDPath : "" ))
{
RetCode = NseGetProp( asPath.Get(), pmdrMDData, pdwMDRequiredDataLen )
? ERROR_SUCCESS : GetLastError();
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetMetaDataW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [out][in] */ PMETADATA_RECORD pmdrMDData,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredDataLen)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDGetMetaDataA( hMDHandle, (LPBYTE)pszPathA, pmdrMDData, pdwMDRequiredDataLen );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDEnumMetaDataA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [out][in] */ PMETADATA_RECORD pmdrMDData,
/* [in] */ DWORD dwMDEnumDataIndex,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredDataLen
)
/*++
Routine Description:
Enumerate properties of object
Arguments:
hMDHandle - open handle
pszMDPath - path to object
pmdrMDData - metadata descriptor
dwMDEnumDataIndex - index to property
pdwMDRequiredDataLen - updated with required length to get property
Returns:
status
--*/
{
DWORD RetCode;
LPSTR pszPath = (LPSTR)pszMDPath;
CDirPath asPath;
POPEN_CTX pOpenCtx;
pOpenCtx = OPEN_CTX::MapHandleToContext( hMDHandle );
// BugFix: 117715 Whistler
// Prefix bug pOpenCtx being used when it could be null
// EBK 5/15/2000
if (pOpenCtx == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if ((pmdrMDData == NULL) ||
((pmdrMDData->dwMDDataLen != 0) && (pmdrMDData->pbMDData == NULL)) ||
((pmdrMDData->dwMDAttributes & METADATA_PARTIAL_PATH) &&
!(pmdrMDData->dwMDAttributes & METADATA_INHERIT)))
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
if ( asPath.Set( pOpenCtx->GetPath() ) &&
asPath.Append( (LPSTR)pszMDPath ) )
{
RetCode = NseGetPropByIndex( asPath.Get(), pmdrMDData, dwMDEnumDataIndex, pdwMDRequiredDataLen )
? ERROR_SUCCESS : GetLastError();
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDEnumMetaDataW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [out][in] */ PMETADATA_RECORD pmdrMDData,
/* [in] */ DWORD dwMDEnumDataIndex,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredDataLen)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDEnumMetaDataA( hMDHandle, (LPBYTE)pszPathA, pmdrMDData, dwMDEnumDataIndex, pdwMDRequiredDataLen );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteMetaDataA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [in] */ DWORD dwMDIdentifier,
/* [in] */ DWORD dwMDDataType
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode;
LPSTR pszPath = (LPSTR)pszMDPath;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteMetaDataW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [in] */ DWORD dwMDIdentifier,
/* [in] */ DWORD dwMDDataType)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDDeleteMetaDataA( hMDHandle, (LPBYTE)pszPathA, dwMDIdentifier, dwMDDataType );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetAllMetaDataA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [in] */ DWORD dwMDAttributes,
/* [in] */ DWORD dwMDUserType,
/* [in] */ DWORD dwMDDataType,
/* [out] */ DWORD __RPC_FAR *pdwMDNumDataEntries,
/* [out] */ DWORD __RPC_FAR *pdwMDDataSetNumber,
/* [in] */ DWORD dwMDBufferSize,
/* [size_is][out] */ unsigned char __RPC_FAR *pbBuffer,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredBufferSize
)
/*++
Routine Description:
Get all properties of object
Arguments:
hMDHandle - open handle
pszMDPath - path to object
dwMDAttributes - metadata attribute, ignored
dwMDUserType - metadata user type, ignored
dwMDDataType - metadata data type, ignored
pdwMDNumDataEntries - updated with count of properties
pdwMDDataSetNumber - ignored
dwMDBufferSize - size of pbBuffer
pbBuffer - buffer where to store properties descriptor and values
pdwMDRequiredBufferSize - updated with required length of buffer
Returns:
status
--*/
{
DWORD RetCode;
CDirPath asPath;
POPEN_CTX pOpenCtx;
pOpenCtx = OPEN_CTX::MapHandleToContext( hMDHandle );
// BugFix: 117707 Whistler
// Prefix bug pOpenCtx being used when it could be null
// EBK 5/15/2000
if (pOpenCtx == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if ((pdwMDNumDataEntries == NULL) || ((dwMDBufferSize != 0) && (pbBuffer == NULL)) ||
((dwMDAttributes & METADATA_PARTIAL_PATH) && !(dwMDAttributes & METADATA_INHERIT)))
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
if ( asPath.Set( pOpenCtx->GetPath() ) &&
asPath.Append( (LPSTR)pszMDPath ) )
{
RetCode = NseGetAllProp( asPath.Get(),
dwMDAttributes,
dwMDUserType,
dwMDDataType,
pdwMDNumDataEntries,
pdwMDDataSetNumber,
dwMDBufferSize,
pbBuffer,
pdwMDRequiredBufferSize
)
? ERROR_SUCCESS : GetLastError();
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetAllMetaDataW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [in] */ DWORD dwMDAttributes,
/* [in] */ DWORD dwMDUserType,
/* [in] */ DWORD dwMDDataType,
/* [out] */ DWORD __RPC_FAR *pdwMDNumDataEntries,
/* [out] */ DWORD __RPC_FAR *pdwMDDataSetNumber,
/* [in] */ DWORD dwMDBufferSize,
/* [size_is][out] */ unsigned char __RPC_FAR *pbBuffer,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredBufferSize)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDGetAllMetaDataA( hMDHandle,
(LPBYTE)pszPathA,
dwMDAttributes,
dwMDUserType,
dwMDDataType,
pdwMDNumDataEntries,
pdwMDDataSetNumber,
dwMDBufferSize,
pbBuffer,
pdwMDRequiredBufferSize );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteAllMetaDataA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDPath,
/* [in] */ DWORD dwMDUserType,
/* [in] */ DWORD dwMDDataType
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteAllMetaDataW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [in] */ DWORD dwMDUserType,
/* [in] */ DWORD dwMDDataType)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDCopyMetaDataA(
/* [in] */ METADATA_HANDLE hMDSourceHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDSourcePath,
/* [in] */ METADATA_HANDLE hMDDestHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDDestPath,
/* [in] */ DWORD dwMDAttributes,
/* [in] */ DWORD dwMDUserType,
/* [in] */ DWORD dwMDDataType,
/* [in] */ BOOL bCopyFlag
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if (((!bCopyFlag) && (dwMDAttributes & METADATA_INHERIT)) ||
((dwMDAttributes & METADATA_PARTIAL_PATH) && !(dwMDAttributes & METADATA_INHERIT)))
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDCopyMetaDataW(
/* [in] */ METADATA_HANDLE hMDSourceHandle,
/* [string][in][unique] */ LPCWSTR pszMDSourcePath,
/* [in] */ METADATA_HANDLE hMDDestHandle,
/* [string][in][unique] */ LPCWSTR pszMDDestPath,
/* [in] */ DWORD dwMDAttributes,
/* [in] */ DWORD dwMDUserType,
/* [in] */ DWORD dwMDDataType,
/* [in] */ BOOL bMDCopyFlag)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetMetaDataPathsA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDPath,
/* [in] */ DWORD dwMDIdentifier,
/* [in] */ DWORD dwMDDataType,
/* [in] */ DWORD dwMDBufferSize,
/* [size_is][out] */ unsigned char __RPC_FAR *pszMDBuffer,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredBufferSize)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetMetaDataPathsW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [in] */ DWORD dwMDIdentifier,
/* [in] */ DWORD dwMDDataType,
/* [in] */ DWORD dwMDBufferSize,
/* [size_is][out] */ LPWSTR pszMDBuffer,
/* [out] */ DWORD __RPC_FAR *pdwMDRequiredBufferSize)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDOpenMetaObjectA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [in] */ DWORD dwMDAccessRequested,
/* [in] */ DWORD dwMDTimeOut,
/* [out] */ PMETADATA_HANDLE phMDNewHandle
)
/*++
Routine Description:
Open access to metadata
Arguments:
hMDHandle - open handle where to open
pszMDPath - path to open
dwMDAccessRequested - access rights, ignored
dwMDTimeOut - ignored
phMDNewHandle - updated with new handle
Returns:
status
--*/
{
DWORD RetCode;
POPEN_CTX pOpCtx;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if ((phMDNewHandle == NULL) || ((dwMDAccessRequested & (METADATA_PERMISSION_READ | METADATA_PERMISSION_WRITE)) == 0))
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
if ( pOpCtx = new OPEN_CTX(dwMDAccessRequested) )
{
if ( pOpCtx->GetHandle() &&
pOpCtx->SetPath( "" ) &&
pOpCtx->AppendPath( pszMDPath ? (LPSTR)pszMDPath : "") )
{
CDirPath asTemp;
asTemp.Set( pOpCtx->GetPath() );
for ( ;; )
{
// BugFix: 117700 Whistler
// Prefix bug asTemp.Get being null
// EBK 5/15/2000
if (asTemp.Get() == NULL)
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
if ( NseOpenObjs( asTemp.Get() ) )
{
*phMDNewHandle = pOpCtx->GetHandle();
RetCode = ERROR_SUCCESS;
break;
}
else
{
RetCode = GetLastError();
if ( RetCode == ERROR_PATH_BUSY &&
dwMDTimeOut )
{
DWORD dwDelay = min( dwMDTimeOut, 100 );
Sleep( dwDelay );
dwMDTimeOut -= dwDelay;
}
else
{
break;
}
}
}
if ( RetCode != ERROR_SUCCESS )
{
delete pOpCtx;
}
}
else
{
delete pOpCtx;
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
else
{
RetCode = ERROR_NOT_ENOUGH_MEMORY;
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDOpenMetaObjectW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [in] */ DWORD dwMDAccessRequested,
/* [in] */ DWORD dwMDTimeOut,
/* [out] */ PMETADATA_HANDLE phMDNewHandle)
{
STRAU strauPath;
LPSTR pszPathA = NULL;
if ( pszMDPath )
{
if ( !strauPath.Copy( (LPWSTR)pszMDPath ) )
{
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
pszPathA = strauPath.QueryStrA();
if (pszPathA == NULL) {
return ReturnCodeToHresult(ERROR_NOT_ENOUGH_MEMORY);
}
}
return ComMDOpenMetaObjectA( hMDHandle,
(LPBYTE)pszPathA,
dwMDAccessRequested,
dwMDTimeOut,
phMDNewHandle );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDCloseMetaObject(
/* [in] */ METADATA_HANDLE hMDHandle
)
/*++
Routine Description:
Close access to metadata
Arguments:
hMDHandle - open handle to close
Returns:
status
--*/
{
DWORD RetCode;
BOOL bPulseWrite = FALSE;
BOOL bPulseRead = FALSE;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
NseCloseObjs( TRUE );
delete OPEN_CTX::MapHandleToContext( hMDHandle );
RetCode = ERROR_SUCCESS;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDChangePermissions(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [in] */ DWORD dwMDTimeOut,
/* [in] */ DWORD dwMDAccessRequested
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDSaveData(
METADATA_HANDLE hMDHandle
)
/*++
Routine Description:
Save data to persistent storage
Arguments:
None
Returns:
status
--*/
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else
{
if ( !NseSaveObjs() )
{
RetCode = GetLastError();
}
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetHandleInfo(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [out] */ PMETADATA_HANDLE_INFO pmdhiInfo
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if (pmdhiInfo == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetSystemChangeNumber(
/* [out] */ DWORD __RPC_FAR *pdwSystemChangeNumber
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if (pdwSystemChangeNumber == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetDataSetNumberA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in] */ unsigned char __RPC_FAR *pszMDPath,
/* [out] */ DWORD __RPC_FAR *pdwMDDataSetNumber
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode;
LPSTR pszPath = (LPSTR)pszMDPath;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if (pdwMDDataSetNumber == NULL)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetDataSetNumberW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [out] */ DWORD __RPC_FAR *pdwMDDataSetNumber)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDAddRefReferenceData(
/* [in] */ DWORD dwMDDataTag
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if (dwMDDataTag == 0)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDReleaseReferenceData(
/* [in] */ DWORD dwMDDataTag
)
/*++
Routine Description:
Not supported
Arguments:
Returns:
error : either NSE not initialized or not supported
--*/
{
DWORD RetCode = ERROR_SUCCESS;
if (g_dwInitialized == 0)
{
RetCode = MD_ERROR_NOT_INITIALIZED;
}
else if (dwMDDataTag == 0)
{
RetCode = ERROR_INVALID_PARAMETER;
}
else
{
RetCode = ERROR_NOT_SUPPORTED;
}
return ReturnCodeToHresult(RetCode);
}
inline HRESULT
NSEPCOM::ReturnCodeToHresult(
DWORD dwReturnCode
)
/*++
Routine Description:
Convert NT error code to HRESULT
Arguments:
dwReturnCode - NT Error code
Return Value:
HRESULT
--*/
{
DWORD hrReturn;
if (dwReturnCode < 0x10000)
{
hrReturn = HRESULT_FROM_WIN32(dwReturnCode);
}
else
{
hrReturn = (DWORD)E_FAIL;
}
return(hrReturn);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDSetLastChangeTimeA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDPath,
/* [in] */ PFILETIME pftMDLastChangeTime
)
/*++
Routine Description:
Set the last change time associated with a Meta Object.
Arguments:
Handle - METADATA_MASTER_ROOT_HANDLE or a handle returned by MDOpenMetaObject with write permission.
Path - The path of the affected meta object, relative to the path of Handle.
LastChangeTime - The new change time for the meta object.
Return Value:
DWORD - ERROR_SUCCESS
MD_ERROR_NOT_INITIALIZED
ERROR_INVALID_PARAMETER
ERROR_PATH_NOT_FOUND
ERROR_NOT_SUPPORTED
Notes:
Last change times are also updated whenever data or child objects are set, added, or deleted.
--*/
{
DWORD RetCode = ERROR_NOT_SUPPORTED;
return RETURNCODETOHRESULT(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDSetLastChangeTimeW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [in] */ PFILETIME pftMDLastChangeTime)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetLastChangeTimeA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDPath,
/* [out] */ PFILETIME pftMDLastChangeTime
)
/*++
Routine Description:
Set the last change time associated with a Meta Object.
Arguments:
Handle - METADATA_MASTER_ROOT_HANDLE or a handle returned by MDOpenMetaObject with write permission.
Path - The path of the affected meta object, relative to the path of Handle.
LastChangeTime - Place to return the change time for the meta object.
Return Value:
DWORD - ERROR_SUCCESS
MD_ERROR_NOT_INITIALIZED
ERROR_INVALID_PARAMETER
ERROR_PATH_NOT_FOUND
ERROR_NOT_SUPPORTED
Notes:
Last change times are also updated whenever data or child objects are set, added, or deleted.
--*/
{
DWORD RetCode = ERROR_NOT_SUPPORTED;
return RETURNCODETOHRESULT(RetCode);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDGetLastChangeTimeW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDPath,
/* [out] */ PFILETIME pftMDLastChangeTime)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDBackupA(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDBackupLocation,
/* [in] */ DWORD dwMDVersion,
/* [in] */ DWORD dwMDFlags)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDBackupW(
/* [in] */ METADATA_HANDLE hMDHandle,
/* [string][in][unique] */ LPCWSTR pszMDBackupLocation,
/* [in] */ DWORD dwMDVersion,
/* [in] */ DWORD dwMDFlags)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDRestoreA(
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDBackupLocation,
/* [in] */ DWORD dwMDVersion,
/* [in] */ DWORD dwMDFlags)
{
return ComMDRestoreW( (LPCWSTR)pszMDBackupLocation, dwMDVersion, dwMDFlags );
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDRestoreW(
/* [string][in][unique] */ LPCWSTR pszMDBackupLocation,
/* [in] */ DWORD dwMDVersion,
/* [in] */ DWORD dwMDFlags)
{
//
// disregard current in-memory changes
//
// Any open handle ( should be at most one, as NSEPM reject Open request
// if an open handle exist ) will cause a small memory leak ( the open context )
// because ADMCOM disable handles w/o closing them.
//
NseCloseObjs( FALSE );
return S_OK;
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDEnumBackupsA(
/* [size_is (MD_BACKUP_MAX_LEN)][in, out] */ unsigned char __RPC_FAR *pszMDBackupLocation,
/* [out] */ DWORD *pdwMDVersion,
/* [out] */ PFILETIME pftMDBackupTime,
/* [in] */ DWORD dwMDEnumIndex)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDEnumBackupsW(
/* [size_is (MD_BACKUP_MAX_LEN)][in, out] */ LPWSTR pszMDBackupLocation,
/* [out] */ DWORD *pdwVersion,
/* [out] */ PFILETIME pftMDBackupTime,
/* [in] */ DWORD dwMDEnumIndex)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteBackupA(
/* [string][in][unique] */ unsigned char __RPC_FAR *pszMDBackupLocation,
/* [in] */ DWORD dwMDVersion)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
HRESULT STDMETHODCALLTYPE
NSEPCOM::ComMDDeleteBackupW(
/* [string][in][unique] */ LPCWSTR pszMDBackupLocation,
/* [in] */ DWORD dwMDVersion)
{
return ReturnCodeToHresult(ERROR_NOT_SUPPORTED);
}
#if 0
HRESULT
NSEPCOM::SetMdIf(
LPBYTE pMd
)
/*++
Routine Description:
Set the metadata interface to be used by NSE
Arguments:
pMD - ptr to IMDCOM interface
Return Value:
status
--*/
{
m_pMdIf = (IMDCOM*)pMd;
g_pMdIf = (IMDCOM*)pMd;
#if defined(TEST_ADMACL)
InitializeAdminAcl( g_pMdIf );
#endif
return S_OK;
}
#endif
Reference in a new issue Copy permalink