| /* |
| * Misc marshaling routines |
| * |
| * Copyright 2009 Huw Davies |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| #include <stdarg.h> |
| #include <string.h> |
| |
| #define COBJMACROS |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wingdi.h" |
| #include "winuser.h" |
| #include "winerror.h" |
| #include "objbase.h" |
| #include "oleauto.h" |
| #include "oledb.h" |
| |
| #include "row_server.h" |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(oledb); |
| |
| HRESULT CALLBACK IDBCreateCommand_CreateCommand_Proxy(IDBCreateCommand* This, IUnknown *pUnkOuter, |
| REFIID riid, IUnknown **ppCommand) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p, %p, %s, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppCommand); |
| hr = IDBCreateCommand_RemoteCreateCommand_Proxy(This, pUnkOuter, riid, ppCommand, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IDBCreateCommand_CreateCommand_Stub(IDBCreateCommand* This, IUnknown *pUnkOuter, |
| REFIID riid, IUnknown **ppCommand, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %p, %s, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppCommand, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IDBCreateCommand_CreateCommand(This, pUnkOuter, riid, ppCommand); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBCreateSession_CreateSession_Proxy(IDBCreateSession* This, IUnknown *pUnkOuter, |
| REFIID riid, IUnknown **ppDBSession) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| 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 __RPC_STUB IDBCreateSession_CreateSession_Stub(IDBCreateSession* This, IUnknown *pUnkOuter, |
| REFIID riid, IUnknown **ppDBSession, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| TRACE("(%p, %p, %s, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), |
| ppDBSession, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IDBCreateSession_CreateSession(This, pUnkOuter, riid, ppDBSession); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBProperties_GetProperties_Proxy(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[], |
| ULONG *pcPropertySets, DBPROPSET **prgPropertySets) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| 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 __RPC_STUB IDBProperties_GetProperties_Stub(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets, |
| ULONG *pcPropertySets, DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, |
| prgPropertySets, ppErrorInfoRem); |
| *pcPropertySets = 0; |
| *ppErrorInfoRem = NULL; |
| hr = IDBProperties_GetProperties(This, cPropertyIDSets, rgPropertyIDSets, |
| pcPropertySets, prgPropertySets); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBProperties_GetPropertyInfo_Proxy(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[], |
| ULONG *pcPropertyInfoSets, DBPROPINFOSET **prgPropertyInfoSets, |
| OLECHAR **ppDescBuffer) |
| { |
| FIXME("(%p, %d, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets, |
| prgPropertyInfoSets, ppDescBuffer); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IDBProperties_GetPropertyInfo_Stub(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets, |
| ULONG *pcPropertyInfoSets, DBPROPINFOSET **prgPropertyInfoSets, |
| ULONG *pcOffsets, DBBYTEOFFSET **prgDescOffsets, ULONG *pcbDescBuffer, |
| OLECHAR **ppDescBuffer, IErrorInfo **ppErrorInfoRem) |
| { |
| FIXME("(%p, %d, %p, %p, %p, %p, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets, |
| prgPropertyInfoSets, pcOffsets, prgDescOffsets, pcbDescBuffer, ppDescBuffer, ppErrorInfoRem); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IDBProperties_SetProperties_Proxy(IDBProperties* This, ULONG cPropertySets, DBPROPSET rgPropertySets[]) |
| { |
| ULONG prop_set, prop, total_props = 0; |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| 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 = IDBProperties_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 __RPC_STUB IDBProperties_SetProperties_Stub(IDBProperties* This, ULONG cPropertySets, DBPROPSET *rgPropertySets, |
| ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem) |
| { |
| ULONG prop_set, prop, total_props = 0; |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, cTotalProps, |
| rgPropStatus, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IDBProperties_SetProperties(This, cPropertySets, rgPropertySets); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| for(prop_set = 0; prop_set < cPropertySets; prop_set++) |
| for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++) |
| rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus; |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBInitialize_Initialize_Proxy(IDBInitialize* This) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)\n", This); |
| hr = IDBInitialize_RemoteInitialize_Proxy(This, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IDBInitialize_Initialize_Stub(IDBInitialize* This, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| TRACE("(%p, %p)\n", This, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IDBInitialize_Initialize(This); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBInitialize_Uninitialize_Proxy(IDBInitialize* This) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)\n", This); |
| hr = IDBInitialize_RemoteUninitialize_Proxy(This, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IDBInitialize_Uninitialize_Stub(IDBInitialize* This, IErrorInfo **error) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %p)\n", This, error); |
| *error = NULL; |
| hr = IDBInitialize_Uninitialize(This); |
| if(FAILED(hr)) GetErrorInfo(0, error); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBDataSourceAdmin_CreateDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets, |
| DBPROPSET rgPropertySets[], IUnknown *pUnkOuter, |
| REFIID riid, IUnknown **ppDBSession) |
| { |
| ULONG prop_set, prop, total_props = 0; |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| 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; |
| } |
| |
| HRESULT __RPC_STUB IDBDataSourceAdmin_CreateDataSource_Stub(IDBDataSourceAdmin* This, ULONG cPropertySets, |
| DBPROPSET *rgPropertySets, IUnknown *pUnkOuter, |
| REFIID riid, IUnknown **ppDBSession, ULONG cTotalProps, |
| DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem) |
| { |
| ULONG prop_set, prop, total_props = 0; |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %p, %s, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, pUnkOuter, |
| debugstr_guid(riid), ppDBSession, cTotalProps, rgPropStatus, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IDBDataSourceAdmin_CreateDataSource(This, cPropertySets, rgPropertySets, pUnkOuter, riid, ppDBSession); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| for(prop_set = 0; prop_set < cPropertySets; prop_set++) |
| for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++) |
| rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus; |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBDataSourceAdmin_DestroyDataSource_Proxy(IDBDataSourceAdmin* This) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)\n", This); |
| hr = IDBDataSourceAdmin_RemoteDestroyDataSource_Proxy(This, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IDBDataSourceAdmin_DestroyDataSource_Stub(IDBDataSourceAdmin* This, IErrorInfo **error) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %p)\n", This, error); |
| *error = NULL; |
| hr = IDBDataSourceAdmin_DestroyDataSource(This); |
| if(FAILED(hr)) GetErrorInfo(0, error); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBDataSourceAdmin_GetCreationProperties_Proxy(IDBDataSourceAdmin* This, ULONG cPropertyIDSets, |
| const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets, |
| DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer) |
| { |
| FIXME("(%p, %d, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets, |
| prgPropertyInfoSets, ppDescBuffer); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IDBDataSourceAdmin_GetCreationProperties_Stub(IDBDataSourceAdmin* This, ULONG cPropertyIDSets, |
| const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertyInfoSets, |
| DBPROPINFOSET **prgPropertyInfoSets, DBCOUNTITEM *pcOffsets, |
| DBBYTEOFFSET **prgDescOffsets, ULONG *pcbDescBuffer, |
| OLECHAR **ppDescBuffer, IErrorInfo **error) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %p, %p, %p, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets, |
| prgPropertyInfoSets, pcOffsets, prgDescOffsets, pcbDescBuffer, ppDescBuffer, error); |
| *error = NULL; |
| hr = IDBDataSourceAdmin_GetCreationProperties(This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets, |
| prgPropertyInfoSets, ppDescBuffer); |
| if(FAILED(hr)) GetErrorInfo(0, error); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBDataSourceAdmin_ModifyDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets, DBPROPSET rgPropertySets[]) |
| { |
| IErrorInfo *error = NULL; |
| 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 __RPC_STUB IDBDataSourceAdmin_ModifyDataSource_Stub(IDBDataSourceAdmin* This, ULONG cPropertySets, |
| DBPROPSET *rgPropertySets, IErrorInfo **error) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, error); |
| *error = NULL; |
| hr = IDBDataSourceAdmin_ModifyDataSource(This, cPropertySets, rgPropertySets); |
| if(FAILED(hr)) GetErrorInfo(0, error); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK ISessionProperties_GetProperties_Proxy(ISessionProperties* This, ULONG cPropertyIDSets, |
| const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets, |
| DBPROPSET **prgPropertySets) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, |
| pcPropertySets, prgPropertySets); |
| |
| hr = ISessionProperties_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, |
| prgPropertySets, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB ISessionProperties_GetProperties_Stub(ISessionProperties* This, ULONG cPropertyIDSets, |
| const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertySets, |
| DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, |
| pcPropertySets, prgPropertySets, ppErrorInfoRem); |
| |
| hr = ISessionProperties_GetProperties(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets); |
| if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK ISessionProperties_SetProperties_Proxy(ISessionProperties* This, ULONG cPropertySets, DBPROPSET rgPropertySets[]) |
| { |
| ULONG prop_set, prop, total_props = 0; |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| 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 __RPC_STUB ISessionProperties_SetProperties_Stub(ISessionProperties* This, ULONG cPropertySets, DBPROPSET *rgPropertySets, |
| ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem) |
| { |
| ULONG prop_set, prop, total_props = 0; |
| HRESULT hr; |
| |
| TRACE("(%p, %d, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, cTotalProps, |
| rgPropStatus, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = ISessionProperties_SetProperties(This, cPropertySets, rgPropertySets); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| for(prop_set = 0; prop_set < cPropertySets; prop_set++) |
| for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++) |
| rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus; |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IOpenRowset_OpenRowset_Proxy(IOpenRowset* This, IUnknown *pUnkOuter, DBID *pTableID, DBID *pIndexID, |
| REFIID riid, ULONG cPropertySets, DBPROPSET rgPropertySets[], IUnknown **ppRowset) |
| { |
| FIXME("(%p, %p, %p, %p, %s, %d, %p, %p): stub\n", This, pUnkOuter, pTableID, pIndexID, debugstr_guid(riid), |
| cPropertySets, rgPropertySets, ppRowset); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IOpenRowset_OpenRowset_Stub(IOpenRowset* This, IUnknown *pUnkOuter, DBID *pTableID, DBID *pIndexID, |
| REFIID riid, ULONG cPropertySets, DBPROPSET *rgPropertySets, |
| IUnknown **ppRowset, ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| FIXME("(%p, %p, %p, %p, %s, %d, %p, %p, %d, %p, %p): stub\n", This, pUnkOuter, pTableID, pIndexID, debugstr_guid(riid), |
| cPropertySets, rgPropertySets, ppRowset, cTotalProps, rgPropStatus, ppErrorInfoRem); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IBindResource_Bind_Proxy(IBindResource* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags, |
| REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, DBIMPLICITSESSION *pImplSession, |
| DBBINDURLSTATUS *pdwBindStatus, IUnknown **ppUnk) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags, |
| debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pImplSession, pdwBindStatus, ppUnk); |
| |
| if(pUnkOuter) |
| { |
| FIXME("Aggregation not supported\n"); |
| return CLASS_E_NOAGGREGATION; |
| } |
| |
| hr = IBindResource_RemoteBind_Proxy(This, pUnkOuter, pwszURL, dwBindURLFlags, rguid, riid, pAuthenticate, |
| pImplSession ? pImplSession->pUnkOuter : NULL, pImplSession ? pImplSession->piid : NULL, |
| pImplSession ? &pImplSession->pSession : NULL, pdwBindStatus, ppUnk); |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IBindResource_Bind_Stub(IBindResource* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags, |
| REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, IUnknown *pSessionUnkOuter, |
| IID *piid, IUnknown **ppSession, DBBINDURLSTATUS *pdwBindStatus, IUnknown **ppUnk) |
| { |
| HRESULT hr; |
| DBIMPLICITSESSION impl_session; |
| IWineRowServer *server; |
| IMarshal *marshal; |
| IUnknown *obj; |
| |
| TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags, |
| debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pSessionUnkOuter, piid, ppSession, pdwBindStatus, ppUnk); |
| |
| *ppUnk = NULL; |
| |
| if(IsEqualGUID(rguid, &DBGUID_ROWSET)) |
| hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&server); |
| else if(IsEqualGUID(rguid, &DBGUID_ROW)) |
| hr = CoCreateInstance(&CLSID_wine_row_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&server); |
| else |
| { |
| hr = E_NOTIMPL; |
| FIXME("Unhandled object %s\n", debugstr_guid(rguid)); |
| } |
| |
| if(FAILED(hr)) return hr; |
| |
| impl_session.pUnkOuter = pSessionUnkOuter; |
| impl_session.piid = piid; |
| impl_session.pSession = NULL; |
| |
| IWineRowServer_GetMarshal(server, &marshal); |
| |
| hr = IBindResource_Bind(This, (IUnknown*)marshal, pwszURL, dwBindURLFlags, rguid, &IID_IUnknown, pAuthenticate, |
| ppSession ? &impl_session : NULL, pdwBindStatus, &obj); |
| |
| IMarshal_Release(marshal); |
| if(FAILED(hr)) |
| { |
| IWineRowServer_Release(server); |
| return hr; |
| } |
| |
| IWineRowServer_SetInnerUnk(server, obj); |
| hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk); |
| IUnknown_Release(obj); |
| |
| if(ppSession) *ppSession = impl_session.pSession; |
| return hr; |
| } |
| |
| HRESULT CALLBACK ICreateRow_CreateRow_Proxy(ICreateRow* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags, |
| REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, DBIMPLICITSESSION *pImplSession, |
| DBBINDURLSTATUS *pdwBindStatus, LPOLESTR *ppwszNewURL, IUnknown **ppUnk) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags, |
| debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pImplSession, pdwBindStatus, ppwszNewURL, ppUnk); |
| |
| if(pUnkOuter) |
| { |
| FIXME("Aggregation not supported\n"); |
| return CLASS_E_NOAGGREGATION; |
| } |
| |
| hr = ICreateRow_RemoteCreateRow_Proxy(This, pUnkOuter, pwszURL, dwBindURLFlags, rguid, riid, pAuthenticate, |
| pImplSession ? pImplSession->pUnkOuter : NULL, pImplSession ? pImplSession->piid : NULL, |
| pImplSession ? &pImplSession->pSession : NULL, pdwBindStatus, ppwszNewURL, ppUnk); |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB ICreateRow_CreateRow_Stub(ICreateRow* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags, |
| REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, IUnknown *pSessionUnkOuter, |
| IID *piid, IUnknown **ppSession, DBBINDURLSTATUS *pdwBindStatus, |
| LPOLESTR *ppwszNewURL, IUnknown **ppUnk) |
| { |
| HRESULT hr; |
| DBIMPLICITSESSION impl_session; |
| IWineRowServer *row_server; |
| IMarshal *marshal; |
| IUnknown *obj; |
| |
| TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags, |
| debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pSessionUnkOuter, piid, ppSession, pdwBindStatus, ppwszNewURL, |
| ppUnk); |
| |
| *ppUnk = NULL; |
| |
| hr = CoCreateInstance(&CLSID_wine_row_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&row_server); |
| if(FAILED(hr)) return hr; |
| |
| impl_session.pUnkOuter = pSessionUnkOuter; |
| impl_session.piid = piid; |
| impl_session.pSession = NULL; |
| |
| IWineRowServer_GetMarshal(row_server, &marshal); |
| |
| hr = ICreateRow_CreateRow(This, (IUnknown*) marshal, pwszURL, dwBindURLFlags, rguid, &IID_IUnknown, pAuthenticate, |
| ppSession ? &impl_session : NULL, pdwBindStatus, ppwszNewURL, &obj); |
| IMarshal_Release(marshal); |
| |
| if(FAILED(hr)) |
| { |
| IWineRowServer_Release(row_server); |
| return hr; |
| } |
| |
| IWineRowServer_SetInnerUnk(row_server, obj); |
| hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk); |
| IUnknown_Release(obj); |
| |
| if(ppSession) *ppSession = impl_session.pSession; |
| return hr; |
| } |
| |
| HRESULT CALLBACK IAccessor_AddRefAccessor_Proxy(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *refcount) |
| { |
| IErrorInfo *errorinfo; |
| DBREFCOUNT ref; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%08lx, %p)\n", This, hAccessor, refcount); |
| |
| if (!refcount) |
| refcount = &ref; |
| |
| errorinfo = NULL; |
| hr = IAccessor_RemoteAddRefAccessor_Proxy(This, hAccessor, refcount, &errorinfo); |
| if (errorinfo) |
| { |
| SetErrorInfo(0, errorinfo); |
| IErrorInfo_Release(errorinfo); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IAccessor_AddRefAccessor_Stub(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%08lx, %p, %p)\n", This, hAccessor, pcRefCount, ppErrorInfoRem); |
| |
| hr = IAccessor_AddRefAccessor(This, hAccessor, pcRefCount); |
| if (FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IAccessor_CreateAccessor_Proxy(IAccessor* This, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings, |
| const DBBINDING rgBindings[], DBLENGTH cbRowSize, HACCESSOR *phAccessor, |
| DBBINDSTATUS rgStatus[]) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| DBCOUNTITEM i; |
| |
| TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings, |
| cbRowSize, phAccessor, rgStatus); |
| |
| for(i = 0; i < cBindings; i++) |
| { |
| TRACE("%ld: ord %ld val off %ld len off %ld stat off %ld part %04x mem_owner %d max_len %ld 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 __RPC_STUB IAccessor_CreateAccessor_Stub(IAccessor* This, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings, |
| DBBINDING *rgBindings, DBLENGTH cbRowSize, HACCESSOR *phAccessor, |
| DBBINDSTATUS *rgStatus, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings, |
| cbRowSize, phAccessor, rgStatus, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IAccessor_CreateAccessor(This, dwAccessorFlags, cBindings, rgBindings, |
| cbRowSize, phAccessor, rgStatus); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IAccessor_GetBindings_Proxy(IAccessor* This, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags, |
| DBCOUNTITEM *pcBindings, DBBINDING **prgBindings) |
| { |
| FIXME("(%p): stub\n", This); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IAccessor_GetBindings_Stub(IAccessor* This, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags, |
| DBCOUNTITEM *pcBindings, DBBINDING **prgBindings, IErrorInfo **ppErrorInfoRem) |
| { |
| FIXME("(%p): stub\n", This); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IAccessor_ReleaseAccessor_Proxy(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| 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; |
| } |
| |
| HRESULT __RPC_STUB IAccessor_ReleaseAccessor_Stub(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%lx, %p, %p)\n", This, hAccessor, pcRefCount, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| |
| hr = IAccessor_ReleaseAccessor(This, hAccessor, pcRefCount); |
| |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| return hr; |
| } |
| |
| HRESULT CALLBACK IRowsetInfo_GetProperties_Proxy(IRowsetInfo* This, const ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[], |
| ULONG *pcPropertySets, DBPROPSET **prgPropertySets) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| ULONG i; |
| |
| TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets); |
| |
| for(i = 0; i < cPropertyIDSets; i++) |
| { |
| unsigned 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%u: 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; |
| } |
| |
| HRESULT __RPC_STUB IRowsetInfo_GetProperties_Stub(IRowsetInfo* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets, |
| ULONG *pcPropertySets, DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| |
| hr = IRowsetInfo_GetProperties(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| TRACE("returning %08x\n", hr); |
| return hr; |
| } |
| |
| HRESULT CALLBACK IRowsetInfo_GetReferencedRowset_Proxy(IRowsetInfo* This, DBORDINAL iOrdinal, REFIID riid, IUnknown **ppReferencedRowset) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%ld, %s, %p)\n", This, iOrdinal, debugstr_guid(riid), ppReferencedRowset); |
| |
| hr = IRowsetInfo_RemoteGetReferencedRowset_Proxy(This, iOrdinal, riid, ppReferencedRowset, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IRowsetInfo_GetReferencedRowset_Stub(IRowsetInfo* This, DBORDINAL iOrdinal, REFIID riid, IUnknown **ppReferencedRowset, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%ld, %s, %p, %p)\n", This, iOrdinal, debugstr_guid(riid), ppReferencedRowset, ppErrorInfoRem); |
| |
| hr = IRowsetInfo_GetReferencedRowset(This, iOrdinal, riid, ppReferencedRowset); |
| if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IRowsetInfo_GetSpecification_Proxy(IRowsetInfo* This, REFIID riid, IUnknown **ppSpecification) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppSpecification); |
| |
| hr = IRowsetInfo_RemoteGetSpecification_Proxy(This, riid, ppSpecification, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IRowsetInfo_GetSpecification_Stub(IRowsetInfo* This, REFIID riid, IUnknown **ppSpecification, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%s, %p, %p)\n", This, debugstr_guid(riid), ppSpecification, ppErrorInfoRem); |
| |
| hr = IRowsetInfo_GetSpecification(This, riid, ppSpecification); |
| if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK ICommand_Cancel_Proxy(ICommand* This) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)\n", This); |
| |
| hr = ICommand_RemoteCancel_Proxy(This, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB ICommand_Cancel_Stub(ICommand* This, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%p)\n", This, ppErrorInfoRem); |
| |
| hr = ICommand_Cancel(This); |
| if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK ICommand_Execute_Proxy(ICommand* This, IUnknown *pUnkOuter, REFIID riid, |
| DBPARAMS *pParams, DBROWCOUNT *pcRowsAffected, IUnknown **ppRowset) |
| { |
| HRESULT hr; |
| DBROWCOUNT affected; |
| |
| *ppRowset = NULL; |
| |
| TRACE("(%p)->(%p, %s, %p, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), pParams, |
| pcRowsAffected, ppRowset); |
| |
| if(pParams) |
| { |
| FIXME("Unhandled params {%p, %ld, %08lx}\n", pParams->pData, pParams->cParamSets, pParams->hAccessor); |
| return E_NOTIMPL; |
| } |
| |
| if(pUnkOuter) |
| { |
| FIXME("Aggregation not supported\n"); |
| return CLASS_E_NOAGGREGATION; |
| } |
| |
| hr = ICommand_RemoteExecute_Proxy(This, pUnkOuter, riid, 0, 0, NULL, 0, NULL, NULL, 0, NULL, NULL, &affected, |
| ppRowset); |
| |
| TRACE("Execute returns %08x\n", hr); |
| |
| if(pcRowsAffected) *pcRowsAffected = affected; |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB ICommand_Execute_Stub(ICommand* This, IUnknown *pUnkOuter, REFIID riid, HACCESSOR hAccessor, |
| DB_UPARAMS cParamSets, GUID *pGuid, ULONG ulGuidOffset, RMTPACK *pInputParams, |
| RMTPACK *pOutputParams, DBCOUNTITEM cBindings, DBBINDING *rgBindings, |
| DBSTATUS *rgStatus, DBROWCOUNT *pcRowsAffected, IUnknown **ppRowset) |
| { |
| IWineRowServer *rowset_server; |
| IMarshal *marshal; |
| IUnknown *obj = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%p, %s, %08lx, %ld, %p, %d, %p, %p, %ld, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), |
| hAccessor, cParamSets, pGuid, ulGuidOffset, pInputParams, pOutputParams, cBindings, rgBindings, rgStatus, |
| pcRowsAffected, ppRowset); |
| |
| *ppRowset = NULL; |
| |
| hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&rowset_server); |
| if(FAILED(hr)) return hr; |
| |
| IWineRowServer_GetMarshal(rowset_server, &marshal); |
| |
| hr = ICommand_Execute(This, (IUnknown*)marshal, &IID_IUnknown, NULL, pcRowsAffected, &obj); |
| |
| IMarshal_Release(marshal); |
| |
| if(FAILED(hr)) |
| { |
| IWineRowServer_Release(rowset_server); |
| return hr; |
| } |
| |
| IWineRowServer_SetInnerUnk(rowset_server, obj); |
| hr = IUnknown_QueryInterface(obj, riid, (void**)ppRowset); |
| IUnknown_Release(obj); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK ICommand_GetDBSession_Proxy(ICommand* This, REFIID riid, IUnknown **ppSession) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppSession); |
| |
| hr = ICommand_RemoteGetDBSession_Proxy(This, riid, ppSession, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB ICommand_GetDBSession_Stub(ICommand* This, REFIID riid, IUnknown **ppSession, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%s, %p, %p)\n", This, debugstr_guid(riid), ppSession, ppErrorInfoRem); |
| |
| hr = ICommand_GetDBSession(This, riid, ppSession); |
| if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK ICommandText_GetCommandText_Proxy(ICommandText* This, GUID *pguidDialect, LPOLESTR *ppwszCommand) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%p, %p)\n", This, pguidDialect, ppwszCommand); |
| |
| hr = ICommandText_RemoteGetCommandText_Proxy(This, pguidDialect, ppwszCommand, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB ICommandText_GetCommandText_Stub(ICommandText* This, GUID *pguidDialect, |
| LPOLESTR *ppwszCommand, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%p, %p, %p)\n", This, pguidDialect, ppwszCommand, ppErrorInfoRem); |
| |
| hr = ICommandText_GetCommandText(This, pguidDialect, ppwszCommand); |
| if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK ICommandText_SetCommandText_Proxy(ICommandText* This, REFGUID rguidDialect, LPCOLESTR pwszCommand) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| 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 __RPC_STUB ICommandText_SetCommandText_Stub(ICommandText* This, REFGUID rguidDialect, LPCOLESTR pwszCommand, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%s, %s, %p)\n", This, debugstr_guid(rguidDialect), debugstr_w(pwszCommand), |
| ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = ICommandText_SetCommandText(This, rguidDialect, pwszCommand); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBAsynchNotify_OnLowResource_Proxy(IDBAsynchNotify* This, DB_DWRESERVE dwReserved) |
| { |
| TRACE("(%p)->(%08lx)\n", This, dwReserved); |
| return IDBAsynchNotify_RemoteOnLowResource_Proxy(This, dwReserved); |
| } |
| |
| HRESULT __RPC_STUB IDBAsynchNotify_OnLowResource_Stub(IDBAsynchNotify* This, DB_DWRESERVE dwReserved) |
| { |
| TRACE("(%p)->(%08lx)\n", This, dwReserved); |
| return IDBAsynchNotify_OnLowResource(This, dwReserved); |
| } |
| |
| HRESULT CALLBACK IDBAsynchNotify_OnProgress_Proxy(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation, |
| DBCOUNTITEM ulProgress, DBCOUNTITEM ulProgressMax, DBASYNCHPHASE eAsynchPhase, |
| LPOLESTR pwszStatusText) |
| { |
| TRACE("(%p)->(%lx, %d, %ld, %ld, %d, %s)\n", This, hChapter, eOperation, ulProgress, ulProgressMax, |
| eAsynchPhase, debugstr_w(pwszStatusText)); |
| |
| return IDBAsynchNotify_RemoteOnProgress_Proxy(This, hChapter, eOperation, ulProgress, ulProgressMax, eAsynchPhase, |
| pwszStatusText); |
| } |
| |
| HRESULT __RPC_STUB IDBAsynchNotify_OnProgress_Stub(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation, |
| DBCOUNTITEM ulProgress, DBCOUNTITEM ulProgressMax, DBASYNCHPHASE eAsynchPhase, |
| LPOLESTR pwszStatusText) |
| { |
| TRACE("(%p)->(%lx, %d, %ld, %ld, %d, %s)\n", This, hChapter, eOperation, ulProgress, ulProgressMax, |
| eAsynchPhase, debugstr_w(pwszStatusText)); |
| return IDBAsynchNotify_OnProgress(This, hChapter, eOperation, ulProgress, ulProgressMax, eAsynchPhase, |
| pwszStatusText); |
| } |
| |
| HRESULT CALLBACK IDBAsynchNotify_OnStop_Proxy(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation, |
| HRESULT hrStatus, LPOLESTR pwszStatusText) |
| { |
| TRACE("(%p)->(%lx, %d, %08x, %s)\n", This, hChapter, eOperation, hrStatus, debugstr_w(pwszStatusText)); |
| return IDBAsynchNotify_RemoteOnStop_Proxy(This, hChapter, eOperation, hrStatus, pwszStatusText); |
| } |
| |
| HRESULT __RPC_STUB IDBAsynchNotify_OnStop_Stub(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation, |
| HRESULT hrStatus, LPOLESTR pwszStatusText) |
| { |
| TRACE("(%p)->(%lx, %d, %08x, %s)\n", This, hChapter, eOperation, hrStatus, debugstr_w(pwszStatusText)); |
| return IDBAsynchNotify_OnStop(This, hChapter, eOperation, hrStatus, pwszStatusText); |
| } |
| |
| HRESULT CALLBACK IDBAsynchStatus_Abort_Proxy(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%lx, %d)\n", This, hChapter, eOperation); |
| |
| hr = IDBAsynchStatus_RemoteAbort_Proxy(This, hChapter, eOperation, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IDBAsynchStatus_Abort_Stub(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%lx, %d, %p)\n", This, hChapter, eOperation, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IDBAsynchStatus_Abort(This, hChapter, eOperation); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IDBAsynchStatus_GetStatus_Proxy(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation, |
| DBCOUNTITEM *pulProgress, DBCOUNTITEM *pulProgressMax, DBASYNCHPHASE *peAsynchPhase, |
| LPOLESTR *ppwszStatusText) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%lx, %d, %p, %p, %p, %p)\n", This, hChapter, eOperation, pulProgress, pulProgressMax, |
| peAsynchPhase, ppwszStatusText); |
| |
| hr = IDBAsynchStatus_RemoteGetStatus_Proxy(This, hChapter, eOperation, pulProgress, pulProgressMax, peAsynchPhase, |
| ppwszStatusText, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IDBAsynchStatus_GetStatus_Stub(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation, |
| DBCOUNTITEM *pulProgress, DBCOUNTITEM *pulProgressMax, DBASYNCHPHASE *peAsynchPhase, |
| LPOLESTR *ppwszStatusText, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%lx, %d, %p, %p, %p, %p, %p)\n", This, hChapter, eOperation, pulProgress, pulProgressMax, |
| peAsynchPhase, ppwszStatusText, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IDBAsynchStatus_GetStatus(This, hChapter, eOperation, pulProgress, pulProgressMax, peAsynchPhase, ppwszStatusText); |
| if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IRowsetNotify_OnRowChange_Proxy(IRowsetNotify* This, IRowset *rowset, DBCOUNTITEM rows, HROW *hrows, DBREASON reason, |
| DBEVENTPHASE phase, BOOL cantdeny) |
| { |
| TRACE("(%p)->(%p %ld %p %d %d %d)\n", This, rowset, rows, hrows, reason, phase, cantdeny); |
| return IRowsetNotify_RemoteOnRowChange_Proxy(This, rowset, rows, hrows, reason, phase, cantdeny); |
| } |
| |
| HRESULT __RPC_STUB IRowsetNotify_OnRowChange_Stub(IRowsetNotify* This, IRowset *rowset, DBCOUNTITEM rows, HROW *hrows, DBREASON reason, |
| DBEVENTPHASE phase, BOOL cantdeny) |
| { |
| TRACE("(%p)->(%p %ld %p %d %d %d)\n", This, rowset, rows, hrows, reason, phase, cantdeny); |
| return IRowsetNotify_OnRowChange(This, rowset, rows, hrows, reason, phase, cantdeny); |
| } |
| |
| HRESULT CALLBACK IRowsetNotify_OnFieldChange_Proxy(IRowsetNotify* This, IRowset *rowset, HROW row, DBORDINAL ccols, DBORDINAL *columns, |
| DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny) |
| { |
| TRACE("(%p)->(%p %lx %ld %p %d %d %d)\n", This, rowset, row, ccols, columns, reason, phase, cantdeny); |
| return IRowsetNotify_RemoteOnFieldChange_Proxy(This, rowset, row, ccols, columns, reason, phase, cantdeny); |
| } |
| |
| HRESULT __RPC_STUB IRowsetNotify_OnFieldChange_Stub(IRowsetNotify* This, IRowset *rowset, HROW row, DBORDINAL ccols, DBORDINAL *columns, |
| DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny) |
| { |
| TRACE("(%p)->(%p %lx %ld %p %d %d %d)\n", This, rowset, row, ccols, columns, reason, phase, cantdeny); |
| return IRowsetNotify_OnFieldChange(This, rowset, row, ccols, columns, reason, phase, cantdeny); |
| } |
| |
| HRESULT CALLBACK IRowsetNotify_OnRowsetChange_Proxy(IRowsetNotify* This, IRowset *rowset, DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny) |
| { |
| TRACE("(%p)->(%p %d %d %d)\n", This, rowset, reason, phase, cantdeny); |
| return IRowsetNotify_RemoteOnRowsetChange_Proxy(This, rowset, reason, phase, cantdeny); |
| } |
| |
| HRESULT __RPC_STUB IRowsetNotify_OnRowsetChange_Stub(IRowsetNotify* This, IRowset *rowset, DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny) |
| { |
| TRACE("(%p)->(%p %d %d %d)\n", This, rowset, reason, phase, cantdeny); |
| return IRowsetNotify_OnRowsetChange(This, rowset, reason, phase, cantdeny); |
| } |
| |
| |
| HRESULT CALLBACK ISourcesRowset_GetSourcesRowset_Proxy(ISourcesRowset* This, IUnknown *pUnkOuter, REFIID riid, ULONG cPropertySets, |
| DBPROPSET rgProperties[], IUnknown **ppSourcesRowset) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%p %s %d %p %p)\n", This, pUnkOuter, debugstr_guid(riid), cPropertySets, rgProperties, ppSourcesRowset); |
| |
| hr = ISourcesRowset_RemoteGetSourcesRowset_Proxy(This, pUnkOuter, riid, cPropertySets, rgProperties, ppSourcesRowset, 0, NULL, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB ISourcesRowset_GetSourcesRowset_Stub(ISourcesRowset* This, IUnknown *pUnkOuter, REFIID riid, ULONG cPropertySets, |
| DBPROPSET *rgProperties, IUnknown **ppSourcesRowset, ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->(%p %s %d %p %p %d %p %p)\n", This, pUnkOuter, debugstr_guid(riid), cPropertySets, rgProperties, ppSourcesRowset, |
| cTotalProps, rgPropStatus, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = ISourcesRowset_GetSourcesRowset(This, pUnkOuter, riid, cPropertySets, rgProperties, ppSourcesRowset); |
| if(FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IErrorRecords_GetRecordCount_Proxy(IErrorRecords* This, ULONG *records) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->%p\n", This, records); |
| |
| hr = IErrorRecords_RemoteGetRecordCount_Proxy(This, records, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IErrorRecords_GetRecordCount_Stub(IErrorRecords* This, ULONG *pcRecords, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->%p %p\n", This, pcRecords, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IErrorRecords_GetRecordCount(This, pcRecords); |
| if(FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IErrorRecords_GetErrorParameters_Proxy(IErrorRecords* This, ULONG ulRecordNum, DISPPARAMS *pdispparams) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %p\n", This, ulRecordNum, pdispparams); |
| |
| hr = IErrorRecords_RemoteGetErrorParameters_Proxy(This, ulRecordNum, pdispparams, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IErrorRecords_GetErrorParameters_Stub(IErrorRecords* This, ULONG ulRecordNum, DISPPARAMS *pdispparams, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %p %p\n", This, ulRecordNum, pdispparams, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IErrorRecords_GetErrorParameters(This, ulRecordNum, pdispparams); |
| if(FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IErrorRecords_GetErrorInfo_Proxy(IErrorRecords* This, ULONG ulRecordNum, LCID lcid, IErrorInfo **ppErrorInfo) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %d %p\n", This, ulRecordNum, lcid, ppErrorInfo); |
| |
| hr = IErrorRecords_RemoteGetErrorInfo_Proxy(This, ulRecordNum, lcid, ppErrorInfo, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IErrorRecords_GetErrorInfo_Stub(IErrorRecords* This, ULONG ulRecordNum, LCID lcid, |
| IErrorInfo **ppErrorInfo, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %d %p %p\n", This, ulRecordNum, lcid, ppErrorInfo, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IErrorRecords_GetErrorInfo(This, ulRecordNum, lcid, ppErrorInfo); |
| if(FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IErrorRecords_GetCustomErrorObject_Proxy(IErrorRecords* This, ULONG ulRecordNum, REFIID riid, |
| IUnknown **ppObject) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %s %p\n", This, ulRecordNum, debugstr_guid(riid), ppObject); |
| |
| hr = IErrorRecords_RemoteGetCustomErrorObject_Proxy(This, ulRecordNum, riid, ppObject, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IErrorRecords_GetCustomErrorObject_Stub(IErrorRecords* This, ULONG ulRecordNum, REFIID riid, |
| IUnknown **ppObject, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %s %p %p\n", This, ulRecordNum, debugstr_guid(riid), ppObject, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IErrorRecords_GetCustomErrorObject(This, ulRecordNum, riid, ppObject); |
| if(FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IErrorRecords_GetBasicErrorInfo_Proxy(IErrorRecords* This, ULONG ulRecordNum, ERRORINFO *pErrorInfo) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %p\n", This, ulRecordNum, pErrorInfo); |
| |
| hr = IErrorRecords_RemoteGetBasicErrorInfo_Proxy(This, ulRecordNum, pErrorInfo, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IErrorRecords_GetBasicErrorInfo_Stub(IErrorRecords* This, ULONG ulRecordNum, ERRORINFO *pErrorInfo, |
| IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->%d %p %p\n", This, ulRecordNum, pErrorInfo, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IErrorRecords_GetBasicErrorInfo(This, ulRecordNum, pErrorInfo); |
| if(FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT CALLBACK IErrorRecords_AddErrorRecord_Proxy(IErrorRecords* This, ERRORINFO *pErrorInfo, DWORD dwLookupID, |
| DISPPARAMS *pdispparams, IUnknown *punkCustomError, DWORD dwDynamicErrorID) |
| { |
| IErrorInfo *error = NULL; |
| HRESULT hr; |
| |
| TRACE("(%p)->%p %d %p %p %d\n", This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, dwDynamicErrorID); |
| |
| hr = IErrorRecords_RemoteAddErrorRecord_Proxy(This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, |
| dwDynamicErrorID, &error); |
| if(error) |
| { |
| SetErrorInfo(0, error); |
| IErrorInfo_Release(error); |
| } |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IErrorRecords_AddErrorRecord_Stub(IErrorRecords* This, ERRORINFO *pErrorInfo, DWORD dwLookupID, |
| DISPPARAMS *pdispparams, IUnknown *punkCustomError, DWORD dwDynamicErrorID, IErrorInfo **ppErrorInfoRem) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p)->%p %d %p %p %d %p\n", This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, |
| dwDynamicErrorID, ppErrorInfoRem); |
| |
| *ppErrorInfoRem = NULL; |
| hr = IErrorRecords_AddErrorRecord(This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, dwDynamicErrorID); |
| if(FAILED(hr)) |
| GetErrorInfo(0, ppErrorInfoRem); |
| |
| return hr; |
| } |
| |
| HRESULT __RPC_STUB IRowPosition_Initialize_Stub(IRowPosition* This, IUnknown *rowset, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(%p %p): stub\n", This, rowset, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IRowPosition_SetRowPosition_Stub(IRowPosition* This, HCHAPTER chapter, HROW row, DBPOSITIONFLAGS flags, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(%lx %lx %d %p): stub\n", This, chapter, row, flags, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IRowPosition_GetRowset_Stub(IRowPosition* This, REFIID riid, IUnknown **rowset, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(%s %p %p): stub\n", This, debugstr_guid(riid), rowset, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IRowPosition_GetRowPosition_Stub(IRowPosition* This, HCHAPTER *chapter, HROW *row, DBPOSITIONFLAGS *flags, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(%p %p %p %p): stub\n", This, chapter, row, flags, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IRowPosition_ClearRowPosition_Stub(IRowPosition* This, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(%p): stub\n", This, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IRowPosition_ClearRowPosition_Proxy(IRowPosition* This) |
| { |
| FIXME("(%p): stub\n", This); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IRowPosition_GetRowPosition_Proxy(IRowPosition* This, HCHAPTER *chapter, HROW *row, DBPOSITIONFLAGS *flags) |
| { |
| FIXME("(%p)->(%p %p %p): stub\n", This, chapter, row, flags); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IRowPosition_GetRowset_Proxy(IRowPosition* This, REFIID riid, IUnknown **rowset) |
| { |
| FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), rowset); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IRowPosition_Initialize_Proxy(IRowPosition* This, IUnknown *rowset) |
| { |
| FIXME("(%p)->(%p): stub\n", This, rowset); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IRowPosition_SetRowPosition_Proxy(IRowPosition* This, HCHAPTER chapter, HROW row, DBPOSITIONFLAGS flags) |
| { |
| FIXME("(%p)->(%lx %lx %d): stub\n", This, chapter, row, flags); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IRowPositionChange_OnRowPositionChange_Stub(IRowPositionChange* This, DBREASON reason, DBEVENTPHASE phase, |
| BOOL cant_deny, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(0x%x 0x%x %d %p): stub\n", This, reason, phase, cant_deny, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IRowPositionChange_OnRowPositionChange_Proxy(IRowPositionChange* This, DBREASON reason, DBEVENTPHASE phase, |
| BOOL cant_deny) |
| { |
| FIXME("(%p)->(0x%x 0x%x %d): stub\n", This, reason, phase, cant_deny); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IChapteredRowset_ReleaseChapter_Stub(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(%lx %p %p): stub\n", This, chapter, refcount, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IChapteredRowset_AddRefChapter_Stub(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount, IErrorInfo **errorinfo) |
| { |
| FIXME("(%p)->(%lx %p %p): stub\n", This, chapter, refcount, errorinfo); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IChapteredRowset_AddRefChapter_Proxy(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount) |
| { |
| FIXME("(%p)->(%lx %p): stub\n", This, chapter, refcount); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IChapteredRowset_ReleaseChapter_Proxy(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount) |
| { |
| FIXME("(%p)->(%lx %p): stub\n", This, chapter, refcount); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IColumnsInfo_GetColumnInfo_Proxy(IColumnsInfo* This, DBORDINAL *columns, |
| DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer) |
| { |
| FIXME("(%p)->(%p %p %p): stub\n", This, columns, colinfo, stringsbuffer); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IColumnsInfo_GetColumnInfo_Stub(IColumnsInfo* This, DBORDINAL *columns, DBCOLUMNINFO **col_info, |
| DBBYTEOFFSET **name_offsets, DBBYTEOFFSET **columnid_offsets, DBLENGTH *string_len, OLECHAR **stringsbuffer, |
| IErrorInfo **error) |
| { |
| FIXME("(%p)->(%p %p %p %p %p %p %p): stub\n", This, columns, col_info, name_offsets, columnid_offsets, |
| string_len, stringsbuffer, error); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT CALLBACK IColumnsInfo_MapColumnIDs_Proxy(IColumnsInfo* This, DBORDINAL column_ids, const DBID *dbids, |
| DBORDINAL *columns) |
| { |
| FIXME("(%p)->(%lu %p %p): stub\n", This, column_ids, dbids, columns); |
| return E_NOTIMPL; |
| } |
| |
| HRESULT __RPC_STUB IColumnsInfo_MapColumnIDs_Stub(IColumnsInfo* This, DBORDINAL column_ids, const DBID *dbids, |
| DBORDINAL *columns, IErrorInfo **error) |
| { |
| FIXME("(%p)->(%lu %p %p %p): stub\n", This, column_ids, dbids, columns, error); |
| return E_NOTIMPL; |
| } |
