mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-31 12:54:13 +00:00
1466 lines
45 KiB
C
1466 lines
45 KiB
C
/*
|
|
* Row and rowset servers / proxies.
|
|
*
|
|
* Copyright 2010 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
|
|
#define NONAMELESSUNION
|
|
#define NONAMELESSSTRUCT
|
|
|
|
#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);
|
|
|
|
static inline DBLENGTH db_type_size(DBTYPE type, DBLENGTH var_len)
|
|
{
|
|
switch(type)
|
|
{
|
|
case DBTYPE_I1:
|
|
case DBTYPE_UI1:
|
|
return 1;
|
|
case DBTYPE_I2:
|
|
case DBTYPE_UI2:
|
|
return 2;
|
|
case DBTYPE_I4:
|
|
case DBTYPE_UI4:
|
|
case DBTYPE_R4:
|
|
return 4;
|
|
case DBTYPE_I8:
|
|
case DBTYPE_UI8:
|
|
case DBTYPE_R8:
|
|
return 8;
|
|
case DBTYPE_CY:
|
|
return sizeof(CY);
|
|
case DBTYPE_FILETIME:
|
|
return sizeof(FILETIME);
|
|
case DBTYPE_BSTR:
|
|
return sizeof(BSTR);
|
|
case DBTYPE_GUID:
|
|
return sizeof(GUID);
|
|
case DBTYPE_WSTR:
|
|
return var_len;
|
|
default:
|
|
FIXME("Unhandled type %04x\n", type);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
IWineRowServer IWineRowServer_iface;
|
|
|
|
LONG ref;
|
|
|
|
CLSID class;
|
|
IMarshal *marshal;
|
|
IUnknown *inner_unk;
|
|
} server;
|
|
|
|
static inline server *impl_from_IWineRowServer(IWineRowServer *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, server, IWineRowServer_iface);
|
|
}
|
|
|
|
static HRESULT WINAPI server_QueryInterface(IWineRowServer *iface, REFIID riid, void **obj)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
|
|
|
|
*obj = NULL;
|
|
|
|
if(IsEqualIID(riid, &IID_IUnknown) ||
|
|
IsEqualIID(riid, &IID_IWineRowServer))
|
|
{
|
|
*obj = iface;
|
|
}
|
|
else
|
|
{
|
|
if(!IsEqualIID(riid, &IID_IMarshal)) /* We use standard marshalling */
|
|
FIXME("interface %s not implemented\n", debugstr_guid(riid));
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IWineRowServer_AddRef(iface);
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI server_AddRef(IWineRowServer *iface)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
TRACE("(%p)\n", This);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI server_Release(IWineRowServer *iface)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
LONG ref;
|
|
|
|
TRACE("(%p)\n", This);
|
|
|
|
ref = InterlockedDecrement(&This->ref);
|
|
if(ref == 0)
|
|
{
|
|
IMarshal_Release(This->marshal);
|
|
if(This->inner_unk) IUnknown_Release(This->inner_unk);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
static HRESULT WINAPI server_SetInnerUnk(IWineRowServer *iface, IUnknown *inner)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
|
|
if(This->inner_unk) IUnknown_Release(This->inner_unk);
|
|
|
|
if(inner) IUnknown_AddRef(inner);
|
|
This->inner_unk = inner;
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetMarshal(IWineRowServer *iface, IMarshal **marshal)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
|
|
IMarshal_AddRef(This->marshal);
|
|
*marshal = This->marshal;
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetColumns(IWineRowServer* iface, DBORDINAL num_cols,
|
|
wine_getcolumns_in *in_data, wine_getcolumns_out *out_data)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
HRESULT hr;
|
|
DBORDINAL i;
|
|
DBCOLUMNACCESS *cols;
|
|
IRow *row;
|
|
|
|
TRACE("(%p)->(%ld, %p, %p)\n", This, num_cols, in_data, out_data);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRow, (void**)&row);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
cols = CoTaskMemAlloc(num_cols * sizeof(cols[0]));
|
|
|
|
for(i = 0; i < num_cols; i++)
|
|
{
|
|
TRACE("%ld:\tmax_len %ld type %04x\n", i, in_data[i].max_len, in_data[i].type);
|
|
cols[i].pData = CoTaskMemAlloc(db_type_size(in_data[i].type, in_data[i].max_len));
|
|
cols[i].columnid = in_data[i].columnid;
|
|
cols[i].cbMaxLen = in_data[i].max_len;
|
|
cols[i].wType = in_data[i].type;
|
|
cols[i].bPrecision = in_data[i].precision;
|
|
cols[i].bScale = in_data[i].scale;
|
|
}
|
|
|
|
hr = IRow_GetColumns(row, num_cols, cols);
|
|
IRow_Release(row);
|
|
|
|
for(i = 0; i < num_cols; i++)
|
|
{
|
|
VariantInit(&out_data[i].v);
|
|
if(cols[i].dwStatus == DBSTATUS_S_OK)
|
|
{
|
|
V_VT(&out_data[i].v) = in_data[i].type;
|
|
memcpy(&V_I1(&out_data[i].v), cols[i].pData, cols[i].cbDataLen);
|
|
}
|
|
CoTaskMemFree(cols[i].pData);
|
|
out_data[i].data_len = cols[i].cbDataLen;
|
|
out_data[i].status = cols[i].dwStatus;
|
|
}
|
|
|
|
CoTaskMemFree(cols);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetSourceRowset(IWineRowServer* iface, REFIID riid, IUnknown **ppRowset,
|
|
HROW *phRow)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p): stub\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_Open(IWineRowServer* iface, IUnknown *pUnkOuter, DBID *pColumnID,
|
|
REFGUID rguidColumnType, DWORD dwBindFlags, REFIID riid,
|
|
IUnknown **ppUnk)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
IRow *row;
|
|
HRESULT hr;
|
|
IWineRowServer *new_server;
|
|
IMarshal *marshal;
|
|
IUnknown *obj;
|
|
|
|
TRACE("(%p)->(%p, %p, %s, %08x, %s, %p)\n", This, pUnkOuter, pColumnID, debugstr_guid(rguidColumnType),
|
|
dwBindFlags, debugstr_guid(riid), ppUnk);
|
|
|
|
*ppUnk = NULL;
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRow, (void**)&row);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
if(IsEqualGUID(rguidColumnType, &DBGUID_ROWSET))
|
|
hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&new_server);
|
|
else
|
|
{
|
|
FIXME("Unhandled object %s\n", debugstr_guid(rguidColumnType));
|
|
hr = E_NOTIMPL;
|
|
}
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
IRow_Release(row);
|
|
return hr;
|
|
}
|
|
|
|
IWineRowServer_GetMarshal(new_server, &marshal);
|
|
hr = IRow_Open(row, (IUnknown*)marshal, pColumnID, rguidColumnType, dwBindFlags, &IID_IUnknown, &obj);
|
|
IMarshal_Release(marshal);
|
|
IRow_Release(row);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
IWineRowServer_Release(new_server);
|
|
return hr;
|
|
}
|
|
|
|
IWineRowServer_SetInnerUnk(new_server, obj);
|
|
hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk);
|
|
IUnknown_Release(obj);
|
|
|
|
TRACE("returning %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_SetColumns(IWineRowServer* iface, DBORDINAL num_cols,
|
|
wine_setcolumns_in *in_data, DBSTATUS *status)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
HRESULT hr;
|
|
DBORDINAL i;
|
|
DBCOLUMNACCESS *cols;
|
|
IRowChange *row_change;
|
|
|
|
TRACE("(%p)->(%ld, %p, %p)\n", This, num_cols, in_data, status);
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowChange, (void**)&row_change);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
cols = CoTaskMemAlloc(num_cols * sizeof(cols[0]));
|
|
|
|
for(i = 0; i < num_cols; i++)
|
|
{
|
|
TRACE("%ld:\ttype %04x\n", i, in_data[i].type);
|
|
cols[i].pData = CoTaskMemAlloc(db_type_size(in_data[i].type, in_data[i].max_len));
|
|
memcpy(cols[i].pData, &V_I1(&in_data[i].v), db_type_size(in_data[i].type, in_data[i].max_len));
|
|
cols[i].columnid = in_data[i].columnid;
|
|
cols[i].cbDataLen = in_data[i].data_len;
|
|
cols[i].dwStatus = in_data[i].status;
|
|
cols[i].cbMaxLen = in_data[i].max_len;
|
|
cols[i].wType = in_data[i].type;
|
|
cols[i].bPrecision = in_data[i].precision;
|
|
cols[i].bScale = in_data[i].scale;
|
|
}
|
|
|
|
hr = IRowChange_SetColumns(row_change, num_cols, cols);
|
|
IRowChange_Release(row_change);
|
|
|
|
for(i = 0; i < num_cols; i++)
|
|
{
|
|
CoTaskMemFree(cols[i].pData);
|
|
status[i] = cols[i].dwStatus;
|
|
}
|
|
|
|
CoTaskMemFree(cols);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_AddRefRows(IWineRowServer* iface, DBCOUNTITEM cRows,
|
|
const HROW rghRows[], DBREFCOUNT rgRefCounts[],
|
|
DBROWSTATUS rgRowStatus[])
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
IRowset *rowset;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%ld, %p, %p, %p)\n", This, cRows, rghRows, rgRefCounts, rgRowStatus);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IRowset_AddRefRows(rowset, cRows, rghRows, rgRefCounts, rgRowStatus);
|
|
|
|
IRowset_Release(rowset);
|
|
TRACE("returning %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetData(IWineRowServer* iface, HROW hRow,
|
|
HACCESSOR hAccessor, BYTE *pData, DWORD size)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
IRowset *rowset;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%08lx, %08lx, %p, %d)\n", This, hRow, hAccessor, pData, size);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IRowset_GetData(rowset, hRow, hAccessor, pData);
|
|
|
|
IRowset_Release(rowset);
|
|
TRACE("returning %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetNextRows(IWineRowServer* iface, HCHAPTER hReserved, DBROWOFFSET lRowsOffset,
|
|
DBROWCOUNT cRows, DBCOUNTITEM *pcRowObtained, HROW **prghRows)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
IRowset *rowset;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%08lx, %ld, %ld, %p, %p)\n", This, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
*prghRows = NULL;
|
|
|
|
hr = IRowset_GetNextRows(rowset, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
|
|
IRowset_Release(rowset);
|
|
TRACE("returning %08x, got %ld rows\n", hr, *pcRowObtained);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_ReleaseRows(IWineRowServer* iface, DBCOUNTITEM cRows, const HROW rghRows[],
|
|
DBROWOPTIONS rgRowOptions[], DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
IRowset *rowset;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%ld, %p, %p, %p, %p)\n", This, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IRowset_ReleaseRows(rowset, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
|
|
IRowset_Release(rowset);
|
|
|
|
TRACE("returning %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_RestartPosition(IWineRowServer* iface, HCHAPTER hReserved)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p)->(%08lx): stub\n", This, hReserved);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_Compare(IWineRowServer *iface, HCHAPTER hReserved, DBBKMARK cbBookmark1,
|
|
const BYTE *pBookmark1, DBBKMARK cbBookmark2, const BYTE *pBookmark2,
|
|
DBCOMPARE *pComparison)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p): stub\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetRowsAt(IWineRowServer *iface, HWATCHREGION hReserved1, HCHAPTER hReserved2,
|
|
DBBKMARK cbBookmark, const BYTE *pBookmark, DBROWOFFSET lRowsOffset,
|
|
DBROWCOUNT cRows, DBCOUNTITEM *pcRowsObtained, HROW **prghRows)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
IRowsetLocate *rowsetlocate;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%08lx, %08lx, %ld, %p, %ld, %ld, %p, %p\n", This, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset, cRows,
|
|
pcRowsObtained, prghRows);
|
|
|
|
*prghRows = NULL;
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowsetLocate, (void**)&rowsetlocate);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IRowsetLocate_GetRowsAt(rowsetlocate, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset,
|
|
cRows, pcRowsObtained, prghRows);
|
|
IRowsetLocate_Release(rowsetlocate);
|
|
|
|
TRACE("returning %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetRowsByBookmark(IWineRowServer *iface, HCHAPTER hReserved, DBCOUNTITEM cRows,
|
|
const DBBKMARK rgcbBookmarks[], const BYTE * rgpBookmarks[],
|
|
HROW rghRows[], DBROWSTATUS rgRowStatus[])
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p): stub\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_Hash(IWineRowServer *iface, HCHAPTER hReserved, DBBKMARK cBookmarks,
|
|
const DBBKMARK rgcbBookmarks[], const BYTE * rgpBookmarks[],
|
|
DBHASHVALUE rgHashedValues[], DBROWSTATUS rgBookmarkStatus[])
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p): stub\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetProperties(IWineRowServer* iface, ULONG cPropertyIDSets,
|
|
const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertySets,
|
|
DBPROPSET **prgPropertySets)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
IRowsetInfo *rowsetinfo;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowsetInfo, (void**)&rowsetinfo);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IRowsetInfo_GetProperties(rowsetinfo, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
|
|
IRowsetInfo_Release(rowsetinfo);
|
|
|
|
TRACE("returning %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetReferencedRowset(IWineRowServer* iface, DBORDINAL iOrdinal,
|
|
REFIID riid, IUnknown **ppReferencedRowset)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p): stub\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetSpecification(IWineRowServer* iface, REFIID riid,
|
|
IUnknown **ppSpecification)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p): stub\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_AddRefAccessor(IWineRowServer* iface, HACCESSOR hAccessor,
|
|
DBREFCOUNT *pcRefCount)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
FIXME("(%p): stub\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI server_CreateAccessor(IWineRowServer* iface, DBACCESSORFLAGS dwAccessorFlags,
|
|
DBCOUNTITEM cBindings, const DBBINDING *rgBindings, DBLENGTH cbRowSize,
|
|
HACCESSOR *phAccessor, DBBINDSTATUS *rgStatus)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
HRESULT hr;
|
|
IAccessor *accessor;
|
|
|
|
TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, rgStatus);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IAccessor, (void**)&accessor);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IAccessor_CreateAccessor(accessor, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, rgStatus);
|
|
IAccessor_Release(accessor);
|
|
|
|
TRACE("returning %08x, accessor %08lx\n", hr, *phAccessor);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_GetBindings(IWineRowServer* iface, HACCESSOR hAccessor,
|
|
DBACCESSORFLAGS *pdwAccessorFlags, DBCOUNTITEM *pcBindings,
|
|
DBBINDING **prgBindings)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
HRESULT hr;
|
|
IAccessor *accessor;
|
|
|
|
TRACE("(%p)->(%08lx, %p, %p, %p)\n", This, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IAccessor, (void**)&accessor);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IAccessor_GetBindings(accessor, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
|
|
IAccessor_Release(accessor);
|
|
|
|
TRACE("returning %08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI server_ReleaseAccessor(IWineRowServer* iface, HACCESSOR hAccessor,
|
|
DBREFCOUNT *pcRefCount)
|
|
{
|
|
server *This = impl_from_IWineRowServer(iface);
|
|
HRESULT hr;
|
|
IAccessor *accessor;
|
|
|
|
TRACE("(%p)->(%08lx, %p)\n", This, hAccessor, pcRefCount);
|
|
|
|
hr = IUnknown_QueryInterface(This->inner_unk, &IID_IAccessor, (void**)&accessor);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IAccessor_ReleaseAccessor(accessor, hAccessor, pcRefCount);
|
|
IAccessor_Release(accessor);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static const IWineRowServerVtbl server_vtbl =
|
|
{
|
|
server_QueryInterface,
|
|
server_AddRef,
|
|
server_Release,
|
|
server_SetInnerUnk,
|
|
server_GetMarshal,
|
|
server_GetColumns,
|
|
server_GetSourceRowset,
|
|
server_Open,
|
|
server_SetColumns,
|
|
server_AddRefRows,
|
|
server_GetData,
|
|
server_GetNextRows,
|
|
server_ReleaseRows,
|
|
server_RestartPosition,
|
|
server_Compare,
|
|
server_GetRowsAt,
|
|
server_GetRowsByBookmark,
|
|
server_Hash,
|
|
server_GetProperties,
|
|
server_GetReferencedRowset,
|
|
server_GetSpecification,
|
|
server_AddRefAccessor,
|
|
server_CreateAccessor,
|
|
server_GetBindings,
|
|
server_ReleaseAccessor
|
|
};
|
|
|
|
static HRESULT create_server(IUnknown *outer, const CLSID *class, void **obj)
|
|
{
|
|
server *server;
|
|
TRACE("(%p, %s, %p)\n", outer, debugstr_guid(class), obj);
|
|
|
|
*obj = NULL;
|
|
|
|
server = HeapAlloc(GetProcessHeap(), 0, sizeof(*server));
|
|
if(!server) return E_OUTOFMEMORY;
|
|
|
|
server->IWineRowServer_iface.lpVtbl = &server_vtbl;
|
|
server->ref = 1;
|
|
server->class = *class;
|
|
server->inner_unk = NULL;
|
|
if(IsEqualGUID(class, &CLSID_wine_row_server))
|
|
create_row_marshal((IUnknown*)server, (void**)&server->marshal);
|
|
else if(IsEqualGUID(class, &CLSID_wine_rowset_server))
|
|
create_rowset_marshal((IUnknown*)server, (void**)&server->marshal);
|
|
else
|
|
ERR("create_server called with class %s\n", debugstr_guid(class));
|
|
|
|
*obj = server;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT create_row_server(IUnknown *outer, void **obj)
|
|
{
|
|
return create_server(outer, &CLSID_wine_row_server, obj);
|
|
}
|
|
|
|
HRESULT create_rowset_server(IUnknown *outer, void **obj)
|
|
{
|
|
return create_server(outer, &CLSID_wine_rowset_server, obj);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
IRow IRow_iface;
|
|
IRowChange IRowChange_iface;
|
|
|
|
LONG ref;
|
|
|
|
IWineRowServer *server;
|
|
} row_proxy;
|
|
|
|
static inline row_proxy *impl_from_IRow(IRow *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, row_proxy, IRow_iface);
|
|
}
|
|
|
|
static inline row_proxy *impl_from_IRowChange(IRowChange *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, row_proxy, IRowChange_iface);
|
|
}
|
|
|
|
static HRESULT WINAPI row_QueryInterface(IRow *iface, REFIID iid, void **obj)
|
|
{
|
|
row_proxy *This = impl_from_IRow(iface);
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
|
|
|
|
if(IsEqualIID(iid, &IID_IUnknown) ||
|
|
IsEqualIID(iid, &IID_IRow))
|
|
{
|
|
*obj = &This->IRow_iface;
|
|
}
|
|
else if(IsEqualIID(iid, &IID_IRowChange))
|
|
{
|
|
*obj = &This->IRowChange_iface;
|
|
}
|
|
else
|
|
{
|
|
FIXME("interface %s not implemented\n", debugstr_guid(iid));
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IRow_AddRef(iface);
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI row_AddRef(IRow *iface)
|
|
{
|
|
row_proxy *This = impl_from_IRow(iface);
|
|
TRACE("(%p)\n", This);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI row_Release(IRow *iface)
|
|
{
|
|
row_proxy *This = impl_from_IRow(iface);
|
|
LONG ref;
|
|
|
|
TRACE("(%p)\n", This);
|
|
|
|
ref = InterlockedDecrement(&This->ref);
|
|
if(ref == 0)
|
|
{
|
|
if(This->server) IWineRowServer_Release(This->server);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
static HRESULT WINAPI row_GetColumns(IRow* iface, DBORDINAL cColumns, DBCOLUMNACCESS rgColumns[])
|
|
{
|
|
row_proxy *This = impl_from_IRow(iface);
|
|
DBORDINAL i;
|
|
wine_getcolumns_in *in_data;
|
|
wine_getcolumns_out *out_data;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%ld, %p)\n", This, cColumns, rgColumns);
|
|
|
|
in_data = CoTaskMemAlloc(cColumns * sizeof(in_data[0]));
|
|
out_data = CoTaskMemAlloc(cColumns * sizeof(out_data[0]));
|
|
|
|
for(i = 0; i < cColumns; i++)
|
|
{
|
|
TRACE("%ld:\tdata %p data_len %ld status %08x max_len %ld type %04x\n", i, rgColumns[i].pData,
|
|
rgColumns[i].cbDataLen, rgColumns[i].dwStatus, rgColumns[i].cbMaxLen, rgColumns[i].wType);
|
|
in_data[i].columnid = rgColumns[i].columnid;
|
|
in_data[i].max_len = rgColumns[i].cbMaxLen;
|
|
in_data[i].type = rgColumns[i].wType;
|
|
in_data[i].precision = rgColumns[i].bPrecision;
|
|
in_data[i].scale = rgColumns[i].bScale;
|
|
}
|
|
|
|
hr = IWineRowServer_GetColumns(This->server, cColumns, in_data, out_data);
|
|
|
|
for(i = 0; i < cColumns; i++)
|
|
{
|
|
rgColumns[i].cbDataLen = out_data[i].data_len;
|
|
rgColumns[i].dwStatus = out_data[i].status;
|
|
if(rgColumns[i].dwStatus == DBSTATUS_S_OK)
|
|
memcpy(rgColumns[i].pData, &V_I1(&out_data[i].v), out_data[i].data_len);
|
|
}
|
|
|
|
CoTaskMemFree(out_data);
|
|
CoTaskMemFree(in_data);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI row_GetSourceRowset(IRow* iface, REFIID riid, IUnknown **ppRowset,
|
|
HROW *phRow)
|
|
{
|
|
row_proxy *This = impl_from_IRow(iface);
|
|
|
|
FIXME("(%p)->(%s, %p, %p): stub\n", This, debugstr_guid(riid), ppRowset, phRow);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI row_Open(IRow* iface, IUnknown *pUnkOuter,
|
|
DBID *pColumnID, REFGUID rguidColumnType,
|
|
DWORD dwBindFlags, REFIID riid, IUnknown **ppUnk)
|
|
{
|
|
row_proxy *This = impl_from_IRow(iface);
|
|
|
|
TRACE("(%p)->(%p, %p, %s, %08x, %s, %p)\n", This, pUnkOuter, pColumnID, debugstr_guid(rguidColumnType),
|
|
dwBindFlags, debugstr_guid(riid), ppUnk);
|
|
if(pUnkOuter)
|
|
{
|
|
FIXME("Aggregation not supported\n");
|
|
return CLASS_E_NOAGGREGATION;
|
|
}
|
|
|
|
return IWineRowServer_Open(This->server, pUnkOuter, pColumnID, rguidColumnType, dwBindFlags, riid, ppUnk);
|
|
}
|
|
|
|
static const IRowVtbl row_vtbl =
|
|
{
|
|
row_QueryInterface,
|
|
row_AddRef,
|
|
row_Release,
|
|
row_GetColumns,
|
|
row_GetSourceRowset,
|
|
row_Open
|
|
};
|
|
|
|
static HRESULT WINAPI row_change_QueryInterface(IRowChange *iface, REFIID iid, void **obj)
|
|
{
|
|
row_proxy *This = impl_from_IRowChange(iface);
|
|
return IUnknown_QueryInterface((IUnknown *)This, iid, obj);
|
|
}
|
|
|
|
static ULONG WINAPI row_change_AddRef(IRowChange *iface)
|
|
{
|
|
row_proxy *This = impl_from_IRowChange(iface);
|
|
return IUnknown_AddRef((IUnknown*)This);
|
|
}
|
|
|
|
static ULONG WINAPI row_change_Release(IRowChange *iface)
|
|
{
|
|
row_proxy *This = impl_from_IRowChange(iface);
|
|
return IUnknown_Release((IUnknown*)This);
|
|
}
|
|
|
|
static HRESULT WINAPI row_change_SetColumns(IRowChange *iface, DBORDINAL cColumns,
|
|
DBCOLUMNACCESS rgColumns[])
|
|
{
|
|
row_proxy *This = impl_from_IRowChange(iface);
|
|
HRESULT hr;
|
|
wine_setcolumns_in *in_data;
|
|
DBSTATUS *status;
|
|
DBORDINAL i;
|
|
|
|
TRACE("(%p)->(%ld, %p)\n", This, cColumns, rgColumns);
|
|
|
|
in_data = CoTaskMemAlloc(cColumns * sizeof(in_data[0]));
|
|
status = CoTaskMemAlloc(cColumns * sizeof(status[0]));
|
|
|
|
for(i = 0; i < cColumns; i++)
|
|
{
|
|
TRACE("%ld: wtype %04x max %08lx len %08lx\n", i, rgColumns[i].wType, rgColumns[i].cbMaxLen, rgColumns[i].cbDataLen);
|
|
V_VT(&in_data[i].v) = rgColumns[i].wType;
|
|
memcpy(&V_I1(&in_data[i].v), rgColumns[i].pData, db_type_size(rgColumns[i].wType, rgColumns[i].cbDataLen));
|
|
in_data[i].columnid = rgColumns[i].columnid;
|
|
in_data[i].data_len = rgColumns[i].cbDataLen;
|
|
in_data[i].status = rgColumns[i].dwStatus;
|
|
in_data[i].max_len = rgColumns[i].cbMaxLen;
|
|
in_data[i].type = rgColumns[i].wType;
|
|
in_data[i].precision = rgColumns[i].bPrecision;
|
|
in_data[i].scale = rgColumns[i].bScale;
|
|
}
|
|
|
|
hr = IWineRowServer_SetColumns(This->server, cColumns, in_data, status);
|
|
|
|
for(i = 0; i < cColumns; i++)
|
|
rgColumns[i].dwStatus = status[i];
|
|
|
|
CoTaskMemFree(status);
|
|
CoTaskMemFree(in_data);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static const IRowChangeVtbl row_change_vtbl =
|
|
{
|
|
row_change_QueryInterface,
|
|
row_change_AddRef,
|
|
row_change_Release,
|
|
row_change_SetColumns
|
|
};
|
|
|
|
static HRESULT create_row_proxy(IWineRowServer *server, IUnknown **obj)
|
|
{
|
|
row_proxy *proxy;
|
|
|
|
TRACE("(%p, %p)\n", server, obj);
|
|
*obj = NULL;
|
|
|
|
proxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*proxy));
|
|
if(!proxy) return E_OUTOFMEMORY;
|
|
|
|
proxy->IRow_iface.lpVtbl = &row_vtbl;
|
|
proxy->IRowChange_iface.lpVtbl = &row_change_vtbl;
|
|
proxy->ref = 1;
|
|
IWineRowServer_AddRef(server);
|
|
proxy->server = server;
|
|
|
|
*obj = (IUnknown*)&proxy->IRow_iface;
|
|
TRACE("returning %p\n", *obj);
|
|
return S_OK;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
IRowsetLocate IRowsetLocate_iface;
|
|
IRowsetInfo IRowsetInfo_iface;
|
|
IAccessor IAccessor_iface;
|
|
|
|
LONG ref;
|
|
|
|
IWineRowServer *server;
|
|
} rowset_proxy;
|
|
|
|
static inline rowset_proxy *impl_from_IRowsetLocate(IRowsetLocate *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, rowset_proxy, IRowsetLocate_iface);
|
|
}
|
|
|
|
static inline rowset_proxy *impl_from_IRowsetInfo(IRowsetInfo *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, rowset_proxy, IRowsetInfo_iface);
|
|
}
|
|
|
|
static inline rowset_proxy *impl_from_IAccessor(IAccessor *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, rowset_proxy, IAccessor_iface);
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_QueryInterface(IRowsetLocate *iface, REFIID iid, void **obj)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
|
|
|
|
*obj = NULL;
|
|
|
|
if(IsEqualIID(iid, &IID_IUnknown) ||
|
|
IsEqualIID(iid, &IID_IRowset) ||
|
|
IsEqualIID(iid, &IID_IRowsetLocate))
|
|
{
|
|
*obj = &This->IRowsetLocate_iface;
|
|
}
|
|
else if(IsEqualIID(iid, &IID_IRowsetInfo))
|
|
{
|
|
*obj = &This->IRowsetInfo_iface;
|
|
}
|
|
else if(IsEqualIID(iid, &IID_IAccessor))
|
|
{
|
|
*obj = &This->IAccessor_iface;
|
|
}
|
|
else
|
|
{
|
|
FIXME("interface %s not implemented\n", debugstr_guid(iid));
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IRowsetLocate_AddRef(iface);
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI rowsetlocate_AddRef(IRowsetLocate *iface)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
TRACE("(%p)\n", This);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI rowsetlocate_Release(IRowsetLocate *iface)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
LONG ref;
|
|
|
|
TRACE("(%p)\n", This);
|
|
|
|
ref = InterlockedDecrement(&This->ref);
|
|
if(ref == 0)
|
|
{
|
|
if(This->server) IWineRowServer_Release(This->server);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_AddRefRows(IRowsetLocate *iface, DBCOUNTITEM cRows, const HROW rghRows[],
|
|
DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
HRESULT hr;
|
|
DBREFCOUNT *refs = rgRefCounts;
|
|
DBSTATUS *stats = rgRowStatus;
|
|
|
|
TRACE("(%p)->(%ld, %p, %p, %p)\n", This, cRows, rghRows, rgRefCounts, rgRowStatus);
|
|
|
|
if(!refs) refs = CoTaskMemAlloc(cRows * sizeof(refs[0]));
|
|
if(!stats) stats = CoTaskMemAlloc(cRows * sizeof(stats[0]));
|
|
|
|
hr = IWineRowServer_AddRefRows(This->server, cRows, rghRows, refs, stats);
|
|
|
|
if(refs != rgRefCounts) CoTaskMemFree(refs);
|
|
if(stats != rgRowStatus) CoTaskMemFree(stats);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_GetData(IRowsetLocate *iface, HROW hRow, HACCESSOR hAccessor, void *pData)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
HRESULT hr;
|
|
IAccessor *accessor;
|
|
DBACCESSORFLAGS flags;
|
|
DBCOUNTITEM count, i;
|
|
DBBINDING *bindings;
|
|
DWORD max_len = 0;
|
|
|
|
TRACE("(%p)->(%lx, %lx, %p)\n", This, hRow, hAccessor, pData);
|
|
|
|
hr = IRowsetLocate_QueryInterface(iface, &IID_IAccessor, (void**)&accessor);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
hr = IAccessor_GetBindings(accessor, hAccessor, &flags, &count, &bindings);
|
|
IAccessor_Release(accessor);
|
|
if(FAILED(hr)) return hr;
|
|
|
|
TRACE("got %ld bindings\n", count);
|
|
for(i = 0; i < count; i++)
|
|
{
|
|
TRACE("%ld\tord %ld offs: val %ld len %ld stat %ld, part %x, max len %ld type %04x\n",
|
|
i, bindings[i].iOrdinal, bindings[i].obValue, bindings[i].obLength, bindings[i].obStatus,
|
|
bindings[i].dwPart, bindings[i].cbMaxLen, bindings[i].wType);
|
|
if(bindings[i].dwPart & DBPART_LENGTH && bindings[i].obLength >= max_len)
|
|
max_len = bindings[i].obLength + sizeof(DBLENGTH);
|
|
if(bindings[i].dwPart & DBPART_STATUS && bindings[i].obStatus >= max_len)
|
|
max_len = bindings[i].obStatus + sizeof(DWORD);
|
|
if(bindings[i].dwPart & DBPART_VALUE && bindings[i].obValue >= max_len)
|
|
max_len = bindings[i].obValue + db_type_size(bindings[i].wType, bindings[i].cbMaxLen);
|
|
|
|
}
|
|
TRACE("max_len %d\n", max_len);
|
|
|
|
CoTaskMemFree(bindings);
|
|
|
|
hr = IWineRowServer_GetData(This->server, hRow, hAccessor, pData, max_len);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_GetNextRows(IRowsetLocate *iface, HCHAPTER hReserved, DBROWOFFSET lRowsOffset,
|
|
DBROWCOUNT cRows, DBCOUNTITEM *pcRowObtained, HROW **prghRows)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
HRESULT hr;
|
|
HROW *rows = NULL;
|
|
|
|
TRACE("(%p)->(%08lx, %ld, %ld, %p, %p)\n", This, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
|
|
|
|
hr = IWineRowServer_GetNextRows(This->server, hReserved, lRowsOffset, cRows, pcRowObtained, &rows);
|
|
if(*prghRows)
|
|
{
|
|
memcpy(*prghRows, rows, *pcRowObtained * sizeof(rows[0]));
|
|
CoTaskMemFree(rows);
|
|
}
|
|
else
|
|
*prghRows = rows;
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_ReleaseRows(IRowsetLocate *iface, DBCOUNTITEM cRows, const HROW rghRows[],
|
|
DBROWOPTIONS rgRowOptions[], DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
HRESULT hr;
|
|
DBROWOPTIONS *options = rgRowOptions;
|
|
DBREFCOUNT *refs = rgRefCounts;
|
|
DBROWSTATUS *status = rgRowStatus;
|
|
|
|
TRACE("(%p)->(%ld, %p, %p, %p, %p)\n", This, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
|
|
|
|
if(!options)
|
|
{
|
|
options = CoTaskMemAlloc(cRows * sizeof(options[0]));
|
|
memset(options, 0, cRows * sizeof(options[0]));
|
|
}
|
|
if(!refs) refs = CoTaskMemAlloc(cRows * sizeof(refs[0]));
|
|
if(!status) status = CoTaskMemAlloc(cRows * sizeof(status[0]));
|
|
|
|
hr = IWineRowServer_ReleaseRows(This->server, cRows, rghRows, options, refs, status);
|
|
|
|
if(status != rgRowStatus) CoTaskMemFree(status);
|
|
if(refs != rgRefCounts) CoTaskMemFree(refs);
|
|
if(options != rgRowOptions) CoTaskMemFree(options);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_RestartPosition(IRowsetLocate* iface, HCHAPTER hReserved)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
|
|
FIXME("(%p)->(%lx): stub\n", This, hReserved);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_Compare(IRowsetLocate *iface, HCHAPTER hReserved, DBBKMARK cbBookmark1, const BYTE *pBookmark1,
|
|
DBBKMARK cbBookmark2, const BYTE *pBookmark2, DBCOMPARE *pComparison)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
FIXME("(%p)\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_GetRowsAt(IRowsetLocate *iface, HWATCHREGION hReserved1, HCHAPTER hReserved2, DBBKMARK cbBookmark,
|
|
const BYTE *pBookmark, DBROWOFFSET lRowsOffset, DBROWCOUNT cRows, DBCOUNTITEM *pcRowsObtained,
|
|
HROW **prghRows)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
HRESULT hr;
|
|
HROW *rows = NULL;
|
|
|
|
TRACE("(%p)->(%08lx, %08lx, %ld, %p, %ld, %ld, %p, %p\n", This, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset, cRows,
|
|
pcRowsObtained, prghRows);
|
|
|
|
hr = IWineRowServer_GetRowsAt(This->server, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset, cRows, pcRowsObtained, &rows);
|
|
|
|
if(*prghRows)
|
|
{
|
|
memcpy(*prghRows, rows, *pcRowsObtained * sizeof(rows[0]));
|
|
CoTaskMemFree(rows);
|
|
}
|
|
else
|
|
*prghRows = rows;
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_GetRowsByBookmark(IRowsetLocate *iface, HCHAPTER hReserved, DBCOUNTITEM cRows, const DBBKMARK rgcbBookmarks[],
|
|
const BYTE * rgpBookmarks[], HROW rghRows[], DBROWSTATUS rgRowStatus[])
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
FIXME("(%p)\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetlocate_Hash(IRowsetLocate *iface, HCHAPTER hReserved, DBBKMARK cBookmarks, const DBBKMARK rgcbBookmarks[],
|
|
const BYTE * rgpBookmarks[], DBHASHVALUE rgHashedValues[], DBROWSTATUS rgBookmarkStatus[])
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetLocate(iface);
|
|
FIXME("(%p)\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IRowsetLocateVtbl rowsetlocate_vtbl =
|
|
{
|
|
rowsetlocate_QueryInterface,
|
|
rowsetlocate_AddRef,
|
|
rowsetlocate_Release,
|
|
rowsetlocate_AddRefRows,
|
|
rowsetlocate_GetData,
|
|
rowsetlocate_GetNextRows,
|
|
rowsetlocate_ReleaseRows,
|
|
rowsetlocate_RestartPosition,
|
|
rowsetlocate_Compare,
|
|
rowsetlocate_GetRowsAt,
|
|
rowsetlocate_GetRowsByBookmark,
|
|
rowsetlocate_Hash
|
|
};
|
|
|
|
static HRESULT WINAPI rowsetinfo_QueryInterface(IRowsetInfo *iface, REFIID iid, void **obj)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetInfo(iface);
|
|
return IUnknown_QueryInterface((IUnknown *)This, iid, obj);
|
|
}
|
|
|
|
static ULONG WINAPI rowsetinfo_AddRef(IRowsetInfo *iface)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetInfo(iface);
|
|
return IUnknown_AddRef((IUnknown *)This);
|
|
}
|
|
|
|
static ULONG WINAPI rowsetinfo_Release(IRowsetInfo *iface)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetInfo(iface);
|
|
return IUnknown_Release((IUnknown *)This);
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetinfo_GetProperties(IRowsetInfo *iface, const ULONG cPropertyIDSets,
|
|
const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets,
|
|
DBPROPSET **prgPropertySets)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetInfo(iface);
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
|
|
|
|
hr = IWineRowServer_GetProperties(This->server, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetinfo_GetReferencedRowset(IRowsetInfo *iface, DBORDINAL iOrdinal, REFIID riid,
|
|
IUnknown **ppReferencedRowset)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetInfo(iface);
|
|
FIXME("(%p)\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI rowsetinfo_GetSpecification(IRowsetInfo *iface, REFIID riid, IUnknown **ppSpecification)
|
|
{
|
|
rowset_proxy *This = impl_from_IRowsetInfo(iface);
|
|
FIXME("(%p)\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IRowsetInfoVtbl rowsetinfo_vtbl =
|
|
{
|
|
rowsetinfo_QueryInterface,
|
|
rowsetinfo_AddRef,
|
|
rowsetinfo_Release,
|
|
rowsetinfo_GetProperties,
|
|
rowsetinfo_GetReferencedRowset,
|
|
rowsetinfo_GetSpecification
|
|
};
|
|
|
|
static HRESULT WINAPI accessor_QueryInterface(IAccessor *iface, REFIID iid, void **obj)
|
|
{
|
|
rowset_proxy *This = impl_from_IAccessor(iface);
|
|
return IUnknown_QueryInterface((IUnknown *)This, iid, obj);
|
|
}
|
|
|
|
static ULONG WINAPI accessor_AddRef(IAccessor *iface)
|
|
{
|
|
rowset_proxy *This = impl_from_IAccessor(iface);
|
|
return IUnknown_AddRef((IUnknown *)This);
|
|
}
|
|
|
|
static ULONG WINAPI accessor_Release(IAccessor *iface)
|
|
{
|
|
rowset_proxy *This = impl_from_IAccessor(iface);
|
|
return IUnknown_Release((IUnknown *)This);
|
|
}
|
|
|
|
static HRESULT WINAPI accessor_AddRefAccessor(IAccessor *iface, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
|
|
{
|
|
rowset_proxy *This = impl_from_IAccessor(iface);
|
|
FIXME("(%p)\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI accessor_CreateAccessor(IAccessor *iface, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings,
|
|
const DBBINDING rgBindings[], DBLENGTH cbRowSize, HACCESSOR *phAccessor,
|
|
DBBINDSTATUS rgStatus[])
|
|
{
|
|
rowset_proxy *This = impl_from_IAccessor(iface);
|
|
HRESULT hr;
|
|
DBBINDSTATUS *status;
|
|
|
|
TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, rgStatus);
|
|
|
|
if(!rgStatus) status = CoTaskMemAlloc(cBindings * sizeof(status[0]));
|
|
else status = rgStatus;
|
|
|
|
hr = IWineRowServer_CreateAccessor(This->server, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, status);
|
|
|
|
if(!rgStatus) CoTaskMemFree(status);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI accessor_GetBindings(IAccessor *iface, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags,
|
|
DBCOUNTITEM *pcBindings, DBBINDING **prgBindings)
|
|
{
|
|
rowset_proxy *This = impl_from_IAccessor(iface);
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%08lx, %p, %p, %p)\n", This, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
|
|
|
|
hr = IWineRowServer_GetBindings(This->server, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI accessor_ReleaseAccessor(IAccessor *iface, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
|
|
{
|
|
rowset_proxy *This = impl_from_IAccessor(iface);
|
|
HRESULT hr;
|
|
DBREFCOUNT ref;
|
|
|
|
TRACE("(%p)->(%08lx, %p)\n", This, hAccessor, pcRefCount);
|
|
|
|
hr = IWineRowServer_ReleaseAccessor(This->server, hAccessor, &ref);
|
|
if(pcRefCount) *pcRefCount = ref;
|
|
return hr;
|
|
}
|
|
|
|
static const IAccessorVtbl accessor_vtbl =
|
|
{
|
|
accessor_QueryInterface,
|
|
accessor_AddRef,
|
|
accessor_Release,
|
|
accessor_AddRefAccessor,
|
|
accessor_CreateAccessor,
|
|
accessor_GetBindings,
|
|
accessor_ReleaseAccessor
|
|
};
|
|
|
|
static HRESULT create_rowset_proxy(IWineRowServer *server, IUnknown **obj)
|
|
{
|
|
rowset_proxy *proxy;
|
|
|
|
TRACE("(%p, %p)\n", server, obj);
|
|
*obj = NULL;
|
|
|
|
proxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*proxy));
|
|
if(!proxy) return E_OUTOFMEMORY;
|
|
|
|
proxy->IRowsetLocate_iface.lpVtbl = &rowsetlocate_vtbl;
|
|
proxy->IRowsetInfo_iface.lpVtbl = &rowsetinfo_vtbl;
|
|
proxy->IAccessor_iface.lpVtbl = &accessor_vtbl;
|
|
proxy->ref = 1;
|
|
IWineRowServer_AddRef(server);
|
|
proxy->server = server;
|
|
|
|
*obj = (IUnknown *)&proxy->IRowsetLocate_iface;
|
|
TRACE("returning %p\n", *obj);
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT create_proxy(IWineRowServer *server, const CLSID *class, IUnknown **obj)
|
|
{
|
|
*obj = NULL;
|
|
|
|
if(IsEqualGUID(class, &CLSID_wine_row_proxy))
|
|
return create_row_proxy(server, obj);
|
|
else if(IsEqualGUID(class, &CLSID_wine_rowset_proxy))
|
|
return create_rowset_proxy(server, obj);
|
|
else
|
|
FIXME("Unhandled proxy class %s\n", debugstr_guid(class));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/* Marshal impl */
|
|
|
|
typedef struct
|
|
{
|
|
IMarshal IMarshal_iface;
|
|
|
|
LONG ref;
|
|
CLSID unmarshal_class;
|
|
IUnknown *outer;
|
|
} marshal;
|
|
|
|
static inline marshal *impl_from_IMarshal(IMarshal *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, marshal, IMarshal_iface);
|
|
}
|
|
|
|
static HRESULT WINAPI marshal_QueryInterface(IMarshal *iface, REFIID iid, void **obj)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
|
|
|
|
if(IsEqualIID(iid, &IID_IUnknown) ||
|
|
IsEqualIID(iid, &IID_IMarshal))
|
|
{
|
|
*obj = iface;
|
|
}
|
|
else
|
|
{
|
|
FIXME("interface %s not implemented\n", debugstr_guid(iid));
|
|
*obj = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IMarshal_AddRef(iface);
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI marshal_AddRef(IMarshal *iface)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
TRACE("(%p)\n", This);
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI marshal_Release(IMarshal *iface)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
LONG ref;
|
|
|
|
TRACE("(%p)\n", This);
|
|
|
|
ref = InterlockedDecrement(&This->ref);
|
|
if(ref == 0)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
static HRESULT WINAPI marshal_GetUnmarshalClass(IMarshal *iface, REFIID iid, void *obj,
|
|
DWORD dwDestContext, void *pvDestContext,
|
|
DWORD mshlflags, CLSID *clsid)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
TRACE("(%p)->(%s, %p, %08x, %p, %08x, %p)\n", This, debugstr_guid(iid), obj, dwDestContext,
|
|
pvDestContext, mshlflags, clsid);
|
|
|
|
*clsid = This->unmarshal_class;
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI marshal_GetMarshalSizeMax(IMarshal *iface, REFIID iid, void *obj,
|
|
DWORD dwDestContext, void *pvDestContext,
|
|
DWORD mshlflags, DWORD *size)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
TRACE("(%p)->(%s, %p, %08x, %p, %08x, %p)\n", This, debugstr_guid(iid), obj, dwDestContext,
|
|
pvDestContext, mshlflags, size);
|
|
|
|
return CoGetMarshalSizeMax(size, &IID_IWineRowServer, This->outer, dwDestContext, pvDestContext,
|
|
mshlflags);
|
|
}
|
|
|
|
static HRESULT WINAPI marshal_MarshalInterface(IMarshal *iface, IStream *stream, REFIID iid,
|
|
void *obj, DWORD dwDestContext, void *pvDestContext,
|
|
DWORD mshlflags)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
TRACE("(%p)->(%p, %s, %p, %08x, %p, %08x)\n", This, stream, debugstr_guid(iid), obj, dwDestContext,
|
|
pvDestContext, mshlflags);
|
|
|
|
return CoMarshalInterface(stream, &IID_IWineRowServer, This->outer, dwDestContext, pvDestContext, mshlflags);
|
|
}
|
|
|
|
static HRESULT WINAPI marshal_UnmarshalInterface(IMarshal *iface, IStream *stream,
|
|
REFIID iid, void **obj)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
HRESULT hr;
|
|
IWineRowServer *server;
|
|
IUnknown *proxy;
|
|
|
|
TRACE("(%p)->(%p, %s, %p)\n", This, stream, debugstr_guid(iid), obj);
|
|
*obj = NULL;
|
|
|
|
hr = CoUnmarshalInterface(stream, &IID_IWineRowServer, (void**)&server);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = create_proxy(server, &This->unmarshal_class, &proxy);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = IUnknown_QueryInterface(proxy, iid, obj);
|
|
IUnknown_Release(proxy);
|
|
}
|
|
IWineRowServer_Release(server);
|
|
}
|
|
|
|
TRACE("returning %p\n", *obj);
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI marshal_ReleaseMarshalData(IMarshal *iface, IStream *stream)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
TRACE("(%p)->(%p)\n", This, stream);
|
|
return CoReleaseMarshalData(stream);
|
|
}
|
|
|
|
static HRESULT WINAPI marshal_DisconnectObject(IMarshal *iface, DWORD dwReserved)
|
|
{
|
|
marshal *This = impl_from_IMarshal(iface);
|
|
FIXME("(%p)->(%08x)\n", This, dwReserved);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const IMarshalVtbl marshal_vtbl =
|
|
{
|
|
marshal_QueryInterface,
|
|
marshal_AddRef,
|
|
marshal_Release,
|
|
marshal_GetUnmarshalClass,
|
|
marshal_GetMarshalSizeMax,
|
|
marshal_MarshalInterface,
|
|
marshal_UnmarshalInterface,
|
|
marshal_ReleaseMarshalData,
|
|
marshal_DisconnectObject
|
|
};
|
|
|
|
static HRESULT create_marshal(IUnknown *outer, const CLSID *class, void **obj)
|
|
{
|
|
marshal *marshal;
|
|
|
|
TRACE("(%p, %p)\n", outer, obj);
|
|
*obj = NULL;
|
|
|
|
marshal = HeapAlloc(GetProcessHeap(), 0, sizeof(*marshal));
|
|
if(!marshal) return E_OUTOFMEMORY;
|
|
|
|
marshal->unmarshal_class = *class;
|
|
marshal->outer = outer; /* don't ref outer unk */
|
|
marshal->IMarshal_iface.lpVtbl = &marshal_vtbl;
|
|
marshal->ref = 1;
|
|
|
|
*obj = &marshal->IMarshal_iface;
|
|
TRACE("returning %p\n", *obj);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT create_row_marshal(IUnknown *outer, void **obj)
|
|
{
|
|
TRACE("(%p, %p)\n", outer, obj);
|
|
return create_marshal(outer, &CLSID_wine_row_proxy, obj);
|
|
}
|
|
|
|
HRESULT create_rowset_marshal(IUnknown *outer, void **obj)
|
|
{
|
|
TRACE("(%p, %p)\n", outer, obj);
|
|
return create_marshal(outer, &CLSID_wine_rowset_proxy, obj);
|
|
}
|