dlls/msdaps/row_server.c

   1 /*
   2  *    Row and rowset servers / proxies.
   3  *
   4  * Copyright 2010 Huw Davies
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include <stdarg.h>
  21 #include <string.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "winerror.h"
  32 #include "objbase.h"
  33 #include "oleauto.h"
  34 #include "oledb.h"
  35
  36 #include "row_server.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  41
  42 static inline DBLENGTH db_type_size(DBTYPE type, DBLENGTH var_len)
  43 {
  44     switch(type)
  45     {
  46     case DBTYPE_I1:
  47     case DBTYPE_UI1:
  48         return 1;
  49     case DBTYPE_I2:
  50     case DBTYPE_UI2:
  51         return 2;
  52     case DBTYPE_I4:
  53     case DBTYPE_UI4:
  54     case DBTYPE_R4:
  55         return 4;
  56     case DBTYPE_I8:
  57     case DBTYPE_UI8:
  58     case DBTYPE_R8:
  59         return 8;
  60     case DBTYPE_CY:
  61         return sizeof(CY);
  62     case DBTYPE_FILETIME:
  63         return sizeof(FILETIME);
  64     case DBTYPE_BSTR:
  65         return sizeof(BSTR);
  66     case DBTYPE_GUID:
  67         return sizeof(GUID);
  68     case DBTYPE_WSTR:
  69         return var_len;
  70     default:
  71         FIXME("Unhandled type %04x\n", type);
  72         return 0;
  73     }
  74 }
  75
  76 typedef struct
  77 {
  78     IWineRowServer IWineRowServer_iface;
  79
  80     LONG ref;
  81
  82     CLSID class;
  83     IMarshal *marshal;
  84     IUnknown *inner_unk;
  85 } server;
  86
  87 static inline server *impl_from_IWineRowServer(IWineRowServer *iface)
  88 {
  89     return CONTAINING_RECORD(iface, server, IWineRowServer_iface);
  90 }
  91
  92 static HRESULT WINAPI server_QueryInterface(IWineRowServer *iface, REFIID riid, void **obj)
  93 {
  94     server *This = impl_from_IWineRowServer(iface);
  95     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
  96
  97     *obj = NULL;
  98
  99     if(IsEqualIID(riid, &IID_IUnknown) ||
 100        IsEqualIID(riid, &IID_IWineRowServer))
 101     {
 102         *obj = iface;
 103     }
 104     else
 105     {
 106         if(!IsEqualIID(riid, &IID_IMarshal)) /* We use standard marshalling */
 107             FIXME("interface %s not implemented\n", debugstr_guid(riid));
 108         return E_NOINTERFACE;
 109     }
 110
 111     IWineRowServer_AddRef(iface);
 112     return S_OK;
 113 }
 114
 115 static ULONG WINAPI server_AddRef(IWineRowServer *iface)
 116 {
 117     server *This = impl_from_IWineRowServer(iface);
 118     TRACE("(%p)\n", This);
 119
 120     return InterlockedIncrement(&This->ref);
 121 }
 122
 123 static ULONG WINAPI server_Release(IWineRowServer *iface)
 124 {
 125     server *This = impl_from_IWineRowServer(iface);
 126     LONG ref;
 127
 128     TRACE("(%p)\n", This);
 129
 130     ref = InterlockedDecrement(&This->ref);
 131     if(ref == 0)
 132     {
 133         IMarshal_Release(This->marshal);
 134         if(This->inner_unk) IUnknown_Release(This->inner_unk);
 135         HeapFree(GetProcessHeap(), 0, This);
 136     }
 137
 138     return ref;
 139 }
 140
 141 static HRESULT WINAPI server_SetInnerUnk(IWineRowServer *iface, IUnknown *inner)
 142 {
 143     server *This = impl_from_IWineRowServer(iface);
 144
 145     if(This->inner_unk) IUnknown_Release(This->inner_unk);
 146
 147     if(inner) IUnknown_AddRef(inner);
 148     This->inner_unk = inner;
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI server_GetMarshal(IWineRowServer *iface, IMarshal **marshal)
 153 {
 154     server *This = impl_from_IWineRowServer(iface);
 155
 156     IMarshal_AddRef(This->marshal);
 157     *marshal = This->marshal;
 158     return S_OK;
 159 }
 160
 161 static HRESULT WINAPI server_GetColumns(IWineRowServer* iface, DBORDINAL num_cols,
 162                                         wine_getcolumns_in *in_data, wine_getcolumns_out *out_data)
 163 {
 164     server *This = impl_from_IWineRowServer(iface);
 165     HRESULT hr;
 166     DBORDINAL i;
 167     DBCOLUMNACCESS *cols;
 168     IRow *row;
 169
 170     TRACE("(%p)->(%ld, %p, %p)\n", This, num_cols, in_data, out_data);
 171
 172     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRow, (void**)&row);
 173     if(FAILED(hr)) return hr;
 174
 175     cols = CoTaskMemAlloc(num_cols * sizeof(cols[0]));
 176
 177     for(i = 0; i < num_cols; i++)
 178     {
 179         TRACE("%ld:\tmax_len %ld type %04x\n", i, in_data[i].max_len, in_data[i].type);
 180         cols[i].pData        = CoTaskMemAlloc(db_type_size(in_data[i].type, in_data[i].max_len));
 181         cols[i].columnid     = in_data[i].columnid;
 182         cols[i].cbMaxLen     = in_data[i].max_len;
 183         cols[i].wType        = in_data[i].type;
 184         cols[i].bPrecision   = in_data[i].precision;
 185         cols[i].bScale       = in_data[i].scale;
 186     }
 187
 188     hr = IRow_GetColumns(row, num_cols, cols);
 189     IRow_Release(row);
 190
 191     for(i = 0; i < num_cols; i++)
 192     {
 193         VariantInit(&out_data[i].v);
 194         if(cols[i].dwStatus == DBSTATUS_S_OK)
 195         {
 196             V_VT(&out_data[i].v) = in_data[i].type;
 197             memcpy(&V_I1(&out_data[i].v), cols[i].pData, cols[i].cbDataLen);
 198         }
 199         CoTaskMemFree(cols[i].pData);
 200         out_data[i].data_len = cols[i].cbDataLen;
 201         out_data[i].status   = cols[i].dwStatus;
 202     }
 203
 204     CoTaskMemFree(cols);
 205
 206     return hr;
 207 }
 208
 209 static HRESULT WINAPI server_GetSourceRowset(IWineRowServer* iface, REFIID riid, IUnknown **ppRowset,
 210                                              HROW *phRow)
 211 {
 212     server *This = impl_from_IWineRowServer(iface);
 213     FIXME("(%p): stub\n", This);
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI server_Open(IWineRowServer* iface, IUnknown *pUnkOuter, DBID *pColumnID,
 218                                   REFGUID rguidColumnType, DWORD dwBindFlags, REFIID riid,
 219                                   IUnknown **ppUnk)
 220 {
 221     server *This = impl_from_IWineRowServer(iface);
 222     IRow *row;
 223     HRESULT hr;
 224     IWineRowServer *new_server;
 225     IMarshal *marshal;
 226     IUnknown *obj;
 227
 228     TRACE("(%p)->(%p, %p, %s, %08x, %s, %p)\n", This, pUnkOuter, pColumnID, debugstr_guid(rguidColumnType),
 229           dwBindFlags, debugstr_guid(riid), ppUnk);
 230
 231     *ppUnk = NULL;
 232
 233     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRow, (void**)&row);
 234     if(FAILED(hr)) return hr;
 235
 236     if(IsEqualGUID(rguidColumnType, &DBGUID_ROWSET))
 237         hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&new_server);
 238     else
 239     {
 240         FIXME("Unhandled object %s\n", debugstr_guid(rguidColumnType));
 241         hr = E_NOTIMPL;
 242     }
 243
 244     if(FAILED(hr))
 245     {
 246         IRow_Release(row);
 247         return hr;
 248     }
 249
 250     IWineRowServer_GetMarshal(new_server, &marshal);
 251     hr = IRow_Open(row, (IUnknown*)marshal, pColumnID, rguidColumnType, dwBindFlags, &IID_IUnknown, &obj);
 252     IMarshal_Release(marshal);
 253     IRow_Release(row);
 254
 255     if(FAILED(hr))
 256     {
 257         IWineRowServer_Release(new_server);
 258         return hr;
 259     }
 260
 261     IWineRowServer_SetInnerUnk(new_server, obj);
 262     hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk);
 263     IUnknown_Release(obj);
 264
 265     TRACE("returning %08x\n", hr);
 266     return hr;
 267 }
 268
 269 static HRESULT WINAPI server_SetColumns(IWineRowServer* iface, DBORDINAL num_cols,
 270                                         wine_setcolumns_in *in_data, DBSTATUS *status)
 271 {
 272     server *This = impl_from_IWineRowServer(iface);
 273     HRESULT hr;
 274     DBORDINAL i;
 275     DBCOLUMNACCESS *cols;
 276     IRowChange *row_change;
 277
 278     TRACE("(%p)->(%ld, %p, %p)\n", This, num_cols, in_data, status);
 279     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowChange, (void**)&row_change);
 280     if(FAILED(hr)) return hr;
 281
 282     cols = CoTaskMemAlloc(num_cols * sizeof(cols[0]));
 283
 284     for(i = 0; i < num_cols; i++)
 285     {
 286         TRACE("%ld:\ttype %04x\n", i, in_data[i].type);
 287         cols[i].pData        = CoTaskMemAlloc(db_type_size(in_data[i].type, in_data[i].max_len));
 288         memcpy(cols[i].pData, &V_I1(&in_data[i].v), db_type_size(in_data[i].type, in_data[i].max_len));
 289         cols[i].columnid     = in_data[i].columnid;
 290         cols[i].cbDataLen    = in_data[i].data_len;
 291         cols[i].dwStatus     = in_data[i].status;
 292         cols[i].cbMaxLen     = in_data[i].max_len;
 293         cols[i].wType        = in_data[i].type;
 294         cols[i].bPrecision   = in_data[i].precision;
 295         cols[i].bScale       = in_data[i].scale;
 296     }
 297
 298     hr = IRowChange_SetColumns(row_change, num_cols, cols);
 299     IRowChange_Release(row_change);
 300
 301     for(i = 0; i < num_cols; i++)
 302     {
 303         CoTaskMemFree(cols[i].pData);
 304         status[i] = cols[i].dwStatus;
 305     }
 306
 307     CoTaskMemFree(cols);
 308
 309     return hr;
 310 }
 311
 312 static HRESULT WINAPI server_AddRefRows(IWineRowServer* iface, DBCOUNTITEM cRows,
 313                                         const HROW rghRows[], DBREFCOUNT rgRefCounts[],
 314                                         DBROWSTATUS rgRowStatus[])
 315 {
 316     server *This = impl_from_IWineRowServer(iface);
 317     IRowset *rowset;
 318     HRESULT hr;
 319
 320     TRACE("(%p)->(%ld, %p, %p, %p)\n", This, cRows, rghRows, rgRefCounts, rgRowStatus);
 321
 322     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
 323     if(FAILED(hr)) return hr;
 324
 325     hr = IRowset_AddRefRows(rowset, cRows, rghRows, rgRefCounts, rgRowStatus);
 326
 327     IRowset_Release(rowset);
 328     TRACE("returning %08x\n", hr);
 329     return hr;
 330 }
 331
 332 static HRESULT WINAPI server_GetData(IWineRowServer* iface, HROW hRow,
 333                                      HACCESSOR hAccessor, BYTE *pData, DWORD size)
 334 {
 335     server *This = impl_from_IWineRowServer(iface);
 336     IRowset *rowset;
 337     HRESULT hr;
 338
 339     TRACE("(%p)->(%08lx, %08lx, %p, %d)\n", This, hRow, hAccessor, pData, size);
 340
 341     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
 342     if(FAILED(hr)) return hr;
 343
 344     hr = IRowset_GetData(rowset, hRow, hAccessor, pData);
 345
 346     IRowset_Release(rowset);
 347     TRACE("returning %08x\n", hr);
 348     return hr;
 349 }
 350
 351 static HRESULT WINAPI server_GetNextRows(IWineRowServer* iface, HCHAPTER hReserved, DBROWOFFSET lRowsOffset,
 352                                          DBROWCOUNT cRows, DBCOUNTITEM *pcRowObtained, HROW **prghRows)
 353 {
 354     server *This = impl_from_IWineRowServer(iface);
 355     IRowset *rowset;
 356     HRESULT hr;
 357
 358     TRACE("(%p)->(%08lx, %ld, %ld, %p, %p)\n", This, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
 359
 360     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
 361     if(FAILED(hr)) return hr;
 362
 363     *prghRows = NULL;
 364
 365     hr = IRowset_GetNextRows(rowset, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
 366     IRowset_Release(rowset);
 367     TRACE("returning %08x, got %ld rows\n", hr, *pcRowObtained);
 368     return hr;
 369 }
 370
 371 static HRESULT WINAPI server_ReleaseRows(IWineRowServer* iface, DBCOUNTITEM cRows, const HROW rghRows[],
 372                                          DBROWOPTIONS rgRowOptions[], DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
 373 {
 374     server *This = impl_from_IWineRowServer(iface);
 375     IRowset *rowset;
 376     HRESULT hr;
 377
 378     TRACE("(%p)->(%ld, %p, %p, %p, %p)\n", This, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
 379
 380     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
 381     if(FAILED(hr)) return hr;
 382
 383     hr = IRowset_ReleaseRows(rowset, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
 384     IRowset_Release(rowset);
 385
 386     TRACE("returning %08x\n", hr);
 387     return hr;
 388 }
 389
 390 static HRESULT WINAPI server_RestartPosition(IWineRowServer* iface, HCHAPTER hReserved)
 391 {
 392     server *This = impl_from_IWineRowServer(iface);
 393     FIXME("(%p)->(%08lx): stub\n", This, hReserved);
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI server_Compare(IWineRowServer *iface, HCHAPTER hReserved, DBBKMARK cbBookmark1,
 398                                      const BYTE *pBookmark1, DBBKMARK cbBookmark2, const BYTE *pBookmark2,
 399                                      DBCOMPARE *pComparison)
 400 {
 401     server *This = impl_from_IWineRowServer(iface);
 402     FIXME("(%p): stub\n", This);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI server_GetRowsAt(IWineRowServer *iface, HWATCHREGION hReserved1, HCHAPTER hReserved2,
 407                                        DBBKMARK cbBookmark, const BYTE *pBookmark, DBROWOFFSET lRowsOffset,
 408                                        DBROWCOUNT cRows, DBCOUNTITEM *pcRowsObtained, HROW **prghRows)
 409 {
 410     server *This = impl_from_IWineRowServer(iface);
 411     IRowsetLocate *rowsetlocate;
 412     HRESULT hr;
 413
 414     TRACE("(%p)->(%08lx, %08lx, %ld, %p, %ld, %ld, %p, %p\n", This, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset, cRows,
 415           pcRowsObtained, prghRows);
 416
 417     *prghRows = NULL;
 418
 419     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowsetLocate, (void**)&rowsetlocate);
 420     if(FAILED(hr)) return hr;
 421
 422     hr = IRowsetLocate_GetRowsAt(rowsetlocate, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset,
 423                                  cRows, pcRowsObtained, prghRows);
 424     IRowsetLocate_Release(rowsetlocate);
 425
 426     TRACE("returning %08x\n", hr);
 427     return hr;
 428 }
 429
 430 static HRESULT WINAPI server_GetRowsByBookmark(IWineRowServer *iface, HCHAPTER hReserved, DBCOUNTITEM cRows,
 431                                                const DBBKMARK rgcbBookmarks[], const BYTE * rgpBookmarks[],
 432                                                HROW rghRows[], DBROWSTATUS rgRowStatus[])
 433 {
 434     server *This = impl_from_IWineRowServer(iface);
 435     FIXME("(%p): stub\n", This);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI server_Hash(IWineRowServer *iface, HCHAPTER hReserved, DBBKMARK cBookmarks,
 440                                   const DBBKMARK rgcbBookmarks[], const BYTE * rgpBookmarks[],
 441                                   DBHASHVALUE rgHashedValues[], DBROWSTATUS rgBookmarkStatus[])
 442 {
 443     server *This = impl_from_IWineRowServer(iface);
 444     FIXME("(%p): stub\n", This);
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI server_GetProperties(IWineRowServer* iface, ULONG cPropertyIDSets,
 449                                            const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertySets,
 450                                            DBPROPSET **prgPropertySets)
 451 {
 452     server *This = impl_from_IWineRowServer(iface);
 453     IRowsetInfo *rowsetinfo;
 454     HRESULT hr;
 455
 456     TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
 457
 458     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowsetInfo, (void**)&rowsetinfo);
 459     if(FAILED(hr)) return hr;
 460
 461     hr = IRowsetInfo_GetProperties(rowsetinfo, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
 462     IRowsetInfo_Release(rowsetinfo);
 463
 464     TRACE("returning %08x\n", hr);
 465     return hr;
 466 }
 467
 468 static HRESULT WINAPI server_GetReferencedRowset(IWineRowServer* iface, DBORDINAL iOrdinal,
 469                                                  REFIID riid, IUnknown **ppReferencedRowset)
 470 {
 471     server *This = impl_from_IWineRowServer(iface);
 472     FIXME("(%p): stub\n", This);
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI server_GetSpecification(IWineRowServer* iface, REFIID riid,
 477                                                IUnknown **ppSpecification)
 478 {
 479     server *This = impl_from_IWineRowServer(iface);
 480     FIXME("(%p): stub\n", This);
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT WINAPI server_AddRefAccessor(IWineRowServer* iface, HACCESSOR hAccessor,
 485                                             DBREFCOUNT *pcRefCount)
 486 {
 487     server *This = impl_from_IWineRowServer(iface);
 488     FIXME("(%p): stub\n", This);
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI server_CreateAccessor(IWineRowServer* iface, DBACCESSORFLAGS dwAccessorFlags,
 493                                             DBCOUNTITEM cBindings, const DBBINDING *rgBindings, DBLENGTH cbRowSize,
 494                                             HACCESSOR *phAccessor, DBBINDSTATUS *rgStatus)
 495 {
 496     server *This = impl_from_IWineRowServer(iface);
 497     HRESULT hr;
 498     IAccessor *accessor;
 499
 500     TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, rgStatus);
 501
 502     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IAccessor, (void**)&accessor);
 503     if(FAILED(hr)) return hr;
 504
 505     hr = IAccessor_CreateAccessor(accessor, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, rgStatus);
 506     IAccessor_Release(accessor);
 507
 508     TRACE("returning %08x, accessor %08lx\n", hr, *phAccessor);
 509     return hr;
 510 }
 511
 512 static HRESULT WINAPI server_GetBindings(IWineRowServer* iface, HACCESSOR hAccessor,
 513                                          DBACCESSORFLAGS *pdwAccessorFlags, DBCOUNTITEM *pcBindings,
 514                                          DBBINDING **prgBindings)
 515 {
 516     server *This = impl_from_IWineRowServer(iface);
 517     HRESULT hr;
 518     IAccessor *accessor;
 519
 520     TRACE("(%p)->(%08lx, %p, %p, %p)\n", This, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
 521
 522     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IAccessor, (void**)&accessor);
 523     if(FAILED(hr)) return hr;
 524
 525     hr = IAccessor_GetBindings(accessor, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
 526     IAccessor_Release(accessor);
 527
 528     TRACE("returning %08x\n", hr);
 529     return hr;
 530 }
 531
 532 static HRESULT WINAPI server_ReleaseAccessor(IWineRowServer* iface, HACCESSOR hAccessor,
 533                                              DBREFCOUNT *pcRefCount)
 534 {
 535     server *This = impl_from_IWineRowServer(iface);
 536     HRESULT hr;
 537     IAccessor *accessor;
 538
 539     TRACE("(%p)->(%08lx, %p)\n", This, hAccessor, pcRefCount);
 540
 541     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IAccessor, (void**)&accessor);
 542     if(FAILED(hr)) return hr;
 543
 544     hr = IAccessor_ReleaseAccessor(accessor, hAccessor, pcRefCount);
 545     IAccessor_Release(accessor);
 546
 547     return hr;
 548 }
 549
 550 static const IWineRowServerVtbl server_vtbl =
 551 {
 552     server_QueryInterface,
 553     server_AddRef,
 554     server_Release,
 555     server_SetInnerUnk,
 556     server_GetMarshal,
 557     server_GetColumns,
 558     server_GetSourceRowset,
 559     server_Open,
 560     server_SetColumns,
 561     server_AddRefRows,
 562     server_GetData,
 563     server_GetNextRows,
 564     server_ReleaseRows,
 565     server_RestartPosition,
 566     server_Compare,
 567     server_GetRowsAt,
 568     server_GetRowsByBookmark,
 569     server_Hash,
 570     server_GetProperties,
 571     server_GetReferencedRowset,
 572     server_GetSpecification,
 573     server_AddRefAccessor,
 574     server_CreateAccessor,
 575     server_GetBindings,
 576     server_ReleaseAccessor
 577 };
 578
 579 static HRESULT create_server(IUnknown *outer, const CLSID *class, void **obj)
 580 {
 581     server *server;
 582     TRACE("(%p, %s, %p)\n", outer, debugstr_guid(class), obj);
 583
 584     *obj = NULL;
 585
 586     server = HeapAlloc(GetProcessHeap(), 0, sizeof(*server));
 587     if(!server) return E_OUTOFMEMORY;
 588
 589     server->IWineRowServer_iface.lpVtbl = &server_vtbl;
 590     server->ref = 1;
 591     server->class = *class;
 592     server->inner_unk = NULL;
 593     if(IsEqualGUID(class, &CLSID_wine_row_server))
 594         create_row_marshal((IUnknown*)server, (void**)&server->marshal);
 595     else if(IsEqualGUID(class, &CLSID_wine_rowset_server))
 596         create_rowset_marshal((IUnknown*)server, (void**)&server->marshal);
 597     else
 598         ERR("create_server called with class %s\n", debugstr_guid(class));
 599
 600     *obj = server;
 601     return S_OK;
 602 }
 603
 604 HRESULT create_row_server(IUnknown *outer, void **obj)
 605 {
 606     return create_server(outer, &CLSID_wine_row_server, obj);
 607 }
 608
 609 HRESULT create_rowset_server(IUnknown *outer, void **obj)
 610 {
 611     return create_server(outer, &CLSID_wine_rowset_server, obj);
 612 }
 613
 614 typedef struct
 615 {
 616     IRow IRow_iface;
 617     IRowChange IRowChange_iface;
 618
 619     LONG ref;
 620
 621     IWineRowServer *server;
 622 } row_proxy;
 623
 624 static inline row_proxy *impl_from_IRow(IRow *iface)
 625 {
 626     return CONTAINING_RECORD(iface, row_proxy, IRow_iface);
 627 }
 628
 629 static inline row_proxy *impl_from_IRowChange(IRowChange *iface)
 630 {
 631     return CONTAINING_RECORD(iface, row_proxy, IRowChange_iface);
 632 }
 633
 634 static HRESULT WINAPI row_QueryInterface(IRow *iface, REFIID iid, void **obj)
 635 {
 636     row_proxy *This = impl_from_IRow(iface);
 637     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
 638
 639     if(IsEqualIID(iid, &IID_IUnknown) ||
 640        IsEqualIID(iid, &IID_IRow))
 641     {
 642         *obj = &This->IRow_iface;
 643     }
 644     else if(IsEqualIID(iid, &IID_IRowChange))
 645     {
 646         *obj = &This->IRowChange_iface;
 647     }
 648     else
 649     {
 650         FIXME("interface %s not implemented\n", debugstr_guid(iid));
 651         return E_NOINTERFACE;
 652     }
 653
 654     IRow_AddRef(iface);
 655     return S_OK;
 656 }
 657
 658 static ULONG WINAPI row_AddRef(IRow *iface)
 659 {
 660     row_proxy *This = impl_from_IRow(iface);
 661     TRACE("(%p)\n", This);
 662
 663     return InterlockedIncrement(&This->ref);
 664 }
 665
 666 static ULONG WINAPI row_Release(IRow *iface)
 667 {
 668     row_proxy *This = impl_from_IRow(iface);
 669     LONG ref;
 670
 671     TRACE("(%p)\n", This);
 672
 673     ref = InterlockedDecrement(&This->ref);
 674     if(ref == 0)
 675     {
 676         if(This->server) IWineRowServer_Release(This->server);
 677         HeapFree(GetProcessHeap(), 0, This);
 678     }
 679
 680     return ref;
 681 }
 682
 683 static HRESULT WINAPI row_GetColumns(IRow* iface, DBORDINAL cColumns, DBCOLUMNACCESS rgColumns[])
 684 {
 685     row_proxy *This = impl_from_IRow(iface);
 686     DBORDINAL i;
 687     wine_getcolumns_in *in_data;
 688     wine_getcolumns_out *out_data;
 689     HRESULT hr;
 690
 691     TRACE("(%p)->(%ld, %p)\n", This, cColumns, rgColumns);
 692
 693     in_data = CoTaskMemAlloc(cColumns * sizeof(in_data[0]));
 694     out_data = CoTaskMemAlloc(cColumns * sizeof(out_data[0]));
 695
 696     for(i = 0; i < cColumns; i++)
 697     {
 698         TRACE("%ld:\tdata %p data_len %ld status %08x max_len %ld type %04x\n", i, rgColumns[i].pData,
 699               rgColumns[i].cbDataLen, rgColumns[i].dwStatus, rgColumns[i].cbMaxLen, rgColumns[i].wType);
 700         in_data[i].columnid     = rgColumns[i].columnid;
 701         in_data[i].max_len      = rgColumns[i].cbMaxLen;
 702         in_data[i].type         = rgColumns[i].wType;
 703         in_data[i].precision    = rgColumns[i].bPrecision;
 704         in_data[i].scale        = rgColumns[i].bScale;
 705     }
 706
 707     hr = IWineRowServer_GetColumns(This->server, cColumns, in_data, out_data);
 708
 709     for(i = 0; i < cColumns; i++)
 710     {
 711         rgColumns[i].cbDataLen = out_data[i].data_len;
 712         rgColumns[i].dwStatus  = out_data[i].status;
 713         if(rgColumns[i].dwStatus == DBSTATUS_S_OK)
 714             memcpy(rgColumns[i].pData, &V_I1(&out_data[i].v), out_data[i].data_len);
 715     }
 716
 717     CoTaskMemFree(out_data);
 718     CoTaskMemFree(in_data);
 719     return hr;
 720 }
 721
 722 static HRESULT WINAPI row_GetSourceRowset(IRow* iface, REFIID riid, IUnknown **ppRowset,
 723                                           HROW *phRow)
 724 {
 725     row_proxy *This = impl_from_IRow(iface);
 726
 727     FIXME("(%p)->(%s, %p, %p): stub\n", This, debugstr_guid(riid), ppRowset, phRow);
 728
 729     return E_NOTIMPL;
 730 }
 731
 732 static HRESULT WINAPI row_Open(IRow* iface, IUnknown *pUnkOuter,
 733                                DBID *pColumnID, REFGUID rguidColumnType,
 734                                DWORD dwBindFlags, REFIID riid, IUnknown **ppUnk)
 735 {
 736     row_proxy *This = impl_from_IRow(iface);
 737
 738     TRACE("(%p)->(%p, %p, %s, %08x, %s, %p)\n", This, pUnkOuter, pColumnID, debugstr_guid(rguidColumnType),
 739           dwBindFlags, debugstr_guid(riid), ppUnk);
 740     if(pUnkOuter)
 741     {
 742         FIXME("Aggregation not supported\n");
 743         return CLASS_E_NOAGGREGATION;
 744     }
 745
 746     return IWineRowServer_Open(This->server, pUnkOuter, pColumnID, rguidColumnType, dwBindFlags, riid, ppUnk);
 747 }
 748
 749 static const IRowVtbl row_vtbl =
 750 {
 751     row_QueryInterface,
 752     row_AddRef,
 753     row_Release,
 754     row_GetColumns,
 755     row_GetSourceRowset,
 756     row_Open
 757 };
 758
 759 static HRESULT WINAPI row_change_QueryInterface(IRowChange *iface, REFIID iid, void **obj)
 760 {
 761     row_proxy *This = impl_from_IRowChange(iface);
 762     return IUnknown_QueryInterface((IUnknown *)This, iid, obj);
 763 }
 764
 765 static ULONG WINAPI row_change_AddRef(IRowChange *iface)
 766 {
 767     row_proxy *This = impl_from_IRowChange(iface);
 768     return IUnknown_AddRef((IUnknown*)This);
 769 }
 770
 771 static ULONG WINAPI row_change_Release(IRowChange *iface)
 772 {
 773     row_proxy *This = impl_from_IRowChange(iface);
 774     return IUnknown_Release((IUnknown*)This);
 775 }
 776
 777 static HRESULT WINAPI row_change_SetColumns(IRowChange *iface, DBORDINAL cColumns,
 778                                             DBCOLUMNACCESS rgColumns[])
 779 {
 780     row_proxy *This = impl_from_IRowChange(iface);
 781     HRESULT hr;
 782     wine_setcolumns_in *in_data;
 783     DBSTATUS *status;
 784     DBORDINAL i;
 785
 786     TRACE("(%p)->(%ld, %p)\n", This, cColumns, rgColumns);
 787
 788     in_data = CoTaskMemAlloc(cColumns * sizeof(in_data[0]));
 789     status = CoTaskMemAlloc(cColumns * sizeof(status[0]));
 790
 791     for(i = 0; i < cColumns; i++)
 792     {
 793         TRACE("%ld: wtype %04x max %08lx len %08lx\n", i, rgColumns[i].wType, rgColumns[i].cbMaxLen, rgColumns[i].cbDataLen);
 794         V_VT(&in_data[i].v) = rgColumns[i].wType;
 795         memcpy(&V_I1(&in_data[i].v), rgColumns[i].pData, db_type_size(rgColumns[i].wType, rgColumns[i].cbDataLen));
 796         in_data[i].columnid = rgColumns[i].columnid;
 797         in_data[i].data_len = rgColumns[i].cbDataLen;
 798         in_data[i].status = rgColumns[i].dwStatus;
 799         in_data[i].max_len = rgColumns[i].cbMaxLen;
 800         in_data[i].type = rgColumns[i].wType;
 801         in_data[i].precision = rgColumns[i].bPrecision;
 802         in_data[i].scale = rgColumns[i].bScale;
 803     }
 804
 805     hr = IWineRowServer_SetColumns(This->server, cColumns, in_data, status);
 806
 807     for(i = 0; i < cColumns; i++)
 808         rgColumns[i].dwStatus = status[i];
 809
 810     CoTaskMemFree(status);
 811     CoTaskMemFree(in_data);
 812
 813     return hr;
 814 }
 815
 816 static const IRowChangeVtbl row_change_vtbl =
 817 {
 818     row_change_QueryInterface,
 819     row_change_AddRef,
 820     row_change_Release,
 821     row_change_SetColumns
 822 };
 823
 824 static HRESULT create_row_proxy(IWineRowServer *server, IUnknown **obj)
 825 {
 826     row_proxy *proxy;
 827
 828     TRACE("(%p, %p)\n", server, obj);
 829     *obj = NULL;
 830
 831     proxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*proxy));
 832     if(!proxy) return E_OUTOFMEMORY;
 833
 834     proxy->IRow_iface.lpVtbl = &row_vtbl;
 835     proxy->IRowChange_iface.lpVtbl = &row_change_vtbl;
 836     proxy->ref = 1;
 837     IWineRowServer_AddRef(server);
 838     proxy->server = server;
 839
 840     *obj = (IUnknown*)&proxy->IRow_iface;
 841     TRACE("returning %p\n", *obj);
 842     return S_OK;
 843 }
 844
 845 typedef struct
 846 {
 847     IRowsetLocate IRowsetLocate_iface;
 848     IRowsetInfo IRowsetInfo_iface;
 849     IAccessor IAccessor_iface;
 850
 851     LONG ref;
 852
 853     IWineRowServer *server;
 854 } rowset_proxy;
 855
 856 static inline rowset_proxy *impl_from_IRowsetLocate(IRowsetLocate *iface)
 857 {
 858     return CONTAINING_RECORD(iface, rowset_proxy, IRowsetLocate_iface);
 859 }
 860
 861 static inline rowset_proxy *impl_from_IRowsetInfo(IRowsetInfo *iface)
 862 {
 863     return CONTAINING_RECORD(iface, rowset_proxy, IRowsetInfo_iface);
 864 }
 865
 866 static inline rowset_proxy *impl_from_IAccessor(IAccessor *iface)
 867 {
 868     return CONTAINING_RECORD(iface, rowset_proxy, IAccessor_iface);
 869 }
 870
 871 static HRESULT WINAPI rowsetlocate_QueryInterface(IRowsetLocate *iface, REFIID iid, void **obj)
 872 {
 873     rowset_proxy *This = impl_from_IRowsetLocate(iface);
 874     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
 875
 876     *obj = NULL;
 877
 878     if(IsEqualIID(iid, &IID_IUnknown) ||
 879        IsEqualIID(iid, &IID_IRowset) ||
 880        IsEqualIID(iid, &IID_IRowsetLocate))
 881     {
 882         *obj = &This->IRowsetLocate_iface;
 883     }
 884     else if(IsEqualIID(iid, &IID_IRowsetInfo))
 885     {
 886         *obj = &This->IRowsetInfo_iface;
 887     }
 888     else if(IsEqualIID(iid, &IID_IAccessor))
 889     {
 890         *obj = &This->IAccessor_iface;
 891     }
 892     else
 893     {
 894         FIXME("interface %s not implemented\n", debugstr_guid(iid));
 895         return E_NOINTERFACE;
 896     }
 897
 898     IRowsetLocate_AddRef(iface);
 899     return S_OK;
 900 }
 901
 902 static ULONG WINAPI rowsetlocate_AddRef(IRowsetLocate *iface)
 903 {
 904     rowset_proxy *This = impl_from_IRowsetLocate(iface);
 905     TRACE("(%p)\n", This);
 906
 907     return InterlockedIncrement(&This->ref);
 908 }
 909
 910 static ULONG WINAPI rowsetlocate_Release(IRowsetLocate *iface)
 911 {
 912     rowset_proxy *This = impl_from_IRowsetLocate(iface);
 913     LONG ref;
 914
 915     TRACE("(%p)\n", This);
 916
 917     ref = InterlockedDecrement(&This->ref);
 918     if(ref == 0)
 919     {
 920         if(This->server) IWineRowServer_Release(This->server);
 921         HeapFree(GetProcessHeap(), 0, This);
 922     }
 923
 924     return ref;
 925 }
 926
 927 static HRESULT WINAPI rowsetlocate_AddRefRows(IRowsetLocate *iface, DBCOUNTITEM cRows, const HROW rghRows[],
 928                                               DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
 929 {
 930     rowset_proxy *This = impl_from_IRowsetLocate(iface);
 931     HRESULT hr;
 932     DBREFCOUNT *refs = rgRefCounts;
 933     DBSTATUS *stats = rgRowStatus;
 934
 935     TRACE("(%p)->(%ld, %p, %p, %p)\n", This, cRows, rghRows, rgRefCounts, rgRowStatus);
 936
 937     if(!refs) refs = CoTaskMemAlloc(cRows * sizeof(refs[0]));
 938     if(!stats) stats = CoTaskMemAlloc(cRows * sizeof(stats[0]));
 939
 940     hr = IWineRowServer_AddRefRows(This->server, cRows, rghRows, refs, stats);
 941
 942     if(refs != rgRefCounts) CoTaskMemFree(refs);
 943     if(stats != rgRowStatus) CoTaskMemFree(stats);
 944
 945     return hr;
 946 }
 947
 948 static HRESULT WINAPI rowsetlocate_GetData(IRowsetLocate *iface, HROW hRow, HACCESSOR hAccessor, void *pData)
 949 {
 950     rowset_proxy *This = impl_from_IRowsetLocate(iface);
 951     HRESULT hr;
 952     IAccessor *accessor;
 953     DBACCESSORFLAGS flags;
 954     DBCOUNTITEM count, i;
 955     DBBINDING *bindings;
 956     DWORD max_len = 0;
 957
 958     TRACE("(%p)->(%lx, %lx, %p)\n", This, hRow, hAccessor, pData);
 959
 960     hr = IRowsetLocate_QueryInterface(iface, &IID_IAccessor, (void**)&accessor);
 961     if(FAILED(hr)) return hr;
 962
 963     hr = IAccessor_GetBindings(accessor, hAccessor, &flags, &count, &bindings);
 964     IAccessor_Release(accessor);
 965     if(FAILED(hr)) return hr;
 966
 967     TRACE("got %ld bindings\n", count);
 968     for(i = 0; i < count; i++)
 969     {
 970         TRACE("%ld\tord %ld offs: val %ld len %ld stat %ld, part %x, max len %ld type %04x\n",
 971               i, bindings[i].iOrdinal, bindings[i].obValue, bindings[i].obLength, bindings[i].obStatus,
 972               bindings[i].dwPart, bindings[i].cbMaxLen, bindings[i].wType);
 973         if(bindings[i].dwPart & DBPART_LENGTH && bindings[i].obLength >= max_len)
 974             max_len = bindings[i].obLength + sizeof(DBLENGTH);
 975         if(bindings[i].dwPart & DBPART_STATUS && bindings[i].obStatus >= max_len)
 976             max_len = bindings[i].obStatus + sizeof(DWORD);
 977         if(bindings[i].dwPart & DBPART_VALUE && bindings[i].obValue >= max_len)
 978             max_len = bindings[i].obValue + db_type_size(bindings[i].wType, bindings[i].cbMaxLen);
 979
 980     }
 981     TRACE("max_len %d\n", max_len);
 982
 983     CoTaskMemFree(bindings);
 984
 985     hr = IWineRowServer_GetData(This->server, hRow, hAccessor, pData, max_len);
 986
 987     return hr;
 988 }
 989
 990 static HRESULT WINAPI rowsetlocate_GetNextRows(IRowsetLocate *iface, HCHAPTER hReserved, DBROWOFFSET lRowsOffset,
 991                                                DBROWCOUNT cRows, DBCOUNTITEM *pcRowObtained, HROW **prghRows)
 992 {
 993     rowset_proxy *This = impl_from_IRowsetLocate(iface);
 994     HRESULT hr;
 995     HROW *rows = NULL;
 996
 997     TRACE("(%p)->(%08lx, %ld, %ld, %p, %p)\n", This, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
 998
 999     hr = IWineRowServer_GetNextRows(This->server, hReserved, lRowsOffset, cRows, pcRowObtained, &rows);
1000     if(*prghRows)
1001     {
1002         memcpy(*prghRows, rows, *pcRowObtained * sizeof(rows[0]));
1003         CoTaskMemFree(rows);
1004     }
1005     else
1006         *prghRows = rows;
1007
1008     return hr;
1009 }
1010
1011 static HRESULT WINAPI rowsetlocate_ReleaseRows(IRowsetLocate *iface, DBCOUNTITEM cRows, const HROW rghRows[],
1012                                                DBROWOPTIONS rgRowOptions[], DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
1013 {
1014     rowset_proxy *This = impl_from_IRowsetLocate(iface);
1015     HRESULT hr;
1016     DBROWOPTIONS *options = rgRowOptions;
1017     DBREFCOUNT *refs = rgRefCounts;
1018     DBROWSTATUS *status = rgRowStatus;
1019
1020     TRACE("(%p)->(%ld, %p, %p, %p, %p)\n", This, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
1021
1022     if(!options)
1023     {
1024         options = CoTaskMemAlloc(cRows * sizeof(options[0]));
1025         memset(options, 0, cRows * sizeof(options[0]));
1026     }
1027     if(!refs) refs = CoTaskMemAlloc(cRows * sizeof(refs[0]));
1028     if(!status) status = CoTaskMemAlloc(cRows * sizeof(status[0]));
1029
1030     hr = IWineRowServer_ReleaseRows(This->server, cRows, rghRows, options, refs, status);
1031
1032     if(status != rgRowStatus) CoTaskMemFree(status);
1033     if(refs != rgRefCounts) CoTaskMemFree(refs);
1034     if(options != rgRowOptions) CoTaskMemFree(options);
1035
1036     return hr;
1037 }
1038
1039 static HRESULT WINAPI rowsetlocate_RestartPosition(IRowsetLocate* iface, HCHAPTER hReserved)
1040 {
1041     rowset_proxy *This = impl_from_IRowsetLocate(iface);
1042
1043     FIXME("(%p)->(%lx): stub\n", This, hReserved);
1044
1045     return E_NOTIMPL;
1046 }
1047
1048 static HRESULT WINAPI rowsetlocate_Compare(IRowsetLocate *iface, HCHAPTER hReserved, DBBKMARK cbBookmark1, const BYTE *pBookmark1,
1049                                            DBBKMARK cbBookmark2, const BYTE *pBookmark2, DBCOMPARE *pComparison)
1050 {
1051     rowset_proxy *This = impl_from_IRowsetLocate(iface);
1052     FIXME("(%p)\n", This);
1053     return E_NOTIMPL;
1054 }
1055
1056 static HRESULT WINAPI rowsetlocate_GetRowsAt(IRowsetLocate *iface, HWATCHREGION hReserved1, HCHAPTER hReserved2, DBBKMARK cbBookmark,
1057                                              const BYTE *pBookmark, DBROWOFFSET lRowsOffset, DBROWCOUNT cRows, DBCOUNTITEM *pcRowsObtained,
1058                                              HROW **prghRows)
1059 {
1060     rowset_proxy *This = impl_from_IRowsetLocate(iface);
1061     HRESULT hr;
1062     HROW *rows = NULL;
1063
1064     TRACE("(%p)->(%08lx, %08lx, %ld, %p, %ld, %ld, %p, %p\n", This, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset, cRows,
1065           pcRowsObtained, prghRows);
1066
1067     hr = IWineRowServer_GetRowsAt(This->server, hReserved1, hReserved2, cbBookmark, pBookmark, lRowsOffset, cRows, pcRowsObtained, &rows);
1068
1069     if(*prghRows)
1070     {
1071         memcpy(*prghRows, rows, *pcRowsObtained * sizeof(rows[0]));
1072         CoTaskMemFree(rows);
1073     }
1074     else
1075         *prghRows = rows;
1076
1077     return hr;
1078 }
1079
1080 static HRESULT WINAPI rowsetlocate_GetRowsByBookmark(IRowsetLocate *iface, HCHAPTER hReserved, DBCOUNTITEM cRows, const DBBKMARK rgcbBookmarks[],
1081                                                      const BYTE * rgpBookmarks[], HROW rghRows[], DBROWSTATUS rgRowStatus[])
1082 {
1083     rowset_proxy *This = impl_from_IRowsetLocate(iface);
1084     FIXME("(%p)\n", This);
1085     return E_NOTIMPL;
1086 }
1087
1088 static HRESULT WINAPI rowsetlocate_Hash(IRowsetLocate *iface, HCHAPTER hReserved, DBBKMARK cBookmarks, const DBBKMARK rgcbBookmarks[],
1089                                         const BYTE * rgpBookmarks[], DBHASHVALUE rgHashedValues[], DBROWSTATUS rgBookmarkStatus[])
1090 {
1091     rowset_proxy *This = impl_from_IRowsetLocate(iface);
1092     FIXME("(%p)\n", This);
1093     return E_NOTIMPL;
1094 }
1095
1096 static const IRowsetLocateVtbl rowsetlocate_vtbl =
1097 {
1098     rowsetlocate_QueryInterface,
1099     rowsetlocate_AddRef,
1100     rowsetlocate_Release,
1101     rowsetlocate_AddRefRows,
1102     rowsetlocate_GetData,
1103     rowsetlocate_GetNextRows,
1104     rowsetlocate_ReleaseRows,
1105     rowsetlocate_RestartPosition,
1106     rowsetlocate_Compare,
1107     rowsetlocate_GetRowsAt,
1108     rowsetlocate_GetRowsByBookmark,
1109     rowsetlocate_Hash
1110 };
1111
1112 static HRESULT WINAPI rowsetinfo_QueryInterface(IRowsetInfo *iface, REFIID iid, void **obj)
1113 {
1114     rowset_proxy *This = impl_from_IRowsetInfo(iface);
1115     return IUnknown_QueryInterface((IUnknown *)This, iid, obj);
1116 }
1117
1118 static ULONG WINAPI rowsetinfo_AddRef(IRowsetInfo *iface)
1119 {
1120     rowset_proxy *This = impl_from_IRowsetInfo(iface);
1121     return IUnknown_AddRef((IUnknown *)This);
1122 }
1123
1124 static ULONG WINAPI rowsetinfo_Release(IRowsetInfo *iface)
1125 {
1126     rowset_proxy *This = impl_from_IRowsetInfo(iface);
1127     return IUnknown_Release((IUnknown *)This);
1128 }
1129
1130 static HRESULT WINAPI rowsetinfo_GetProperties(IRowsetInfo *iface, const ULONG cPropertyIDSets,
1131                                                const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets,
1132                                                DBPROPSET **prgPropertySets)
1133 {
1134     rowset_proxy *This = impl_from_IRowsetInfo(iface);
1135     HRESULT hr;
1136
1137     TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
1138
1139     hr = IWineRowServer_GetProperties(This->server, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
1140
1141     return hr;
1142 }
1143
1144 static HRESULT WINAPI rowsetinfo_GetReferencedRowset(IRowsetInfo *iface, DBORDINAL iOrdinal, REFIID riid,
1145                                                      IUnknown **ppReferencedRowset)
1146 {
1147     rowset_proxy *This = impl_from_IRowsetInfo(iface);
1148     FIXME("(%p)\n", This);
1149     return E_NOTIMPL;
1150 }
1151
1152 static HRESULT WINAPI rowsetinfo_GetSpecification(IRowsetInfo *iface, REFIID riid, IUnknown **ppSpecification)
1153 {
1154     rowset_proxy *This = impl_from_IRowsetInfo(iface);
1155     FIXME("(%p)\n", This);
1156     return E_NOTIMPL;
1157 }
1158
1159 static const IRowsetInfoVtbl rowsetinfo_vtbl =
1160 {
1161     rowsetinfo_QueryInterface,
1162     rowsetinfo_AddRef,
1163     rowsetinfo_Release,
1164     rowsetinfo_GetProperties,
1165     rowsetinfo_GetReferencedRowset,
1166     rowsetinfo_GetSpecification
1167 };
1168
1169 static HRESULT WINAPI accessor_QueryInterface(IAccessor *iface, REFIID iid, void **obj)
1170 {
1171     rowset_proxy *This = impl_from_IAccessor(iface);
1172     return IUnknown_QueryInterface((IUnknown *)This, iid, obj);
1173 }
1174
1175 static ULONG WINAPI accessor_AddRef(IAccessor *iface)
1176 {
1177     rowset_proxy *This = impl_from_IAccessor(iface);
1178     return IUnknown_AddRef((IUnknown *)This);
1179 }
1180
1181 static ULONG WINAPI accessor_Release(IAccessor *iface)
1182 {
1183     rowset_proxy *This = impl_from_IAccessor(iface);
1184     return IUnknown_Release((IUnknown *)This);
1185 }
1186
1187 static HRESULT WINAPI accessor_AddRefAccessor(IAccessor *iface, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
1188 {
1189     rowset_proxy *This = impl_from_IAccessor(iface);
1190     FIXME("(%p)\n", This);
1191     return E_NOTIMPL;
1192 }
1193
1194 static HRESULT WINAPI accessor_CreateAccessor(IAccessor *iface, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings,
1195                                               const DBBINDING rgBindings[], DBLENGTH cbRowSize, HACCESSOR *phAccessor,
1196                                               DBBINDSTATUS rgStatus[])
1197 {
1198     rowset_proxy *This = impl_from_IAccessor(iface);
1199     HRESULT hr;
1200     DBBINDSTATUS *status;
1201
1202     TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, rgStatus);
1203
1204     if(!rgStatus) status = CoTaskMemAlloc(cBindings * sizeof(status[0]));
1205     else status = rgStatus;
1206
1207     hr = IWineRowServer_CreateAccessor(This->server, dwAccessorFlags, cBindings, rgBindings, cbRowSize, phAccessor, status);
1208
1209     if(!rgStatus) CoTaskMemFree(status);
1210
1211     return hr;
1212 }
1213
1214 static HRESULT WINAPI accessor_GetBindings(IAccessor *iface, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags,
1215                                            DBCOUNTITEM *pcBindings, DBBINDING **prgBindings)
1216 {
1217     rowset_proxy *This = impl_from_IAccessor(iface);
1218     HRESULT hr;
1219
1220     TRACE("(%p)->(%08lx, %p, %p, %p)\n", This, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
1221
1222     hr = IWineRowServer_GetBindings(This->server, hAccessor, pdwAccessorFlags, pcBindings, prgBindings);
1223
1224     return hr;
1225 }
1226
1227 static HRESULT WINAPI accessor_ReleaseAccessor(IAccessor *iface, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
1228 {
1229     rowset_proxy *This = impl_from_IAccessor(iface);
1230     HRESULT hr;
1231     DBREFCOUNT ref;
1232
1233     TRACE("(%p)->(%08lx, %p)\n", This, hAccessor, pcRefCount);
1234
1235     hr = IWineRowServer_ReleaseAccessor(This->server, hAccessor, &ref);
1236     if(pcRefCount) *pcRefCount = ref;
1237     return hr;
1238 }
1239
1240 static const IAccessorVtbl accessor_vtbl =
1241 {
1242     accessor_QueryInterface,
1243     accessor_AddRef,
1244     accessor_Release,
1245     accessor_AddRefAccessor,
1246     accessor_CreateAccessor,
1247     accessor_GetBindings,
1248     accessor_ReleaseAccessor
1249 };
1250
1251 static HRESULT create_rowset_proxy(IWineRowServer *server, IUnknown **obj)
1252 {
1253     rowset_proxy *proxy;
1254
1255     TRACE("(%p, %p)\n", server, obj);
1256     *obj = NULL;
1257
1258     proxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*proxy));
1259     if(!proxy) return E_OUTOFMEMORY;
1260
1261     proxy->IRowsetLocate_iface.lpVtbl = &rowsetlocate_vtbl;
1262     proxy->IRowsetInfo_iface.lpVtbl = &rowsetinfo_vtbl;
1263     proxy->IAccessor_iface.lpVtbl = &accessor_vtbl;
1264     proxy->ref = 1;
1265     IWineRowServer_AddRef(server);
1266     proxy->server = server;
1267
1268     *obj = (IUnknown *)&proxy->IRowsetLocate_iface;
1269     TRACE("returning %p\n", *obj);
1270     return S_OK;
1271 }
1272
1273 static HRESULT create_proxy(IWineRowServer *server, const CLSID *class, IUnknown **obj)
1274 {
1275     *obj = NULL;
1276
1277     if(IsEqualGUID(class, &CLSID_wine_row_proxy))
1278         return create_row_proxy(server, obj);
1279     else if(IsEqualGUID(class, &CLSID_wine_rowset_proxy))
1280         return create_rowset_proxy(server, obj);
1281     else
1282         FIXME("Unhandled proxy class %s\n", debugstr_guid(class));
1283     return E_NOTIMPL;
1284 }
1285
1286 /* Marshal impl */
1287
1288 typedef struct
1289 {
1290     IMarshal IMarshal_iface;
1291
1292     LONG ref;
1293     CLSID unmarshal_class;
1294     IUnknown *outer;
1295 } marshal;
1296
1297 static inline marshal *impl_from_IMarshal(IMarshal *iface)
1298 {
1299     return CONTAINING_RECORD(iface, marshal, IMarshal_iface);
1300 }
1301
1302 static HRESULT WINAPI marshal_QueryInterface(IMarshal *iface, REFIID iid, void **obj)
1303 {
1304     marshal *This = impl_from_IMarshal(iface);
1305     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
1306
1307     if(IsEqualIID(iid, &IID_IUnknown) ||
1308        IsEqualIID(iid, &IID_IMarshal))
1309     {
1310         *obj = iface;
1311     }
1312     else
1313     {
1314         FIXME("interface %s not implemented\n", debugstr_guid(iid));
1315         *obj = NULL;
1316         return E_NOINTERFACE;
1317     }
1318
1319     IMarshal_AddRef(iface);
1320     return S_OK;
1321 }
1322
1323 static ULONG WINAPI marshal_AddRef(IMarshal *iface)
1324 {
1325     marshal *This = impl_from_IMarshal(iface);
1326     TRACE("(%p)\n", This);
1327     return InterlockedIncrement(&This->ref);
1328 }
1329
1330 static ULONG WINAPI marshal_Release(IMarshal *iface)
1331 {
1332     marshal *This = impl_from_IMarshal(iface);
1333     LONG ref;
1334
1335     TRACE("(%p)\n", This);
1336
1337     ref = InterlockedDecrement(&This->ref);
1338     if(ref == 0)
1339     {
1340         HeapFree(GetProcessHeap(), 0, This);
1341     }
1342
1343     return ref;
1344 }
1345
1346 static HRESULT WINAPI marshal_GetUnmarshalClass(IMarshal *iface, REFIID iid, void *obj,
1347                                                 DWORD dwDestContext, void *pvDestContext,
1348                                                 DWORD mshlflags, CLSID *clsid)
1349 {
1350     marshal *This = impl_from_IMarshal(iface);
1351     TRACE("(%p)->(%s, %p, %08x, %p, %08x, %p)\n", This, debugstr_guid(iid), obj, dwDestContext,
1352           pvDestContext, mshlflags, clsid);
1353
1354     *clsid = This->unmarshal_class;
1355     return S_OK;
1356 }
1357
1358 static HRESULT WINAPI marshal_GetMarshalSizeMax(IMarshal *iface, REFIID iid, void *obj,
1359                                                 DWORD dwDestContext, void *pvDestContext,
1360                                                 DWORD mshlflags, DWORD *size)
1361 {
1362     marshal *This = impl_from_IMarshal(iface);
1363     TRACE("(%p)->(%s, %p, %08x, %p, %08x, %p)\n", This, debugstr_guid(iid), obj, dwDestContext,
1364           pvDestContext, mshlflags, size);
1365
1366     return CoGetMarshalSizeMax(size, &IID_IWineRowServer, This->outer, dwDestContext, pvDestContext,
1367                                mshlflags);
1368 }
1369
1370 static HRESULT WINAPI marshal_MarshalInterface(IMarshal *iface, IStream *stream, REFIID iid,
1371                                                void *obj, DWORD dwDestContext, void *pvDestContext,
1372                                                DWORD mshlflags)
1373 {
1374     marshal *This = impl_from_IMarshal(iface);
1375     TRACE("(%p)->(%p, %s, %p, %08x, %p, %08x)\n", This, stream, debugstr_guid(iid), obj, dwDestContext,
1376           pvDestContext, mshlflags);
1377
1378     return CoMarshalInterface(stream, &IID_IWineRowServer, This->outer, dwDestContext, pvDestContext, mshlflags);
1379 }
1380
1381 static HRESULT WINAPI marshal_UnmarshalInterface(IMarshal *iface, IStream *stream,
1382                                                  REFIID iid, void **obj)
1383 {
1384     marshal *This = impl_from_IMarshal(iface);
1385     HRESULT hr;
1386     IWineRowServer *server;
1387     IUnknown *proxy;
1388
1389     TRACE("(%p)->(%p, %s, %p)\n", This, stream, debugstr_guid(iid), obj);
1390     *obj = NULL;
1391
1392     hr = CoUnmarshalInterface(stream, &IID_IWineRowServer, (void**)&server);
1393     if(SUCCEEDED(hr))
1394     {
1395         hr = create_proxy(server, &This->unmarshal_class, &proxy);
1396         if(SUCCEEDED(hr))
1397         {
1398             hr = IUnknown_QueryInterface(proxy, iid, obj);
1399             IUnknown_Release(proxy);
1400         }
1401         IWineRowServer_Release(server);
1402     }
1403
1404     TRACE("returning %p\n", *obj);
1405     return hr;
1406 }
1407
1408 static HRESULT WINAPI marshal_ReleaseMarshalData(IMarshal *iface, IStream *stream)
1409 {
1410     marshal *This = impl_from_IMarshal(iface);
1411     TRACE("(%p)->(%p)\n", This, stream);
1412     return CoReleaseMarshalData(stream);
1413 }
1414
1415 static HRESULT WINAPI marshal_DisconnectObject(IMarshal *iface, DWORD dwReserved)
1416 {
1417     marshal *This = impl_from_IMarshal(iface);
1418     FIXME("(%p)->(%08x)\n", This, dwReserved);
1419
1420     return E_NOTIMPL;
1421 }
1422
1423 static const IMarshalVtbl marshal_vtbl =
1424 {
1425     marshal_QueryInterface,
1426     marshal_AddRef,
1427     marshal_Release,
1428     marshal_GetUnmarshalClass,
1429     marshal_GetMarshalSizeMax,
1430     marshal_MarshalInterface,
1431     marshal_UnmarshalInterface,
1432     marshal_ReleaseMarshalData,
1433     marshal_DisconnectObject
1434 };
1435
1436 static HRESULT create_marshal(IUnknown *outer, const CLSID *class, void **obj)
1437 {
1438     marshal *marshal;
1439
1440     TRACE("(%p, %p)\n", outer, obj);
1441     *obj = NULL;
1442
1443     marshal = HeapAlloc(GetProcessHeap(), 0, sizeof(*marshal));
1444     if(!marshal) return E_OUTOFMEMORY;
1445
1446     marshal->unmarshal_class = *class;
1447     marshal->outer = outer; /* don't ref outer unk */
1448     marshal->IMarshal_iface.lpVtbl = &marshal_vtbl;
1449     marshal->ref = 1;
1450
1451     *obj = &marshal->IMarshal_iface;
1452     TRACE("returning %p\n", *obj);
1453     return S_OK;
1454 }
1455
1456 HRESULT create_row_marshal(IUnknown *outer, void **obj)
1457 {
1458     TRACE("(%p, %p)\n", outer, obj);
1459     return create_marshal(outer, &CLSID_wine_row_proxy, obj);
1460 }
1461
1462 HRESULT create_rowset_marshal(IUnknown *outer, void **obj)
1463 {
1464     TRACE("(%p, %p)\n", outer, obj);
1465     return create_marshal(outer, &CLSID_wine_rowset_proxy, obj);
1466 }