HRESULT CALLBACK IAccessor_CreateAccessor_Proxy(IAccessor* This, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings,
const DBBINDING rgBindings[], DBLENGTH cbRowSize, HACCESSOR *phAccessor,
DBBINDSTATUS rgStatus[])
{
HRESULT hr;
IErrorInfo *error;
DBCOUNTITEM i;
TRACE("(%p)->(%08x, %d, %p, %d, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings,
cbRowSize, phAccessor, rgStatus);
for(i = 0; i < cBindings; i++)
{
TRACE("%d: ord %d val off %d len off %d stat off %d part %04x mem_owner %d max_len %d type %04x\n",
i, rgBindings[i].iOrdinal, rgBindings[i].obValue, rgBindings[i].obLength, rgBindings[i].obStatus,
rgBindings[i].dwPart, rgBindings[i].dwMemOwner, rgBindings[i].cbMaxLen, rgBindings[i].wType);
}
hr = IAccessor_RemoteCreateAccessor_Proxy(This, dwAccessorFlags, cBindings, (DBBINDING *)rgBindings,
cbRowSize, phAccessor, rgStatus, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
TRACE("returning %08x accessor %lx\n", hr, *phAccessor);
return hr;
}
HRESULT CALLBACK ISessionProperties_SetProperties_Proxy(ISessionProperties* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
{
ULONG prop_set, prop, total_props = 0;
HRESULT hr;
IErrorInfo *error;
DBPROPSTATUS *status;
TRACE("(%p, %d, %p)\n", This, cPropertySets, rgPropertySets);
for(prop_set = 0; prop_set < cPropertySets; prop_set++)
total_props += rgPropertySets[prop_set].cProperties;
if(total_props == 0) return S_OK;
status = CoTaskMemAlloc(total_props * sizeof(*status));
if(!status) return E_OUTOFMEMORY;
hr = ISessionProperties_RemoteSetProperties_Proxy(This, cPropertySets, rgPropertySets,
total_props, status, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
total_props = 0;
for(prop_set = 0; prop_set < cPropertySets; prop_set++)
for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
CoTaskMemFree(status);
return hr;
}
HRESULT CALLBACK IRowsetInfo_GetProperties_Proxy(IRowsetInfo* This, const ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
{
HRESULT hr;
IErrorInfo *error;
ULONG i;
TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
for(i = 0; i < cPropertyIDSets; i++)
{
int j;
TRACE("%d: %s %d props\n", i, debugstr_guid(&rgPropertyIDSets[i].guidPropertySet), rgPropertyIDSets[i].cPropertyIDs);
for(j = 0; j < rgPropertyIDSets[i].cPropertyIDs; j++)
TRACE("\t%d: prop id %d\n", j, rgPropertyIDSets[i].rgPropertyIDs[j]);
}
hr = IRowsetInfo_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
/***********************************************************************
* CreateErrorInfo (OLE32.@)
*
* Creates an object used to set details for an error info object.
*
* PARAMS
* pperrinfo [O]. Address where error info creation object will be stored.
*
* RETURNS
* Success: S_OK.
* Failure: HRESULT code.
*/
HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo **pperrinfo)
{
IErrorInfo * pei;
HRESULT res;
TRACE("(%p)\n", pperrinfo);
if(! pperrinfo ) return E_INVALIDARG;
if(!(pei=IErrorInfoImpl_Constructor()))return E_OUTOFMEMORY;
res = IErrorInfo_QueryInterface(pei, &IID_ICreateErrorInfo, (LPVOID*)pperrinfo);
IErrorInfo_Release(pei);
return res;
}
/**
* Print detailed error information if available.
* @param pszExecutable string with the executable name
* @param pszErrorMsg string containing the code location specific error message
* @param rc COM/XPCOM result code
*/
static void PrintErrorInfo(const char *pszExecutable, const char *pszErrorMsg, HRESULT rc)
{
IErrorInfo *ex;
HRESULT rc2 = S_OK;
fprintf(stderr, "%s: %s (rc=%#010x)\n", pszExecutable, pszErrorMsg, (unsigned)rc);
rc2 = g_pVBoxFuncs->pfnGetException(&ex);
if (SUCCEEDED(rc2))
{
IVirtualBoxErrorInfo *ei;
rc2 = IErrorInfo_QueryInterface(ex, &IID_IVirtualBoxErrorInfo, (void **)&ei);
if (FAILED(rc2))
ei = NULL;
if (ei)
{
/* got extended error info, maybe multiple infos */
do
{
LONG resultCode = S_OK;
BSTR componentUtf16 = NULL;
char *component = NULL;
BSTR textUtf16 = NULL;
char *text = NULL;
IVirtualBoxErrorInfo *ei_next = NULL;
fprintf(stderr, "Extended error info (IVirtualBoxErrorInfo):\n");
IVirtualBoxErrorInfo_get_ResultCode(ei, &resultCode);
fprintf(stderr, " resultCode=%#010x\n", (unsigned)resultCode);
IVirtualBoxErrorInfo_get_Component(ei, &componentUtf16);
g_pVBoxFuncs->pfnUtf16ToUtf8(componentUtf16, &component);
g_pVBoxFuncs->pfnComUnallocString(componentUtf16);
fprintf(stderr, " component=%s\n", component);
g_pVBoxFuncs->pfnUtf8Free(component);
IVirtualBoxErrorInfo_get_Text(ei, &textUtf16);
g_pVBoxFuncs->pfnUtf16ToUtf8(textUtf16, &text);
g_pVBoxFuncs->pfnComUnallocString(textUtf16);
fprintf(stderr, " text=%s\n", text);
g_pVBoxFuncs->pfnUtf8Free(text);
rc2 = IVirtualBoxErrorInfo_get_Next(ei, &ei_next);
if (FAILED(rc2))
ei_next = NULL;
IVirtualBoxErrorInfo_Release(ei);
ei = ei_next;
}
while (ei);
}
IErrorInfo_Release(ex);
g_pVBoxFuncs->pfnClearException();
}
}
HRESULT CALLBACK IDBInitialize_Initialize_Proxy(IDBInitialize* This)
{
HRESULT hr;
IErrorInfo *error;
TRACE("(%p)\n", This);
hr = IDBInitialize_RemoteInitialize_Proxy(This, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
HRESULT CALLBACK IDBDataSourceAdmin_DestroyDataSource_Proxy(IDBDataSourceAdmin* This)
{
IErrorInfo *error;
HRESULT hr;
TRACE("(%p)\n", This);
hr = IDBDataSourceAdmin_RemoteDestroyDataSource_Proxy(This, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
HRESULT CALLBACK ICommandText_SetCommandText_Proxy(ICommandText* This, REFGUID rguidDialect, LPCOLESTR pwszCommand)
{
HRESULT hr;
IErrorInfo *error;
TRACE("(%p)->(%s, %s)\n", This, debugstr_guid(rguidDialect), debugstr_w(pwszCommand));
hr = ICommandText_RemoteSetCommandText_Proxy(This, rguidDialect, pwszCommand, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
HRESULT CALLBACK IDBCreateSession_CreateSession_Proxy(IDBCreateSession* This, IUnknown *pUnkOuter,
REFIID riid, IUnknown **ppDBSession)
{
HRESULT hr;
IErrorInfo *error;
TRACE("(%p, %p, %s, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppDBSession);
hr = IDBCreateSession_RemoteCreateSession_Proxy(This, pUnkOuter, riid, ppDBSession, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
HRESULT CALLBACK IDBDataSourceAdmin_ModifyDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
{
IErrorInfo *error;
HRESULT hr;
TRACE("(%p, %d, %p)\n", This, cPropertySets, rgPropertySets);
hr = IDBDataSourceAdmin_RemoteModifyDataSource_Proxy(This, cPropertySets, rgPropertySets, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
HRESULT CALLBACK IDBProperties_GetProperties_Proxy(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
{
HRESULT hr;
IErrorInfo *error;
TRACE("(%p, %d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets,
prgPropertySets);
hr = IDBProperties_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets,
pcPropertySets, prgPropertySets, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
HRESULT CALLBACK IAccessor_ReleaseAccessor_Proxy(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
{
HRESULT hr;
IErrorInfo *error;
DBREFCOUNT ref;
TRACE("(%p)->(%lx, %p)\n", This, hAccessor, pcRefCount);
hr = IAccessor_RemoteReleaseAccessor_Proxy(This, hAccessor, &ref, &error);
if(pcRefCount) *pcRefCount = ref;
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
return hr;
}
/***********************************************************************
* SetErrorInfo (OLE32.@)
*
* Sets the error information object for the current thread.
*
* PARAMS
* dwReserved [I] Reserved. Must be zero.
* perrinfo [I] Error info object.
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG if dwReserved is not zero.
*/
HRESULT WINAPI SetErrorInfo(ULONG dwReserved, IErrorInfo *perrinfo)
{
IErrorInfo * pei;
TRACE("(%d, %p)\n", dwReserved, perrinfo);
if (dwReserved)
{
ERR("dwReserved (0x%x) != 0\n", dwReserved);
return E_INVALIDARG;
}
/* release old errorinfo */
pei = COM_CurrentInfo()->errorinfo;
if (pei) IErrorInfo_Release(pei);
/* set to new value */
COM_CurrentInfo()->errorinfo = perrinfo;
if (perrinfo) IErrorInfo_AddRef(perrinfo);
return S_OK;
}
HRESULT CALLBACK IDBDataSourceAdmin_CreateDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets,
DBPROPSET rgPropertySets[], IUnknown *pUnkOuter,
REFIID riid, IUnknown **ppDBSession)
{
ULONG prop_set, prop, total_props = 0;
HRESULT hr;
IErrorInfo *error;
DBPROPSTATUS *status;
TRACE("(%p, %d, %p, %p, %s, %p)\n", This, cPropertySets, rgPropertySets, pUnkOuter,
debugstr_guid(riid), ppDBSession);
for(prop_set = 0; prop_set < cPropertySets; prop_set++)
total_props += rgPropertySets[prop_set].cProperties;
if(total_props == 0) return S_OK;
status = CoTaskMemAlloc(total_props * sizeof(*status));
if(!status) return E_OUTOFMEMORY;
hr = IDBDataSourceAdmin_RemoteCreateDataSource_Proxy(This, cPropertySets, rgPropertySets, pUnkOuter,
riid, ppDBSession, total_props, status, &error);
if(error)
{
SetErrorInfo(0, error);
IErrorInfo_Release(error);
}
total_props = 0;
for(prop_set = 0; prop_set < cPropertySets; prop_set++)
for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
CoTaskMemFree(status);
return hr;
}
static void test_error_info(void)
{
HRESULT hr;
ICreateErrorInfo *pCreateErrorInfo;
IErrorInfo *pErrorInfo;
static WCHAR wszDescription[] = {'F','a','i','l','e','d',' ','S','p','r','o','c','k','e','t',0};
static WCHAR wszHelpFile[] = {'s','p','r','o','c','k','e','t','.','h','l','p',0};
static WCHAR wszSource[] = {'s','p','r','o','c','k','e','t',0};
IUnknown *unk;
hr = CreateErrorInfo(&pCreateErrorInfo);
ok_ole_success(hr, "CreateErrorInfo");
hr = ICreateErrorInfo_QueryInterface(pCreateErrorInfo, &IID_IUnknown, (void**)&unk);
ok_ole_success(hr, "QI");
IUnknown_Release(unk);
hr = ICreateErrorInfo_SetDescription(pCreateErrorInfo, NULL);
ok_ole_success(hr, "ICreateErrorInfo_SetDescription");
hr = ICreateErrorInfo_SetDescription(pCreateErrorInfo, wszDescription);
ok_ole_success(hr, "ICreateErrorInfo_SetDescription");
hr = ICreateErrorInfo_SetGUID(pCreateErrorInfo, &CLSID_WineTest);
ok_ole_success(hr, "ICreateErrorInfo_SetGUID");
hr = ICreateErrorInfo_SetHelpContext(pCreateErrorInfo, 0xdeadbeef);
ok_ole_success(hr, "ICreateErrorInfo_SetHelpContext");
hr = ICreateErrorInfo_SetHelpFile(pCreateErrorInfo, NULL);
ok_ole_success(hr, "ICreateErrorInfo_SetHelpFile");
hr = ICreateErrorInfo_SetHelpFile(pCreateErrorInfo, wszHelpFile);
ok_ole_success(hr, "ICreateErrorInfo_SetHelpFile");
hr = ICreateErrorInfo_SetSource(pCreateErrorInfo, NULL);
ok_ole_success(hr, "ICreateErrorInfo_SetSource");
hr = ICreateErrorInfo_SetSource(pCreateErrorInfo, wszSource);
ok_ole_success(hr, "ICreateErrorInfo_SetSource");
hr = ICreateErrorInfo_QueryInterface(pCreateErrorInfo, &IID_IErrorInfo, (void **)&pErrorInfo);
ok_ole_success(hr, "ICreateErrorInfo_QueryInterface");
hr = IErrorInfo_QueryInterface(pErrorInfo, &IID_IUnknown, (void**)&unk);
ok_ole_success(hr, "QI");
IUnknown_Release(unk);
ICreateErrorInfo_Release(pCreateErrorInfo);
hr = SetErrorInfo(0, pErrorInfo);
ok_ole_success(hr, "SetErrorInfo");
IErrorInfo_Release(pErrorInfo);
pErrorInfo = NULL;
hr = GetErrorInfo(0, &pErrorInfo);
ok_ole_success(hr, "GetErrorInfo");
IErrorInfo_Release(pErrorInfo);
hr = GetErrorInfo(0, &pErrorInfo);
ok(hr == S_FALSE, "GetErrorInfo should have returned S_FALSE instead of 0x%08x\n", hr);
ok(!pErrorInfo, "pErrorInfo should be set to NULL\n");
hr = SetErrorInfo(0, NULL);
ok_ole_success(hr, "SetErrorInfo");
hr = GetErrorInfo(0xdeadbeef, &pErrorInfo);
ok(hr == E_INVALIDARG, "GetErrorInfo should have returned E_INVALIDARG instead of 0x%08x\n", hr);
hr = SetErrorInfo(0xdeadbeef, NULL);
ok(hr == E_INVALIDARG, "SetErrorInfo should have returned E_INVALIDARG instead of 0x%08x\n", hr);
}
static ULONG WINAPI WINAPI errorrec_Release(IErrorRecords *iface)
{
errorrecords *This = impl_from_IErrorRecords(iface);
return IErrorInfo_Release(&This->IErrorInfo_iface);
}
static void test_errorinfo(void)
{
HRESULT hr;
IUnknown *unk = NULL;
hr = CoCreateInstance(&CSLID_MSDAER, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown,(void**)&unk);
ok(hr == S_OK, "got %08x\n", hr);
if(hr == S_OK)
{
IErrorInfo *errorinfo;
IErrorRecords *errrecs;
hr = IUnknown_QueryInterface(unk, &IID_IErrorInfo, (void**)&errorinfo);
ok(hr == S_OK, "got %08x\n", hr);
if(hr == S_OK)
{
IErrorInfo_Release(errorinfo);
}
hr = IUnknown_QueryInterface(unk, &IID_IErrorRecords, (void**)&errrecs);
ok(hr == S_OK, "got %08x\n", hr);
if(hr == S_OK)
{
ERRORINFO info, info2, info3;
ULONG cnt = 0;
memset(&info, 0, sizeof(ERRORINFO));
info.dwMinor = 1;
memset(&info2, 0, sizeof(ERRORINFO));
info2.dwMinor = 2;
memset(&info3, 0, sizeof(ERRORINFO));
hr = IErrorRecords_AddErrorRecord(errrecs, NULL, 268435456, NULL, NULL, 0);
ok(hr == E_INVALIDARG, "got %08x\n", hr);
hr = IErrorRecords_AddErrorRecord(errrecs, &info, 1, NULL, NULL, 0);
ok(hr == S_OK, "got %08x\n", hr);
hr = IErrorRecords_GetRecordCount(errrecs, &cnt);
ok(hr == S_OK, "got %08x\n", hr);
ok(cnt == 1, "expected 1 got %d\n", cnt);
hr = IErrorRecords_AddErrorRecord(errrecs, &info2, 2, NULL, NULL, 0);
ok(hr == S_OK, "got %08x\n", hr);
hr = IErrorRecords_GetRecordCount(errrecs, &cnt);
ok(hr == S_OK, "got %08x\n", hr);
ok(cnt == 2, "expected 2 got %d\n", cnt);
hr = IErrorRecords_GetBasicErrorInfo(errrecs, 0, NULL);
ok(hr == E_INVALIDARG, "got %08x\n", hr);
hr = IErrorRecords_GetBasicErrorInfo(errrecs, 100, &info3);
ok(hr == DB_E_BADRECORDNUM, "got %08x\n", hr);
hr = IErrorRecords_GetBasicErrorInfo(errrecs, 0, &info3);
todo_wine ok(hr == S_OK, "got %08x\n", hr);
if(hr == S_OK)
{
ok(info3.dwMinor == 2, "expected 2 got %d\n", info3.dwMinor);
}
IErrorRecords_Release(errrecs);
}
IUnknown_Release(unk);
}
}
static ULONG WINAPI ISupportErrorInfoImpl_Release(ISupportErrorInfo* iface)
{
ErrorInfoImpl *This = impl_from_ISupportErrorInfo(iface);
return IErrorInfo_Release(&This->IErrorInfo_iface);
}
