/*++ Copyright (c) 1996 Microsoft Corporation Module Name : mb.hxx Abstract: This module defines the USER-level wrapper class for access to the metabase Author: JohnL 09-Oct-1996 Environment: Win32 - User Mode Project: Internet Server DLL Revision History: --*/ #ifndef _MB_HXX_ #define _MB_HXX_ #if !defined( dllexp) #define dllexp __declspec( dllexport) #endif // !defined( dllexp) // // Default timeout // #define MB_TIMEOUT 5000 // // IIS Service pointer // #define PINETSVC g_pInetSvc /************************************************************ * Type Definitions ************************************************************/ // // Simple wrapper class around the metabase APIs // // The Metabase Interface pointer is assumed to remain valid for the lifetime // of this object. // // The character counts for paths should include the terminating '\0'. // // class MB { public: MB( IMSAdminBase * pMBCom ) : _pMBCom( pMBCom ), _hMB ( NULL ) { } ~MB( VOID ) { Close(); _pMBCom = NULL; } inline BOOL Open( const TCHAR * pszPath, DWORD dwFlags = METADATA_PERMISSION_READ ) { return Open( METADATA_MASTER_ROOT_HANDLE, pszPath, dwFlags ); } inline BOOL Open( METADATA_HANDLE hOpenRoot, const TCHAR * pszPath, DWORD dwFlags = METADATA_PERMISSION_READ ); /* inline BOOL GetAll( const TCHAR * pszPath, DWORD dwFlags, DWORD dwUserType, BUFFER * pBuff, DWORD * pcRecords, DWORD * pdwDataSetNumber ); */ inline BOOL GetDataSetNumber( const TCHAR * pszPath, DWORD * pdwDataSetNumber ); inline BOOL EnumObjects( const TCHAR * pszPath, TCHAR * Name, DWORD Index ) { HRESULT hRes = _pMBCom->EnumKeys( _hMB,pszPath, Name, Index ); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes )); return FALSE; } inline BOOL AddObject( const TCHAR * pszPath ) { HRESULT hRes = _pMBCom->AddKey( _hMB, pszPath ); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes )); return FALSE; } //----------------------------------------------------------------- boydm inline BOOL RenameKey( const TCHAR* pszPath, const TCHAR* pszNewName ) { HRESULT hRes = _pMBCom->RenameKey( _hMB, pszPath, pszNewName ); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes )); return FALSE; } inline BOOL DeleteObject( const TCHAR * pszPath ) { HRESULT hRes = _pMBCom->DeleteKey( _hMB, pszPath ); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes )); return FALSE; } inline BOOL Save( VOID ) { HRESULT hRes = _pMBCom->SaveData(); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes )); return FALSE; } BOOL SetDword( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, DWORD dwValue, DWORD dwFlags = METADATA_INHERIT ) { return SetData( pszPath, dwPropID, dwUserType, DWORD_METADATA, (PVOID) &dwValue, sizeof( DWORD ), dwFlags ); } BOOL SetString( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, TCHAR * pszValue, DWORD dwFlags = METADATA_INHERIT ) { #ifdef _UNICODE return SetData( pszPath, dwPropID, dwUserType, STRING_METADATA, pszValue, (wcslen(pszValue)+1) * 2, // byte count, not character count dwFlags ); #else return SetData( pszPath, dwPropID, dwUserType, STRING_METADATA, pszValue, strlen(pszValue)+1, // string length ignored for inprocess clients dwFlags ); #endif } BOOL GetDword( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, DWORD * pdwValue, DWORD dwFlags = METADATA_INHERIT ) { DWORD cb = sizeof(DWORD); return GetData( pszPath, dwPropID, dwUserType, DWORD_METADATA, pdwValue, &cb, dwFlags ); } BOOL GetString( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, TCHAR * pszValue, DWORD * pcbValue, DWORD dwFlags = METADATA_INHERIT ) { return GetData( pszPath, dwPropID, dwUserType, STRING_METADATA, pszValue, pcbValue, dwFlags ); } /* inline BOOL GetStr( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, STR * strValue, DWORD dwFlags = METADATA_INHERIT, const TCHAR * pszDefault = NULL ); */ inline BOOL SetData( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, DWORD dwDataType, VOID * pvData, DWORD cbData, DWORD dwFlags = METADATA_INHERIT ); inline BOOL GetData( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, DWORD dwDataType, VOID * pvData, DWORD * cbData, DWORD dwFlags = METADATA_INHERIT ); inline BOOL DeleteData(const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, DWORD dwDataType ) { HRESULT hRes = _pMBCom->DeleteData( _hMB, pszPath, dwPropID, dwDataType ); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes )); return(FALSE); } BOOL Close( VOID ) { if ( _hMB ) { _pMBCom->CloseKey( _hMB ); _hMB = NULL; } return TRUE; } METADATA_HANDLE QueryHandle( VOID ) const { return _hMB; } private: IMSAdminBase * _pMBCom; METADATA_HANDLE _hMB; }; inline BOOL MB::Open( METADATA_HANDLE hOpenRoot, const TCHAR * pszPath, DWORD dwFlags ) /*++ Routine Description: Opens the metabase Arguments: hOpenRoot - Relative root or METADATA_MASTER_ROOT_HANDLE pszPath - Path to open dwFlags - Open flags Return: TRUE if success, FALSE on error, (call GetLastError()) --*/ { HRESULT hRes; hRes = _pMBCom->OpenKey( hOpenRoot, pszPath, dwFlags, MB_TIMEOUT, &_hMB ); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes ) ); return FALSE; } inline BOOL MB::SetData( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, DWORD dwDataType, VOID * pvData, DWORD cbData, DWORD dwFlags ) /*++ Routine Description: Sets a metadata property on an openned metabase Arguments: pszPath - Path to set data on dwPropID - Metabase property ID dwUserType - User type for this property dwDataType - Type of data being set (dword, string etc) pvData - Pointer to data cbData - Size of data dwFlags - Inheritance flags Return: TRUE if success, FALSE on error, (call GetLastError()) --*/ { METADATA_RECORD mdRecord; HRESULT hRes; mdRecord.dwMDIdentifier = dwPropID; mdRecord.dwMDAttributes = dwFlags; mdRecord.dwMDUserType = dwUserType; mdRecord.dwMDDataType = dwDataType; mdRecord.dwMDDataLen = cbData; mdRecord.pbMDData = (PBYTE) pvData; hRes = _pMBCom->SetData( _hMB, pszPath, &mdRecord ); if ( SUCCEEDED( hRes )) { return TRUE; } SetLastError( HRESULTTOWIN32( hRes ) ); return FALSE; } inline BOOL MB::GetData( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, DWORD dwDataType, VOID * pvData, DWORD * pcbData, DWORD dwFlags ) /*++ Routine Description: Retrieves a metadata property on an openned metabase Arguments: pszPath - Path to set data on dwPropID - Metabase property ID dwUserType - User type for this property dwDataType - Type of data being set (dword, string etc) pvData - Pointer to data pcbData - Size of pvData, receives size of object dwFlags - Inheritance flags Return: TRUE if success, FALSE on error, (call GetLastError()) --*/ { METADATA_RECORD mdRecord; HRESULT hRes; DWORD dwRequiredLen; mdRecord.dwMDIdentifier = dwPropID; mdRecord.dwMDAttributes = dwFlags; mdRecord.dwMDUserType = dwUserType; mdRecord.dwMDDataType = dwDataType; mdRecord.dwMDDataLen = *pcbData; mdRecord.pbMDData = (PBYTE) pvData; hRes = _pMBCom->GetData( _hMB, pszPath, &mdRecord, &dwRequiredLen ); if ( SUCCEEDED( hRes )) { *pcbData = mdRecord.dwMDDataLen; return TRUE; } *pcbData = dwRequiredLen; SetLastError( HRESULTTOWIN32( hRes ) ); return FALSE; } #ifdef O inline BOOL MB::GetAll( const TCHAR * pszPath, DWORD dwFlags, DWORD dwUserType, BUFFER * pBuff, DWORD * pcRecords, DWORD * pdwDataSetNumber ) /*++ Routine Description: Retrieves all the metabase properties on this path of the request type Arguments: pszPath - Path to set data on dwFlags - Inerhitance flags dwPropID - Metabase property ID dwUserType - User type for this property dwDataType - Type of data being set (dword, string etc) pvData - Pointer to data pcbData - Size of pvData, receives size of object dwFlags - Inheritance flags Return: TRUE if success, FALSE on error, (call GetLastError()) --*/ { DWORD RequiredSize; HRESULT hRes; TryAgain: hRes = _pMBCom->GetAllData( _hMB, (unsigned TCHAR *)pszPath, dwFlags, dwUserType, ALL_METADATA, pcRecords, pdwDataSetNumber, pBuff->QuerySize(), (PBYTE)pBuff->QueryPtr(), &RequiredSize ); // See if we got it, and if we failed because of lack of buffer space // try again. if ( SUCCEEDED(hRes) ) { return TRUE; } // Some sort of error, most likely not enough buffer space. Keep // trying until we get a non-fatal error. if (HRESULT_FACILITY(hRes) == FACILITY_WIN32 && HRESULT_CODE(hRes) == ERROR_INSUFFICIENT_BUFFER) { // Not enough buffer space. RequiredSize contains the amount // the metabase thinks we need. if ( !pBuff->Resize(RequiredSize) ) { // Not enough memory to resize. return FALSE; } goto TryAgain; } return FALSE; } #endif inline BOOL MB::GetDataSetNumber( const TCHAR * pszPath, DWORD * pdwDataSetNumber ) /*++ Routine Description: Retrieves the data set number and size of the data from the metabase. Arguments: pszPath - Path to set data on pdwDataSetNumber - Where to return the data set number. Return: TRUE if success, FALSE on error, (call GetLastError()) --*/ { HRESULT hRes; // // We allow _hMB to be null (root handle) for this API (though technically // all the APIs allow the metabase handle to be null) // hRes = _pMBCom->GetDataSetNumber( _hMB, pszPath, pdwDataSetNumber ); return SUCCEEDED(hRes); } #ifdef O inline BOOL MB::GetStr( const TCHAR * pszPath, DWORD dwPropID, DWORD dwUserType, STR * pstrValue, DWORD dwFlags, const TCHAR * pszDefault ) /*++ Routine Description: Retrieves the string from the metabase. If the value wasn't found and a default is supplied, then the default value is copied to the string. Arguments: pszPath - Path to get data on dwPropID - property id to retrieve dwUserType - User type for this property pstrValue - string that receives the value dwFlags - Metabase flags pszDefault - Default value to use if the string isn't found, NULL for no default value (i.e., will return an error). Return: TRUE if success, FALSE on error, (call GetLastError()) --*/ { DWORD cbSize = pstrValue->QuerySize(); TryAgain: if ( !GetData( pszPath, dwPropID, dwUserType, STRING_METADATA, pstrValue->QueryStr(), &cbSize, dwFlags )) { if ( GetLastError() == MD_ERROR_DATA_NOT_FOUND ) { if ( pszDefault != NULL ) { return pstrValue->Copy( pszDefault ); } return FALSE; } else if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER && pstrValue->Resize( cbSize ) ) { goto TryAgain; } return FALSE; } pstrValue->SetLen( cbSize ); return TRUE; } #endif #endif // _MB_HXX_