/*++ Copyright (c) 1994-1999 Microsoft Corporation Module Name : msg.cpp Abstract: Message Functions Author: Ronald Meijer (ronaldm) Sergei Antonov (sergeia) Project: Internet Services Manager (cluster edition) Revision History: 2/18/2000 sergeia removed dependency on MFC --*/ #include "stdafx.h" #include #include #include "common.h" extern CComModule _Module; #ifdef _MT // // Thread protected stuff // #define RaiseThreadProtection() \ do {\ EnterCriticalSection(&_csSect);\ } while(0) #define LowerThreadProtection() \ do {\ LeaveCriticalSection(&_csSect);\ } while (0) static CRITICAL_SECTION _csSect; #else #pragma message("Module is not thread-safe.") #define RaiseThreadProtection() #define LowerThreadProtection() #endif // _MT BOOL InitErrorFunctionality() /*++ Routine Description: Initialize CError class, and allocate static objects Arguments: None: Return Value: TRUE for success, FALSE for failure --*/ { #ifdef _MT InitializeCriticalSection(&_csSect); #endif // _MT BOOL fOK = CError::AllocateStatics(); if (fOK) { // REGISTER_FACILITY(FACILITY_APPSERVER, "iisui2.dll"); } return fOK; } void TerminateErrorFunctionality() /*++ Routine Description: De-initialize CError class, freeing up static objects Arguments: None Return Value: None --*/ { CError::DeAllocateStatics(); #ifdef _MT DeleteCriticalSection(&_csSect); #endif // _MT } // // Static Initialization: // // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< const TCHAR g_cszNull[] = _T("(Null)"); const TCHAR CError::s_chEscape = _T('%'); // Error text escape const TCHAR CError::s_chEscText = _T('h'); // Escape code for text const TCHAR CError::s_chEscNumber = _T('H'); // Escape code for error code LPCTSTR CError::s_cszLMDLL = _T("netmsg.dll"); // LM Error File LPCTSTR CError::s_cszWSDLL = _T("iisui2.dll"); // Winsock error file LPCTSTR CError::s_cszFacility[] = { /* FACILITY_NULL */ NULL, /* FACILITY_RPC */ NULL, /* FACILITY_DISPATCH */ NULL, /* FACILITY_STORAGE */ NULL, /* FACILITY_ITF */ NULL, /* FACILITY_DS */ NULL, /* 6 */ NULL, /* FACILITY_WIN32 */ NULL, /* FACILITY_WINDOWS */ NULL, /* FACILITY_SSPI */ NULL, /* FACILITY_CONTROL */ NULL, /* FACILITY_CERT */ NULL, /* FACILITY_INTERNET */ _T("metadata.dll"), /* FACILITY_MEDIASERVER */ NULL, /* FACILITY_MSMQ */ NULL, /* FACILITY_SETUPAPI */ NULL, /* FACILITY_SCARD */ NULL, /* 17 (MTX) */ _T("iisui2.dll"), }; HRESULT CError::s_cdwMinLMErr = NERR_BASE; HRESULT CError::s_cdwMaxLMErr = MAX_NERR; HRESULT CError::s_cdwMinWSErr = WSABASEERR; HRESULT CError::s_cdwMaxWSErr = WSABASEERR + 2000; DWORD CError::s_cdwFacilities = (sizeof(CError::s_cszFacility)\ / sizeof(CError::s_cszFacility[0])); // // Allocated objects // CString * CError::s_pstrDefError; CString * CError::s_pstrDefSuccs; CFacilityMap * CError::s_pmapFacilities; BOOL CError::s_fAllocated = FALSE; /* protected */ /* static */ BOOL CError::AllocateStatics() /*++ Routine Description: Allocate static objects Arguments: None Return Value: TRUE for successfull allocation, FALSE otherwise --*/ { RaiseThreadProtection(); if (!AreStaticsAllocated()) { try { CError::s_pstrDefError = new CString; CError::s_pstrDefSuccs = new CString(_T("0x%08lx")); CError::s_pmapFacilities = new CFacilityMap; s_fAllocated = TRUE; if (!CError::s_pstrDefError->LoadString(_Module.GetResourceInstance(), IDS_NO_MESSAGE)) { // // Just in case we didn't load this message from the resources // ASSERT_MSG("Unable to load resource message"); *s_pstrDefError = _T("Error Code: 0x%08lx"); } } catch(std::bad_alloc) { ASSERT_MSG("Initialization Failed"); } } LowerThreadProtection(); return AreStaticsAllocated(); } /* protected */ /* static */ void CError::DeAllocateStatics() /*++ Routine Description: Clean up allocations Arguments: N/A Return Value: N/A --*/ { RaiseThreadProtection(); if (AreStaticsAllocated()) { SAFE_DELETE(CError::s_pstrDefError); SAFE_DELETE(CError::s_pstrDefSuccs); SAFE_DELETE(CError::s_pmapFacilities); s_fAllocated = FALSE; } LowerThreadProtection(); } /*static*/ BOOL CError::AreStaticsAllocated() { return s_fAllocated; } /* static */ HRESULT CError::CvtToInternalFormat( IN HRESULT hrCode ) /*++ Routine Description: Convert WIN32 or HRESULT code to internal (HRESULT) format. Arguments: DWORD dwCode Error code Return Value: HRESULT Notes: HRESULTS are left as is. Lanman and Winsock errors are converted to HRESULTS using private facility codes. --*/ { if (IS_HRESULT(hrCode)) { return hrCode; } if(hrCode >= s_cdwMinLMErr && hrCode <= s_cdwMaxLMErr) { return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_LANMAN, (DWORD)hrCode); } if (hrCode >= s_cdwMinWSErr && hrCode <= s_cdwMaxWSErr) { return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WINSOCK, (DWORD)hrCode); } return HResult(hrCode); } /* static */ void CError::RegisterFacility( IN DWORD dwFacility, IN LPCSTR lpDLL OPTIONAL ) /*++ Routine Description: Register a DLL for a given facility code. Use NULL to unregister the DLL name. Arguments: DWORD dwFacility : Facility code LPCSTR lpDLL : DLL Name. Return Value: None --*/ { RaiseThreadProtection(); ASSERT(AreStaticsAllocated()); if (lpDLL == NULL) { // // Remove the facility // s_pmapFacilities->erase(dwFacility); } else { CString str(lpDLL); // // Register facility // s_pmapFacilities->insert(s_pmapFacilities->begin(), CFacilityMap::value_type(dwFacility, str)); } LowerThreadProtection(); } /* static */ LPCTSTR CError::FindFacility( IN DWORD dwFacility ) /*++ Routine Description: Determine if a DLL name has been registered for the given facility code. Arguments: DWORD dwFacility : Facility code Return Value: Returns the DLL name, or NULL. --*/ { RaiseThreadProtection(); ASSERT(AreStaticsAllocated()); LPCTSTR pRes = NULL; CFacilityMap::iterator it = s_pmapFacilities->find(dwFacility); if (it != s_pmapFacilities->end()) { pRes = (*it).second; } LowerThreadProtection(); return pRes; } CError::~CError() /*++ Routine Description: Destructor Arguments: None Return Value: N/A --*/ { } const CError & CError::Construct( IN HRESULT hr ) /*++ Routine Description: construct with new value. Arguments: HRESULT hr : New value, either an HRESULT or a WIN32 error code. Return Value: Reference to current object --*/ { ASSERT(AreStaticsAllocated()); m_hrCode = CvtToInternalFormat(hr); return *this; } const CError & CError::Construct( IN const CError & err ) /*++ Routine Description: Assign new value. Arguments: CError & err : Error code Return Value: Reference to current object --*/ { ASSERT(AreStaticsAllocated()); m_hrCode = err.m_hrCode; return *this; } int CError::MessageBox( IN UINT nType, IN UINT nHelpContext OPTIONAL ) const /*++ Routine Description: Display error message in a message box Arguments: HRESULT hrCode : HRESULT error code UINT nType : See AfxMessageBox for documentation UINT nHelpContext : See AfxMessageBox for documentation Return Value: AfxMessageBox return code --*/ { CString strMsg; TextFromHRESULT(strMsg); return ::MessageBox(::GetAncestor(::GetFocus(), GA_ROOT), strMsg, NULL, nType); } // // Extend CString just to get at FormatV publically // class CStringEx : public CString { public: void FormatV(LPCTSTR lpszFormat, va_list argList) { CString::FormatV(lpszFormat, argList); } }; int CError::MessageBoxFormat( IN HINSTANCE hInst, IN UINT nFmt, IN UINT nType, IN UINT nHelpContext, ... ) const /*++ Routine Description: Display formatted error message in messagebox. The format string (given as a resource ID) is a normal printf-style string, with the additional parameter of %h, which takes the text equivalent of the error message, or %H, which takes the error return code itself. Arguments: UINT nFmt : Resource format UINT nType : See AfxMessageBox for documentation UINT nHelpContext : See AfxMessageBox for documentation ... More as needed for sprintf Return Value: AfxMessageBox return code --*/ { CString strFmt; CStringEx strMsg; strFmt.LoadString(hInst, nFmt); // // First expand the error // TextFromHRESULTExpand(strFmt); va_list marker; va_start(marker, nHelpContext); strMsg.FormatV(strFmt, marker); va_end(marker); return ::MessageBox(::GetFocus(), strMsg, NULL, nType); } BOOL CError::MessageBoxOnFailure( IN UINT nType, IN UINT nHelpContext OPTIONAL ) const /*++ Routine Description: Display message box if the current error is a failure condition, else do nothing Arguments: UINT nType : See AfxMessageBox for documentation UINT nHelpContext : See AfxMessageBox for documentation Return Value: TRUE if a messagebox was shown, FALSE otherwise --*/ { if (Failed()) { MessageBox(nType, nHelpContext); return TRUE; } return FALSE; } BOOL CError::HasOverride( OUT UINT * pnMessage OPTIONAL ) const /*++ Routine Description: Check to see if a given HRESULT has an override Arguments: HRESULT hrCode : HRESULT to check for UINT * pnMessage : Optionally returns the override Return Value: TRUE if there is an override, FALSE if there is not. --*/ { ASSERT(AreStaticsAllocated()); HRESULT hrCode = CvtToInternalFormat(m_hrCode); if (!mapOverrides.empty()) { COverridesMap::const_iterator it = mapOverrides.find(hrCode); if (it != mapOverrides.end()) { if (pnMessage != NULL) *pnMessage = (*it).second; return TRUE; } } return FALSE; } UINT CError::AddOverride( IN HRESULT hrCode, IN UINT nMessage ) /*++ Routine Description: Add an override for a specific HRESULT. Arguments: HRESULT hrCode : HRESULT to override UINT nMessage : New message, or -1 to remove override Return Value: The previous override, or -1 --*/ { ASSERT(AreStaticsAllocated()); UINT nPrev; hrCode = CvtToInternalFormat(hrCode); // // Fetch the current override // COverridesMap::iterator it = mapOverrides.find(hrCode); nPrev = (it == mapOverrides.end()) ? REMOVE_OVERRIDE : (*it).second; if (nMessage == REMOVE_OVERRIDE) { // // Remove the override // mapOverrides.erase(hrCode); } else { // // Set new override // mapOverrides[hrCode] = nMessage; } return nPrev; } void CError::RemoveAllOverrides() /*++ Routine Description: Remove all overrides Arguments: None Return Value: None --*/ { ASSERT(AreStaticsAllocated()); mapOverrides.clear(); } HRESULT CError::TextFromHRESULT( OUT LPTSTR szBuffer, OUT DWORD cchBuffer ) const /*++ Routine Description: Get text from the given HRESULT. Based on the range that the HRESULT falls in and the facility code, find the location of the message, and fetch it. Arguments: HRESULT hrCode HRESULT or (DWORD WIN32 error) whose message to get LPTSTR szBuffer Buffer to load message text into DWORD cchBuffer Size of buffer in characters. Return Value: HRESULT error code depending on whether the message was found. If the message was not found, some generic message is synthesized in the buffer if a buffer is provided. ERROR_FILE_NOT_FOUND No message found ERROR_INSUFFICIENT_BUFFER Buffer is a NULL pointer or too small --*/ { HRESULT hrReturn = ERROR_SUCCESS; // // First check to see if this message is overridden // UINT nID; HRESULT hrCode = m_hrCode; if (HasOverride(&nID)) { // // Message overridden. Load replacement message // instead. // BOOL fSuccess; // // Attempt to load from calling process first // if (!(fSuccess = ::LoadString( ::GetModuleHandle(NULL), nID, szBuffer, cchBuffer ))) { // // Try this dll // fSuccess = ::LoadString( _Module.GetResourceInstance(), nID, szBuffer, cchBuffer ); } if (fSuccess) { // // Everything ok // return hrReturn; } // // Message didn't exist, skip the override, and // load as normal. // TRACE("Couldn't load %d\n", nID); ASSERT_MSG("Attempted override failed"); } LPCTSTR lpDll = NULL; HINSTANCE hDll = NULL; DWORD dwFacility = HRESULT_FACILITY(hrCode); DWORD dwSeverity = HRESULT_SEVERITY(hrCode); DWORD dwCode = HRESULT_CODE(hrCode); BOOL fSuccess = Succeeded(hrCode); // // Strip off meaningless internal facility codes // if (dwFacility == FACILITY_LANMAN || dwFacility == FACILITY_WINSOCK) { dwFacility = FACILITY_NULL; hrCode = (HRESULT)dwCode; } DWORD dwFlags = FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_MAX_WIDTH_MASK; // // Since we allow both HRESULTS and WIN32 codes to be // used here, we can't rely on the private FACILITY code // for lanman and winsock. // if(hrCode >= s_cdwMinLMErr && hrCode <= s_cdwMaxLMErr) { // // Lanman error // lpDll = s_cszLMDLL; } else if (hrCode >= s_cdwMinWSErr && hrCode <= s_cdwMaxWSErr) { // // Winsock error // lpDll = s_cszWSDLL; } else { // // Attempt to determine message location from facility code. // Check for registered facility first. // lpDll = FindFacility(dwFacility); if (lpDll == NULL) { if (dwFacility < s_cdwFacilities) { lpDll = s_cszFacility[dwFacility]; } else { ASSERT_MSG("Bogus FACILITY code encountered."); lpDll = NULL; } } } do { if (szBuffer == NULL || cchBuffer <= 0) { hrReturn = HResult(ERROR_INSUFFICIENT_BUFFER); break; } if (lpDll) { // // Load message file // hDll = ::LoadLibraryEx( lpDll, NULL, LOAD_LIBRARY_AS_DATAFILE ); if (hDll == NULL) { hrReturn = ::GetLastHRESULT(); break; } dwFlags |= FORMAT_MESSAGE_FROM_HMODULE; } else { dwFlags |= FORMAT_MESSAGE_FROM_SYSTEM; } DWORD dwResult = 0L; DWORD dwID = hrCode; HINSTANCE hSource = hDll; while(!dwResult) { dwResult = ::FormatMessage( dwFlags, (LPVOID)hSource, dwID, 0, szBuffer, cchBuffer, NULL ); if (dwResult > 0) { // // Successfully got a message // hrReturn = ERROR_SUCCESS; break; } hrReturn = ::GetLastHRESULT(); if (dwID != dwCode && !fSuccess) { // // Try the SCODE portion of the error from win32 // if this is an error message // dwID = dwCode; hSource = NULL; continue; } // // Failed to obtain a message // hrReturn = HResult(ERROR_FILE_NOT_FOUND); break; } } while(FALSE); if(hDll != NULL) { ::FreeLibrary(hDll); } if (Failed(hrReturn)) { // // Unable to find the message, synthesize something with // the code in it if there's room (+8 for the number) // CString & strMsg = (fSuccess ? *s_pstrDefSuccs : *s_pstrDefError); if (cchBuffer > (DWORD)strMsg.GetLength() + 8) { TRACE("Substituting default message for %d\n", (DWORD)m_hrCode); wsprintf(szBuffer, (LPCTSTR)strMsg, m_hrCode); } else { // // Not enough room for message code // ASSERT_MSG("Buffer too small for default message -- left blank"); *szBuffer = _T('\0'); } } return hrReturn; } HRESULT CError::TextFromHRESULT( OUT CString & strBuffer ) const /*++ Routine Description: Similar to the function above, but use a CString Arguments: HRESULT hrCode HRESULT or (DWORD WIN32 error) whose message to get CString & strBuffer Buffer to load message text into Return Value: HRESULT error code depending on whether the message was found. If the message was not found, some generic message is synthesized in the buffer if a buffer is provided. ERROR_FILE_NOT_FOUND No message found --*/ { DWORD cchBuffer = 255; HRESULT hr = S_OK; LPTSTR p = NULL; for (;;) { p = strBuffer.get_allocator().allocate(cchBuffer, p); if (p == NULL) { return HResult(ERROR_NOT_ENOUGH_MEMORY); } hr = TextFromHRESULT(p, cchBuffer - 1); if (Win32Error(hr) != ERROR_INSUFFICIENT_BUFFER) { // // Done! // strBuffer.assign(p); break; } // // Insufficient buffer, enlarge and try again // cchBuffer *= 2; } if (p != NULL) { strBuffer.get_allocator().deallocate(p, cchBuffer); } return hr; } BOOL CError::ExpandEscapeCode( IN LPTSTR szBuffer, IN DWORD cchBuffer, OUT IN LPTSTR & lp, IN CString & strReplacement, OUT HRESULT & hr ) const /*++ Routine Description: Expand escape code Arguments: LPTSTR szBuffer Buffer DWORD cchBuffer Size of buffer LPTSTR & lp Pointer to escape code CString & strReplacement Message to replace the escape code HRESULT & hr Returns HRESULT in case of failure Return Value: TRUE if the replacement was successful, FALSE otherwise. In the case of failure, hr will return an HRESULT. In the case of success, lp will be advanced past the replacement string. --*/ { // // Make sure there's room (account for terminating NULL) // Free up 2 spaces for the escape code. // int cchFmt = lstrlen(szBuffer) - 2; int cchReplacement = strReplacement.GetLength(); int cchRemainder = lstrlen(lp + 2); if ((DWORD)(cchReplacement + cchFmt) < cchBuffer) { // // Put it in // MoveMemory( lp + cchReplacement, lp + 2, (cchRemainder + 1) * sizeof(TCHAR) ); CopyMemory(lp, strReplacement, cchReplacement * sizeof(TCHAR)); lp += cchReplacement; return TRUE; } hr = HResult(ERROR_INSUFFICIENT_BUFFER); return FALSE; } LPCTSTR CError::TextFromHRESULTExpand( OUT LPTSTR szBuffer, OUT DWORD cchBuffer, OUT HRESULT * phResult OPTIONAL ) const /*++ Routine Description: Expand %h/%H strings in szBuffer to text from HRESULT, or error code respectively within the limits of szBuffer. Arguments: LPTSTR szBuffer Buffer to load message text into DWORD cchBuffer Buffer size in characters HRESULT * phResult Optional return code Return Value: Pointer to string. --*/ { HRESULT hr = S_OK; if (szBuffer == NULL || cchBuffer <= 0) { hr = HResult(ERROR_INSUFFICIENT_BUFFER); } else { // // Look for the escape sequence // int cReplacements = 0; CString strMessage; LPTSTR lp = szBuffer; while (*lp) { if (*lp == s_chEscape) { switch(*(lp + 1)) { case s_chEscText: // // Replace escape code with text message // hr = TextFromHRESULT(strMessage); if (ExpandEscapeCode( szBuffer, cchBuffer, lp, strMessage, hr )) { ++cReplacements; } break; case s_chEscNumber: // // Replace escape code with numeric error code // strMessage.Format(_T("0x%08x"), m_hrCode); if (ExpandEscapeCode( szBuffer, cchBuffer, lp, strMessage, hr )) { ++cReplacements; } break; default: // // Regular printf-style escape sequence. // break; } } ++lp; } if (!cReplacements) { // // Got to the end without finding any escape codes. // hr = HResult(ERROR_INVALID_PARAMETER); } } if (phResult) { *phResult = hr; } return szBuffer; } LPCTSTR CError::TextFromHRESULTExpand( OUT CString & strBuffer ) const /*++ Routine Description: Expand %h string in strBuffer to text from HRESULT Arguments: CString & strBuffer Buffer to load message text into Return Value: Pointer to string. --*/ { DWORD cchBuffer = strBuffer.GetLength() + 1024; LPTSTR p = NULL; for (;;) { p = strBuffer.get_allocator().allocate(cchBuffer, p); if (p != NULL) { HRESULT hr; TextFromHRESULTExpand(p, cchBuffer - 1, &hr); if (Win32Error(hr) != ERROR_INSUFFICIENT_BUFFER) { // // Done! // strBuffer.assign(p); break; } // // Insufficient buffer, enlarge and try again // cchBuffer *= 2; } } if (p != NULL) { strBuffer.get_allocator().deallocate(p, cchBuffer); } return strBuffer; }