2783 lines
58 KiB
C++
2783 lines
58 KiB
C++
/*++
|
|
|
|
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
|
|
|