/*++ Copyright (c) 1994-2000 Microsoft Corporation Module Name : mdkeys.cpp Abstract: Metabase key wrapper class Author: Ronald Meijer (ronaldm) Sergei Antonov (sergeia) Project: Internet Services Manager Revision History: 2/17/2000 sergeia removed dependency on MFC --*/ // // Include Files // #include "stdafx.h" #include "common.h" #include "inheritancedlg.h" #include "mdkeys.h" // // Constants // #define MB_TIMEOUT (15000) // Timeout in milliseconds #define MB_INIT_BUFF_SIZE ( 256) // Initial buffer size // // CComAuthInfo implementation // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< /* static */ BOOL CComAuthInfo::SplitUserNameAndDomain( IN OUT CString & strUserName, IN CString & strDomainName ) /*++ Routine Description: Split the user name and domain from the given username, which is in the format "domain\user". Return TRUE if the user name contained a domain FALSE if it did not Arguments: CString & strUserName : User name which may contain a domain name CString & strDomainName : Output domain name ("." if local) Return Value: TRUE if a domain is split off --*/ { // // Assume local // strDomainName = _T("."); int nSlash = strUserName.Find(_T("\\")); if (nSlash >= 0) { strDomainName = strUserName.Left(nSlash); strUserName = strUserName.Mid(nSlash + 1); return TRUE; } return FALSE; } /* static */ DWORD CComAuthInfo::VerifyUserPassword( IN LPCTSTR lpstrUserName, IN LPCTSTR lpstrPassword ) /*++ Routine Description: Verify the usernamer password combo checks out Arguments: LPCTSTR lpstrUserName : Domain/username combo LPCTSTR lpstrPassword : Password Return Value: ERROR_SUCCESS if the password checks out, an error code otherwise. --*/ { CString strDomain; CString strUser(lpstrUserName); CString strPassword(lpstrPassword); SplitUserNameAndDomain(strUser, strDomain); // // In order to look up an account name, this process // must first be granted the privilege of doing so. // CError err; { HANDLE hToken; LUID AccountLookupValue; TOKEN_PRIVILEGES tkp; do { if (!::OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken) ) { err.GetLastWinError(); break; } if (!::LookupPrivilegeValue(NULL, SE_TCB_NAME, &AccountLookupValue)) { err.GetLastWinError(); break; } tkp.PrivilegeCount = 1; tkp.Privileges[0].Luid = AccountLookupValue; tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; ::AdjustTokenPrivileges( hToken, FALSE, &tkp, sizeof(TOKEN_PRIVILEGES), (PTOKEN_PRIVILEGES)NULL, (PDWORD)NULL ); err.GetLastWinError(); if (err.Failed()) { break; } HANDLE hUser = NULL; if (::LogonUser( (LPTSTR)(LPCTSTR)strUser, (LPTSTR)(LPCTSTR)strDomain, (LPTSTR)(LPCTSTR)strPassword, LOGON32_LOGON_NETWORK, LOGON32_PROVIDER_DEFAULT, &hUser )) { // // Success! // CloseHandle(hUser); } else { err.GetLastWinError(); } // // Remove the privilege // } while(FALSE); } HANDLE hUser = NULL; if (::LogonUser( (LPTSTR)(LPCTSTR)strUser, (LPTSTR)(LPCTSTR)strDomain, (LPTSTR)(LPCTSTR)strPassword, LOGON32_LOGON_NETWORK, LOGON32_PROVIDER_DEFAULT, &hUser)) { // // Success! // CloseHandle(hUser); } else { err.GetLastWinError(); } return err; } CComAuthInfo::CComAuthInfo( IN LPCOLESTR lpszServerName OPTIONAL, IN LPCOLESTR lpszUserName OPTIONAL, IN LPCOLESTR lpszPassword OPTIONAL ) /*++ Routine Description: Construct CIIServer object Argument: LPCOLESTR lpszServerName : Server name or NULL for local computer LPCOLESTR lpszUserName : User name of blank for no impersonation LPCOLESTR lpszPassword : Password (might be blank or NULL) Return Value: N/A --*/ : m_bstrServerName(), m_bstrUserName(lpszUserName), m_bstrPassword(lpszPassword), m_fLocal(FALSE) { SetComputerName(lpszServerName); } CComAuthInfo::CComAuthInfo( IN CComAuthInfo & auth ) /*++ Routine Description: Copy constructor Arguments: CComAuthInfo & auth : Source object to copy from Return Value: N/A --*/ : m_bstrServerName(auth.m_bstrServerName), m_bstrUserName(auth.m_bstrUserName), m_bstrPassword(auth.m_bstrPassword), m_fLocal(auth.m_fLocal) { } CComAuthInfo::CComAuthInfo( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Copy constructor Arguments: CComAuthInfo * pAuthInfo : Source object to copy from (or NULL) Return Value: N/A --*/ : m_bstrServerName(), m_bstrUserName(), m_bstrPassword(), m_fLocal(FALSE) { if (pAuthInfo) { // // Full authentication information available // m_bstrUserName = pAuthInfo->m_bstrUserName; m_bstrPassword = pAuthInfo->m_bstrPassword; m_bstrServerName = pAuthInfo->m_bstrServerName; m_fLocal = pAuthInfo->m_fLocal; } else { // // Local computer w/o impersonation // SetComputerName(NULL); } } CComAuthInfo & CComAuthInfo::operator =( IN CComAuthInfo & auth ) /*++ Routine Description: Assignment operator Arguments: CComAuthInfo & auth : Source object to copy from Return Value: Reference to current object --*/ { m_bstrServerName = auth.m_bstrServerName; m_bstrUserName = auth.m_bstrUserName; m_bstrPassword = auth.m_bstrPassword; m_fLocal = auth.m_fLocal; return *this; } CComAuthInfo & CComAuthInfo::operator =( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Assignment operator Arguments: CComAuthInfo * pAuthInfo : Source object to copy from (or NULL) Return Value: Reference to current object --*/ { if (pAuthInfo) { m_bstrUserName = pAuthInfo->m_bstrUserName; m_bstrPassword = pAuthInfo->m_bstrPassword; SetComputerName(pAuthInfo->m_bstrServerName); } else { // // Local computer w/o impersonation // m_bstrUserName.Empty(); m_bstrPassword.Empty(); SetComputerName(NULL); } return *this; } CComAuthInfo & CComAuthInfo::operator =( IN LPCTSTR lpszServerName ) /*++ Routine Description: Assignment operator. Assign computer name w/o impersonation Arguments: LPCTSTR lpszServerName : Source server name Return Value: Reference to current object --*/ { RemoveImpersonation(); SetComputerName(lpszServerName); return *this; } void CComAuthInfo::SetComputerName( IN LPCOLESTR lpszServerName OPTIONAL ) /*++ Routine Description: Store the computer name. Determine if its local. Arguments: LPCOLESTR lpszServername : Server name. NULL indicates the local computer Return Value: None --*/ { if (lpszServerName && *lpszServerName) { // // Specific computer name specified // m_bstrServerName = lpszServerName; m_fLocal = ::IsServerLocal(lpszServerName); } else { // // Use local computer name // // CODEWORK: Cache static version of computername maybe? // TCHAR szLocalServer[MAX_PATH + 1]; DWORD dwSize = MAX_PATH; VERIFY(::GetComputerName(szLocalServer, &dwSize)); m_bstrServerName = szLocalServer; m_fLocal = TRUE; } } void CComAuthInfo::SetImpersonation( IN LPCOLESTR lpszUser, IN LPCOLESTR lpszPassword ) /*++ Routine Description: Set impersonation parameters Arguments: LPCOLESTR lpszUser : User name LPCOLESTR lpszPassword : Password Return Value: None --*/ { m_bstrUserName = lpszUser; StorePassword(lpszPassword); } void CComAuthInfo::RemoveImpersonation() /*++ Routine Description: Remove impersonation parameters Arguments: None Return Value: None --*/ { m_bstrUserName.Empty(); m_bstrPassword.Empty(); } COSERVERINFO * CComAuthInfo::CreateServerInfoStruct() const { return (CComAuthInfo::CreateServerInfoStruct(RPC_C_AUTHN_LEVEL_DEFAULT)); } COSERVERINFO * CComAuthInfo::CreateServerInfoStruct(DWORD dwAuthnLevel) const /*++ Routine Description: Create the server info structure. Might return NULL for the no frills case. Arguments: NULL Return Value: A COSERVERINFO structure, or NULL if the computer is local, and no impersonation is required. Notes: Caller must call FreeServerInfoStruct() to prevent memory leaks --*/ { // // Be smart about the server name; optimize for local // computer name. // if (m_fLocal && !UsesImpersonation()) { // // Special, no-frills case. // return NULL; } // // Create the COM server info for CoCreateInstanceEx // COSERVERINFO * pcsiName = NULL; do { pcsiName = new COSERVERINFO; if (!pcsiName) { break; } ZeroMemory(pcsiName, sizeof(COSERVERINFO)); pcsiName->pwszName = m_bstrServerName; // // Set impersonation // if (UsesImpersonation()) { COAUTHINFO * pAuthInfo = new COAUTHINFO; if (!pAuthInfo) { break; } ZeroMemory(pAuthInfo, sizeof(COAUTHINFO)); COAUTHIDENTITY * pAuthIdentityData = new COAUTHIDENTITY; if (!pAuthIdentityData) { break; } ZeroMemory(pAuthIdentityData, sizeof(COAUTHIDENTITY)); CString strUserName(m_bstrUserName); CString strPassword(m_bstrPassword); CString strDomain; // // Break up domain\username combo // SplitUserNameAndDomain(strUserName, strDomain); pAuthIdentityData->UserLength = strUserName.GetLength(); if (pAuthIdentityData->UserLength != 0) { pAuthIdentityData->User = StrDup(strUserName); } pAuthIdentityData->DomainLength = strDomain.GetLength(); if (pAuthIdentityData->DomainLength != 0) { pAuthIdentityData->Domain = StrDup(strDomain); } pAuthIdentityData->PasswordLength = strPassword.GetLength(); if (pAuthIdentityData->PasswordLength) { pAuthIdentityData->Password = StrDup(strPassword); } // RPC_C_AUTHN_LEVEL_DEFAULT 0 // RPC_C_AUTHN_LEVEL_NONE 1 // RPC_C_AUTHN_LEVEL_CONNECT 2 // RPC_C_AUTHN_LEVEL_CALL 3 // RPC_C_AUTHN_LEVEL_PKT 4 // RPC_C_AUTHN_LEVEL_PKT_INTEGRITY 5 // RPC_C_AUTHN_LEVEL_PKT_PRIVACY 6 // you can only specify stuff stronger than RPC_C_AUTHN_LEVEL_CONNECT if (RPC_C_AUTHN_LEVEL_DEFAULT != dwAuthnLevel) { if (dwAuthnLevel >= RPC_C_AUTHN_LEVEL_CONNECT && dwAuthnLevel <= RPC_C_AUTHN_LEVEL_PKT_PRIVACY) { pAuthInfo->dwAuthnLevel = dwAuthnLevel; } else { pAuthInfo->dwAuthnLevel = RPC_C_AUTHN_LEVEL_CONNECT; } } else { pAuthInfo->dwAuthnLevel = RPC_C_AUTHN_LEVEL_DEFAULT; } pAuthIdentityData->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE; pAuthInfo->dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE; pAuthInfo->dwAuthnSvc = RPC_C_AUTHN_WINNT; pAuthInfo->dwAuthzSvc = RPC_C_AUTHZ_NONE; pAuthInfo->pwszServerPrincName = NULL; pAuthInfo->dwCapabilities = EOAC_NONE; pAuthInfo->pAuthIdentityData = pAuthIdentityData; pcsiName->pAuthInfo = pAuthInfo; } } while(FALSE); return pcsiName; } void CComAuthInfo::FreeServerInfoStruct( IN COSERVERINFO * pServerInfo ) const /*++ Routine Description: As mentioned above -- free the server info structure Arguments: COSERVERINFO * pServerInfo : Server info structure Return Value: None --*/ { if (pServerInfo) { if (pServerInfo->pAuthInfo) { if (pServerInfo->pAuthInfo->pAuthIdentityData) { if (pServerInfo->pAuthInfo->pAuthIdentityData) { LocalFree(pServerInfo->pAuthInfo->pAuthIdentityData->User); LocalFree(pServerInfo->pAuthInfo->pAuthIdentityData->Domain); LocalFree(pServerInfo->pAuthInfo->pAuthIdentityData->Password); delete pServerInfo->pAuthInfo->pAuthIdentityData; } } delete pServerInfo->pAuthInfo; } delete pServerInfo; } } HRESULT CComAuthInfo::ApplyProxyBlanket( IN OUT IUnknown * pInterface ) /*++ Routine Description: Set security information on the interface. The user name is of the form domain\username. Arguments: IUnknown * pInterface : Interface Return Value: HRESULT --*/ { HRESULT hr = S_OK; COSERVERINFO * pcsiName = CreateServerInfoStruct(); // // This method should only be called if we're using impersonation. // so the pcsiName returned should never be NULL. // ATLASSERT(pcsiName && pcsiName->pAuthInfo); DWORD dwAuthSvc, dwAuthzSvc, dwAuthnLevel, dwImplLevel, dwCaps; OLECHAR * pServerPrincName; RPC_AUTH_IDENTITY_HANDLE pAuthInfo; hr = ::CoQueryProxyBlanket( pInterface, &dwAuthSvc, &dwAuthzSvc, &pServerPrincName, &dwAuthnLevel, &dwImplLevel, &pAuthInfo, &dwCaps); if (pcsiName && pcsiName->pAuthInfo) { hr = ::CoSetProxyBlanket( pInterface, pcsiName->pAuthInfo->dwAuthnSvc, pcsiName->pAuthInfo->dwAuthzSvc, pcsiName->pAuthInfo->pwszServerPrincName, pcsiName->pAuthInfo->dwAuthnLevel, pcsiName->pAuthInfo->dwImpersonationLevel, pcsiName->pAuthInfo->pAuthIdentityData, pcsiName->pAuthInfo->dwCapabilities ); FreeServerInfoStruct(pcsiName); } return hr; } HRESULT CComAuthInfo::ApplyProxyBlanket( IN OUT IUnknown * pInterface, IN DWORD dwAuthnLevelInput ) /*++ Routine Description: Set security information on the interface. The user name is of the form domain\username. Arguments: IUnknown * pInterface : Interface Return Value: HRESULT --*/ { HRESULT hr = S_OK; COSERVERINFO * pcsiName = CreateServerInfoStruct(dwAuthnLevelInput); // // This method should only be called if we're using impersonation. // so the pcsiName returned should never be NULL. // ATLASSERT(pcsiName && pcsiName->pAuthInfo); DWORD dwAuthSvc, dwAuthzSvc, dwAuthnLevel, dwImplLevel, dwCaps; OLECHAR * pServerPrincName; RPC_AUTH_IDENTITY_HANDLE pAuthInfo; hr = ::CoQueryProxyBlanket( pInterface, &dwAuthSvc, &dwAuthzSvc, &pServerPrincName, &dwAuthnLevel, &dwImplLevel, &pAuthInfo, &dwCaps); if (pcsiName && pcsiName->pAuthInfo) { hr = ::CoSetProxyBlanket( pInterface, pcsiName->pAuthInfo->dwAuthnSvc, pcsiName->pAuthInfo->dwAuthzSvc, pcsiName->pAuthInfo->pwszServerPrincName, pcsiName->pAuthInfo->dwAuthnLevel, pcsiName->pAuthInfo->dwImpersonationLevel, pcsiName->pAuthInfo->pAuthIdentityData, pcsiName->pAuthInfo->dwCapabilities ); FreeServerInfoStruct(pcsiName); } return hr; } // // CMetabasePath implemention // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< const LPCTSTR CMetabasePath::_cszMachine = SZ_MBN_MACHINE; const LPCTSTR CMetabasePath::_cszRoot = SZ_MBN_ROOT; const LPCTSTR CMetabasePath::_cszSep = SZ_MBN_SEP_STR; const TCHAR CMetabasePath::_chSep = SZ_MBN_SEP_CHAR; const CString CMetabasePath::_anySep = SZ_MBN_ANYSEP_STR; /*static*/ BOOL CMetabasePath::IsSeparator(TCHAR c) { return _anySep.find(c) != CString::npos; } /* static */ LPCTSTR CMetabasePath::ConvertToParentPath( OUT IN CString & strMetaPath ) /*++ Routine Description: Given the path, convert it to the parent path e.g. "foo/bar/etc" returns "foo/bar" Arguments: CString & strMetaPath : Path to be converted Return value: Pointer to the converted path, or NULL in case of error --*/ { // TRACE(_T("Getting parent path of %s\n"), strMetaPath); CString::size_type pos, pos_head; if ((pos = strMetaPath.find_last_of(SZ_MBN_ANYSEP_STR)) == strMetaPath.length() - 1) { strMetaPath.erase(pos); } pos = strMetaPath.find_last_of(SZ_MBN_ANYSEP_STR); if (pos == CString::npos) return strMetaPath; pos_head = strMetaPath.find_first_of(SZ_MBN_ANYSEP_STR); if (pos_head != pos) { strMetaPath.erase(pos); } // TRACE(_T("Parent path should be %s\n"), strMetaPath); return strMetaPath; } LPCTSTR CMetabasePath::ConvertToParentPath( CMetabasePath& path ) { return CMetabasePath::ConvertToParentPath(path.m_strMetaPath); } /* static */ LPCTSTR CMetabasePath::TruncatePath( IN int nLevel, IN LPCTSTR lpszMDPath, OUT CString & strNewPath, OUT CString * pstrRemainder OPTIONAL ) /*++ Routine Description: Truncate the given metabase path at the given level, that is, the nLevel'th separator in the path, starting at 0, where 0 will always give lpszPath back whether it started with a separator or not. Examples: "/lm/w3svc/1/foo" at level 2 returns "/lm/w3svc" as does "lm/w3svc/1/foo". Arguments: int nLevel 0-based separator count to truncate at. LPTSTR lpszMDPath Fully-qualified metabase path CString & strNewPath Returns truncated path CString * pstrRemainder Optionally returns the remainder past the nLevel'th separator. Return Value: The truncated path at the level requested. See examples above. *pstrRemainder returns the remainder of the path. If the path does not contain nLevel worth of separators, the entire path is returned, and the remainder will be blank. --*/ { // ASSERT_PTR(lpszMDPath); ATLASSERT(nLevel >= 0); if (!lpszMDPath || nLevel < 0) { // TRACE(_T("TruncatePath: Invalid parameter\n")); return NULL; } // TRACE(_T("Source Path: %s\n"), lpszMDPath); // // Skip the first sep whether it exists or not // LPCTSTR lp = IsSeparator(*lpszMDPath) ? lpszMDPath + 1 : lpszMDPath; LPCTSTR lpRem = NULL; int cSeparators = 0; if (nLevel) { // // Advance to the requested separator level // while (*lp) { if (IsSeparator(*lp)) { if (++cSeparators == nLevel) { break; } } ++lp; } if (!*lp) { // // End of path is considered a separator // ++cSeparators; } ATLASSERT(cSeparators <= nLevel); if (cSeparators == nLevel) { // // Break up the strings // strNewPath = lpszMDPath; strNewPath.erase(lp - lpszMDPath); // TRACE(_T("Path truncated at level %d : %s\n"), nLevel, strNewPath); if (*lp) { lpRem = ++lp; // TRACE(_T("Remainder: %s\n"), lpRem); } } } // // Return remainder // if (pstrRemainder && lpRem) { // ASSERT_WRITE_PTR(pstrRemainder); *pstrRemainder = lpRem; } return strNewPath; } /* static */ DWORD CMetabasePath::GetInstanceNumber( IN LPCTSTR lpszMDPath ) /*++ Routine Description: Get the number of the instance referred to in the given metabase path. Examples: "lm/w3svc/1/foo/bar" will return 1 "lm/w3svc/" will return 0 (master instance) "lm/bogus/path/" will return 0xffffffff (error) Arguments: LPCTSTR lpszMDPath : A metabase path. Return Value: Instance number (0 indicates master instance) or 0xffffffff if the path is in error. --*/ { // TRACE(_T("Determining instance number of %s\n"), lpszMDPath); DWORD dwInstance = 0xffffffff; CString strService, strInst; if (GetServicePath(lpszMDPath, strService, &strInst)) { if (strInst.IsEmpty()) { dwInstance = MASTER_INSTANCE; } else { if (_istdigit(strInst.GetAt(0))) { dwInstance = _ttol(strInst); } } } return dwInstance; } /* static */ LPCTSTR CMetabasePath::GetLastNodeName( IN LPCTSTR lpszMDPath, OUT CString & strNodeName ) /*++ Routine Description: Get the last nodename off the metabase path Example: "/lm/foo/bar/" returns "bar" Arguments: LPCTSTR lpszMDPath : Metabase path Return Value: Pointer to the node name or NULL in case of a malformed path. --*/ { // ASSERT_PTR(lpszMDPath); if (!lpszMDPath || !*lpszMDPath) { return NULL; } // TRACE(_T("Getting last node name from %s\n"), lpszMDPath); LPCTSTR lp; LPCTSTR lpTail; lp = lpTail = lpszMDPath + lstrlen(lpszMDPath) - 1; // // Skip trailing separator // if (IsSeparator(*lp)) { --lpTail; --lp; } strNodeName.Empty(); while (*lp && !IsSeparator(*lp)) { strNodeName += *(lp--); } strNodeName.MakeReverse(); // TRACE(_T("Node is %s\n"), strNodeName); return strNodeName; } /* static */ void CMetabasePath::SplitMetaPathAtInstance( IN LPCTSTR lpszMDPath, OUT CString & strParent, OUT CString & strAlias ) /*++ Routine Description: Split the given path into parent metabase root and alias, with the root being the instance path, and the alias everything following the instance. Arguments: LPCTSTR lpszMDPath : Input path CString & strParent : Outputs the parent path CString & strAlias : Outputs the alias name Return Value: None. --*/ { // ASSERT_PTR(lpszMDPath); // TRACE(_T("Source Path %s\n"), lpszMDPath); strParent = lpszMDPath; strAlias.Empty(); LPTSTR lp = (LPTSTR)lpszMDPath; if (lp == NULL) { return; } int cSeparators = 0; int iChar = 0; // // Looking for "LM/sss/ddd/" <-- 3d slash: // while (*lp && cSeparators < 2) { if (IsSeparator(*lp)) { ++cSeparators; } ++iChar; } if (!*lp) { // // Bogus format // ASSERT_MSG("Bogus Format"); return; } if (_istdigit(*lp)) { // // Not at the master instance, skip one more. // while (*lp) { ++iChar; if (IsSeparator(*lp++)) { break; } } if (!*lp) { // // Bogus format // ASSERT_MSG("Bogus Format"); return; } } strAlias = strParent.Mid(iChar); strParent.erase(iChar); // TRACE(_T("Broken up into %s\n"), strParent); // TRACE(_T(" and %s\n"), strAlias); } /* static */ BOOL CMetabasePath::IsHomeDirectoryPath( IN LPCTSTR lpszMetaPath ) /*++ Routine Description: Determine if the path given describes a root directory Arguments: LPCTSTR lpszMetaPath : Metabase path Return Value: TRUE if the path describes a root directory, FALSE if it does not --*/ { // ASSERT_READ_PTR(lpszMetaPath); LPTSTR lpNode = lpszMetaPath ? StrPBrk(lpszMetaPath, _anySep) : NULL; if (lpNode) { return _tcsicmp(++lpNode, _cszRoot) == 0; } return FALSE; } /* static */ BOOL CMetabasePath::IsMasterInstance( IN LPCTSTR lpszMDPath ) /*++ Routine Description: Determine if the given metabase path points to the master instance (site). This is essentially the service path. Arguments: LPCTSTR lpszMDPath : Metabase path. Return Value: TRUE if the path is the master instance, FALSE otherwise. --*/ { // ASSERT_READ_PTR(lpszMDPath); if (!lpszMDPath || !*lpszMDPath) { return FALSE; } // TRACE(_T("Checking path %s\n"), lpszMDPath); CString strService; CString strRemainder; LPCTSTR lpPath = TruncatePath(2, lpszMDPath, strService, &strRemainder); return lpPath && !strService.IsEmpty() && strRemainder.IsEmpty(); } /* static */ LPCTSTR CMetabasePath::GetServiceInfoPath( IN LPCTSTR lpszMDPath, OUT CString & strInfoPath, IN LPCTSTR lpszDefService OPTIONAL ) /*++ Routine Description: Generate the appropriate metabase service info path for the given metabase path. For example: "lm/w3svc/1/foo/bar" Generates "lm/w3svc/info" Arguments: LPCTSTR lpszMDPath : Input metabase path CString & strInfoPath : Returns the info path LPCTSTR lpszDefService : Optionally specifies the default service to use (e.g "w3svc") if no service could be found in the path. Return Value: The info metabase path or NULL if one could not be generated. --*/ { // // Capability info stored off the service path ("lm/w3svc"). // CString strService; CString strRem; // // Strip off everything past the service // if (!TruncatePath(2, lpszMDPath, strService, &strRem) || strService.IsEmpty()) { if (!lpszDefService) { // TRACEEOLID("Unable to generate info path"); return NULL; } TRACEEOLID("Using default service for info path"); // // Machine path (no service). Use web as default service to // look for capability and version info. // strService = CMetabasePath(TRUE, lpszDefService); } strInfoPath = CMetabasePath(FALSE, strService, SZ_MBN_INFO); // TRACE("Using %s to look for capability info\n", strInfoPath); return strInfoPath; } /* static */ LPCTSTR CMetabasePath::CleanMetaPath( IN OUT CString & strMetaRoot ) /*++ Routine Description: Clean up the metabase path to one valid for internal consumption. This removes the beginning and trailing slashes off the path. Arguments: CString & strMetaRoot : Metabase path to be cleaned up. Return Value: Pointer to the metabase path --*/ { if (!strMetaRoot.IsEmpty()) { int hd = strMetaRoot.find_first_not_of(SZ_MBN_ANYSEP_STR); int tl = strMetaRoot.find_last_not_of(SZ_MBN_ANYSEP_STR); if (hd == CString::npos && tl == CString::npos) { // path contains only separators strMetaRoot.erase(); return strMetaRoot; } else if (hd != CString::npos) { if (tl != CString::npos) tl++; strMetaRoot = strMetaRoot.substr(hd, tl - hd); } #if 0 while (strMetaRoot.GetLength() > 0 && IsSeparator(strMetaRoot[strMetaRoot.GetLength() - 1])) { strMetaRoot.erase(strMetaRoot.GetLength() - 1); } while (strMetaRoot.GetLength() > 0 && IsSeparator(strMetaRoot[0])) { strMetaRoot = strMetaRoot.Right(strMetaRoot.GetLength() - 1); } #endif // looks like IISAdmin works only with separators "/" for (int i = 0; i < strMetaRoot.GetLength(); i++) { if (IsSeparator(strMetaRoot[i])) strMetaRoot.SetAt(i, _chSep); } } return strMetaRoot; } /* static */ LPCTSTR CMetabasePath::CleanMetaPath( IN OUT CMetabasePath & path ) { return CleanMetaPath(path.m_strMetaPath); } CMetabasePath::CMetabasePath( IN BOOL fAddBasePath, IN LPCTSTR lpszMDPath, IN LPCTSTR lpszMDPath2 OPTIONAL, IN LPCTSTR lpszMDPath3 OPTIONAL, IN LPCTSTR lpszMDPath4 OPTIONAL ) /*++ Routine Description: Constructor. Arguments: BOOL fAddBasePath : TRUE to prepend base path ("LM") FALSE if the path is complete LPCTSTR lpszMDPath : Metabase path LPCTSTR lpszMDPath2 : Optional child path LPCTSTR lpszMDPath3 : Optional child path LPCTSTR lpszMDPath4 : Optional child path Return Value: N/A --*/ : m_strMetaPath() { // This will fail for NULL pointer // ASSERT_READ_PTR(lpszMDPath); if (fAddBasePath) { m_strMetaPath = _cszMachine; AppendPath(lpszMDPath); } else { m_strMetaPath = lpszMDPath; } // // Add optional path components // AppendPath(lpszMDPath2); AppendPath(lpszMDPath3); AppendPath(lpszMDPath4); } CMetabasePath::CMetabasePath( IN LPCTSTR lpszSvc, OPTIONAL IN DWORD dwInstance, OPTIONAL IN LPCTSTR lpszParentPath, OPTIONAL IN LPCTSTR lpszAlias OPTIONAL ) /*++ Routine Description: Constructor. Construct with path components. Arguments: LPCTSTR lpszSvc : Service (may be NULL or "") DWORD dwInstance : Instance number (may be 0 for master) LPCTSTR lpszParentPath : Parent path (may be NULL or "") LPCTSTR lpszAlias : Alias (may be NULL or "") Return Value: N/A --*/ : m_strMetaPath() { BuildMetaPath(lpszSvc, dwInstance, lpszParentPath, lpszAlias); } void CMetabasePath::AppendPath( IN LPCTSTR lpszPath ) /*++ Routine Description: Append path to current metabase path Arguments: LPCTSTR lpszPath : Metabase path Return Value: None --*/ { if (lpszPath && *lpszPath) { m_strMetaPath += _cszSep; m_strMetaPath += lpszPath; } } void CMetabasePath::AppendPath( IN DWORD dwInstance ) /*++ Routine Description: Append path to current metabase path Arguments: DWORD dwInstance : Instance path Return Value: None --*/ { // ASSERT(dwInstance >= 0); if (!IS_MASTER_INSTANCE(dwInstance)) { TCHAR szInstance[] = _T("4000000000"); _ltot(dwInstance, szInstance, 10); m_strMetaPath += _cszSep; m_strMetaPath += szInstance; } } void CMetabasePath::BuildMetaPath( IN LPCTSTR lpszSvc OPTIONAL, IN LPCTSTR lpszInstance OPTIONAL, IN LPCTSTR lpszParentPath OPTIONAL, IN LPCTSTR lpszAlias OPTIONAL ) /*++ Routine Description: Build a complete metapath with the given service name, instance number and optional path components. Arguments: LPCTSTR lpszSvc : Service (may be NULL or "") LPCTSTR lpszInstance : Instance (may be NULL or "") LPCTSTR lpszParentPath : Parent path (may be NULL or "") LPCTSTR lpszAlias : Alias (may be NULL or "") Return Value: Pointer to internal buffer containing the path. --*/ { m_strMetaPath = _cszMachine; AppendPath(lpszSvc); AppendPath(lpszInstance); AppendPath(lpszParentPath); if (lpszAlias && *lpszAlias) { // // Special case: If the alias is root, but we're // at the master instance, ignore this. // if (lpszInstance || ::lstrcmpi(_cszRoot, lpszAlias)) { m_strMetaPath += _cszSep; m_strMetaPath += lpszAlias; } } // TRACE(_T("Generated metapath: %s\n"), m_strMetaPath ); } void CMetabasePath::BuildMetaPath( IN LPCTSTR lpszSvc OPTIONAL, IN DWORD dwInstance OPTIONAL, IN LPCTSTR lpszParentPath OPTIONAL, IN LPCTSTR lpszAlias OPTIONAL ) /*++ Routine Description: Build a complete metapath with the given service name, instance number and optional path components. Arguments: LPCTSTR lpszSvc : Service (may be NULL or "") DWORD dwInstance : Instance number (may be 0 for master) LPCTSTR lpszParentPath : Parent path (may be NULL or "") LPCTSTR lpszAlias : Alias (may be NULL or "") Return Value: Pointer to internal buffer containing the path. --*/ { m_strMetaPath = _cszMachine; AppendPath(lpszSvc); AppendPath(dwInstance); AppendPath(lpszParentPath); if (lpszAlias && *lpszAlias) { // // Special case: If the alias is root, but we're // at the master instance, ignore this. // if (!IS_MASTER_INSTANCE(dwInstance) || ::lstrcmpi(_cszRoot, lpszAlias)) { m_strMetaPath += _cszSep; m_strMetaPath += lpszAlias; } } // TRACE(_T("Generated metapath: %s\n"), m_strMetaPath); } // // CIISInterface class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< CIISInterface::CIISInterface( IN CComAuthInfo * pAuthInfo, OPTIONAL IN HRESULT hrInterface OPTIONAL ) /*++ Routine Description: Base class constructor. Arguments: CComAuthInfo * pAuthInfo : Auth info or NULL for local computer HRESULT hrInterface : Initial error code. S_OK by default. Return Value: N/A --*/ : m_auth(pAuthInfo), m_hrInterface(hrInterface) { } HRESULT CIISInterface::Create( IN int cInterfaces, IN const IID rgIID[], IN const GUID rgCLSID[], OUT int * pnInterface, OPTIONAL OUT IUnknown ** ppInterface ) /*++ Routine Description: Create interface. This will try a range of interfaces in order of priority. Arguments: int cInterfaces : Number of interfaces in array. const IID * rgIID : Array if IIDs const GUID * rgCLSID : Array of CLSIDs int * pnInterface : Returns the interface index that was successful. or NULL if not interested. IUnknown ** ppInterface : Returns pointer to the interface. Return Value: HRESULT Notes: This will attempt to create an interface, in order of declaration in the IID and CLSIS arrays. The first successful interface to be created will have its index returned in *pnInterfaces. --*/ { ASSERT(cInterfaces > 0); ASSERT(rgIID && rgCLSID && ppInterface); COSERVERINFO * pcsiName = m_auth.CreateServerInfoStruct(); MULTI_QI rgmqResults; CError err; int nInterface; // // Try to create the interface in order // for (nInterface = 0; nInterface < cInterfaces; ++nInterface) { ZeroMemory(&rgmqResults, sizeof(rgmqResults)); rgmqResults.pIID = &rgIID[nInterface]; // TRACE("Attempting to create interface #%d\n", nInterface); err = ::CoCreateInstanceEx( rgCLSID[nInterface], NULL, CLSCTX_SERVER, pcsiName, 1, &rgmqResults ); if (err.Succeeded() || err.Win32Error() == ERROR_ACCESS_DENIED) { break; } } if(err.Succeeded()) { // // Save the interface pointer // ASSERT_PTR(rgmqResults.pItf); *ppInterface = rgmqResults.pItf; if (pnInterface) { // // Store successful interface index // *pnInterface = nInterface; } // // Strangely enough, I now have still have to apply // the proxy blanket. Apparently this is by design. // if (m_auth.UsesImpersonation()) { ApplyProxyBlanket(); } } // // Clean up // m_auth.FreeServerInfoStruct(pcsiName); return err; } // // CMetaInterface class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< CMetaInterface::CMetaInterface( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Construct and initialize the interface Arguments: CComAuthInfo * pAuthInfo : Authentication info. NULL indicates the local computer. Return Value: N/A --*/ : CIISInterface(pAuthInfo), m_pInterface(NULL), m_iTimeOutValue(MB_TIMEOUT) { // // Initialize the interface // m_hrInterface = Create(); } CMetaInterface::CMetaInterface( IN CMetaInterface * pInterface ) /*++ Routine Description: Construct from existing interface (Copy Constructor) Arguments: CMetaInterface * pInterface : Existing interface Return Value: N/A Notes: Object will not take ownership of the interface, it will merely add to the reference count, and release it upon destruction BUGBUG: if pInterface is NULL, this will AV. --*/ : CIISInterface(&pInterface->m_auth, pInterface->m_hrInterface), m_pInterface(pInterface->m_pInterface), m_iTimeOutValue(pInterface->m_iTimeOutValue) { ASSERT_READ_PTR(m_pInterface); m_pInterface->AddRef(); } CMetaInterface::~CMetaInterface() /*++ Routine Description: Destructor -- releases the interface Arguments: N/A Return Value: N/A --*/ { SAFE_RELEASE(m_pInterface); } HRESULT CMetaInterface::Create() { return CIISInterface::Create( 1, &IID_IMSAdminBase, &CLSID_MSAdminBase, NULL, (IUnknown **)&m_pInterface ); } // // CMetaKey class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< // // Helper macros // #define ASSURE_PROPER_INTERFACE()\ if (!HasInterface()) { ASSERT_MSG("No interface"); return MD_ERROR_NOT_INITIALIZED; } #define ASSURE_OPEN_KEY()\ if (!m_hKey && !m_fAllowRootOperations) { ASSERT_MSG("No open key"); return HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE); } #define FETCH_PROPERTY_DATA_OR_FAIL(dwID, md)\ ZeroMemory(&md, sizeof(md)); \ if (!GetMDFieldDef(dwID, md.dwMDIdentifier, md.dwMDAttributes, md.dwMDUserType, md.dwMDDataType))\ { ASSERT_MSG("Bad property ID"); return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } // // Static Initialization // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #define MD_SERVER_PLATFORM (IIS_MD_SERVER_BASE+100 ) #define MD_SERVER_VERSION_MAJOR (IIS_MD_SERVER_BASE+101 ) #define MD_SERVER_VERSION_MINOR (IIS_MD_SERVER_BASE+102 ) #define MD_SERVER_CAPABILITIES (IIS_MD_SERVER_BASE+103 ) #ifndef MD_APP_PERIODIC_RESTART_TIME #define MD_APP_PERIODIC_RESTART_TIME 2111 #endif #ifndef MD_APP_PERIODIC_RESTART_REQUESTS #define MD_APP_PERIODIC_RESTART_REQUESTS 2112 #endif #ifndef MD_APP_PERIODIC_RESTART_SCHEDULE #define MD_APP_PERIODIC_RESTART_SCHEDULE 2113 #endif #ifndef MD_ASP_DISKTEMPLATECACHEDIRECTORY #define MD_ASP_DISKTEMPLATECACHEDIRECTORY 7036 #endif #ifndef MD_ASP_MAXDISKTEMPLATECACHEFILES #define MD_ASP_MAXDISKTEMPLATECACHEFILES 7040 #endif // // Metabase table // const CMetaKey::MDFIELDDEF CMetaKey::s_rgMetaTable[] = { /////////////////////////////////////////////////////////////////////////// // // !!!IMPORTANT!!! This table must be sorted on dwMDIdentifier. (Will // ASSERT if not not sorted) // { MD_MAX_BANDWIDTH, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_KEY_TYPE, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_SERVER_COMMAND, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_CONNECTION_TIMEOUT, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_CONNECTION_TIMEOUT }, { MD_MAX_CONNECTIONS, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_MAX_CONNECTIONS }, { MD_SERVER_COMMENT, METADATA_INHERIT, IIS_MD_UT_SERVER, STRING_METADATA, IDS_MD_SERVER_COMMENT }, { MD_SERVER_STATE, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_SERVER_AUTOSTART, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_SERVER_SIZE, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_SERVER_SIZE }, { MD_SERVER_LISTEN_BACKLOG, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_SERVER_LISTEN_BACKLOG }, { MD_SERVER_LISTEN_TIMEOUT, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_SERVER_LISTEN_TIMEOUT }, { MD_SERVER_BINDINGS, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, MULTISZ_METADATA, 0 }, { MD_WIN32_ERROR, METADATA_VOLATILE, IIS_MD_UT_FILE, DWORD_METADATA, 0 }, { MD_SERVER_PLATFORM, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_SERVER_VERSION_MAJOR, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_SERVER_VERSION_MINOR, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_SERVER_CAPABILITIES, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_SECURE_BINDINGS, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, MULTISZ_METADATA, 0 }, { MD_FILTER_LOAD_ORDER, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_FILTER_IMAGE_PATH, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_FILTER_STATE, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_FILTER_ENABLED, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_FILTER_FLAGS, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_AUTH_CHANGE_URL, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_AUTH_EXPIRED_URL, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_AUTH_NOTIFY_PWD_EXP_URL, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_ADV_NOTIFY_PWD_EXP_IN_DAYS, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_ADV_CACHE_TTL, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_AUTH_EXPIRED_UNSECUREURL, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_AUTH_CHANGE_FLAGS, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_AUTH_NOTIFY_PWD_EXP_UNSECUREURL, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_FRONTPAGE_WEB, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_MAPCERT, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_MAPNTACCT, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_MAPNAME, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_MAPENABLED, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_MAPREALM, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_MAPPWD, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_ITACCT, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_CPP_CERT11, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SERIAL_CERT11, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_CPP_CERTW, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SERIAL_CERTW, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_CPP_DIGEST, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SERIAL_DIGEST, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_CPP_ITA, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SERIAL_ITA, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_APP_FRIENDLY_NAME, METADATA_INHERIT, IIS_MD_UT_WAM, STRING_METADATA, IDS_MD_APP_FRIENDLY_NAME }, { MD_APP_ROOT, METADATA_INHERIT, IIS_MD_UT_WAM, STRING_METADATA, IDS_MD_APP_ROOT }, { MD_APP_ISOLATED, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, IDS_MD_APP_ISOLATED }, // new stuff { MD_APP_PERIODIC_RESTART_TIME, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, 0 }, { MD_APP_PERIODIC_RESTART_REQUESTS, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, 0 }, { MD_APP_PERIODIC_RESTART_SCHEDULE, METADATA_INHERIT, IIS_MD_UT_WAM, MULTISZ_METADATA, 0 }, // end new stuff { MD_HC_COMPRESSION_DIRECTORY, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_HC_DO_DYNAMIC_COMPRESSION, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_HC_DO_STATIC_COMPRESSION, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_HC_DO_DISK_SPACE_LIMITING, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_HC_MAX_DISK_SPACE_USAGE, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_VR_PATH, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_VR_PATH }, { MD_VR_USERNAME, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_VR_USERNAME }, { MD_VR_PASSWORD, METADATA_INHERIT | METADATA_SECURE, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_VR_PASSWORD }, { MD_VR_ACL, METADATA_NO_ATTRIBUTES, IIS_MD_UT_FILE, BINARY_METADATA, 0 }, { MD_VR_UPDATE, METADATA_NO_ATTRIBUTES, IIS_MD_UT_FILE, DWORD_METADATA, 0 }, { MD_LOG_TYPE, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_LOG_TYPE }, { MD_LOGFILE_DIRECTORY, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_LOGFILE_DIRECTORY }, { MD_LOGFILE_PERIOD, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_LOGFILE_PERIOD }, { MD_LOGFILE_TRUNCATE_SIZE, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_LOGFILE_TRUNCATE_SIZE }, { MD_LOGSQL_DATA_SOURCES, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_LOGSQL_DATA_SOURCES }, { MD_LOGSQL_TABLE_NAME, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_LOGSQL_TABLE_NAME }, { MD_LOGSQL_USER_NAME, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_LOGSQL_USER_NAME }, { MD_LOGSQL_PASSWORD, METADATA_INHERIT | METADATA_SECURE, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_LOGSQL_PASSWORD }, { MD_LOG_PLUGIN_ORDER, METADATA_INHERIT, IIS_MD_UT_SERVER, STRING_METADATA, IDS_MD_LOG_PLUGIN_ORDER }, { MD_LOGEXT_FIELD_MASK, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_LOGEXT_FIELD_MASK }, { MD_LOGFILE_LOCALTIME_ROLLOVER, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_LOGFILE_LOCALTIME_ROLLOVER }, { MD_EXIT_MESSAGE, METADATA_INHERIT, IIS_MD_UT_SERVER, STRING_METADATA, IDS_MD_EXIT_MESSAGE }, { MD_GREETING_MESSAGE, METADATA_INHERIT, IIS_MD_UT_SERVER, MULTISZ_METADATA, IDS_MD_GREETING_MESSAGE }, { MD_MAX_CLIENTS_MESSAGE, METADATA_INHERIT, IIS_MD_UT_SERVER, STRING_METADATA, IDS_MD_MAX_CLIENTS_MESSAGE }, { MD_MSDOS_DIR_OUTPUT, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_MSDOS_DIR_OUTPUT }, { MD_ALLOW_ANONYMOUS, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_ALLOW_ANONYMOUS }, { MD_ANONYMOUS_ONLY, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_ANONYMOUS_ONLY }, { MD_LOG_ANONYMOUS, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_LOG_ANONYMOUS }, { MD_LOG_NONANONYMOUS, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_LOG_NONANONYMOUS }, { MD_SSL_PUBLIC_KEY, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SSL_PRIVATE_KEY, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SSL_KEY_PASSWORD, METADATA_SECURE, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SSL_CERT_HASH, METADATA_INHERIT, IIS_MD_UT_SERVER, BINARY_METADATA, 0 }, { MD_SSL_CERT_STORE_NAME, METADATA_INHERIT, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_SSL_CTL_IDENTIFIER, METADATA_INHERIT, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_SSL_CTL_STORE_NAME, METADATA_INHERIT, IIS_MD_UT_SERVER, STRING_METADATA, 0 }, { MD_SSL_USE_DS_MAPPER, METADATA_NO_ATTRIBUTES, IIS_MD_UT_SERVER, DWORD_METADATA, 0 }, { MD_AUTHORIZATION, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_AUTHORIZATION }, { MD_REALM, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_REALM }, { MD_HTTP_EXPIRES, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_HTTP_EXPIRES }, { MD_HTTP_PICS, METADATA_INHERIT, IIS_MD_UT_FILE, MULTISZ_METADATA, IDS_MD_HTTP_PICS }, { MD_HTTP_CUSTOM, METADATA_INHERIT, IIS_MD_UT_FILE, MULTISZ_METADATA, IDS_MD_HTTP_CUSTOM }, { MD_DIRECTORY_BROWSING, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_DIRECTORY_BROWSING }, { MD_DEFAULT_LOAD_FILE, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_DEFAULT_LOAD_FILE }, { MD_CONTENT_NEGOTIATION, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_CONTENT_NEGOTIATION }, { MD_CUSTOM_ERROR, METADATA_INHERIT, IIS_MD_UT_FILE, MULTISZ_METADATA, IDS_MD_CUSTOM_ERROR }, { MD_FOOTER_DOCUMENT, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_FOOTER_DOCUMENT }, { MD_FOOTER_ENABLED, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_FOOTER_ENABLED }, { MD_HTTP_REDIRECT, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_HTTP_REDIRECT }, { MD_DEFAULT_LOGON_DOMAIN, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_DEFAULT_LOGON_DOMAIN }, { MD_LOGON_METHOD, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_LOGON_METHOD }, { MD_SCRIPT_MAPS, METADATA_INHERIT, IIS_MD_UT_FILE, MULTISZ_METADATA, IDS_MD_SCRIPT_MAPS }, { MD_MIME_MAP, METADATA_INHERIT, IIS_MD_UT_FILE, MULTISZ_METADATA, IDS_MD_MIME_MAP }, { MD_ACCESS_PERM, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_ACCESS_PERM }, { MD_IP_SEC, METADATA_INHERIT | METADATA_REFERENCE, IIS_MD_UT_FILE, BINARY_METADATA, IDS_MD_IP_SEC }, { MD_ANONYMOUS_USER_NAME, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_ANONYMOUS_USER_NAME }, { MD_ANONYMOUS_PWD, METADATA_INHERIT | METADATA_SECURE, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_ANONYMOUS_PWD }, { MD_ANONYMOUS_USE_SUBAUTH, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_ANONYMOUS_USE_SUBAUTH }, { MD_DONT_LOG, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_DONT_LOG }, { MD_ADMIN_ACL, METADATA_INHERIT | METADATA_SECURE | METADATA_REFERENCE,IIS_MD_UT_SERVER, BINARY_METADATA, IDS_MD_ADMIN_ACL }, { MD_SSI_EXEC_DISABLED, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_SSI_EXEC_DISABLED }, { MD_SSL_ACCESS_PERM, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_SSL_ACCESS_PERM }, { MD_NTAUTHENTICATION_PROVIDERS, METADATA_INHERIT, IIS_MD_UT_FILE, STRING_METADATA, IDS_MD_NTAUTHENTICATION_PROVIDERS }, { MD_SCRIPT_TIMEOUT, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_SCRIPT_TIMEOUT }, { MD_CACHE_EXTENSIONS, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_CACHE_EXTENSIONS }, { MD_CREATE_PROCESS_AS_USER, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_CREATE_PROCESS_AS_USER }, { MD_CREATE_PROC_NEW_CONSOLE, METADATA_INHERIT, IIS_MD_UT_SERVER, DWORD_METADATA, IDS_MD_CREATE_PROC_NEW_CONSOLE }, { MD_POOL_IDC_TIMEOUT, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_POOL_IDC_TIMEOUT }, { MD_ALLOW_KEEPALIVES, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_ALLOW_KEEPALIVES }, { MD_IS_CONTENT_INDEXED, METADATA_INHERIT, IIS_MD_UT_FILE, DWORD_METADATA, IDS_MD_IS_CONTENT_INDEXED }, { MD_ISM_ACCESS_CHECK, METADATA_NO_ATTRIBUTES, IIS_MD_UT_FILE, DWORD_METADATA, 0 }, { MD_ASP_BUFFERINGON, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_BUFFERINGON }, { MD_ASP_LOGERRORREQUESTS, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, IDS_ASP_LOGERRORREQUESTS }, { MD_ASP_SCRIPTERRORSSENTTOBROWSER, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_SCRIPTERRORSSENTTOBROWSER }, { MD_ASP_SCRIPTERRORMESSAGE, METADATA_INHERIT, ASP_MD_UT_APP, STRING_METADATA, IDS_ASP_SCRIPTERRORMESSAGE }, { MD_ASP_SCRIPTFILECACHESIZE, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, IDS_ASP_SCRIPTFILECACHESIZE }, { MD_ASP_SCRIPTENGINECACHEMAX, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, IDS_ASP_SCRIPTENGINECACHEMAX }, { MD_ASP_SCRIPTTIMEOUT, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_SCRIPTTIMEOUT }, { MD_ASP_SESSIONTIMEOUT, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_SESSIONTIMEOUT }, { MD_ASP_ENABLEPARENTPATHS, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_ENABLEPARENTPATHS }, { MD_ASP_ALLOWSESSIONSTATE, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_ALLOWSESSIONSTATE }, { MD_ASP_SCRIPTLANGUAGE, METADATA_INHERIT, ASP_MD_UT_APP, STRING_METADATA, IDS_ASP_SCRIPTLANGUAGE }, { MD_ASP_EXCEPTIONCATCHENABLE, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, IDS_ASP_EXCEPTIONCATCHENABLE }, { MD_ASP_ENABLESERVERDEBUG, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_ENABLESERVERDEBUG }, { MD_ASP_ENABLECLIENTDEBUG, METADATA_INHERIT, ASP_MD_UT_APP, DWORD_METADATA, IDS_ASP_ENABLECLIENTDEBUG }, { MD_ASP_DISKTEMPLATECACHEDIRECTORY, METADATA_INHERIT, IIS_MD_UT_WAM, STRING_METADATA, 0 }, { MD_ASP_MAXDISKTEMPLATECACHEFILES, METADATA_INHERIT, IIS_MD_UT_WAM, DWORD_METADATA, 0 }, { MD_WAM_USER_NAME, METADATA_INHERIT, IIS_MD_UT_WAM, STRING_METADATA, 0 }, { MD_WAM_PWD, METADATA_INHERIT, IIS_MD_UT_WAM, STRING_METADATA, 0 } }; #define NUM_ENTRIES (sizeof(CMetaKey::s_rgMetaTable) / sizeof(CMetaKey::s_rgMetaTable[0])) /* static */ int CMetaKey::MapMDIDToTableIndex( IN DWORD dwID ) /*++ Routine Description: Map MD id value to table index. Return -1 if not found Arguments: DWORD dwID : MD id value Return Value: Index into the table that coresponds to the MD id value --*/ { #ifdef _DEBUG { // // Do a quick verification that our metadata // table is sorted correctly. // static BOOL fTableChecked = FALSE; if (!fTableChecked) { for (int n = 1; n < NUM_ENTRIES; ++n) { if (s_rgMetaTable[n].dwMDIdentifier <= s_rgMetaTable[n - 1].dwMDIdentifier) { // TRACE("MD ID Table is out of order: Item is %d %s\n", n, s_rgMetaTable[n].dwMDIdentifier); ASSERT_MSG("MD ID Table out of order"); } } // // But only once. // ++fTableChecked; } } #endif // _DEBUG // // Look up the ID in the table using a binary search // int nRange = NUM_ENTRIES; int nLow = 0; int nHigh = nRange - 1; int nMid; int nHalf; while (nLow <= nHigh) { if (nHalf = nRange / 2) { nMid = nLow + (nRange & 1 ? nHalf : (nHalf - 1)); if (s_rgMetaTable[nMid].dwMDIdentifier == dwID) { return nMid; } else if (s_rgMetaTable[nMid].dwMDIdentifier > dwID) { nHigh = --nMid; nRange = nRange & 1 ? nHalf : nHalf - 1; } else { nLow = ++nMid; nRange = nHalf; } } else if (nRange) { return s_rgMetaTable[nLow].dwMDIdentifier == dwID ? nLow : -1; } else { break; } } return -1; } /* static */ BOOL CMetaKey::GetMDFieldDef( IN DWORD dwID, OUT DWORD & dwMDIdentifier, OUT DWORD & dwMDAttributes, OUT DWORD & dwMDUserType, OUT DWORD & dwMDDataType ) /*++ Routine Description: Get information about metabase property Arguments: DWORD dwID : Meta ID DWORD & dwMDIdentifier : Meta parms DWORD & dwMDAttributes : Meta parms DWORD & dwMDUserType : Meta parms DWORD & dwMDDataType : Meta parms Return Value: TRUE for success, FALSE for failure. --*/ { int nID = MapMDIDToTableIndex(dwID); if (nID == -1) { // // Unrecognized meta data ID // ASSERT_MSG("Unrecognized meta data id"); return FALSE; } dwMDIdentifier = s_rgMetaTable[nID].dwMDIdentifier; dwMDAttributes = s_rgMetaTable[nID].dwMDAttributes; dwMDUserType = s_rgMetaTable[nID].dwMDUserType; dwMDDataType = s_rgMetaTable[nID].dwMDDataType; return TRUE; } /* static */ BOOL CMetaKey::IsPropertyInheritable( IN DWORD dwID ) /*++ Routine Description: Check to see if the given property is inheritable Arguments: DWORD dwID : Metabase ID Return Value: TRUE if the metabase ID is inheritable, FALSE otherwise. --*/ { int nID = MapMDIDToTableIndex(dwID); if (nID == -1) { // // Unrecognized meta data ID // ASSERT_MSG("Unrecognized meta data ID"); return FALSE; } return (s_rgMetaTable[nID].dwMDAttributes & METADATA_INHERIT) != 0; } /* static */ BOOL CMetaKey::GetPropertyDescription( IN DWORD dwID, OUT CString & strName ) /*++ Routine Description: Get a description for the given property Arguments: DWORD dwID : Property ID CString & strName : Returns friendly property name Return Value: TRUE for success, FALSE for failure --*/ { int nID = MapMDIDToTableIndex(dwID); if (nID == -1) { // // Unrecognized meta data ID // ASSERT_MSG("Unrecognized meta data ID"); return FALSE; } UINT uID = s_rgMetaTable[nID].uStringID; BOOL fResult = TRUE; if (uID > 0) { fResult = (strName.LoadString(_Module.GetResourceInstance(), uID) != 0); } else { // // Don't have a friendly name -- fake it // CComBSTR bstrFmt; VERIFY(bstrFmt.LoadString(_Module.GetResourceInstance(), IDS_INHERITANCE_NO_NAME)); strName.Format(bstrFmt, dwID); } return fResult; } CMetaKey::CMetaKey( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Constructor that creates the interface, but does not open the key. This is the ONLY constructor that allows operations from METDATA_MASTER_ROOT_HANDLE (read operations obviously) Arguments: CComAuthInfo * pAuthInfo : If NULL, opens interface on local machine Return Value: N/A --*/ : CMetaInterface(pAuthInfo), m_hKey(METADATA_MASTER_ROOT_HANDLE), m_hBase(NULL), m_hrKey(S_OK), m_dwFlags(0L), m_cbInitialBufferSize(MB_INIT_BUFF_SIZE), m_strMetaPath(), m_fAllowRootOperations(TRUE), m_fOwnKey(TRUE) { m_hrKey = CMetaInterface::QueryResult(); // // Do not open key // } CMetaKey::CMetaKey( IN CMetaInterface * pInterface ) /*++ Routine Description: Construct with pre-existing interface. Does not open any keys Arguments: CMetaInterface * pInterface : Preexisting interface Return Value: N/A --*/ : CMetaInterface(pInterface), m_hKey(NULL), m_hBase(NULL), m_strMetaPath(), m_dwFlags(0L), m_cbInitialBufferSize(MB_INIT_BUFF_SIZE), m_fAllowRootOperations(TRUE), m_fOwnKey(TRUE) { m_hrKey = CMetaInterface::QueryResult(); } CMetaKey::CMetaKey( IN CComAuthInfo * pAuthInfo, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL IN DWORD dwFlags, IN METADATA_HANDLE hkBase ) /*++ Routine Description: Fully defined constructor that opens a key Arguments: CComAuthInfo * pAuthInfo : Auth info or NULL LPCTSTR lpszMDPath : Path or NULL DWORD dwFlags : Open permissions METADATA_HANDLE hkBase : Base key Return Value: N/A --*/ : CMetaInterface(pAuthInfo), // : CMetaInterface((CComAuthInfo *)NULL), m_hKey(NULL), m_hBase(NULL), m_dwFlags(0L), m_cbInitialBufferSize(MB_INIT_BUFF_SIZE), m_fAllowRootOperations(FALSE), m_strMetaPath(), m_fOwnKey(TRUE) { m_hrKey = CMetaInterface::QueryResult(); if (SUCCEEDED(m_hrKey)) { m_hrKey = Open(dwFlags, lpszMDPath, hkBase); } } CMetaKey::CMetaKey( IN CMetaInterface * pInterface, IN LPCTSTR lpszMDPath, OPTIONAL IN DWORD dwFlags, IN METADATA_HANDLE hkBase ) /*++ Routine Description: Fully defined constructor that opens a key Arguments: CMetaInterface * pInterface : Existing interface DWORD dwFlags : Open permissions METADATA_HANDLE hkBase : Base key LPCTSTR lpszMDPath : Path or NULL Return Value: N/A --*/ : CMetaInterface(pInterface), m_hKey(NULL), m_hBase(NULL), m_strMetaPath(), m_dwFlags(0L), m_cbInitialBufferSize(MB_INIT_BUFF_SIZE), m_fAllowRootOperations(FALSE), m_fOwnKey(TRUE) { m_hrKey = CMetaInterface::QueryResult(); if (SUCCEEDED(m_hrKey)) { m_hrKey = Open(dwFlags, lpszMDPath, hkBase); } } CMetaKey::CMetaKey( IN BOOL fOwnKey, IN CMetaKey * pKey ) /*++ Routine Description: Copy constructor. Arguments: BOOL fOwnKey : TRUE to take ownership of the key const CMetaKey * pKey : Existing key Return Value: N/A --*/ : CMetaInterface(pKey), m_hKey(pKey->m_hKey), m_hBase(pKey->m_hBase), m_dwFlags(pKey->m_dwFlags), m_cbInitialBufferSize(pKey->m_cbInitialBufferSize), m_fAllowRootOperations(pKey->m_fAllowRootOperations), m_hrKey(pKey->m_hrKey), m_strMetaPath(pKey->m_strMetaPath), m_fOwnKey(fOwnKey) { // // No provisions for anything else at the moment // ASSERT(!m_fOwnKey); } CMetaKey::~CMetaKey() /*++ Routine Description: Destructor -- Close the key. Arguments: N/A Return Value: N/A --*/ { if (IsOpen() && m_fOwnKey) { Close(); } } /* virtual */ BOOL CMetaKey::Succeeded() const /*++ Routine Description: Determine if object was constructed successfully Arguments: None Return Value: TRUE for success, FALSE for failure --*/ { return SUCCEEDED(m_hrKey); } /* virtual */ HRESULT CMetaKey::QueryResult() const /*++ Routine Description: Return the construction error for this object Arguments: None Return Value: HRESULT from construction errors --*/ { return m_hrKey; } HRESULT CMetaKey::Open( IN DWORD dwFlags, IN LPCTSTR lpszMDPath, OPTIONAL IN METADATA_HANDLE hkBase ) /*++ Routine Description: Attempt to open a metabase key Arguments: DWORD dwFlags : Permission flags LPCTSTR lpszMDPath : Optional path METADATA_HANDLE hkBase : Base metabase key Return Value: HRESULT --*/ { ASSURE_PROPER_INTERFACE(); if (m_hKey != NULL) { ASSERT_MSG("Attempting to open key that already has an open handle"); // TRACEEOLID("Closing that key"); Close(); } // // Base key is stored for reopen purposes only // m_hBase = hkBase; m_strMetaPath = lpszMDPath; m_dwFlags = dwFlags; return OpenKey(m_hBase, m_strMetaPath, m_dwFlags, &m_hKey); } HRESULT CMetaKey::CreatePathFromFailedOpen() /*++ Routine Description: If the path doesn't exist, create it. This method should be called after an Open call failed (because it will have initialized m_strMetaPath. Arguments: None Return Value: HRESULT --*/ { CString strParentPath; CString strObjectName; CString strSavePath(m_strMetaPath); CMetabasePath::SplitMetaPathAtInstance( m_strMetaPath, strParentPath, strObjectName ); CError err(Open( METADATA_PERMISSION_WRITE, strParentPath )); if (err.Succeeded()) { // // This really should never fail, because we're opening // the path at the instance. // err = AddKey(strObjectName); } if (IsOpen()) { Close(); } // // The previous open wiped out the path... // m_strMetaPath = strSavePath; return err; } HRESULT CMetaKey::Close() /*++ Routine Description: Close the currently open key. Arguments: N/A Return Value: N/A --*/ { ASSURE_PROPER_INTERFACE(); HRESULT hr = S_OK; ASSERT(m_hKey != NULL); ASSERT(m_fOwnKey); if (m_hKey) { hr = CloseKey(m_hKey); if (SUCCEEDED(hr)) { m_hKey = NULL; } } return hr; } HRESULT CMetaKey::ConvertToParentPath( IN BOOL fImmediate ) /*++ Routine Description: Change the path to the parent path. Arguments: BOOL fImmediate : If TRUE, the immediate parent's path will be used if FALSE, the first parent that really exists Return Value: HRESULT ERROR_INVALID_PARAMETER if there is no valid path --*/ { BOOL fIsOpen = IsOpen(); if (fIsOpen) { Close(); } CError err; FOREVER { if (!CMetabasePath::ConvertToParentPath(m_strMetaPath)) { // // There is no parent path // err = ERROR_INVALID_PARAMETER; break; } err = ReOpen(); // // Path not found is the only valid error // other than success. // if (fImmediate || err.Succeeded() || err.Win32Error() != ERROR_PATH_NOT_FOUND) { break; } } // // Remember to reset the construction error // which referred to the parent path. // m_hrKey = err; return err; } /* protected */ HRESULT CMetaKey::GetPropertyValue( IN DWORD dwID, OUT IN DWORD & dwSize, OPTIONAL OUT IN void *& pvData, OPTIONAL OUT IN DWORD * pdwDataType, OPTIONAL IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL OUT DWORD * pdwAttributes OPTIONAL ) /*++ Routine Description: Get metadata on the currently open key. Arguments: DWORD dwID : Property ID number DWORD & dwSize : Buffer size (could be 0) void *& pvData : Buffer -- will allocate if NULL DWORD * pdwDataType : NULL or on in contains valid data types, : on out contains actual data type BOOL * pfInheritanceOverride : NULL or on forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key DWORD * pdwAttributes : Optionally returns attributes Return Value: HRESULT ERROR_INVALID_HANDLE : If the handle is not open ERROR_INVALID_PARAMETER : If the property id is not found, or the data type doesn't match requested type ERROR_OUTOFMEMORY : Out of memory --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); METADATA_RECORD mdRecord; FETCH_PROPERTY_DATA_OR_FAIL(dwID, mdRecord); // // If unable to find this property ID in our table, or // if we specified a desired type, and this type doesn't // match it, give up. // if (pdwDataType && *pdwDataType != ALL_METADATA && *pdwDataType != mdRecord.dwMDDataType) { ASSERT_MSG("Invalid parameter"); return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } // // Check to see if inheritance behaviour is overridden // if (pfInheritanceOverride) { if (*pfInheritanceOverride) { mdRecord.dwMDAttributes |= METADATA_INHERIT; } else { mdRecord.dwMDAttributes &= ~METADATA_INHERIT; } } // // This causes a bad parameter error on input otherwise // mdRecord.dwMDAttributes &= ~METADATA_REFERENCE; // // If we're looking for inheritable properties, the path // doesn't have to be completely specified. // if (mdRecord.dwMDAttributes & METADATA_INHERIT) { mdRecord.dwMDAttributes |= (METADATA_PARTIAL_PATH | METADATA_ISINHERITED); } ASSERT(dwSize > 0 || pvData == NULL); mdRecord.dwMDDataLen = dwSize; mdRecord.pbMDData = (LPBYTE)pvData; // // If no buffer provided, allocate one. // HRESULT hr = S_OK; BOOL fBufferTooSmall = FALSE; BOOL fAllocatedMemory = FALSE; DWORD dwInitSize = m_cbInitialBufferSize; do { if(mdRecord.pbMDData == NULL) { mdRecord.dwMDDataLen = dwInitSize; mdRecord.pbMDData = new BYTE[dwInitSize]; if(mdRecord.pbMDData == NULL && dwInitSize > 0) { hr = HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY); break; } ++fAllocatedMemory; } // // Get the data // DWORD dwRequiredDataLen = 0; hr = GetData(m_hKey, lpszMDPath, &mdRecord, &dwRequiredDataLen); // // Re-fetch the buffer if it's too small. // fBufferTooSmall = (HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER) && fAllocatedMemory; if(fBufferTooSmall) { // // Delete the old buffer, and set up for a re-fetch. // delete [] mdRecord.pbMDData; mdRecord.pbMDData = NULL; dwInitSize = dwRequiredDataLen; } } while(fBufferTooSmall); // // Failed // if (FAILED(hr) && fAllocatedMemory) { delete [] mdRecord.pbMDData; mdRecord.pbMDData = NULL; } dwSize = mdRecord.dwMDDataLen; pvData = mdRecord.pbMDData; if (pdwDataType != NULL) { // // Return actual data type // *pdwDataType = mdRecord.dwMDDataType; } if (pdwAttributes != NULL) { // // Return data attributes // *pdwAttributes = mdRecord.dwMDAttributes; } return hr; } /* protected */ HRESULT CMetaKey::GetDataPaths( OUT CStringListEx & strlDataPaths, IN DWORD dwMDIdentifier, IN DWORD dwMDDataType, IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Get data paths Arguments: Return Value: HRESULT --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); // // Start with a small buffer // DWORD dwMDBufferSize = 1024; LPTSTR lpszBuffer = NULL; CError err; do { delete [] lpszBuffer; lpszBuffer = new TCHAR[dwMDBufferSize]; if (lpszBuffer == NULL) { err = ERROR_NOT_ENOUGH_MEMORY; break; } err = CMetaInterface::GetDataPaths( m_hKey, lpszMDPath, dwMDIdentifier, dwMDDataType, dwMDBufferSize, lpszBuffer, &dwMDBufferSize ); } while(err.Win32Error() == ERROR_INSUFFICIENT_BUFFER); if (err.Win32Error() == ERROR_PATH_NOT_FOUND) { // // That's ok... this is some sort of physical directory // that doesn't currently exist in the metabase, and // which therefore doesn't have any descendants anyway. // ZeroMemory(lpszBuffer, dwMDBufferSize); err.Reset(); } if (err.Succeeded()) { strlDataPaths.ConvertFromDoubleNullList(lpszBuffer); delete [] lpszBuffer; } return err; } HRESULT CMetaKey::CheckDescendants( IN DWORD dwID, IN CComAuthInfo * pAuthInfo, OPTIONAL IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Check for descendant overrides; If there are any, bring up a dialog that displays them, and give the user the opportunity the remove the overrides. Arguments: DWORD dwID : Property ID CComAuthInfo * pAuthInfo : Server or NULL LPCTSTR lpszMDPath : Metabase path or NULL Return Value: HRESULT --*/ { ASSURE_PROPER_INTERFACE(); HRESULT hr = S_OK; METADATA_RECORD mdRecord; FETCH_PROPERTY_DATA_OR_FAIL(dwID, mdRecord); if (mdRecord.dwMDAttributes & METADATA_INHERIT) { CStringListEx strlDataPaths; hr = GetDataPaths( strlDataPaths, mdRecord.dwMDIdentifier, mdRecord.dwMDDataType, lpszMDPath ); if (SUCCEEDED(hr) && !strlDataPaths.empty()) { // // Bring up the inheritance override dialog // CInheritanceDlg dlg( dwID, FROM_WRITE_PROPERTY, pAuthInfo, lpszMDPath, strlDataPaths ); if (!dlg.IsEmpty()) { dlg.DoModal(); } } } return hr; } /* protected */ HRESULT CMetaKey::SetPropertyValue( IN DWORD dwID, IN DWORD dwSize, IN void * pvData, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Set metadata on the open key. The key must have been opened with write permission. Arguments: DWORD dwID : Property ID DWORD dwSize : Size of data void * pvData : Data buffer BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key Return Value: HRESULT ERROR_INVALID_HANDLE : If the handle is not open ERROR_INVALID_PARAMETER : If the property id is not found, or the buffer is NULL or of size 0 --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); if (pvData == NULL && dwSize != 0) { ASSERT_MSG("No Data"); return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } METADATA_RECORD mdRecord; FETCH_PROPERTY_DATA_OR_FAIL(dwID, mdRecord); if (pfInheritanceOverride) { if (*pfInheritanceOverride) { mdRecord.dwMDAttributes |= METADATA_INHERIT; } else { mdRecord.dwMDAttributes &= ~METADATA_INHERIT; } } mdRecord.dwMDDataLen = dwSize; mdRecord.pbMDData = (LPBYTE)pvData; return SetData(m_hKey, lpszMDPath, &mdRecord); } /* protected */ HRESULT CMetaKey::GetAllData( IN DWORD dwMDAttributes, IN DWORD dwMDUserType, IN DWORD dwMDDataType, OUT DWORD * pdwMDNumEntries, OUT DWORD * pdwMDDataLen, OUT PBYTE * ppbMDData, IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Get all data off the open key. Buffer is created automatically. Arguments: DWORD dwMDAttributes : Attributes DWORD dwMDUserType : User type to fetch DWORD dwMDDataType : Data type to fetch DWORD * pdwMDNumEntries : Returns number of entries read DWORD * pdwMDDataLen : Returns size of data buffer PBYTE * ppbMDData : Returns data buffer LPCTSTR lpszMDPath : Optional data path Return Value: HRESULT --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); // // Check for valid parameters // if(!pdwMDDataLen || !ppbMDData || !pdwMDNumEntries) { return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } HRESULT hr = S_OK; BOOL fBufferTooSmall = FALSE; DWORD dwMDDataSetNumber; DWORD dwRequiredBufferSize; DWORD dwInitSize = m_cbInitialBufferSize; *ppbMDData = NULL; do { *pdwMDDataLen = dwInitSize; *ppbMDData = new BYTE[dwInitSize]; if (ppbMDData == NULL && dwInitSize > 0) { hr = HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY); break; } hr = CMetaInterface::GetAllData( m_hKey, lpszMDPath, dwMDAttributes, dwMDUserType, dwMDDataType, pdwMDNumEntries, &dwMDDataSetNumber, *pdwMDDataLen, *ppbMDData, &dwRequiredBufferSize ); // // Re-fetch the buffer if it's too small. // fBufferTooSmall = (HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER); if(fBufferTooSmall) { // // Delete the old buffer, and set up for a re-fetch. // delete [] *ppbMDData; dwInitSize = dwRequiredBufferSize; } } while (fBufferTooSmall); if (FAILED(hr)) { // // No good, be sure we don't leak anything // delete [] *ppbMDData; dwInitSize = 0L; } return hr; } HRESULT CMetaKey::QueryValue( IN DWORD dwID, IN OUT DWORD & dwValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL OUT DWORD * pdwAttributes OPTIONAL ) /*++ Routine Description: Fetch data as a DWORD Arguments: DWORD dwID : Property ID DWORD & dwValue : Returns the value read in BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key DWORD * pdwAttributes : Optionally returns attributes Return Value: HRESULT --*/ { DWORD dwSize = sizeof(dwValue); DWORD dwDataType = DWORD_METADATA; void * pvData = &dwValue; return GetPropertyValue( dwID, dwSize, pvData, &dwDataType, pfInheritanceOverride, lpszMDPath, pdwAttributes ); } HRESULT CMetaKey::QueryValue( IN DWORD dwID, IN OUT CString & strValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL OUT DWORD * pdwAttributes OPTIONAL ) /*++ Routine Description: Fetch data as a string Arguments: DWORD dwID : Property ID DWORD & strValue : Returns the value read in BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key DWORD * pdwAttributes : Optionally returns attributes Return Value: HRESULT --*/ { // // Get GetData allocate the buffer for us // DWORD dwSize = 0; DWORD dwDataType = ALL_METADATA; LPTSTR lpData = NULL; HRESULT hr = GetPropertyValue( dwID, dwSize, (void *&)lpData, &dwDataType, pfInheritanceOverride, lpszMDPath, pdwAttributes ); if (SUCCEEDED(hr)) { // // Notes: consider optional auto-expansion on EXPANDSZ_METADATA // (see registry functions), and data type conversions for DWORD // or MULTISZ_METADATA or BINARY_METADATA // if (dwDataType == EXPANDSZ_METADATA || dwDataType == STRING_METADATA) { try { strValue = lpData; } catch(std::bad_alloc) { hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY); } } else { hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } } if (lpData) { delete [] lpData; } return hr; } HRESULT CMetaKey::QueryValue( IN DWORD dwID, IN OUT CStrPassword & strValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL OUT DWORD * pdwAttributes OPTIONAL ) /*++ Routine Description: Fetch data as a string Arguments: DWORD dwID : Property ID CStrPassword & strValue : Returns the value read in BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key DWORD * pdwAttributes : Optionally returns attributes Return Value: HRESULT --*/ { // // Get GetData allocate the buffer for us // DWORD dwSize = 0; DWORD dwDataType = ALL_METADATA; LPTSTR lpData = NULL; HRESULT hr = GetPropertyValue( dwID, dwSize, (void *&)lpData, &dwDataType, pfInheritanceOverride, lpszMDPath, pdwAttributes ); if (SUCCEEDED(hr)) { // // Notes: consider optional auto-expansion on EXPANDSZ_METADATA // (see registry functions), and data type conversions for DWORD // or MULTISZ_METADATA or BINARY_METADATA // if (dwDataType == EXPANDSZ_METADATA || dwDataType == STRING_METADATA) { try { strValue = lpData; } catch(std::bad_alloc) { hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY); } } else { hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } } if (lpData) { delete [] lpData; } return hr; } HRESULT CMetaKey::QueryValue( IN DWORD dwID, IN OUT CComBSTR & strValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL OUT DWORD * pdwAttributes OPTIONAL ) /*++ Routine Description: Fetch data as a string Arguments: DWORD dwID : Property ID DWORD & CComBSTR : Returns the value read in BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key DWORD * pdwAttributes : Optionally returns attributes Return Value: HRESULT --*/ { // // Get GetData allocate the buffer for us // DWORD dwSize = 0; DWORD dwDataType = ALL_METADATA; LPTSTR lpData = NULL; HRESULT hr = GetPropertyValue( dwID, dwSize, (void *&)lpData, &dwDataType, pfInheritanceOverride, lpszMDPath, pdwAttributes ); if (SUCCEEDED(hr)) { // // Notes: consider optional auto-expansion on EXPANDSZ_METADATA // (see registry functions), and data type conversions for DWORD // or MULTISZ_METADATA or BINARY_METADATA // if (dwDataType == EXPANDSZ_METADATA || dwDataType == STRING_METADATA) { strValue = lpData; } else { hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER); } } if (lpData) { delete [] lpData; } return hr; } HRESULT CMetaKey::QueryValue( IN DWORD dwID, IN OUT CStringListEx & strlValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL OUT DWORD * pdwAttributes OPTIONAL ) /*++ Routine Description: Fetch data as a stringlist Arguments: DWORD dwID : Property ID DWORD & strlValue : Returns the value read in BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key DWORD * pdwAttributes : Optionally returns attributes Return Value: HRESULT --*/ { // // Get GetData allocate the buffer for us // DWORD dwSize = 0; DWORD dwDataType = MULTISZ_METADATA; LPTSTR lpData = NULL; HRESULT hr = GetPropertyValue( dwID, dwSize, (void *&)lpData, &dwDataType, pfInheritanceOverride, lpszMDPath, pdwAttributes ); if (SUCCEEDED(hr)) { // // Notes: Consider accepting a single STRING // ASSERT(dwDataType == MULTISZ_METADATA); DWORD err = strlValue.ConvertFromDoubleNullList(lpData, dwSize / sizeof(TCHAR)); hr = HRESULT_FROM_WIN32(err); } if (lpData) { delete [] lpData; } return hr; } HRESULT CMetaKey::QueryValue( IN DWORD dwID, IN OUT CBlob & blValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath, OPTIONAL OUT DWORD * pdwAttributes OPTIONAL ) /*++ Routine Description: Fetch data as a binary blob Arguments: DWORD dwID : Property ID DWORD CBlob & blValue : Returns the binary blob BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path off the open key DWORD * pdwAttributes : Optionally returns attributes Return Value: HRESULT --*/ { // // Get GetData allocate the buffer for us // DWORD dwSize = 0; DWORD dwDataType = BINARY_METADATA; LPBYTE pbData = NULL; HRESULT hr = GetPropertyValue( dwID, dwSize, (void *&)pbData, &dwDataType, pfInheritanceOverride, lpszMDPath, pdwAttributes ); if (SUCCEEDED(hr)) { // // Blob takes ownership of the data, so don't free it... // ASSERT_READ_PTR2(pbData, dwSize); blValue.SetValue(dwSize, pbData, FALSE); } return hr; } HRESULT CMetaKey::SetValue( IN DWORD dwID, IN CStrPassword & strlValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath OPTIONAL ) { LPTSTR lpstr = NULL; HRESULT hr = E_FAIL; lpstr = strlValue.GetClearTextPassword(); if (lpstr) { hr = SetPropertyValue( dwID, strlValue.GetByteLength(), (void *)lpstr, pfInheritanceOverride, lpszMDPath ); strlValue.DestroyClearTextPassword(lpstr); } return hr; } HRESULT CMetaKey::SetValue( IN DWORD dwID, IN CStringListEx & strlValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Store data as string Arguments: DWORD dwID : Property ID CStringListEx & strlValue : Value to be written BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path (or NULL or "") Return Value: HRESULT --*/ { DWORD cCharacters; LPTSTR lpstr = NULL; // // Flatten value // strlValue.ConvertToDoubleNullList(cCharacters, lpstr); HRESULT hr = SetPropertyValue( dwID, cCharacters * sizeof(TCHAR), (void *)lpstr, pfInheritanceOverride, lpszMDPath ); delete [] lpstr; return hr; } HRESULT CMetaKey::SetValue( IN DWORD dwID, IN CBlob & blValue, IN BOOL * pfInheritanceOverride, OPTIONAL IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Store data as binary Arguments: DWORD dwID : Property ID CBlob & blValue : Value to be written BOOL * pfInheritanceOverride : NULL or forces inheritance on/off LPCTSTR lpszMDPath : Optional path (or NULL or "") Return Value: HRESULT --*/ { return SetPropertyValue( dwID, blValue.GetSize(), (void *)blValue.GetData(), pfInheritanceOverride, lpszMDPath ); } HRESULT CMetaKey::DeleteValue( DWORD dwID, LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Delete data Arguments: DWORD dwID : Property ID of property to be deleted LPCTSTR lpszMDPath : Optional path (or NULL or "") Return Value: HRESULT --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); METADATA_RECORD mdRecord; FETCH_PROPERTY_DATA_OR_FAIL(dwID, mdRecord); return DeleteData( m_hKey, lpszMDPath, mdRecord.dwMDIdentifier, mdRecord.dwMDDataType ); } HRESULT CMetaKey::DoesPathExist( IN LPCTSTR lpszMDPath ) /*++ Routine Description: Determine if the path exists Arguments: LPCTSTR lpszMDPath : Relative path off the open key Return Value: HRESULT, or S_OK if the path exists. --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); FILETIME ft; return GetLastChangeTime(m_hKey, lpszMDPath, &ft, FALSE); } HRESULT CMetaInterface::Regenerate() /*++ Routine Description: Attempt to recreate the interface pointer. This assumes that the interface had been successfully created before, but has become invalid at some point afterwards. Arguments: None Return Value: HRESULT --*/ { ASSERT_PTR(m_pInterface); // Must have been initialised SAFE_RELEASE(m_pInterface); m_hrInterface = Create(); return m_hrInterface; } #define GET_TO_INTERFACE2()\ IMSAdminBase2 * pInterface2 = NULL;\ HRESULT hr = GetAdminInterface2(&pInterface2);\ if (SUCCEEDED(hr)) { #define RELEASE_AND_RETURN2()\ if (pInterface2 != NULL)\ pInterface2->Release();\ }\ return hr\ HRESULT CMetaInterface::GetAdminInterface2(IMSAdminBase2 ** pp) { HRESULT hr = S_OK; IMSAdminBase2 * p = NULL; if (pp == NULL) return E_POINTER; if (m_auth.UsesImpersonation()) { IUnknown * punk = NULL; hr = m_pInterface->QueryInterface(__uuidof(IUnknown), (void **)&punk); if (SUCCEEDED(hr)) { if (SUCCEEDED(hr = m_auth.ApplyProxyBlanket(punk))) { if (SUCCEEDED(hr = punk->QueryInterface(IID_IMSAdminBase2, (void **)&p))) { if (p != NULL) { hr = m_auth.ApplyProxyBlanket(p); if (SUCCEEDED(hr)) { *pp = p; } } } } } if (punk != NULL) punk->Release(); } else { hr = m_pInterface->QueryInterface(IID_IMSAdminBase2, (void **)pp); } return hr; } // // CWamInterface class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< CWamInterface::CWamInterface( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Construct and initialize the interface. Arguments: CComAuthInfo * pAuthInfo : Auth info. NULL indicates the local computer. Return Value: N/A --*/ : CIISInterface(pAuthInfo), m_pInterface(NULL), m_fSupportsPooledProc(FALSE) { // // Initialize the interface // m_hrInterface = Create(); } CWamInterface::CWamInterface( IN CWamInterface * pInterface ) /*++ Routine Description: Construct from existing interface (copy constructor) Arguments: CWamInterface * pInterface : Existing interface Return Value: N/A --*/ : CIISInterface(&pInterface->m_auth, pInterface->m_hrInterface), m_pInterface(pInterface->m_pInterface), m_fSupportsPooledProc(FALSE) { ASSERT_PTR(m_pInterface); m_pInterface->AddRef(); } CWamInterface::~CWamInterface() /*++ Routine Description: Destructor -- releases the interface. Arguments: N/A Return Value: N/A --*/ { SAFE_RELEASE(m_pInterface); } /* protected */ HRESULT CWamInterface::Create() /*++ Routine Description: Create the interface with DCOM Arguments: None Return Value: HRESULT Notes: First, it will attempt to create the new interface, if it fails, it will attempt to create the downlevel interface --*/ { CLSID rgCLSID[2]; IID rgIID[2]; rgCLSID[1] = rgCLSID[0] = CLSID_WamAdmin; rgIID[0] = IID_IWamAdmin2; rgIID[1] = IID_IWamAdmin; ASSERT(ARRAY_SIZE(rgCLSID) == ARRAY_SIZE(rgIID)); int cInterfaces = ARRAY_SIZE(rgCLSID); int iInterface; HRESULT hr = CIISInterface::Create( cInterfaces, rgIID, rgCLSID, &iInterface, (IUnknown **)&m_pInterface ); if (SUCCEEDED(hr)) { // // Only supported on IWamAdmin2 // m_fSupportsPooledProc = (rgIID[iInterface] == IID_IWamAdmin2); } return hr; } HRESULT CWamInterface::AppCreate( IN LPCTSTR szMDPath, IN DWORD dwAppProtection ) /*++ Routine Description: Create application Arguments: LPCTSTR szMDPath : Metabase path DWORD dwAppProtection : APP_INPROC to create in-proc app APP_OUTOFPROC to create out-of-proc app APP_POOLEDPROC to create a pooled-proc app Return Value: HRESULT (ERROR_INVALID_PARAMETER if unsupported protection state is requested) --*/ { if (m_fSupportsPooledProc) { // // Interface pointer is really IWamAdmin2, so call the new method // return ((IWamAdmin2 *)m_pInterface)->AppCreate2(szMDPath, dwAppProtection); } // // Call the downlevel API // if (dwAppProtection == APP_INPROC || dwAppProtection == APP_OUTOFPROC) { BOOL fInProc = (dwAppProtection == APP_INPROC); ASSERT_PTR(m_pInterface); return m_pInterface->AppCreate(szMDPath, fInProc); } return CError(ERROR_INVALID_PARAMETER); } // // CMetaback Class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< const LPCTSTR CMetaBack::s_szMasterAppRoot =\ SZ_MBN_SEP_STR SZ_MBN_MACHINE SZ_MBN_SEP_STR SZ_MBN_WEB; CMetaBack::CMetaBack( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Constructor for metabase backup/restore operations class. This object is both a WAM interface and a METABASE interface. Arguments: CComAuthInfo * pAuthInfo : Auth info. NULL indicates the local computer. Return Value: N/A --*/ : m_dwIndex(0), CMetaInterface(pAuthInfo), CWamInterface(pAuthInfo) { } /* virtual */ BOOL CMetaBack::Succeeded() const /*++ Routine Description: Determine if object was constructed successfully. Arguments: None Return Value: TRUE for success, FALSE for failure --*/ { return CMetaInterface::Succeeded() && CWamInterface::Succeeded(); } /* virtual */ HRESULT CMetaBack::QueryResult() const /*++ Routine Description: Return the construction error for this object Arguments: None Return Value: HRESULT from construction errors --*/ { // // Both interfaces must have constructed successfully // HRESULT hr = CMetaInterface::QueryResult(); if (SUCCEEDED(hr)) { hr = CWamInterface::QueryResult(); } return hr; } HRESULT CMetaBack::Restore( IN LPCTSTR lpszLocation, IN DWORD dwVersion ) /*++ Routine Description: Restore metabase Arguments: DWORD dwVersion : Backup version LPCTSTR lpszLocation : Backup location Return Value: HRESULT --*/ { // // Backup and restore the application information from a restore // CString strPath(s_szMasterAppRoot); HRESULT hr = AppDeleteRecoverable(strPath, TRUE); if (SUCCEEDED(hr)) { hr = CMetaInterface::Restore(lpszLocation, dwVersion, 0); if (SUCCEEDED(hr)) { hr = AppRecover(strPath, TRUE); } } return hr; } // // CIISSvcControl class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< CIISSvcControl::CIISSvcControl( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Construct and initialize the interface. Arguments: CComAuthInfo * pAuthInfo : Auth info. NULL indicates the local computer. Return Value: N/A --*/ : CIISInterface(pAuthInfo), m_pInterface(NULL) { // // Initialize the interface // m_hrInterface = Create(); } CIISSvcControl::CIISSvcControl( IN CIISSvcControl * pInterface ) /*++ Routine Description: Construct from existing interface (copy constructor) Arguments: CIISSvcControl * pInterface : Existing interface Return Value: N/A --*/ : CIISInterface(&pInterface->m_auth, pInterface->m_hrInterface), m_pInterface(pInterface->m_pInterface) { ASSERT_PTR(m_pInterface); m_pInterface->AddRef(); } CIISSvcControl::~CIISSvcControl() /*++ Routine Description: Destructor -- releases the interface. Arguments: N/A Return Value: N/A --*/ { SAFE_RELEASE(m_pInterface); } #ifdef KEVLAR // // CWebCluster class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< CWebCluster::CWebCluster( IN CComAuthInfo * pAuthInfo OPTIONAL ) /*++ Routine Description: Construct and initialize the interface. Arguments: CComAuthInfo * pAuthInfo : Authentication information. NULL indicates the local computer Return Value: N/A --*/ : CIISInterface(pAuthInfo), m_pInterface(NULL) { // // Initialize the interface // m_hrInterface = Create(); } /* virtual */ CWebCluster::~CWebCluster() /*++ Routine Description: Destructor -- releases the interface. Arguments: N/A Return Value: N/A --*/ { SAFE_RELEASE(m_pInterface); } #endif // KEVLAR // // CMetaEnumerator Clas // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< CMetaEnumerator::CMetaEnumerator( IN CComAuthInfo * pAuthInfo OPTIONAL, IN LPCTSTR lpszMDPath OPTIONAL, IN METADATA_HANDLE hkBase OPTIONAL ) /*++ Routine Description: Metabase enumerator constructor. This constructor creates a new interface and opens a key. Arguments: CComAuthInfo * pAuthInfo : Auth info. NULL indicates the local computer. LPCTSTR lpszMDPath : Metabase path METADATA_HANDLE hkBase : Metabase handle Return Value: N/A --*/ : CMetaKey(pAuthInfo, lpszMDPath, METADATA_PERMISSION_READ, hkBase), m_dwIndex(0L) { } CMetaEnumerator::CMetaEnumerator( IN CMetaInterface * pInterface, IN LPCTSTR lpszMDPath, OPTIONAL IN METADATA_HANDLE hkBase OPTIONAL ) /*++ Routine Description: Metabase enumerator constructor. This constructor uses an existing interface and opens a key. Arguments: CMetaInterface * pInterface : Existing interface LPCTSTR lpszMDPath : Metabase path METADATA_HANDLE hkBase : Metabase handle Return Value: N/A --*/ : CMetaKey(pInterface, lpszMDPath, METADATA_PERMISSION_READ, hkBase), m_dwIndex(0L) { } CMetaEnumerator::CMetaEnumerator( IN BOOL fOwnKey, IN CMetaKey * pKey ) /*++ Routine Description: Metabase enumerator constructor. This constructor uses an existing interface and open key. Arguments: BOOL fOwnKey : TRUE if we own the key (destructor will close) CMetaKey * pKey : Open key Return Value: N/A --*/ : CMetaKey(fOwnKey, pKey), m_dwIndex(0L) { } HRESULT CMetaEnumerator::Next( OUT CString & strKey, IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Get the next subkey Arguments: CString & str Returns keyname LPCTSTR lpszMDPath Optional subpath Return Value: HRESULT --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); TCHAR buf[MAX_PATH]; HRESULT hr = EnumKeys(m_hKey, lpszMDPath, buf, m_dwIndex++); if (SUCCEEDED(hr)) strKey = buf; return hr; } HRESULT CMetaEnumerator::Next( OUT DWORD & dwKey, OUT CString & strKey, IN LPCTSTR lpszMDPath OPTIONAL ) /*++ Routine Description: Get the next subkey as a DWORD. This skips non-numeric keynames (including 0) until the first numeric key name Arguments: DWORD & dwKey Numeric key CString & strKey Same key in string format LPCTSTR lpszMDPath Optional subpath Return Value: HRESULT --*/ { ASSURE_PROPER_INTERFACE(); ASSURE_OPEN_KEY(); HRESULT hr; TCHAR buf[MAX_PATH]; while (TRUE) { if (SUCCEEDED(hr = EnumKeys(m_hKey, lpszMDPath, buf, m_dwIndex++))) { if (0 != (dwKey = _ttoi(buf))) { strKey = buf; break; } } else break; } return hr; } // This method moved from inline to remove dependency on IIDs and CLSIDs HRESULT CIISSvcControl::Create() { return CIISInterface::Create( 1, &IID_IIisServiceControl, &CLSID_IisServiceControl, NULL, (IUnknown **)&m_pInterface ); } // // CIISApplication class // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<