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     const IWineRowServerVtbl *vtbl;
  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 (server *)((char*)iface - FIELD_OFFSET(server, vtbl));
  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)->(%d, %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("%d:\tmax_len %d 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
 223     FIXME("(%p)->(%p, %p, %s, %08x, %s, %p): stub\n", This, pUnkOuter, pColumnID, debugstr_guid(rguidColumnType),
 224           dwBindFlags, debugstr_guid(riid), ppUnk);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI server_SetColumns(IWineRowServer* iface, DBORDINAL num_cols,
 229                                         wine_setcolumns_in *in_data, DBSTATUS *status)
 230 {
 231     server *This = impl_from_IWineRowServer(iface);
 232     FIXME("(%p)->(%d, %p, %p): stub\n", This, num_cols, in_data, status);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI server_AddRefRows(IWineRowServer* iface, DBCOUNTITEM cRows,
 237                                         const HROW rghRows[], DBREFCOUNT rgRefCounts[],
 238                                         DBROWSTATUS rgRowStatus[])
 239 {
 240     server *This = impl_from_IWineRowServer(iface);
 241     IRowset *rowset;
 242     HRESULT hr;
 243
 244     TRACE("(%p)->(%d, %p, %p, %p)\n", This, cRows, rghRows, rgRefCounts, rgRowStatus);
 245
 246     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
 247     if(FAILED(hr)) return hr;
 248
 249     hr = IRowset_AddRefRows(rowset, cRows, rghRows, rgRefCounts, rgRowStatus);
 250
 251     IRowset_Release(rowset);
 252     TRACE("returning %08x\n", hr);
 253     return hr;
 254 }
 255
 256 static HRESULT WINAPI server_GetData(IWineRowServer* iface, HROW hRow,
 257                                      HACCESSOR hAccessor, BYTE *pData, DWORD size)
 258 {
 259     server *This = impl_from_IWineRowServer(iface);
 260     FIXME("(%p)->(%08lx, %08lx, %p, %d): stub\n", This, hRow, hAccessor, pData, size);
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI server_GetNextRows(IWineRowServer* iface, HCHAPTER hReserved, DBROWOFFSET lRowsOffset,
 265                                          DBROWCOUNT cRows, DBCOUNTITEM *pcRowObtained, HROW **prghRows)
 266 {
 267     server *This = impl_from_IWineRowServer(iface);
 268     IRowset *rowset;
 269     HRESULT hr;
 270
 271     TRACE("(%p)->(%08lx, %d, %d, %p, %p)\n", This, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
 272
 273     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
 274     if(FAILED(hr)) return hr;
 275
 276     *prghRows = NULL;
 277
 278     hr = IRowset_GetNextRows(rowset, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
 279     IRowset_Release(rowset);
 280     TRACE("returning %08x, got %d rows\n", hr, *pcRowObtained);
 281     return hr;
 282 }
 283
 284 static HRESULT WINAPI server_ReleaseRows(IWineRowServer* iface, DBCOUNTITEM cRows, const HROW rghRows[],
 285                                          DBROWOPTIONS rgRowOptions[], DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
 286 {
 287     server *This = impl_from_IWineRowServer(iface);
 288     IRowset *rowset;
 289     HRESULT hr;
 290
 291     TRACE("(%p)->(%d, %p, %p, %p, %p)\n", This, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
 292
 293     hr = IUnknown_QueryInterface(This->inner_unk, &IID_IRowset, (void**)&rowset);
 294     if(FAILED(hr)) return hr;
 295
 296     hr = IRowset_ReleaseRows(rowset, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
 297     IRowset_Release(rowset);
 298
 299     TRACE("returning %08x\n", hr);
 300     return hr;
 301 }
 302
 303 static HRESULT WINAPI server_RestartPosition(IWineRowServer* iface, HCHAPTER hReserved)
 304 {
 305     server *This = impl_from_IWineRowServer(iface);
 306     FIXME("(%p)->(%08lx): stub\n", This, hReserved);
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI server_Compare(IWineRowServer *iface, HCHAPTER hReserved, DBBKMARK cbBookmark1,
 311                                      const BYTE *pBookmark1, DBBKMARK cbBookmark2, const BYTE *pBookmark2,
 312                                      DBCOMPARE *pComparison)
 313 {
 314     server *This = impl_from_IWineRowServer(iface);
 315     FIXME("(%p): stub\n", This);
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI server_GetRowsAt(IWineRowServer *iface, HWATCHREGION hReserved1, HCHAPTER hReserved2,
 320                                        DBBKMARK cbBookmark, const BYTE *pBookmark, DBROWOFFSET lRowsOffset,
 321                                        DBROWCOUNT cRows, DBCOUNTITEM *pcRowsObtained, HROW **prghRows)
 322 {
 323     server *This = impl_from_IWineRowServer(iface);
 324
 325     FIXME("(%p)->(%08lx, %08lx, %d, %p, %d, %d, %p, %p): stub\n", This, hReserved1, hReserved2, cbBookmark, pBookmark,
 326           lRowsOffset, cRows, pcRowsObtained, prghRows);
 327
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI server_GetRowsByBookmark(IWineRowServer *iface, HCHAPTER hReserved, DBCOUNTITEM cRows,
 332                                                const DBBKMARK rgcbBookmarks[], const BYTE * rgpBookmarks[],
 333                                                HROW rghRows[], DBROWSTATUS rgRowStatus[])
 334 {
 335     server *This = impl_from_IWineRowServer(iface);
 336     FIXME("(%p): stub\n", This);
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI server_Hash(IWineRowServer *iface, HCHAPTER hReserved, DBBKMARK cBookmarks,
 341                                   const DBBKMARK rgcbBookmarks[], const BYTE * rgpBookmarks[],
 342                                   DBHASHVALUE rgHashedValues[], DBROWSTATUS rgBookmarkStatus[])
 343 {
 344     server *This = impl_from_IWineRowServer(iface);
 345     FIXME("(%p): stub\n", This);
 346     return E_NOTIMPL;
 347 }
 348
 349 static const IWineRowServerVtbl server_vtbl =
 350 {
 351     server_QueryInterface,
 352     server_AddRef,
 353     server_Release,
 354     server_SetInnerUnk,
 355     server_GetMarshal,
 356     server_GetColumns,
 357     server_GetSourceRowset,
 358     server_Open,
 359     server_SetColumns,
 360     server_AddRefRows,
 361     server_GetData,
 362     server_GetNextRows,
 363     server_ReleaseRows,
 364     server_RestartPosition,
 365     server_Compare,
 366     server_GetRowsAt,
 367     server_GetRowsByBookmark,
 368     server_Hash
 369 };
 370
 371 static HRESULT create_server(IUnknown *outer, const CLSID *class, void **obj)
 372 {
 373     server *server;
 374     TRACE("(%p, %s, %p)\n", outer, debugstr_guid(class), obj);
 375
 376     *obj = NULL;
 377
 378     server = HeapAlloc(GetProcessHeap(), 0, sizeof(*server));
 379     if(!server) return E_OUTOFMEMORY;
 380
 381     server->vtbl = &server_vtbl;
 382     server->ref = 1;
 383     server->class = *class;
 384     server->inner_unk = NULL;
 385     if(IsEqualGUID(class, &CLSID_wine_row_server))
 386         create_row_marshal((IUnknown*)server, (void**)&server->marshal);
 387     else if(IsEqualGUID(class, &CLSID_wine_rowset_server))
 388         create_rowset_marshal((IUnknown*)server, (void**)&server->marshal);
 389     else
 390         ERR("create_server called with class %s\n", debugstr_guid(class));
 391
 392     *obj = server;
 393     return S_OK;
 394 }
 395
 396 HRESULT create_row_server(IUnknown *outer, void **obj)
 397 {
 398     return create_server(outer, &CLSID_wine_row_server, obj);
 399 }
 400
 401 HRESULT create_rowset_server(IUnknown *outer, void **obj)
 402 {
 403     return create_server(outer, &CLSID_wine_rowset_server, obj);
 404 }
 405
 406 typedef struct
 407 {
 408     const IRowVtbl *row_vtbl;
 409     const IRowChangeVtbl *row_change_vtbl;
 410
 411     LONG ref;
 412
 413     IWineRowServer *server;
 414 } row_proxy;
 415
 416 static inline row_proxy *impl_from_IRow(IRow *iface)
 417 {
 418     return (row_proxy *)((char*)iface - FIELD_OFFSET(row_proxy, row_vtbl));
 419 }
 420
 421 static inline row_proxy *impl_from_IRowChange(IRowChange *iface)
 422 {
 423     return (row_proxy *)((char*)iface - FIELD_OFFSET(row_proxy, row_change_vtbl));
 424 }
 425
 426 static HRESULT WINAPI row_QueryInterface(IRow *iface, REFIID iid, void **obj)
 427 {
 428     row_proxy *This = impl_from_IRow(iface);
 429     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
 430
 431     if(IsEqualIID(iid, &IID_IUnknown) ||
 432        IsEqualIID(iid, &IID_IRow))
 433     {
 434         *obj = &This->row_vtbl;
 435     }
 436     else if(IsEqualIID(iid, &IID_IRowChange))
 437     {
 438         *obj = &This->row_change_vtbl;
 439     }
 440     else
 441     {
 442         FIXME("interface %s not implemented\n", debugstr_guid(iid));
 443         return E_NOINTERFACE;
 444     }
 445
 446     IRow_AddRef(iface);
 447     return S_OK;
 448 }
 449
 450 static ULONG WINAPI row_AddRef(IRow *iface)
 451 {
 452     row_proxy *This = impl_from_IRow(iface);
 453     TRACE("(%p)\n", This);
 454
 455     return InterlockedIncrement(&This->ref);
 456 }
 457
 458 static ULONG WINAPI row_Release(IRow *iface)
 459 {
 460     row_proxy *This = impl_from_IRow(iface);
 461     LONG ref;
 462
 463     TRACE("(%p)\n", This);
 464
 465     ref = InterlockedDecrement(&This->ref);
 466     if(ref == 0)
 467     {
 468         if(This->server) IWineRowServer_Release(This->server);
 469         HeapFree(GetProcessHeap(), 0, This);
 470     }
 471
 472     return ref;
 473 }
 474
 475 static HRESULT WINAPI row_GetColumns(IRow* iface, DBORDINAL cColumns, DBCOLUMNACCESS rgColumns[])
 476 {
 477     row_proxy *This = impl_from_IRow(iface);
 478     DBORDINAL i;
 479     wine_getcolumns_in *in_data;
 480     wine_getcolumns_out *out_data;
 481     HRESULT hr;
 482
 483     TRACE("(%p)->(%d, %p)\n", This, cColumns, rgColumns);
 484
 485     in_data = CoTaskMemAlloc(cColumns * sizeof(in_data[0]));
 486     out_data = CoTaskMemAlloc(cColumns * sizeof(out_data[0]));
 487
 488     for(i = 0; i < cColumns; i++)
 489     {
 490         TRACE("%d:\tdata %p data_len %d status %08x max_len %d type %04x\n", i, rgColumns[i].pData,
 491               rgColumns[i].cbDataLen, rgColumns[i].dwStatus, rgColumns[i].cbMaxLen, rgColumns[i].wType);
 492         in_data[i].columnid     = rgColumns[i].columnid;
 493         in_data[i].max_len      = rgColumns[i].cbMaxLen;
 494         in_data[i].type         = rgColumns[i].wType;
 495         in_data[i].precision    = rgColumns[i].bPrecision;
 496         in_data[i].scale        = rgColumns[i].bScale;
 497     }
 498
 499     hr = IWineRowServer_GetColumns(This->server, cColumns, in_data, out_data);
 500
 501     for(i = 0; i < cColumns; i++)
 502     {
 503         rgColumns[i].cbDataLen = out_data[i].data_len;
 504         rgColumns[i].dwStatus  = out_data[i].status;
 505         if(rgColumns[i].dwStatus == DBSTATUS_S_OK)
 506             memcpy(rgColumns[i].pData, &V_I1(&out_data[i].v), out_data[i].data_len);
 507     }
 508
 509     CoTaskMemFree(out_data);
 510     CoTaskMemFree(in_data);
 511     return hr;
 512 }
 513
 514 static HRESULT WINAPI row_GetSourceRowset(IRow* iface, REFIID riid, IUnknown **ppRowset,
 515                                           HROW *phRow)
 516 {
 517     row_proxy *This = impl_from_IRow(iface);
 518
 519     FIXME("(%p)->(%s, %p, %p): stub\n", This, debugstr_guid(riid), ppRowset, phRow);
 520
 521     return E_NOTIMPL;
 522 }
 523
 524 static HRESULT WINAPI row_Open(IRow* iface, IUnknown *pUnkOuter,
 525                                DBID *pColumnID, REFGUID rguidColumnType,
 526                                DWORD dwBindFlags, REFIID riid, IUnknown **ppUnk)
 527 {
 528     row_proxy *This = impl_from_IRow(iface);
 529
 530     FIXME("(%p)->(%p, %p, %s, %08x, %s, %p): stub\n", This, pUnkOuter, pColumnID, debugstr_guid(rguidColumnType),
 531           dwBindFlags, debugstr_guid(riid), ppUnk);
 532
 533     return E_NOTIMPL;
 534 }
 535
 536 static const IRowVtbl row_vtbl =
 537 {
 538     row_QueryInterface,
 539     row_AddRef,
 540     row_Release,
 541     row_GetColumns,
 542     row_GetSourceRowset,
 543     row_Open
 544 };
 545
 546 static HRESULT WINAPI row_change_QueryInterface(IRowChange *iface, REFIID iid, void **obj)
 547 {
 548     row_proxy *This = impl_from_IRowChange(iface);
 549     return IUnknown_QueryInterface((IUnknown *)This, iid, obj);
 550 }
 551
 552 static ULONG WINAPI row_change_AddRef(IRowChange *iface)
 553 {
 554     row_proxy *This = impl_from_IRowChange(iface);
 555     return IUnknown_AddRef((IUnknown*)This);
 556 }
 557
 558 static ULONG WINAPI row_change_Release(IRowChange *iface)
 559 {
 560     row_proxy *This = impl_from_IRowChange(iface);
 561     return IUnknown_Release((IUnknown*)This);
 562 }
 563
 564 static HRESULT WINAPI row_change_SetColumns(IRowChange *iface, DBORDINAL cColumns,
 565                                             DBCOLUMNACCESS rgColumns[])
 566 {
 567     row_proxy *This = impl_from_IRowChange(iface);
 568     FIXME("(%p)->(%d, %p)\n", This, cColumns, rgColumns);
 569     return E_NOTIMPL;
 570 }
 571
 572 static const IRowChangeVtbl row_change_vtbl =
 573 {
 574     row_change_QueryInterface,
 575     row_change_AddRef,
 576     row_change_Release,
 577     row_change_SetColumns
 578 };
 579
 580 static HRESULT create_row_proxy(IWineRowServer *server, IUnknown **obj)
 581 {
 582     row_proxy *proxy;
 583
 584     TRACE("(%p, %p)\n", server, obj);
 585     *obj = NULL;
 586
 587     proxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*proxy));
 588     if(!proxy) return E_OUTOFMEMORY;
 589
 590     proxy->row_vtbl = &row_vtbl;
 591     proxy->row_change_vtbl = &row_change_vtbl;
 592     proxy->ref = 1;
 593     IWineRowServer_AddRef(server);
 594     proxy->server = server;
 595
 596     *obj = (IUnknown*)&proxy->row_vtbl;
 597     TRACE("returing %p\n", *obj);
 598     return S_OK;
 599 }
 600
 601 typedef struct
 602 {
 603     const IRowsetVtbl *rowset_vtbl;
 604
 605     LONG ref;
 606
 607     IWineRowServer *server;
 608 } rowset_proxy;
 609
 610 static inline rowset_proxy *impl_from_IRowset(IRowset *iface)
 611 {
 612     return (rowset_proxy *)((char*)iface - FIELD_OFFSET(rowset_proxy, rowset_vtbl));
 613 }
 614
 615 static HRESULT WINAPI rowset_QueryInterface(IRowset *iface, REFIID iid, void **obj)
 616 {
 617     rowset_proxy *This = impl_from_IRowset(iface);
 618     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
 619
 620     *obj = NULL;
 621
 622     if(IsEqualIID(iid, &IID_IUnknown) ||
 623        IsEqualIID(iid, &IID_IRowset))
 624     {
 625         *obj = &This->rowset_vtbl;
 626     }
 627     else
 628     {
 629         FIXME("interface %s not implemented\n", debugstr_guid(iid));
 630         return E_NOINTERFACE;
 631     }
 632
 633     IRowset_AddRef(iface);
 634     return S_OK;
 635 }
 636
 637 static ULONG WINAPI rowset_AddRef(IRowset *iface)
 638 {
 639     rowset_proxy *This = impl_from_IRowset(iface);
 640     TRACE("(%p)\n", This);
 641
 642     return InterlockedIncrement(&This->ref);
 643 }
 644
 645 static ULONG WINAPI rowset_Release(IRowset *iface)
 646 {
 647     rowset_proxy *This = impl_from_IRowset(iface);
 648     LONG ref;
 649
 650     TRACE("(%p)\n", This);
 651
 652     ref = InterlockedDecrement(&This->ref);
 653     if(ref == 0)
 654     {
 655         if(This->server) IWineRowServer_Release(This->server);
 656         HeapFree(GetProcessHeap(), 0, This);
 657     }
 658
 659     return ref;
 660 }
 661
 662 static HRESULT WINAPI rowset_AddRefRows(IRowset *iface, DBCOUNTITEM cRows, const HROW rghRows[],
 663                                         DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
 664 {
 665     rowset_proxy *This = impl_from_IRowset(iface);
 666     HRESULT hr;
 667     DBREFCOUNT *refs = rgRefCounts;
 668     DBSTATUS *stats = rgRowStatus;
 669
 670     TRACE("(%p)->(%d, %p, %p, %p)\n", This, cRows, rghRows, rgRefCounts, rgRowStatus);
 671
 672     if(!refs) refs = CoTaskMemAlloc(cRows * sizeof(refs[0]));
 673     if(!stats) stats = CoTaskMemAlloc(cRows * sizeof(stats[0]));
 674
 675     hr = IWineRowServer_AddRefRows(This->server, cRows, rghRows, refs, stats);
 676
 677     if(refs != rgRefCounts) CoTaskMemFree(refs);
 678     if(stats != rgRowStatus) CoTaskMemFree(stats);
 679
 680     return hr;
 681 }
 682
 683 static HRESULT WINAPI rowset_GetData(IRowset *iface, HROW hRow, HACCESSOR hAccessor, void *pData)
 684 {
 685     rowset_proxy *This = impl_from_IRowset(iface);
 686
 687     FIXME("(%p)->(%lx, %lx, %p): stub\n", This, hRow, hAccessor, pData);
 688
 689     return E_NOTIMPL;
 690 }
 691
 692 static HRESULT WINAPI rowset_GetNextRows(IRowset *iface, HCHAPTER hReserved, DBROWOFFSET lRowsOffset,
 693                                          DBROWCOUNT cRows, DBCOUNTITEM *pcRowObtained, HROW **prghRows)
 694 {
 695     rowset_proxy *This = impl_from_IRowset(iface);
 696     HRESULT hr;
 697     HROW *rows = NULL;
 698
 699     TRACE("(%p)->(%08lx, %d, %d, %p, %p)\n", This, hReserved, lRowsOffset, cRows, pcRowObtained, prghRows);
 700
 701     hr = IWineRowServer_GetNextRows(This->server, hReserved, lRowsOffset, cRows, pcRowObtained, &rows);
 702     if(*prghRows)
 703     {
 704         memcpy(*prghRows, rows, *pcRowObtained * sizeof(rows[0]));
 705         CoTaskMemFree(rows);
 706     }
 707     else
 708         *prghRows = rows;
 709
 710     return hr;
 711 }
 712
 713 static HRESULT WINAPI rowset_ReleaseRows(IRowset *iface, DBCOUNTITEM cRows, const HROW rghRows[],
 714                                          DBROWOPTIONS rgRowOptions[], DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
 715 {
 716     rowset_proxy *This = impl_from_IRowset(iface);
 717     HRESULT hr;
 718     DBROWOPTIONS *options = rgRowOptions;
 719     DBREFCOUNT *refs = rgRefCounts;
 720     DBROWSTATUS *status = rgRowStatus;
 721
 722     TRACE("(%p)->(%d, %p, %p, %p, %p)\n", This, cRows, rghRows, rgRowOptions, rgRefCounts, rgRowStatus);
 723
 724     if(!options)
 725     {
 726         options = CoTaskMemAlloc(cRows * sizeof(options[0]));
 727         memset(options, 0, cRows * sizeof(options[0]));
 728     }
 729     if(!refs) refs = CoTaskMemAlloc(cRows * sizeof(refs[0]));
 730     if(!status) status = CoTaskMemAlloc(cRows * sizeof(status[0]));
 731
 732     hr = IWineRowServer_ReleaseRows(This->server, cRows, rghRows, options, refs, status);
 733
 734     if(status != rgRowStatus) CoTaskMemFree(status);
 735     if(refs != rgRefCounts) CoTaskMemFree(refs);
 736     if(options != rgRowOptions) CoTaskMemFree(options);
 737
 738     return hr;
 739 }
 740
 741 static HRESULT WINAPI rowset_RestartPosition(IRowset* iface, HCHAPTER hReserved)
 742 {
 743     rowset_proxy *This = impl_from_IRowset(iface);
 744
 745     FIXME("(%p)->(%lx): stub\n", This, hReserved);
 746
 747     return E_NOTIMPL;
 748 }
 749
 750 static const IRowsetVtbl rowset_vtbl =
 751 {
 752     rowset_QueryInterface,
 753     rowset_AddRef,
 754     rowset_Release,
 755     rowset_AddRefRows,
 756     rowset_GetData,
 757     rowset_GetNextRows,
 758     rowset_ReleaseRows,
 759     rowset_RestartPosition
 760 };
 761
 762 HRESULT create_rowset_proxy(IWineRowServer *server, IUnknown **obj)
 763 {
 764     rowset_proxy *proxy;
 765
 766     TRACE("(%p, %p)\n", server, obj);
 767     *obj = NULL;
 768
 769     proxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*proxy));
 770     if(!proxy) return E_OUTOFMEMORY;
 771
 772     proxy->rowset_vtbl = &rowset_vtbl;
 773     proxy->ref = 1;
 774     IWineRowServer_AddRef(server);
 775     proxy->server = server;
 776
 777     *obj = (IUnknown *)&proxy->rowset_vtbl;
 778     TRACE("returing %p\n", *obj);
 779     return S_OK;
 780 }
 781
 782 static HRESULT create_proxy(IWineRowServer *server, const CLSID *class, IUnknown **obj)
 783 {
 784     *obj = NULL;
 785
 786     if(IsEqualGUID(class, &CLSID_wine_row_proxy))
 787         return create_row_proxy(server, obj);
 788     else if(IsEqualGUID(class, &CLSID_wine_rowset_proxy))
 789         return create_rowset_proxy(server, obj);
 790     else
 791         FIXME("Unhandled proxy class %s\n", debugstr_guid(class));
 792     return E_NOTIMPL;
 793 }
 794
 795 /* Marshal impl */
 796
 797 typedef struct
 798 {
 799     const IMarshalVtbl *marshal_vtbl;
 800
 801     LONG ref;
 802     CLSID unmarshal_class;
 803     IUnknown *outer;
 804 } marshal;
 805
 806 static inline marshal *impl_from_IMarshal(IMarshal *iface)
 807 {
 808     return (marshal *)((char*)iface - FIELD_OFFSET(marshal, marshal_vtbl));
 809 }
 810
 811 static HRESULT WINAPI marshal_QueryInterface(IMarshal *iface, REFIID iid, void **obj)
 812 {
 813     marshal *This = impl_from_IMarshal(iface);
 814     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(iid), obj);
 815
 816     if(IsEqualIID(iid, &IID_IUnknown) ||
 817        IsEqualIID(iid, &IID_IMarshal))
 818     {
 819         *obj = iface;
 820     }
 821     else
 822     {
 823         FIXME("interface %s not implemented\n", debugstr_guid(iid));
 824         *obj = NULL;
 825         return E_NOINTERFACE;
 826     }
 827
 828     IMarshal_AddRef(iface);
 829     return S_OK;
 830 }
 831
 832 static ULONG WINAPI marshal_AddRef(IMarshal *iface)
 833 {
 834     marshal *This = impl_from_IMarshal(iface);
 835     TRACE("(%p)\n", This);
 836     return InterlockedIncrement(&This->ref);
 837 }
 838
 839 static ULONG WINAPI marshal_Release(IMarshal *iface)
 840 {
 841     marshal *This = impl_from_IMarshal(iface);
 842     LONG ref;
 843
 844     TRACE("(%p)\n", This);
 845
 846     ref = InterlockedDecrement(&This->ref);
 847     if(ref == 0)
 848     {
 849         HeapFree(GetProcessHeap(), 0, This);
 850     }
 851
 852     return ref;
 853 }
 854
 855 static HRESULT WINAPI marshal_GetUnmarshalClass(IMarshal *iface, REFIID iid, void *obj,
 856                                                 DWORD dwDestContext, void *pvDestContext,
 857                                                 DWORD mshlflags, CLSID *clsid)
 858 {
 859     marshal *This = impl_from_IMarshal(iface);
 860     TRACE("(%p)->(%s, %p, %08x, %p, %08x, %p)\n", This, debugstr_guid(iid), obj, dwDestContext,
 861           pvDestContext, mshlflags, clsid);
 862
 863     *clsid = This->unmarshal_class;
 864     return S_OK;
 865 }
 866
 867 static HRESULT WINAPI marshal_GetMarshalSizeMax(IMarshal *iface, REFIID iid, void *obj,
 868                                                 DWORD dwDestContext, void *pvDestContext,
 869                                                 DWORD mshlflags, DWORD *size)
 870 {
 871     marshal *This = impl_from_IMarshal(iface);
 872     TRACE("(%p)->(%s, %p, %08x, %p, %08x, %p)\n", This, debugstr_guid(iid), obj, dwDestContext,
 873           pvDestContext, mshlflags, size);
 874
 875     return CoGetMarshalSizeMax(size, &IID_IWineRowServer, This->outer, dwDestContext, pvDestContext,
 876                                mshlflags);
 877 }
 878
 879 static HRESULT WINAPI marshal_MarshalInterface(IMarshal *iface, IStream *stream, REFIID iid,
 880                                                void *obj, DWORD dwDestContext, void *pvDestContext,
 881                                                DWORD mshlflags)
 882 {
 883     marshal *This = impl_from_IMarshal(iface);
 884     TRACE("(%p)->(%p, %s, %p, %08x, %p, %08x)\n", This, stream, debugstr_guid(iid), obj, dwDestContext,
 885           pvDestContext, mshlflags);
 886
 887     return CoMarshalInterface(stream, &IID_IWineRowServer, This->outer, dwDestContext, pvDestContext, mshlflags);
 888 }
 889
 890 static HRESULT WINAPI marshal_UnmarshalInterface(IMarshal *iface, IStream *stream,
 891                                                  REFIID iid, void **obj)
 892 {
 893     marshal *This = impl_from_IMarshal(iface);
 894     HRESULT hr;
 895     IWineRowServer *server;
 896     IUnknown *proxy;
 897
 898     TRACE("(%p)->(%p, %s, %p)\n", This, stream, debugstr_guid(iid), obj);
 899     *obj = NULL;
 900
 901     hr = CoUnmarshalInterface(stream, &IID_IWineRowServer, (void**)&server);
 902     if(SUCCEEDED(hr))
 903     {
 904         hr = create_proxy(server, &This->unmarshal_class, &proxy);
 905         if(SUCCEEDED(hr))
 906         {
 907             hr = IUnknown_QueryInterface(proxy, iid, obj);
 908             IUnknown_Release(proxy);
 909         }
 910         IWineRowServer_Release(server);
 911     }
 912
 913     TRACE("returing %p\n", *obj);
 914     return hr;
 915 }
 916
 917 static HRESULT WINAPI marshal_ReleaseMarshalData(IMarshal *iface, IStream *stream)
 918 {
 919     marshal *This = impl_from_IMarshal(iface);
 920     TRACE("(%p)->(%p)\n", This, stream);
 921     return CoReleaseMarshalData(stream);
 922 }
 923
 924 static HRESULT WINAPI marshal_DisconnectObject(IMarshal *iface, DWORD dwReserved)
 925 {
 926     marshal *This = impl_from_IMarshal(iface);
 927     FIXME("(%p)->(%08x)\n", This, dwReserved);
 928
 929     return E_NOTIMPL;
 930 }
 931
 932 static const IMarshalVtbl marshal_vtbl =
 933 {
 934     marshal_QueryInterface,
 935     marshal_AddRef,
 936     marshal_Release,
 937     marshal_GetUnmarshalClass,
 938     marshal_GetMarshalSizeMax,
 939     marshal_MarshalInterface,
 940     marshal_UnmarshalInterface,
 941     marshal_ReleaseMarshalData,
 942     marshal_DisconnectObject
 943 };
 944
 945 static HRESULT create_marshal(IUnknown *outer, const CLSID *class, void **obj)
 946 {
 947     marshal *marshal;
 948
 949     TRACE("(%p, %p)\n", outer, obj);
 950     *obj = NULL;
 951
 952     marshal = HeapAlloc(GetProcessHeap(), 0, sizeof(*marshal));
 953     if(!marshal) return E_OUTOFMEMORY;
 954
 955     marshal->unmarshal_class = *class;
 956     marshal->outer = outer; /* don't ref outer unk */
 957     marshal->marshal_vtbl = &marshal_vtbl;
 958     marshal->ref = 1;
 959
 960     *obj = &marshal->marshal_vtbl;
 961     TRACE("returing %p\n", *obj);
 962     return S_OK;
 963 }
 964
 965 HRESULT create_row_marshal(IUnknown *outer, void **obj)
 966 {
 967     TRACE("(%p, %p)\n", outer, obj);
 968     return create_marshal(outer, &CLSID_wine_row_proxy, obj);
 969 }
 970
 971 HRESULT create_rowset_marshal(IUnknown *outer, void **obj)
 972 {
 973     TRACE("(%p, %p)\n", outer, obj);
 974     return create_marshal(outer, &CLSID_wine_rowset_proxy, obj);
 975 }