HRESULT
COMError::GenerateError(HM::String sDescription)
{
if (sDescription == _T(""))
{
sDescription = "The operation failed. Please check the hMailServer log for details.";
}
// Get the ICreateErrorInfo Interface
ICreateErrorInfo *pCreateErrorInfo = NULL;
HRESULT hSuccess = CreateErrorInfo(&pCreateErrorInfo);
ATLASSERT(SUCCEEDED(hSuccess));
// pCreateErrorInfo->SetGUID(CLSID_BaseApp);
pCreateErrorInfo->SetDescription(sDescription.AllocSysString());
HM::String sSource = "hMailServer COM library";
pCreateErrorInfo->SetSource(sSource.AllocSysString());
IErrorInfo *pErrInfo;
if (SUCCEEDED(pCreateErrorInfo->QueryInterface(IID_IErrorInfo,
reinterpret_cast<void**>(&pErrInfo))))
{
SetErrorInfo(0, pErrInfo);
pErrInfo->Release();
}
pCreateErrorInfo->Release();
return MAKE_HRESULT(1, FACILITY_ITF, 1001);
}
// Given an EXCEPINFO, register the error information with the
// IErrorInfo interface.
BOOL PyCom_SetCOMErrorFromExcepInfo(const EXCEPINFO *pexcepinfo, REFIID riid)
{
ICreateErrorInfo *pICEI;
HRESULT hr = CreateErrorInfo(&pICEI);
if ( SUCCEEDED(hr) )
{
pICEI->SetGUID(riid);
pICEI->SetHelpContext(pexcepinfo->dwHelpContext);
if ( pexcepinfo->bstrDescription )
pICEI->SetDescription(pexcepinfo->bstrDescription);
if ( pexcepinfo->bstrHelpFile )
pICEI->SetHelpFile(pexcepinfo->bstrHelpFile);
if ( pexcepinfo->bstrSource )
pICEI->SetSource(pexcepinfo->bstrSource);
IErrorInfo *pIEI;
Py_BEGIN_ALLOW_THREADS
hr = pICEI->QueryInterface(IID_IErrorInfo, (LPVOID*) &pIEI);
Py_END_ALLOW_THREADS
if ( SUCCEEDED(hr) )
{
SetErrorInfo(0, pIEI);
pIEI->Release();
}
pICEI->Release();
}
return SUCCEEDED(hr);
}
// The CreateComErrorInfo function uses CreateErrorInfo to create error
// object, which is then filled with the error information and passed to
// the acceptor by a call to SetErrorInfo.
void CreateComErrorInfo(const char* description, const char* source,
const char* helpFile, UInt32 helpContext)
{
ICreateErrorInfo* createErrInfo;
IErrorInfo* errInfo;
std::basic_string<wchar_t> buf;
if (CreateErrorInfo(&createErrInfo) == S_OK)
{
createErrInfo->SetGUID(IID_IErrorInfo);
if (description != NULL)
{
buf = WideStringFromMultiByteString(description);
createErrInfo->SetDescription(const_cast<wchar_t*>(buf.c_str()));
}
if (source != NULL)
{
buf = WideStringFromMultiByteString(source);
createErrInfo->SetSource(const_cast<wchar_t*>(buf.c_str()));
}
if (helpFile != NULL)
{
buf = WideStringFromMultiByteString(helpFile);
createErrInfo->SetHelpFile(const_cast<wchar_t*>(buf.c_str()));
}
createErrInfo->SetHelpContext(helpContext);
if (createErrInfo->QueryInterface(IID_IErrorInfo, (void**)(&errInfo)) == S_OK)
{
SetErrorInfo(0, errInfo);
errInfo->Release();
}
createErrInfo->Release();
}
}
void VLCSupportErrorInfo::setErrorInfo(LPCOLESTR progid, REFIID riid, const char *description)
{
BSTR bstrDescription = BSTRFromCStr(CP_UTF8, description);
if( NULL != bstrDescription )
{
ICreateErrorInfo* pcerrinfo;
HRESULT hr = CreateErrorInfo(&pcerrinfo);
if( SUCCEEDED(hr) )
{
IErrorInfo* perrinfo;
pcerrinfo->SetSource((LPOLESTR)progid);
pcerrinfo->SetGUID(riid);
pcerrinfo->SetDescription((LPOLESTR)bstrDescription);
hr = pcerrinfo->QueryInterface(IID_IErrorInfo, (LPVOID*) &perrinfo);
if( SUCCEEDED(hr) )
{
::SetErrorInfo(0, perrinfo);
perrinfo->Release();
}
pcerrinfo->Release();
}
SysFreeString(bstrDescription);
}
};
//
//
// makes an HRESULT with a code based on the DOM error code
//
HRESULT MakeHRESULT(DOMException& ex)
{
ICreateErrorInfo* pCErr = NULL;
HRESULT sc = CreateErrorInfo(&pCErr);
if(SUCCEEDED(sc)) {
const XMLCh* msg = ex.msg;
if(msg == NULL)
{
if(ex.code >= DOMException::INDEX_SIZE_ERR &&
ex.code <= DOMException::VALIDATION_ERR)
{
sc = pCErr->SetDescription(Msgs[ex.code]);
}
else
{
sc = pCErr->SetDescription(Msgs[0]);
}
}
else
{
sc = pCErr->SetDescription(SysAllocString(ex.msg));
}
IErrorInfo* pErr = NULL;
sc = pCErr->QueryInterface(IID_IErrorInfo,(void**) &pErr);
if(SUCCEEDED(sc))
{
sc = SetErrorInfo(0,pErr);
pErr->Release();
}
pCErr->Release();
}
return 0x80040600 + ex.code;
}
STDMETHODIMP nsXPCDispTestMethods::CreateError()
{
CComBSTR someText(L"CreateError Test");
ICreateErrorInfo * pCreateError;
IErrorInfo * pError;
HRESULT result = CreateErrorInfo(&pCreateError);
if (FAILED(result))
return E_NOTIMPL;
result = pCreateError->QueryInterface(&pError);
if (FAILED(result))
return E_NOTIMPL;
result = pCreateError->SetDescription(someText);
if (FAILED(result))
return E_NOTIMPL;
result = pCreateError->SetGUID(IID_nsIXPCDispTestMethods);
if (FAILED(result))
return E_NOTIMPL;
CComBSTR source(L"XPCIDispatchTest.nsXPCDispTestMethods.1");
result = pCreateError->SetSource(source);
if (FAILED(result))
return E_NOTIMPL;
result = SetErrorInfo(0, pError);
if (FAILED(result))
return E_NOTIMPL;
pError->Release();
pCreateError->Release();
return E_FAIL;
}
//---------------------------------------------------------------------------
// RaiseException
//
// Raises an exception using the given source and description
//---------------------------------------------------------------------------
void
CAdRotator::RaiseException (
LPOLESTR strDescr
)
{
HRESULT hr;
ICreateErrorInfo *pICreateErr;
IErrorInfo *pIErr;
LANGID langID = LANG_NEUTRAL;
/*
* Thread-safe exception handling means that we call
* CreateErrorInfo which gives us an ICreateErrorInfo pointer
* that we then use to set the error information (basically
* to set the fields of an EXCEPINFO structure. We then
* call SetErrorInfo to attach this error to the current
* thread. ITypeInfo::Invoke will look for this when it
* returns from whatever function was invokes by calling
* GetErrorInfo.
*/
WCHAR strSource[MAX_RESSTRINGSIZE];
if ( ::LoadStringW(
_Module.GetResourceInstance(),
IDS_ERROR_SOURCE,
strSource,
MAX_RESSTRINGSIZE ) > 0 )
{
//Not much we can do if this fails.
if (!FAILED(CreateErrorInfo(&pICreateErr)))
{
pICreateErr->SetGUID(CLSID_AdRotator);
pICreateErr->SetHelpFile(L"");
pICreateErr->SetHelpContext(0L);
pICreateErr->SetSource(strSource);
pICreateErr->SetDescription(strDescr);
hr = pICreateErr->QueryInterface(IID_IErrorInfo, (void**)&pIErr);
if (SUCCEEDED(hr))
{
if(SUCCEEDED(SetErrorInfo(0L, pIErr)))
{
pIErr->Release();
}
}
}
pICreateErr->Release();
}
}
template <class T> HRESULT SepaControlDispatch<T>::SetErrorInfo(const wchar_t *pMessage) const
{
ICreateErrorInfo *pCreateErrorInfo;
IErrorInfo *pErrorInfo;
if (SUCCEEDED(CreateErrorInfo(&pCreateErrorInfo)))
{
pCreateErrorInfo->SetDescription(_bstr_t(pMessage).Detach());
pCreateErrorInfo->SetGUID(__uuidof(this));
pCreateErrorInfo->SetSource(_bstr_t(TEXT("Separatista")).Detach());
if (SUCCEEDED(pCreateErrorInfo->QueryInterface(IID_IErrorInfo, (LPVOID*)&pErrorInfo)))
{
::SetErrorInfo(0, pErrorInfo);
pErrorInfo->Release();
}
pCreateErrorInfo->Release();
}
return DISP_E_EXCEPTION;
}
HRESULT ComErrorInfo(const CLSID& clsid, REFIID riid, IErrorInfo ** ppErrInfo, LPCTSTR pszDesc)
{
USES_CONVERSION;
ICreateErrorInfo* pcei = NULL;
IErrorInfo * pei = NULL;
LPOLESTR lpsz;
if(ppErrInfo == NULL) {
return E_POINTER;
}
*ppErrInfo = NULL;
if(clsid == CLSID_NULL) {
return S_FALSE;
}
HRESULT hr = CreateErrorInfo(&pcei);
if(FAILED(hr)) {
return hr;
}
ProgIDFromCLSID(clsid, &lpsz);
if (lpsz != NULL) {
pcei->SetSource(lpsz);
::CoTaskMemFree(lpsz);
}
lpsz = T2OLE(pszDesc);
pcei->SetDescription(lpsz);
//Interface ID of the interface whose method is throwing the Except.
pcei->SetGUID(riid);
hr = pcei->QueryInterface(IID_IErrorInfo, (void**) &pei);
if(SUCCEEDED(hr)) {
*ppErrInfo = pei;
}
pcei->Release();
return hr;
}
void CMarshalErrorInfo::GenerateErrorInfo(REFGUID rGUID,
_bstr_t source, _bstr_t message)
{
ICreateErrorInfo* pCreateInfo = NULL;
IErrorInfo* pErrorInfo = NULL;
// 创建ICreateErrorInfo对象
CreateErrorInfo(&pCreateInfo);
// 设置属性值
pCreateInfo->SetGUID(rGUID);
pCreateInfo->SetSource(source);
pCreateInfo->SetDescription(message);
// 获得pCreateInfo的IErrorInfo接口引用
pCreateInfo->QueryInterface(IID_IErrorInfo, (void**)&pErrorInfo);
// 设置IErrorInfo
SetErrorInfo(0,pErrorInfo);
// 释放对象
pErrorInfo->Release();
pCreateInfo->Release();
}
HRESULT DualHandleException(REFIID riidSource, const CException* pAnyException)
{
USES_CONVERSION;
ASSERT_VALID(pAnyException);
TRACE0("DualHandleException called\n");
// Set ErrInfo object so that VTLB binding container
// applications can get rich error information.
ICreateErrorInfo* pcerrinfo;
HRESULT hr = CreateErrorInfo(&pcerrinfo);
if (SUCCEEDED(hr))
{
TCHAR szDescription[256];
LPCTSTR pszDescription = szDescription;
GUID guid = GUID_NULL;
DWORD dwHelpContext = 0;
BSTR bstrHelpFile = NULL;
BSTR bstrSource = NULL;
if (pAnyException->IsKindOf(RUNTIME_CLASS(COleDispatchException)))
{
// specific IDispatch style exception
COleDispatchException* e = (COleDispatchException*)pAnyException;
guid = riidSource;
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF,
(e->m_wCode + 0x200));
pszDescription = e->m_strDescription;
dwHelpContext = e->m_dwHelpContext;
// propagate source and help file if present
// call ::SysAllocString directly so no further exceptions are thrown
if (!e->m_strHelpFile.IsEmpty())
bstrHelpFile = ::SysAllocString(T2COLE(e->m_strHelpFile));
if (!e->m_strSource.IsEmpty())
bstrSource = ::SysAllocString(T2COLE(e->m_strSource));
}
else if (pAnyException->IsKindOf(RUNTIME_CLASS(CMemoryException)))
{
// failed memory allocation
AfxLoadString(AFX_IDP_FAILED_MEMORY_ALLOC, szDescription);
hr = E_OUTOFMEMORY;
}
else
{
// other unknown/uncommon error
AfxLoadString(AFX_IDP_INTERNAL_FAILURE, szDescription);
hr = E_UNEXPECTED;
}
if (bstrHelpFile == NULL && dwHelpContext != 0)
bstrHelpFile = ::SysAllocString(T2COLE(AfxGetApp()->m_pszHelpFilePath));
if (bstrSource == NULL)
bstrSource = ::SysAllocString(T2COLE(AfxGetAppName()));
// Set up ErrInfo object
pcerrinfo->SetGUID(guid);
pcerrinfo->SetDescription(::SysAllocString(T2COLE(pszDescription)));
pcerrinfo->SetHelpContext(dwHelpContext);
pcerrinfo->SetHelpFile(bstrHelpFile);
pcerrinfo->SetSource(bstrSource);
TRACE(_T("\tSource = %ws\n"), bstrSource);
TRACE(_T("\tDescription = %s\n"), pszDescription);
TRACE(_T("\tHelpContext = %lx\n"), dwHelpContext);
TRACE(_T("\tHelpFile = %ws\n"), bstrHelpFile);
// Set the ErrInfo object for the current thread
IErrorInfo* perrinfo;
if (SUCCEEDED(pcerrinfo->QueryInterface(IID_IErrorInfo, (LPVOID*)&perrinfo)))
{
SetErrorInfo(0, perrinfo);
perrinfo->Release();
}
pcerrinfo->Release();
}
TRACE(_T("DualHandleException returning HRESULT %lx\n"), hr);
return hr;
}
HRESULT
ceDispatchSetErrorInfoSub(
IN HRESULT hrError,
OPTIONAL IN WCHAR const *pwszIDispatchMethod,
OPTIONAL IN WCHAR const *pwszDescription,
OPTIONAL IN WCHAR const *pwszSource,
OPTIONAL IN IID const *piid,
OPTIONAL IN WCHAR const *pwszHelpFile,
IN DWORD dwHelpFileContext)
{
HRESULT hr;
WCHAR const *pwszError = NULL;
ICreateErrorInfo *pCreateErrorInfo = NULL;
IErrorInfo *pErrorInfo = NULL;
if (NULL != pwszIDispatchMethod)
{
pwszError = ceGetErrorMessageText(hrError, TRUE);
}
hr = CreateErrorInfo(&pCreateErrorInfo);
_JumpIfError(hr, error, "CreateErrorInfo");
if (NULL != piid)
{
hr = pCreateErrorInfo->SetGUID(*piid);
_PrintIfError(hr, "SetGUID");
}
if (NULL != pwszSource)
{
hr = pCreateErrorInfo->SetSource(const_cast<WCHAR *>(pwszSource));
_PrintIfError(hr, "SetSource");
}
if (NULL != pwszDescription)
{
hr = pCreateErrorInfo->SetDescription(
const_cast<WCHAR *>(pwszDescription));
_PrintIfError(hr, "SetDescription");
}
if (NULL != pwszHelpFile)
{
hr = pCreateErrorInfo->SetHelpFile(const_cast<WCHAR *>(pwszHelpFile));
_PrintIfError(hr, "SetHelpFile");
hr = pCreateErrorInfo->SetHelpContext(dwHelpFileContext);
_PrintIfError(hr, "SetHelpContext");
}
hr = pCreateErrorInfo->QueryInterface(
IID_IErrorInfo,
(VOID **) &pErrorInfo);
_JumpIfError(hr, error, "QueryInterface");
SetErrorInfo(0, pErrorInfo);
hr = S_OK;
error:
if (NULL != pwszError)
{
LocalFree(const_cast<WCHAR *>(pwszError));
}
if (NULL != pErrorInfo)
{
pErrorInfo->Release();
}
if (NULL != pCreateErrorInfo)
{
pCreateErrorInfo->Release();
}
return(hr);
}
// Throws the given error code and the message corresponding to the code. If the code is
// a standard code and no message is provided, then the message is extracted from the system.
HRESULT CCOMError::DispatchError(HRESULT hError, REFCLSID clsid, LPCTSTR source, LPCTSTR description,
DWORD helpContext, LPCTSTR helpFileName)
{
// This function uses ATL conversion macros
// (Hence we must use this MACRO provided by ATL)
USES_CONVERSION;
// Convert the description to OLE string
LPOLESTR wszError = NULL;
if(description != NULL)
{
// Convert to wide char
wszError = T2OLE(description);
}
else
{
// If the code is a Win32 error code
if(HRESULT_FACILITY(hError) == FACILITY_WIN32)
{
// Get the error from the system
LPTSTR szError = NULL;
if(!::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
NULL,
HRESULT_CODE(hError),
MAKELANGID(LANG_USER_DEFAULT, SUBLANG_DEFAULT),
(LPTSTR)&szError,
0,
NULL))
return HRESULT_FROM_WIN32(GetLastError());
// Convert the Error multibyte string to OLE string
if(szError != NULL)
{
// Convert to wide char
wszError = T2OLE(szError);
// Free the multibyte string
LocalFree(szError);
}
}
}
// Convert the source string to OLE string
LPOLESTR wszSource = NULL;
if(source != NULL)
wszSource = T2OLE(source);
// Convert the help filename to OLE string
LPOLESTR wszHelpFile = NULL;
if(helpFileName != NULL)
wszHelpFile = T2OLE(helpFileName);
// Get the ICreateErrorInfo Interface
ICreateErrorInfo *pCreateErrorInfo = NULL;
HRESULT hSuccess = CreateErrorInfo(&pCreateErrorInfo);
ATLASSERT(SUCCEEDED(hSuccess));
// Fill the error information into it
pCreateErrorInfo->SetGUID(clsid);
if(wszError != NULL)
pCreateErrorInfo->SetDescription(wszError);
if(wszSource != NULL)
pCreateErrorInfo->SetSource(wszSource);
if(wszHelpFile != NULL)
pCreateErrorInfo->SetHelpFile(wszHelpFile);
pCreateErrorInfo->SetHelpContext(helpContext);
// Get the IErrorInfo interface
IErrorInfo *pErrorInfo = NULL;
hSuccess = pCreateErrorInfo->QueryInterface(IID_IErrorInfo, (LPVOID *)&pErrorInfo);
if(FAILED(hSuccess))
{
pCreateErrorInfo->Release();
return hSuccess;
}
// Set this error information in the current thread
hSuccess = SetErrorInfo(0, pErrorInfo);
// Finally release the interfaces
pCreateErrorInfo->Release();
pErrorInfo->Release();
// Failed to set the error info!
if(FAILED(hSuccess))
return hSuccess;
// And, Return the error code that was asked
// to be dispatched
HRESULT result = MAKE_HRESULT(1, FACILITY_ITF, hError);
return result;
}
