dlls/msdaps/usrmarshal.c

   1 /*
   2  *    Misc marshaling routines
   3  *
   4  * Copyright 2009 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
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winuser.h"
  29 #include "winerror.h"
  30 #include "objbase.h"
  31 #include "oleauto.h"
  32 #include "oledb.h"
  33
  34 #include "row_server.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  39
  40 HRESULT CALLBACK IDBCreateCommand_CreateCommand_Proxy(IDBCreateCommand* This, IUnknown *pUnkOuter,
  41                                                       REFIID riid, IUnknown **ppCommand)
  42 {
  43     IErrorInfo *error = NULL;
  44     HRESULT hr;
  45
  46     TRACE("(%p, %p, %s, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppCommand);
  47     hr = IDBCreateCommand_RemoteCreateCommand_Proxy(This, pUnkOuter, riid, ppCommand, &error);
  48     if(error)
  49     {
  50         SetErrorInfo(0, error);
  51         IErrorInfo_Release(error);
  52     }
  53     return hr;
  54 }
  55
  56 HRESULT __RPC_STUB IDBCreateCommand_CreateCommand_Stub(IDBCreateCommand* This, IUnknown *pUnkOuter,
  57                                                        REFIID riid, IUnknown **ppCommand, IErrorInfo **ppErrorInfoRem)
  58 {
  59     HRESULT hr;
  60
  61     TRACE("(%p, %p, %s, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppCommand, ppErrorInfoRem);
  62
  63     *ppErrorInfoRem = NULL;
  64     hr = IDBCreateCommand_CreateCommand(This, pUnkOuter, riid, ppCommand);
  65     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
  66
  67     return hr;
  68 }
  69
  70 HRESULT CALLBACK IDBCreateSession_CreateSession_Proxy(IDBCreateSession* This, IUnknown *pUnkOuter,
  71                                                       REFIID riid, IUnknown **ppDBSession)
  72 {
  73     IErrorInfo *error = NULL;
  74     HRESULT hr;
  75
  76     TRACE("(%p, %p, %s, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppDBSession);
  77     hr = IDBCreateSession_RemoteCreateSession_Proxy(This, pUnkOuter, riid, ppDBSession, &error);
  78     if(error)
  79     {
  80         SetErrorInfo(0, error);
  81         IErrorInfo_Release(error);
  82     }
  83     return hr;
  84 }
  85
  86 HRESULT __RPC_STUB IDBCreateSession_CreateSession_Stub(IDBCreateSession* This, IUnknown *pUnkOuter,
  87                                                        REFIID riid, IUnknown **ppDBSession, IErrorInfo **ppErrorInfoRem)
  88 {
  89     HRESULT hr;
  90     TRACE("(%p, %p, %s, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid),
  91           ppDBSession, ppErrorInfoRem);
  92
  93     *ppErrorInfoRem = NULL;
  94     hr = IDBCreateSession_CreateSession(This, pUnkOuter, riid, ppDBSession);
  95     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
  96
  97     return hr;
  98 }
  99
 100 HRESULT CALLBACK IDBProperties_GetProperties_Proxy(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
 101                                                    ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
 102 {
 103     IErrorInfo *error = NULL;
 104     HRESULT hr;
 105
 106     TRACE("(%p, %d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets,
 107           prgPropertySets);
 108     hr = IDBProperties_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets,
 109                                                  pcPropertySets, prgPropertySets, &error);
 110     if(error)
 111     {
 112         SetErrorInfo(0, error);
 113         IErrorInfo_Release(error);
 114     }
 115     return hr;
 116 }
 117
 118 HRESULT __RPC_STUB IDBProperties_GetProperties_Stub(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets,
 119                                                     ULONG *pcPropertySets, DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem)
 120 {
 121     HRESULT hr;
 122
 123     TRACE("(%p, %d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets,
 124           prgPropertySets, ppErrorInfoRem);
 125     *pcPropertySets = 0;
 126     *ppErrorInfoRem = NULL;
 127     hr = IDBProperties_GetProperties(This, cPropertyIDSets, rgPropertyIDSets,
 128         pcPropertySets, prgPropertySets);
 129     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 130
 131     return hr;
 132 }
 133
 134 HRESULT CALLBACK IDBProperties_GetPropertyInfo_Proxy(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
 135                                                      ULONG *pcPropertyInfoSets, DBPROPINFOSET **prgPropertyInfoSets,
 136                                                      OLECHAR **ppDescBuffer)
 137 {
 138     FIXME("(%p, %d, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 139           prgPropertyInfoSets, ppDescBuffer);
 140     return E_NOTIMPL;
 141 }
 142
 143 HRESULT __RPC_STUB IDBProperties_GetPropertyInfo_Stub(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets,
 144                                                       ULONG *pcPropertyInfoSets, DBPROPINFOSET **prgPropertyInfoSets,
 145                                                       ULONG *pcOffsets, DBBYTEOFFSET **prgDescOffsets, ULONG *pcbDescBuffer,
 146                                                       OLECHAR **ppDescBuffer, IErrorInfo **ppErrorInfoRem)
 147 {
 148     FIXME("(%p, %d, %p, %p, %p, %p, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 149           prgPropertyInfoSets, pcOffsets, prgDescOffsets, pcbDescBuffer, ppDescBuffer, ppErrorInfoRem);
 150     return E_NOTIMPL;
 151 }
 152
 153 HRESULT CALLBACK IDBProperties_SetProperties_Proxy(IDBProperties* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
 154 {
 155     ULONG prop_set, prop, total_props = 0;
 156     IErrorInfo *error = NULL;
 157     HRESULT hr;
 158     DBPROPSTATUS *status;
 159
 160     TRACE("(%p, %d, %p)\n", This, cPropertySets, rgPropertySets);
 161
 162     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 163         total_props += rgPropertySets[prop_set].cProperties;
 164
 165     if(total_props == 0) return S_OK;
 166
 167     status = CoTaskMemAlloc(total_props * sizeof(*status));
 168     if(!status) return E_OUTOFMEMORY;
 169
 170     hr = IDBProperties_RemoteSetProperties_Proxy(This, cPropertySets, rgPropertySets,
 171                                                  total_props, status, &error);
 172     if(error)
 173     {
 174         SetErrorInfo(0, error);
 175         IErrorInfo_Release(error);
 176     }
 177
 178     total_props = 0;
 179     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 180         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
 181             rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
 182
 183     CoTaskMemFree(status);
 184     return hr;
 185 }
 186
 187 HRESULT __RPC_STUB IDBProperties_SetProperties_Stub(IDBProperties* This, ULONG cPropertySets, DBPROPSET *rgPropertySets,
 188                                                     ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem)
 189 {
 190     ULONG prop_set, prop, total_props = 0;
 191     HRESULT hr;
 192
 193     TRACE("(%p, %d, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, cTotalProps,
 194           rgPropStatus, ppErrorInfoRem);
 195
 196     *ppErrorInfoRem = NULL;
 197     hr = IDBProperties_SetProperties(This, cPropertySets, rgPropertySets);
 198     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 199
 200     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 201         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
 202             rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus;
 203
 204     return hr;
 205 }
 206
 207 HRESULT CALLBACK IDBInitialize_Initialize_Proxy(IDBInitialize* This)
 208 {
 209     IErrorInfo *error = NULL;
 210     HRESULT hr;
 211
 212     TRACE("(%p)\n", This);
 213     hr = IDBInitialize_RemoteInitialize_Proxy(This, &error);
 214     if(error)
 215     {
 216         SetErrorInfo(0, error);
 217         IErrorInfo_Release(error);
 218     }
 219     return hr;
 220 }
 221
 222 HRESULT __RPC_STUB IDBInitialize_Initialize_Stub(IDBInitialize* This, IErrorInfo **ppErrorInfoRem)
 223 {
 224     HRESULT hr;
 225     TRACE("(%p, %p)\n", This, ppErrorInfoRem);
 226
 227     *ppErrorInfoRem = NULL;
 228     hr = IDBInitialize_Initialize(This);
 229     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 230
 231     return hr;
 232 }
 233
 234 HRESULT CALLBACK IDBInitialize_Uninitialize_Proxy(IDBInitialize* This)
 235 {
 236     IErrorInfo *error = NULL;
 237     HRESULT hr;
 238
 239     TRACE("(%p)\n", This);
 240     hr = IDBInitialize_RemoteUninitialize_Proxy(This, &error);
 241     if(error)
 242     {
 243         SetErrorInfo(0, error);
 244         IErrorInfo_Release(error);
 245     }
 246     return hr;
 247 }
 248
 249 HRESULT __RPC_STUB IDBInitialize_Uninitialize_Stub(IDBInitialize* This, IErrorInfo **error)
 250 {
 251     HRESULT hr;
 252
 253     TRACE("(%p, %p)\n", This, error);
 254     *error = NULL;
 255     hr = IDBInitialize_Uninitialize(This);
 256     if(FAILED(hr)) GetErrorInfo(0, error);
 257
 258     return hr;
 259 }
 260
 261 HRESULT CALLBACK IDBDataSourceAdmin_CreateDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets,
 262                                                            DBPROPSET rgPropertySets[], IUnknown *pUnkOuter,
 263                                                            REFIID riid, IUnknown **ppDBSession)
 264 {
 265     ULONG prop_set, prop, total_props = 0;
 266     IErrorInfo *error = NULL;
 267     HRESULT hr;
 268     DBPROPSTATUS *status;
 269
 270     TRACE("(%p, %d, %p, %p, %s, %p)\n", This, cPropertySets, rgPropertySets, pUnkOuter,
 271           debugstr_guid(riid), ppDBSession);
 272
 273     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 274         total_props += rgPropertySets[prop_set].cProperties;
 275
 276     if(total_props == 0) return S_OK;
 277
 278     status = CoTaskMemAlloc(total_props * sizeof(*status));
 279     if(!status) return E_OUTOFMEMORY;
 280
 281     hr = IDBDataSourceAdmin_RemoteCreateDataSource_Proxy(This, cPropertySets, rgPropertySets, pUnkOuter,
 282                                                          riid, ppDBSession, total_props, status, &error);
 283     if(error)
 284     {
 285         SetErrorInfo(0, error);
 286         IErrorInfo_Release(error);
 287     }
 288
 289     total_props = 0;
 290     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 291         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
 292             rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
 293
 294     CoTaskMemFree(status);
 295     return hr;
 296 }
 297
 298 HRESULT __RPC_STUB IDBDataSourceAdmin_CreateDataSource_Stub(IDBDataSourceAdmin* This, ULONG cPropertySets,
 299                                                             DBPROPSET *rgPropertySets, IUnknown *pUnkOuter,
 300                                                             REFIID riid, IUnknown **ppDBSession, ULONG cTotalProps,
 301                                                             DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem)
 302 {
 303     ULONG prop_set, prop, total_props = 0;
 304     HRESULT hr;
 305
 306     TRACE("(%p, %d, %p, %p, %s, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, pUnkOuter,
 307           debugstr_guid(riid), ppDBSession, cTotalProps, rgPropStatus, ppErrorInfoRem);
 308
 309     *ppErrorInfoRem = NULL;
 310     hr = IDBDataSourceAdmin_CreateDataSource(This, cPropertySets, rgPropertySets, pUnkOuter, riid, ppDBSession);
 311     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 312
 313     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 314         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
 315             rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus;
 316
 317     return hr;
 318 }
 319
 320 HRESULT CALLBACK IDBDataSourceAdmin_DestroyDataSource_Proxy(IDBDataSourceAdmin* This)
 321 {
 322     IErrorInfo *error = NULL;
 323     HRESULT hr;
 324
 325     TRACE("(%p)\n", This);
 326     hr = IDBDataSourceAdmin_RemoteDestroyDataSource_Proxy(This, &error);
 327     if(error)
 328     {
 329         SetErrorInfo(0, error);
 330         IErrorInfo_Release(error);
 331     }
 332     return hr;
 333 }
 334
 335 HRESULT __RPC_STUB IDBDataSourceAdmin_DestroyDataSource_Stub(IDBDataSourceAdmin* This, IErrorInfo **error)
 336 {
 337     HRESULT hr;
 338
 339     TRACE("(%p, %p)\n", This, error);
 340     *error = NULL;
 341     hr = IDBDataSourceAdmin_DestroyDataSource(This);
 342     if(FAILED(hr)) GetErrorInfo(0, error);
 343
 344     return hr;
 345 }
 346
 347 HRESULT CALLBACK IDBDataSourceAdmin_GetCreationProperties_Proxy(IDBDataSourceAdmin* This, ULONG cPropertyIDSets,
 348                                                                 const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets,
 349                                                                 DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer)
 350 {
 351     FIXME("(%p, %d, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 352           prgPropertyInfoSets, ppDescBuffer);
 353     return E_NOTIMPL;
 354 }
 355
 356 HRESULT __RPC_STUB IDBDataSourceAdmin_GetCreationProperties_Stub(IDBDataSourceAdmin* This, ULONG cPropertyIDSets,
 357                                                                  const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertyInfoSets,
 358                                                                  DBPROPINFOSET **prgPropertyInfoSets, DBCOUNTITEM *pcOffsets,
 359                                                                  DBBYTEOFFSET **prgDescOffsets, ULONG *pcbDescBuffer,
 360                                                                  OLECHAR **ppDescBuffer, IErrorInfo **error)
 361 {
 362     HRESULT hr;
 363
 364     TRACE("(%p, %d, %p, %p, %p, %p, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 365           prgPropertyInfoSets, pcOffsets, prgDescOffsets, pcbDescBuffer, ppDescBuffer, error);
 366     *error = NULL;
 367     hr = IDBDataSourceAdmin_GetCreationProperties(This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 368         prgPropertyInfoSets, ppDescBuffer);
 369     if(FAILED(hr)) GetErrorInfo(0, error);
 370
 371     return hr;
 372 }
 373
 374 HRESULT CALLBACK IDBDataSourceAdmin_ModifyDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
 375 {
 376     IErrorInfo *error = NULL;
 377     HRESULT hr;
 378
 379     TRACE("(%p, %d, %p)\n", This, cPropertySets, rgPropertySets);
 380     hr = IDBDataSourceAdmin_RemoteModifyDataSource_Proxy(This, cPropertySets, rgPropertySets, &error);
 381     if(error)
 382     {
 383         SetErrorInfo(0, error);
 384         IErrorInfo_Release(error);
 385     }
 386
 387     return hr;
 388 }
 389
 390 HRESULT __RPC_STUB IDBDataSourceAdmin_ModifyDataSource_Stub(IDBDataSourceAdmin* This, ULONG cPropertySets,
 391                                                             DBPROPSET *rgPropertySets, IErrorInfo **error)
 392 {
 393     HRESULT hr;
 394
 395     TRACE("(%p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, error);
 396     *error = NULL;
 397     hr = IDBDataSourceAdmin_ModifyDataSource(This, cPropertySets, rgPropertySets);
 398     if(FAILED(hr)) GetErrorInfo(0, error);
 399
 400     return hr;
 401 }
 402
 403 HRESULT CALLBACK ISessionProperties_GetProperties_Proxy(ISessionProperties* This, ULONG cPropertyIDSets,
 404                                                         const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets,
 405                                                         DBPROPSET **prgPropertySets)
 406 {
 407     IErrorInfo *error = NULL;
 408     HRESULT hr;
 409
 410     TRACE("(%p, %d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets,
 411           pcPropertySets, prgPropertySets);
 412
 413     hr = ISessionProperties_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets,
 414         prgPropertySets, &error);
 415     if(error)
 416     {
 417         SetErrorInfo(0, error);
 418         IErrorInfo_Release(error);
 419     }
 420
 421     return hr;
 422 }
 423
 424 HRESULT __RPC_STUB ISessionProperties_GetProperties_Stub(ISessionProperties* This, ULONG cPropertyIDSets,
 425                                                          const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertySets,
 426                                                          DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem)
 427 {
 428     HRESULT hr;
 429
 430     TRACE("(%p, %d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets,
 431           pcPropertySets, prgPropertySets, ppErrorInfoRem);
 432
 433     hr = ISessionProperties_GetProperties(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
 434     if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 435
 436     return hr;
 437 }
 438
 439 HRESULT CALLBACK ISessionProperties_SetProperties_Proxy(ISessionProperties* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
 440 {
 441     ULONG prop_set, prop, total_props = 0;
 442     IErrorInfo *error = NULL;
 443     HRESULT hr;
 444     DBPROPSTATUS *status;
 445
 446     TRACE("(%p, %d, %p)\n", This, cPropertySets, rgPropertySets);
 447
 448     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 449         total_props += rgPropertySets[prop_set].cProperties;
 450
 451     if(total_props == 0) return S_OK;
 452
 453     status = CoTaskMemAlloc(total_props * sizeof(*status));
 454     if(!status) return E_OUTOFMEMORY;
 455
 456     hr = ISessionProperties_RemoteSetProperties_Proxy(This, cPropertySets, rgPropertySets,
 457                                                       total_props, status, &error);
 458     if(error)
 459     {
 460         SetErrorInfo(0, error);
 461         IErrorInfo_Release(error);
 462     }
 463
 464     total_props = 0;
 465     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 466         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
 467             rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
 468
 469     CoTaskMemFree(status);
 470     return hr;
 471 }
 472
 473 HRESULT __RPC_STUB ISessionProperties_SetProperties_Stub(ISessionProperties* This, ULONG cPropertySets, DBPROPSET *rgPropertySets,
 474                                                          ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem)
 475 {
 476     ULONG prop_set, prop, total_props = 0;
 477     HRESULT hr;
 478
 479     TRACE("(%p, %d, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, cTotalProps,
 480           rgPropStatus, ppErrorInfoRem);
 481
 482     *ppErrorInfoRem = NULL;
 483     hr = ISessionProperties_SetProperties(This, cPropertySets, rgPropertySets);
 484     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 485
 486     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
 487         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
 488             rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus;
 489
 490     return hr;
 491 }
 492
 493 HRESULT CALLBACK IOpenRowset_OpenRowset_Proxy(IOpenRowset* This, IUnknown *pUnkOuter, DBID *pTableID, DBID *pIndexID,
 494                                               REFIID riid, ULONG cPropertySets, DBPROPSET rgPropertySets[], IUnknown **ppRowset)
 495 {
 496     FIXME("(%p, %p, %p, %p, %s, %d, %p, %p): stub\n", This, pUnkOuter, pTableID, pIndexID, debugstr_guid(riid),
 497           cPropertySets, rgPropertySets, ppRowset);
 498     return E_NOTIMPL;
 499 }
 500
 501 HRESULT __RPC_STUB IOpenRowset_OpenRowset_Stub(IOpenRowset* This, IUnknown *pUnkOuter, DBID *pTableID, DBID *pIndexID,
 502                                                REFIID riid, ULONG cPropertySets, DBPROPSET *rgPropertySets,
 503                                                IUnknown **ppRowset, ULONG cTotalProps, DBPROPSTATUS *rgPropStatus,
 504                                                IErrorInfo **ppErrorInfoRem)
 505 {
 506     FIXME("(%p, %p, %p, %p, %s, %d, %p, %p, %d, %p, %p): stub\n", This, pUnkOuter, pTableID, pIndexID, debugstr_guid(riid),
 507           cPropertySets, rgPropertySets, ppRowset, cTotalProps, rgPropStatus, ppErrorInfoRem);
 508     return E_NOTIMPL;
 509 }
 510
 511 HRESULT CALLBACK IBindResource_Bind_Proxy(IBindResource* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
 512                                           REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, DBIMPLICITSESSION *pImplSession,
 513                                           DBBINDURLSTATUS *pdwBindStatus, IUnknown **ppUnk)
 514 {
 515     HRESULT hr;
 516
 517     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
 518           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pImplSession, pdwBindStatus, ppUnk);
 519
 520     if(pUnkOuter)
 521     {
 522         FIXME("Aggregation not supported\n");
 523         return CLASS_E_NOAGGREGATION;
 524     }
 525
 526     hr = IBindResource_RemoteBind_Proxy(This, pUnkOuter, pwszURL, dwBindURLFlags, rguid, riid, pAuthenticate,
 527                                         pImplSession ? pImplSession->pUnkOuter : NULL, pImplSession ? pImplSession->piid : NULL,
 528                                         pImplSession ? &pImplSession->pSession : NULL, pdwBindStatus, ppUnk);
 529     return hr;
 530 }
 531
 532 HRESULT __RPC_STUB IBindResource_Bind_Stub(IBindResource* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
 533                                            REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, IUnknown *pSessionUnkOuter,
 534                                            IID *piid, IUnknown **ppSession, DBBINDURLSTATUS *pdwBindStatus, IUnknown **ppUnk)
 535 {
 536     HRESULT hr;
 537     DBIMPLICITSESSION impl_session;
 538     IWineRowServer *server;
 539     IMarshal *marshal;
 540     IUnknown *obj;
 541
 542     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
 543           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pSessionUnkOuter, piid, ppSession, pdwBindStatus, ppUnk);
 544
 545     *ppUnk = NULL;
 546
 547     if(IsEqualGUID(rguid, &DBGUID_ROWSET))
 548         hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&server);
 549     else if(IsEqualGUID(rguid, &DBGUID_ROW))
 550         hr = CoCreateInstance(&CLSID_wine_row_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&server);
 551     else
 552     {
 553         hr = E_NOTIMPL;
 554         FIXME("Unhandled object %s\n", debugstr_guid(rguid));
 555     }
 556
 557     if(FAILED(hr)) return hr;
 558
 559     impl_session.pUnkOuter = pSessionUnkOuter;
 560     impl_session.piid = piid;
 561     impl_session.pSession = NULL;
 562
 563     IWineRowServer_GetMarshal(server, &marshal);
 564
 565     hr = IBindResource_Bind(This, (IUnknown*)marshal, pwszURL, dwBindURLFlags, rguid, &IID_IUnknown, pAuthenticate,
 566                             ppSession ? &impl_session : NULL, pdwBindStatus, &obj);
 567
 568     IMarshal_Release(marshal);
 569     if(FAILED(hr))
 570     {
 571         IWineRowServer_Release(server);
 572         return hr;
 573     }
 574
 575     IWineRowServer_SetInnerUnk(server, obj);
 576     hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk);
 577     IUnknown_Release(obj);
 578
 579     if(ppSession) *ppSession = impl_session.pSession;
 580     return hr;
 581 }
 582
 583 HRESULT CALLBACK ICreateRow_CreateRow_Proxy(ICreateRow* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
 584                                             REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, DBIMPLICITSESSION *pImplSession,
 585                                             DBBINDURLSTATUS *pdwBindStatus, LPOLESTR *ppwszNewURL, IUnknown **ppUnk)
 586 {
 587     HRESULT hr;
 588
 589     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
 590           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pImplSession, pdwBindStatus, ppwszNewURL, ppUnk);
 591
 592     if(pUnkOuter)
 593     {
 594         FIXME("Aggregation not supported\n");
 595         return CLASS_E_NOAGGREGATION;
 596     }
 597
 598     hr = ICreateRow_RemoteCreateRow_Proxy(This, pUnkOuter, pwszURL, dwBindURLFlags, rguid, riid, pAuthenticate,
 599                                           pImplSession ? pImplSession->pUnkOuter : NULL, pImplSession ? pImplSession->piid : NULL,
 600                                           pImplSession ? &pImplSession->pSession : NULL, pdwBindStatus, ppwszNewURL, ppUnk);
 601     return hr;
 602 }
 603
 604 HRESULT __RPC_STUB ICreateRow_CreateRow_Stub(ICreateRow* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
 605                                              REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, IUnknown *pSessionUnkOuter,
 606                                              IID *piid, IUnknown **ppSession, DBBINDURLSTATUS *pdwBindStatus,
 607                                              LPOLESTR *ppwszNewURL, IUnknown **ppUnk)
 608 {
 609     HRESULT hr;
 610     DBIMPLICITSESSION impl_session;
 611     IWineRowServer *row_server;
 612     IMarshal *marshal;
 613     IUnknown *obj;
 614
 615     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
 616           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pSessionUnkOuter, piid, ppSession, pdwBindStatus, ppwszNewURL,
 617           ppUnk);
 618
 619     *ppUnk = NULL;
 620
 621     hr = CoCreateInstance(&CLSID_wine_row_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&row_server);
 622     if(FAILED(hr)) return hr;
 623
 624     impl_session.pUnkOuter = pSessionUnkOuter;
 625     impl_session.piid = piid;
 626     impl_session.pSession = NULL;
 627
 628     IWineRowServer_GetMarshal(row_server, &marshal);
 629
 630     hr = ICreateRow_CreateRow(This, (IUnknown*) marshal, pwszURL, dwBindURLFlags, rguid, &IID_IUnknown, pAuthenticate,
 631                               ppSession ? &impl_session : NULL, pdwBindStatus, ppwszNewURL, &obj);
 632     IMarshal_Release(marshal);
 633
 634     if(FAILED(hr))
 635     {
 636         IWineRowServer_Release(row_server);
 637         return hr;
 638     }
 639
 640     IWineRowServer_SetInnerUnk(row_server, obj);
 641     hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk);
 642     IUnknown_Release(obj);
 643
 644     if(ppSession) *ppSession = impl_session.pSession;
 645     return hr;
 646 }
 647
 648 HRESULT CALLBACK IAccessor_AddRefAccessor_Proxy(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *refcount)
 649 {
 650     IErrorInfo *errorinfo;
 651     DBREFCOUNT ref;
 652     HRESULT hr;
 653
 654     TRACE("(%p)->(%08lx, %p)\n", This, hAccessor, refcount);
 655
 656     if (!refcount)
 657         refcount = &ref;
 658
 659     errorinfo = NULL;
 660     hr = IAccessor_RemoteAddRefAccessor_Proxy(This, hAccessor, refcount, &errorinfo);
 661     if (errorinfo)
 662     {
 663         SetErrorInfo(0, errorinfo);
 664         IErrorInfo_Release(errorinfo);
 665     }
 666
 667     return hr;
 668 }
 669
 670 HRESULT __RPC_STUB IAccessor_AddRefAccessor_Stub(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount,
 671                                                  IErrorInfo **ppErrorInfoRem)
 672 {
 673     HRESULT hr;
 674
 675     TRACE("(%p)->(%08lx, %p, %p)\n", This, hAccessor, pcRefCount, ppErrorInfoRem);
 676
 677     hr = IAccessor_AddRefAccessor(This, hAccessor, pcRefCount);
 678     if (FAILED(hr))
 679         GetErrorInfo(0, ppErrorInfoRem);
 680
 681     return hr;
 682 }
 683
 684 HRESULT CALLBACK IAccessor_CreateAccessor_Proxy(IAccessor* This, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings,
 685                                                 const DBBINDING rgBindings[], DBLENGTH cbRowSize, HACCESSOR *phAccessor,
 686                                                 DBBINDSTATUS rgStatus[])
 687 {
 688     IErrorInfo *error = NULL;
 689     HRESULT hr;
 690     DBCOUNTITEM i;
 691
 692     TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings,
 693           cbRowSize, phAccessor, rgStatus);
 694
 695     for(i = 0; i < cBindings; i++)
 696     {
 697         TRACE("%ld: ord %ld val off %ld len off %ld stat off %ld part %04x mem_owner %d max_len %ld type %04x\n",
 698               i, rgBindings[i].iOrdinal, rgBindings[i].obValue, rgBindings[i].obLength, rgBindings[i].obStatus,
 699               rgBindings[i].dwPart, rgBindings[i].dwMemOwner, rgBindings[i].cbMaxLen, rgBindings[i].wType);
 700     }
 701
 702     hr = IAccessor_RemoteCreateAccessor_Proxy(This, dwAccessorFlags, cBindings, (DBBINDING *)rgBindings,
 703                                               cbRowSize, phAccessor, rgStatus, &error);
 704     if(error)
 705     {
 706         SetErrorInfo(0, error);
 707         IErrorInfo_Release(error);
 708     }
 709
 710     TRACE("returning %08x accessor %lx\n", hr, *phAccessor);
 711     return hr;
 712 }
 713
 714 HRESULT __RPC_STUB IAccessor_CreateAccessor_Stub(IAccessor* This, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings,
 715                                                  DBBINDING *rgBindings, DBLENGTH cbRowSize, HACCESSOR *phAccessor,
 716                                                  DBBINDSTATUS *rgStatus, IErrorInfo **ppErrorInfoRem)
 717 {
 718     HRESULT hr;
 719
 720     TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings,
 721           cbRowSize, phAccessor, rgStatus, ppErrorInfoRem);
 722
 723     *ppErrorInfoRem = NULL;
 724     hr = IAccessor_CreateAccessor(This, dwAccessorFlags, cBindings, rgBindings,
 725                                   cbRowSize, phAccessor, rgStatus);
 726     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 727
 728     return hr;
 729 }
 730
 731 HRESULT CALLBACK IAccessor_GetBindings_Proxy(IAccessor* This, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags,
 732                                              DBCOUNTITEM *pcBindings, DBBINDING **prgBindings)
 733 {
 734     FIXME("(%p): stub\n", This);
 735     return E_NOTIMPL;
 736 }
 737
 738 HRESULT __RPC_STUB IAccessor_GetBindings_Stub(IAccessor* This, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags,
 739                                               DBCOUNTITEM *pcBindings, DBBINDING **prgBindings, IErrorInfo **ppErrorInfoRem)
 740 {
 741     FIXME("(%p): stub\n", This);
 742     return E_NOTIMPL;
 743 }
 744
 745 HRESULT CALLBACK IAccessor_ReleaseAccessor_Proxy(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
 746 {
 747     IErrorInfo *error = NULL;
 748     HRESULT hr;
 749     DBREFCOUNT ref;
 750
 751     TRACE("(%p)->(%lx, %p)\n", This, hAccessor, pcRefCount);
 752
 753     hr = IAccessor_RemoteReleaseAccessor_Proxy(This, hAccessor, &ref, &error);
 754
 755     if(pcRefCount) *pcRefCount = ref;
 756     if(error)
 757     {
 758         SetErrorInfo(0, error);
 759         IErrorInfo_Release(error);
 760     }
 761     return hr;
 762 }
 763
 764 HRESULT __RPC_STUB IAccessor_ReleaseAccessor_Stub(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount,
 765                                                   IErrorInfo **ppErrorInfoRem)
 766 {
 767     HRESULT hr;
 768
 769     TRACE("(%p)->(%lx, %p, %p)\n", This, hAccessor, pcRefCount, ppErrorInfoRem);
 770
 771     *ppErrorInfoRem = NULL;
 772
 773     hr = IAccessor_ReleaseAccessor(This, hAccessor, pcRefCount);
 774
 775     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 776     return hr;
 777 }
 778
 779 HRESULT CALLBACK IRowsetInfo_GetProperties_Proxy(IRowsetInfo* This, const ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
 780                                                  ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
 781 {
 782     IErrorInfo *error = NULL;
 783     HRESULT hr;
 784     ULONG i;
 785
 786     TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
 787
 788     for(i = 0; i < cPropertyIDSets; i++)
 789     {
 790         unsigned int j;
 791         TRACE("%d: %s %d props\n", i, debugstr_guid(&rgPropertyIDSets[i].guidPropertySet), rgPropertyIDSets[i].cPropertyIDs);
 792         for(j = 0; j < rgPropertyIDSets[i].cPropertyIDs; j++)
 793             TRACE("\t%u: prop id %d\n", j, rgPropertyIDSets[i].rgPropertyIDs[j]);
 794     }
 795
 796     hr = IRowsetInfo_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets, &error);
 797
 798     if(error)
 799     {
 800         SetErrorInfo(0, error);
 801         IErrorInfo_Release(error);
 802     }
 803     return hr;
 804 }
 805
 806 HRESULT __RPC_STUB IRowsetInfo_GetProperties_Stub(IRowsetInfo* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets,
 807                                                   ULONG *pcPropertySets, DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem)
 808 {
 809     HRESULT hr;
 810
 811     TRACE("(%p)->(%d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets, ppErrorInfoRem);
 812
 813     *ppErrorInfoRem = NULL;
 814
 815     hr = IRowsetInfo_GetProperties(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
 816     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 817     TRACE("returning %08x\n", hr);
 818     return hr;
 819 }
 820
 821 HRESULT CALLBACK IRowsetInfo_GetReferencedRowset_Proxy(IRowsetInfo* This, DBORDINAL iOrdinal, REFIID riid, IUnknown **ppReferencedRowset)
 822 {
 823     IErrorInfo *error = NULL;
 824     HRESULT hr;
 825
 826     TRACE("(%p)->(%ld, %s, %p)\n", This, iOrdinal, debugstr_guid(riid), ppReferencedRowset);
 827
 828     hr = IRowsetInfo_RemoteGetReferencedRowset_Proxy(This, iOrdinal, riid, ppReferencedRowset, &error);
 829     if(error)
 830     {
 831         SetErrorInfo(0, error);
 832         IErrorInfo_Release(error);
 833     }
 834
 835     return hr;
 836 }
 837
 838 HRESULT __RPC_STUB IRowsetInfo_GetReferencedRowset_Stub(IRowsetInfo* This, DBORDINAL iOrdinal, REFIID riid, IUnknown **ppReferencedRowset,
 839                                                         IErrorInfo **ppErrorInfoRem)
 840 {
 841     HRESULT hr;
 842
 843     TRACE("(%p)->(%ld, %s, %p, %p)\n", This, iOrdinal, debugstr_guid(riid), ppReferencedRowset, ppErrorInfoRem);
 844
 845     hr = IRowsetInfo_GetReferencedRowset(This, iOrdinal, riid, ppReferencedRowset);
 846     if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 847
 848     return hr;
 849 }
 850
 851 HRESULT CALLBACK IRowsetInfo_GetSpecification_Proxy(IRowsetInfo* This, REFIID riid, IUnknown **ppSpecification)
 852 {
 853     IErrorInfo *error = NULL;
 854     HRESULT hr;
 855
 856     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppSpecification);
 857
 858     hr = IRowsetInfo_RemoteGetSpecification_Proxy(This, riid, ppSpecification, &error);
 859     if(error)
 860     {
 861         SetErrorInfo(0, error);
 862         IErrorInfo_Release(error);
 863     }
 864
 865     return hr;
 866 }
 867
 868 HRESULT __RPC_STUB IRowsetInfo_GetSpecification_Stub(IRowsetInfo* This, REFIID riid, IUnknown **ppSpecification, IErrorInfo **ppErrorInfoRem)
 869 {
 870     HRESULT hr;
 871
 872     TRACE("(%p)->(%s, %p, %p)\n", This, debugstr_guid(riid), ppSpecification, ppErrorInfoRem);
 873
 874     hr = IRowsetInfo_GetSpecification(This, riid, ppSpecification);
 875     if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 876
 877     return hr;
 878 }
 879
 880 HRESULT CALLBACK ICommand_Cancel_Proxy(ICommand* This)
 881 {
 882     IErrorInfo *error = NULL;
 883     HRESULT hr;
 884
 885     TRACE("(%p)\n", This);
 886
 887     hr = ICommand_RemoteCancel_Proxy(This, &error);
 888     if(error)
 889     {
 890         SetErrorInfo(0, error);
 891         IErrorInfo_Release(error);
 892     }
 893
 894     return hr;
 895 }
 896
 897 HRESULT __RPC_STUB ICommand_Cancel_Stub(ICommand* This, IErrorInfo **ppErrorInfoRem)
 898 {
 899     HRESULT hr;
 900
 901     TRACE("(%p)->(%p)\n", This, ppErrorInfoRem);
 902
 903     hr = ICommand_Cancel(This);
 904     if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
 905
 906     return hr;
 907 }
 908
 909 HRESULT CALLBACK ICommand_Execute_Proxy(ICommand* This, IUnknown *pUnkOuter, REFIID riid,
 910                                         DBPARAMS *pParams, DBROWCOUNT *pcRowsAffected, IUnknown **ppRowset)
 911 {
 912     HRESULT hr;
 913     DBROWCOUNT affected;
 914
 915     *ppRowset = NULL;
 916
 917     TRACE("(%p)->(%p, %s, %p, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), pParams,
 918           pcRowsAffected, ppRowset);
 919
 920     if(pParams)
 921     {
 922         FIXME("Unhandled params {%p, %ld, %08lx}\n", pParams->pData, pParams->cParamSets, pParams->hAccessor);
 923         return E_NOTIMPL;
 924     }
 925
 926     if(pUnkOuter)
 927     {
 928         FIXME("Aggregation not supported\n");
 929         return CLASS_E_NOAGGREGATION;
 930     }
 931
 932     hr = ICommand_RemoteExecute_Proxy(This, pUnkOuter, riid, 0, 0, NULL, 0, NULL, NULL, 0, NULL, NULL, &affected,
 933                                       ppRowset);
 934
 935     TRACE("Execute returns %08x\n", hr);
 936
 937     if(pcRowsAffected) *pcRowsAffected = affected;
 938
 939     return hr;
 940 }
 941
 942 HRESULT __RPC_STUB ICommand_Execute_Stub(ICommand* This, IUnknown *pUnkOuter, REFIID riid, HACCESSOR hAccessor,
 943                                          DB_UPARAMS cParamSets, GUID *pGuid, ULONG ulGuidOffset, RMTPACK *pInputParams,
 944                                          RMTPACK *pOutputParams, DBCOUNTITEM cBindings, DBBINDING *rgBindings,
 945                                          DBSTATUS *rgStatus, DBROWCOUNT *pcRowsAffected, IUnknown **ppRowset)
 946 {
 947     IWineRowServer *rowset_server;
 948     IMarshal *marshal;
 949     IUnknown *obj = NULL;
 950     HRESULT hr;
 951
 952     TRACE("(%p)->(%p, %s, %08lx, %ld, %p, %d, %p, %p, %ld, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid),
 953           hAccessor, cParamSets, pGuid, ulGuidOffset, pInputParams, pOutputParams, cBindings, rgBindings, rgStatus,
 954           pcRowsAffected, ppRowset);
 955
 956     *ppRowset = NULL;
 957
 958     hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&rowset_server);
 959     if(FAILED(hr)) return hr;
 960
 961     IWineRowServer_GetMarshal(rowset_server, &marshal);
 962
 963     hr = ICommand_Execute(This, (IUnknown*)marshal, &IID_IUnknown, NULL, pcRowsAffected, &obj);
 964
 965     IMarshal_Release(marshal);
 966
 967     if(FAILED(hr))
 968     {
 969         IWineRowServer_Release(rowset_server);
 970         return hr;
 971     }
 972
 973     IWineRowServer_SetInnerUnk(rowset_server, obj);
 974     hr = IUnknown_QueryInterface(obj, riid, (void**)ppRowset);
 975     IUnknown_Release(obj);
 976
 977     return hr;
 978 }
 979
 980 HRESULT CALLBACK ICommand_GetDBSession_Proxy(ICommand* This, REFIID riid, IUnknown **ppSession)
 981 {
 982     IErrorInfo *error = NULL;
 983     HRESULT hr;
 984
 985     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppSession);
 986
 987     hr = ICommand_RemoteGetDBSession_Proxy(This, riid, ppSession, &error);
 988     if(error)
 989     {
 990         SetErrorInfo(0, error);
 991         IErrorInfo_Release(error);
 992     }
 993
 994     return hr;
 995 }
 996
 997 HRESULT __RPC_STUB ICommand_GetDBSession_Stub(ICommand* This, REFIID riid, IUnknown **ppSession, IErrorInfo **ppErrorInfoRem)
 998 {
 999     HRESULT hr;
1000
1001     TRACE("(%p)->(%s, %p, %p)\n", This, debugstr_guid(riid), ppSession, ppErrorInfoRem);
1002
1003     hr = ICommand_GetDBSession(This, riid, ppSession);
1004     if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
1005
1006     return hr;
1007 }
1008
1009 HRESULT CALLBACK ICommandText_GetCommandText_Proxy(ICommandText* This, GUID *pguidDialect, LPOLESTR *ppwszCommand)
1010 {
1011     IErrorInfo *error = NULL;
1012     HRESULT hr;
1013
1014     TRACE("(%p)->(%p, %p)\n", This, pguidDialect, ppwszCommand);
1015
1016     hr = ICommandText_RemoteGetCommandText_Proxy(This, pguidDialect, ppwszCommand, &error);
1017     if(error)
1018     {
1019         SetErrorInfo(0, error);
1020         IErrorInfo_Release(error);
1021     }
1022
1023     return hr;
1024 }
1025
1026 HRESULT __RPC_STUB ICommandText_GetCommandText_Stub(ICommandText* This, GUID *pguidDialect,
1027                                                     LPOLESTR *ppwszCommand, IErrorInfo **ppErrorInfoRem)
1028 {
1029     HRESULT hr;
1030
1031     TRACE("(%p)->(%p, %p, %p)\n", This, pguidDialect, ppwszCommand, ppErrorInfoRem);
1032
1033     hr = ICommandText_GetCommandText(This, pguidDialect, ppwszCommand);
1034     if (FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
1035
1036     return hr;
1037 }
1038
1039 HRESULT CALLBACK ICommandText_SetCommandText_Proxy(ICommandText* This, REFGUID rguidDialect, LPCOLESTR pwszCommand)
1040 {
1041     IErrorInfo *error = NULL;
1042     HRESULT hr;
1043
1044     TRACE("(%p)->(%s, %s)\n", This, debugstr_guid(rguidDialect), debugstr_w(pwszCommand));
1045
1046     hr = ICommandText_RemoteSetCommandText_Proxy(This, rguidDialect, pwszCommand, &error);
1047     if(error)
1048     {
1049         SetErrorInfo(0, error);
1050         IErrorInfo_Release(error);
1051     }
1052     return hr;
1053 }
1054
1055 HRESULT __RPC_STUB ICommandText_SetCommandText_Stub(ICommandText* This, REFGUID rguidDialect, LPCOLESTR pwszCommand,
1056                                                     IErrorInfo **ppErrorInfoRem)
1057 {
1058     HRESULT hr;
1059
1060     TRACE("(%p)->(%s, %s, %p)\n", This, debugstr_guid(rguidDialect), debugstr_w(pwszCommand),
1061           ppErrorInfoRem);
1062
1063     *ppErrorInfoRem = NULL;
1064     hr = ICommandText_SetCommandText(This, rguidDialect, pwszCommand);
1065     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
1066
1067     return hr;
1068 }
1069
1070 HRESULT CALLBACK IDBAsynchNotify_OnLowResource_Proxy(IDBAsynchNotify* This, DB_DWRESERVE dwReserved)
1071 {
1072     TRACE("(%p)->(%08lx)\n", This, dwReserved);
1073     return IDBAsynchNotify_RemoteOnLowResource_Proxy(This, dwReserved);
1074 }
1075
1076 HRESULT __RPC_STUB IDBAsynchNotify_OnLowResource_Stub(IDBAsynchNotify* This, DB_DWRESERVE dwReserved)
1077 {
1078     TRACE("(%p)->(%08lx)\n", This, dwReserved);
1079     return IDBAsynchNotify_OnLowResource(This, dwReserved);
1080 }
1081
1082 HRESULT CALLBACK IDBAsynchNotify_OnProgress_Proxy(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
1083                                                   DBCOUNTITEM ulProgress, DBCOUNTITEM ulProgressMax, DBASYNCHPHASE eAsynchPhase,
1084                                                   LPOLESTR pwszStatusText)
1085 {
1086     TRACE("(%p)->(%lx, %d, %ld, %ld, %d, %s)\n", This, hChapter, eOperation, ulProgress, ulProgressMax,
1087           eAsynchPhase, debugstr_w(pwszStatusText));
1088
1089     return IDBAsynchNotify_RemoteOnProgress_Proxy(This, hChapter, eOperation, ulProgress, ulProgressMax, eAsynchPhase,
1090                                                   pwszStatusText);
1091 }
1092
1093 HRESULT __RPC_STUB IDBAsynchNotify_OnProgress_Stub(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
1094                                                    DBCOUNTITEM ulProgress, DBCOUNTITEM ulProgressMax, DBASYNCHPHASE eAsynchPhase,
1095                                                    LPOLESTR pwszStatusText)
1096 {
1097     TRACE("(%p)->(%lx, %d, %ld, %ld, %d, %s)\n", This, hChapter, eOperation, ulProgress, ulProgressMax,
1098           eAsynchPhase, debugstr_w(pwszStatusText));
1099     return IDBAsynchNotify_OnProgress(This, hChapter, eOperation, ulProgress, ulProgressMax, eAsynchPhase,
1100                                       pwszStatusText);
1101 }
1102
1103 HRESULT CALLBACK IDBAsynchNotify_OnStop_Proxy(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
1104                                               HRESULT hrStatus, LPOLESTR pwszStatusText)
1105 {
1106     TRACE("(%p)->(%lx, %d, %08x, %s)\n", This, hChapter, eOperation, hrStatus, debugstr_w(pwszStatusText));
1107     return IDBAsynchNotify_RemoteOnStop_Proxy(This, hChapter, eOperation, hrStatus, pwszStatusText);
1108 }
1109
1110 HRESULT __RPC_STUB IDBAsynchNotify_OnStop_Stub(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
1111                                                HRESULT hrStatus, LPOLESTR pwszStatusText)
1112 {
1113     TRACE("(%p)->(%lx, %d, %08x, %s)\n", This, hChapter, eOperation, hrStatus, debugstr_w(pwszStatusText));
1114     return IDBAsynchNotify_OnStop(This, hChapter, eOperation, hrStatus, pwszStatusText);
1115 }
1116
1117 HRESULT CALLBACK IDBAsynchStatus_Abort_Proxy(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation)
1118 {
1119     IErrorInfo *error = NULL;
1120     HRESULT hr;
1121
1122     TRACE("(%p)->(%lx, %d)\n", This, hChapter, eOperation);
1123
1124     hr = IDBAsynchStatus_RemoteAbort_Proxy(This, hChapter, eOperation, &error);
1125     if(error)
1126     {
1127         SetErrorInfo(0, error);
1128         IErrorInfo_Release(error);
1129     }
1130     return hr;
1131 }
1132
1133 HRESULT __RPC_STUB IDBAsynchStatus_Abort_Stub(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
1134                                               IErrorInfo **ppErrorInfoRem)
1135 {
1136     HRESULT hr;
1137
1138     TRACE("(%p)->(%lx, %d, %p)\n", This, hChapter, eOperation, ppErrorInfoRem);
1139
1140     *ppErrorInfoRem = NULL;
1141     hr = IDBAsynchStatus_Abort(This, hChapter, eOperation);
1142     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
1143
1144     return hr;
1145 }
1146
1147 HRESULT CALLBACK IDBAsynchStatus_GetStatus_Proxy(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
1148                                                  DBCOUNTITEM *pulProgress, DBCOUNTITEM *pulProgressMax, DBASYNCHPHASE *peAsynchPhase,
1149                                                  LPOLESTR *ppwszStatusText)
1150 {
1151     IErrorInfo *error = NULL;
1152     HRESULT hr;
1153
1154     TRACE("(%p)->(%lx, %d, %p, %p, %p, %p)\n", This, hChapter, eOperation, pulProgress, pulProgressMax,
1155           peAsynchPhase, ppwszStatusText);
1156
1157     hr = IDBAsynchStatus_RemoteGetStatus_Proxy(This, hChapter, eOperation, pulProgress, pulProgressMax, peAsynchPhase,
1158         ppwszStatusText, &error);
1159     if(error)
1160     {
1161         SetErrorInfo(0, error);
1162         IErrorInfo_Release(error);
1163     }
1164     return hr;
1165 }
1166
1167 HRESULT __RPC_STUB IDBAsynchStatus_GetStatus_Stub(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
1168                                                   DBCOUNTITEM *pulProgress, DBCOUNTITEM *pulProgressMax, DBASYNCHPHASE *peAsynchPhase,
1169                                                   LPOLESTR *ppwszStatusText, IErrorInfo **ppErrorInfoRem)
1170 {
1171     HRESULT hr;
1172
1173     TRACE("(%p)->(%lx, %d, %p, %p, %p, %p, %p)\n", This, hChapter, eOperation, pulProgress, pulProgressMax,
1174           peAsynchPhase, ppwszStatusText, ppErrorInfoRem);
1175
1176     *ppErrorInfoRem = NULL;
1177     hr = IDBAsynchStatus_GetStatus(This, hChapter, eOperation, pulProgress, pulProgressMax, peAsynchPhase, ppwszStatusText);
1178     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
1179
1180     return hr;
1181 }
1182
1183 HRESULT CALLBACK IRowsetNotify_OnRowChange_Proxy(IRowsetNotify* This, IRowset *rowset, DBCOUNTITEM rows, HROW *hrows, DBREASON reason,
1184                                                  DBEVENTPHASE phase, BOOL cantdeny)
1185 {
1186     TRACE("(%p)->(%p %ld %p %d %d %d)\n", This, rowset, rows, hrows, reason, phase, cantdeny);
1187     return IRowsetNotify_RemoteOnRowChange_Proxy(This, rowset, rows, hrows, reason, phase, cantdeny);
1188 }
1189
1190 HRESULT __RPC_STUB IRowsetNotify_OnRowChange_Stub(IRowsetNotify* This, IRowset *rowset, DBCOUNTITEM rows, HROW *hrows, DBREASON reason,
1191                                                   DBEVENTPHASE phase, BOOL cantdeny)
1192 {
1193     TRACE("(%p)->(%p %ld %p %d %d %d)\n", This, rowset, rows, hrows, reason, phase, cantdeny);
1194     return IRowsetNotify_OnRowChange(This, rowset, rows, hrows, reason, phase, cantdeny);
1195 }
1196
1197 HRESULT CALLBACK IRowsetNotify_OnFieldChange_Proxy(IRowsetNotify* This, IRowset *rowset, HROW row, DBORDINAL ccols, DBORDINAL *columns,
1198                                                    DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny)
1199 {
1200     TRACE("(%p)->(%p %lx %ld %p %d %d %d)\n", This, rowset, row, ccols, columns, reason, phase, cantdeny);
1201     return IRowsetNotify_RemoteOnFieldChange_Proxy(This, rowset, row, ccols, columns, reason, phase, cantdeny);
1202 }
1203
1204 HRESULT __RPC_STUB IRowsetNotify_OnFieldChange_Stub(IRowsetNotify* This, IRowset *rowset, HROW row, DBORDINAL ccols, DBORDINAL *columns,
1205                                                     DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny)
1206 {
1207     TRACE("(%p)->(%p %lx %ld %p %d %d %d)\n", This, rowset, row, ccols, columns, reason, phase, cantdeny);
1208     return IRowsetNotify_OnFieldChange(This, rowset, row, ccols, columns, reason, phase, cantdeny);
1209 }
1210
1211 HRESULT CALLBACK IRowsetNotify_OnRowsetChange_Proxy(IRowsetNotify* This, IRowset *rowset, DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny)
1212 {
1213     TRACE("(%p)->(%p %d %d %d)\n", This, rowset, reason, phase, cantdeny);
1214     return IRowsetNotify_RemoteOnRowsetChange_Proxy(This, rowset, reason, phase, cantdeny);
1215 }
1216
1217 HRESULT __RPC_STUB IRowsetNotify_OnRowsetChange_Stub(IRowsetNotify* This, IRowset *rowset, DBREASON reason, DBEVENTPHASE phase, BOOL cantdeny)
1218 {
1219     TRACE("(%p)->(%p %d %d %d)\n", This, rowset, reason, phase, cantdeny);
1220     return IRowsetNotify_OnRowsetChange(This, rowset, reason, phase, cantdeny);
1221 }
1222
1223
1224 HRESULT CALLBACK ISourcesRowset_GetSourcesRowset_Proxy(ISourcesRowset* This, IUnknown *pUnkOuter, REFIID riid, ULONG cPropertySets,
1225                               DBPROPSET rgProperties[], IUnknown **ppSourcesRowset)
1226 {
1227     IErrorInfo *error = NULL;
1228     HRESULT hr;
1229
1230     TRACE("(%p)->(%p %s %d %p %p)\n", This, pUnkOuter, debugstr_guid(riid), cPropertySets, rgProperties, ppSourcesRowset);
1231
1232     hr = ISourcesRowset_RemoteGetSourcesRowset_Proxy(This, pUnkOuter, riid, cPropertySets, rgProperties, ppSourcesRowset, 0, NULL, &error);
1233     if(error)
1234     {
1235         SetErrorInfo(0, error);
1236         IErrorInfo_Release(error);
1237     }
1238
1239     return hr;
1240 }
1241
1242 HRESULT __RPC_STUB ISourcesRowset_GetSourcesRowset_Stub(ISourcesRowset* This, IUnknown *pUnkOuter, REFIID riid, ULONG cPropertySets,
1243                                  DBPROPSET *rgProperties, IUnknown **ppSourcesRowset, ULONG cTotalProps, DBPROPSTATUS *rgPropStatus,
1244                                  IErrorInfo **ppErrorInfoRem)
1245 {
1246     HRESULT hr;
1247
1248     TRACE("(%p)->(%p %s %d %p %p %d %p %p)\n", This, pUnkOuter, debugstr_guid(riid), cPropertySets, rgProperties, ppSourcesRowset,
1249                                 cTotalProps, rgPropStatus, ppErrorInfoRem);
1250
1251     *ppErrorInfoRem = NULL;
1252     hr = ISourcesRowset_GetSourcesRowset(This, pUnkOuter, riid, cPropertySets, rgProperties, ppSourcesRowset);
1253     if(FAILED(hr))
1254         GetErrorInfo(0, ppErrorInfoRem);
1255
1256     return hr;
1257 }
1258
1259 HRESULT CALLBACK IErrorRecords_GetRecordCount_Proxy(IErrorRecords* This, ULONG *records)
1260 {
1261     IErrorInfo *error = NULL;
1262     HRESULT hr;
1263
1264     TRACE("(%p)->%p\n", This, records);
1265
1266     hr = IErrorRecords_RemoteGetRecordCount_Proxy(This, records, &error);
1267     if(error)
1268     {
1269         SetErrorInfo(0, error);
1270         IErrorInfo_Release(error);
1271     }
1272
1273     return hr;
1274 }
1275
1276 HRESULT __RPC_STUB IErrorRecords_GetRecordCount_Stub(IErrorRecords* This, ULONG *pcRecords, IErrorInfo **ppErrorInfoRem)
1277 {
1278     HRESULT hr;
1279
1280     TRACE("(%p)->%p %p\n", This, pcRecords, ppErrorInfoRem);
1281
1282     *ppErrorInfoRem = NULL;
1283     hr = IErrorRecords_GetRecordCount(This, pcRecords);
1284     if(FAILED(hr))
1285         GetErrorInfo(0, ppErrorInfoRem);
1286
1287     return hr;
1288 }
1289
1290 HRESULT CALLBACK IErrorRecords_GetErrorParameters_Proxy(IErrorRecords* This, ULONG ulRecordNum, DISPPARAMS *pdispparams)
1291 {
1292     IErrorInfo *error = NULL;
1293     HRESULT hr;
1294
1295     TRACE("(%p)->%d %p\n", This, ulRecordNum, pdispparams);
1296
1297     hr = IErrorRecords_RemoteGetErrorParameters_Proxy(This, ulRecordNum, pdispparams, &error);
1298     if(error)
1299     {
1300         SetErrorInfo(0, error);
1301         IErrorInfo_Release(error);
1302     }
1303
1304     return hr;
1305 }
1306
1307 HRESULT __RPC_STUB IErrorRecords_GetErrorParameters_Stub(IErrorRecords* This, ULONG ulRecordNum, DISPPARAMS *pdispparams,
1308     IErrorInfo **ppErrorInfoRem)
1309 {
1310     HRESULT hr;
1311
1312     TRACE("(%p)->%d %p %p\n", This, ulRecordNum, pdispparams, ppErrorInfoRem);
1313
1314     *ppErrorInfoRem = NULL;
1315     hr = IErrorRecords_GetErrorParameters(This, ulRecordNum, pdispparams);
1316     if(FAILED(hr))
1317         GetErrorInfo(0, ppErrorInfoRem);
1318
1319     return hr;
1320 }
1321
1322 HRESULT CALLBACK IErrorRecords_GetErrorInfo_Proxy(IErrorRecords* This, ULONG ulRecordNum, LCID lcid, IErrorInfo **ppErrorInfo)
1323 {
1324     IErrorInfo *error = NULL;
1325     HRESULT hr;
1326
1327     TRACE("(%p)->%d %d %p\n", This, ulRecordNum, lcid, ppErrorInfo);
1328
1329     hr = IErrorRecords_RemoteGetErrorInfo_Proxy(This, ulRecordNum, lcid, ppErrorInfo, &error);
1330     if(error)
1331     {
1332         SetErrorInfo(0, error);
1333         IErrorInfo_Release(error);
1334     }
1335
1336     return hr;
1337 }
1338
1339 HRESULT __RPC_STUB IErrorRecords_GetErrorInfo_Stub(IErrorRecords* This, ULONG ulRecordNum, LCID lcid,
1340     IErrorInfo **ppErrorInfo, IErrorInfo **ppErrorInfoRem)
1341 {
1342     HRESULT hr;
1343
1344     TRACE("(%p)->%d %d %p %p\n", This, ulRecordNum, lcid, ppErrorInfo, ppErrorInfoRem);
1345
1346     *ppErrorInfoRem = NULL;
1347     hr = IErrorRecords_GetErrorInfo(This, ulRecordNum, lcid, ppErrorInfo);
1348     if(FAILED(hr))
1349         GetErrorInfo(0, ppErrorInfoRem);
1350
1351     return hr;
1352 }
1353
1354 HRESULT CALLBACK IErrorRecords_GetCustomErrorObject_Proxy(IErrorRecords* This, ULONG ulRecordNum, REFIID riid,
1355     IUnknown **ppObject)
1356 {
1357     IErrorInfo *error = NULL;
1358     HRESULT hr;
1359
1360     TRACE("(%p)->%d %s %p\n", This, ulRecordNum, debugstr_guid(riid), ppObject);
1361
1362     hr = IErrorRecords_RemoteGetCustomErrorObject_Proxy(This, ulRecordNum, riid, ppObject, &error);
1363     if(error)
1364     {
1365         SetErrorInfo(0, error);
1366         IErrorInfo_Release(error);
1367     }
1368     return hr;
1369 }
1370
1371 HRESULT __RPC_STUB IErrorRecords_GetCustomErrorObject_Stub(IErrorRecords* This, ULONG ulRecordNum, REFIID riid,
1372     IUnknown **ppObject, IErrorInfo **ppErrorInfoRem)
1373 {
1374     HRESULT hr;
1375
1376     TRACE("(%p)->%d %s %p %p\n", This, ulRecordNum, debugstr_guid(riid), ppObject, ppErrorInfoRem);
1377
1378     *ppErrorInfoRem = NULL;
1379     hr = IErrorRecords_GetCustomErrorObject(This, ulRecordNum, riid, ppObject);
1380     if(FAILED(hr))
1381         GetErrorInfo(0, ppErrorInfoRem);
1382
1383     return hr;
1384 }
1385
1386 HRESULT CALLBACK IErrorRecords_GetBasicErrorInfo_Proxy(IErrorRecords* This, ULONG ulRecordNum, ERRORINFO *pErrorInfo)
1387 {
1388     IErrorInfo *error = NULL;
1389     HRESULT hr;
1390
1391     TRACE("(%p)->%d %p\n", This, ulRecordNum, pErrorInfo);
1392
1393     hr = IErrorRecords_RemoteGetBasicErrorInfo_Proxy(This, ulRecordNum, pErrorInfo, &error);
1394     if(error)
1395     {
1396         SetErrorInfo(0, error);
1397         IErrorInfo_Release(error);
1398     }
1399
1400     return hr;
1401 }
1402
1403 HRESULT __RPC_STUB IErrorRecords_GetBasicErrorInfo_Stub(IErrorRecords* This, ULONG ulRecordNum, ERRORINFO *pErrorInfo,
1404     IErrorInfo **ppErrorInfoRem)
1405 {
1406     HRESULT hr;
1407
1408     TRACE("(%p)->%d %p %p\n", This, ulRecordNum, pErrorInfo, ppErrorInfoRem);
1409
1410     *ppErrorInfoRem = NULL;
1411     hr = IErrorRecords_GetBasicErrorInfo(This, ulRecordNum, pErrorInfo);
1412     if(FAILED(hr))
1413         GetErrorInfo(0, ppErrorInfoRem);
1414
1415     return hr;
1416 }
1417
1418 HRESULT CALLBACK IErrorRecords_AddErrorRecord_Proxy(IErrorRecords* This, ERRORINFO *pErrorInfo, DWORD dwLookupID,
1419     DISPPARAMS *pdispparams, IUnknown *punkCustomError, DWORD dwDynamicErrorID)
1420 {
1421     IErrorInfo *error = NULL;
1422     HRESULT hr;
1423
1424     TRACE("(%p)->%p %d %p %p %d\n", This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, dwDynamicErrorID);
1425
1426     hr = IErrorRecords_RemoteAddErrorRecord_Proxy(This, pErrorInfo, dwLookupID, pdispparams, punkCustomError,
1427         dwDynamicErrorID, &error);
1428     if(error)
1429     {
1430         SetErrorInfo(0, error);
1431         IErrorInfo_Release(error);
1432     }
1433     return hr;
1434 }
1435
1436 HRESULT __RPC_STUB IErrorRecords_AddErrorRecord_Stub(IErrorRecords* This, ERRORINFO *pErrorInfo, DWORD dwLookupID,
1437     DISPPARAMS *pdispparams, IUnknown *punkCustomError, DWORD dwDynamicErrorID, IErrorInfo **ppErrorInfoRem)
1438 {
1439     HRESULT hr;
1440
1441     TRACE("(%p)->%p %d %p %p %d %p\n", This, pErrorInfo, dwLookupID, pdispparams, punkCustomError,
1442                         dwDynamicErrorID, ppErrorInfoRem);
1443
1444     *ppErrorInfoRem = NULL;
1445     hr = IErrorRecords_AddErrorRecord(This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, dwDynamicErrorID);
1446     if(FAILED(hr))
1447         GetErrorInfo(0, ppErrorInfoRem);
1448
1449     return hr;
1450 }
1451
1452 HRESULT __RPC_STUB IRowPosition_Initialize_Stub(IRowPosition* This, IUnknown *rowset, IErrorInfo **errorinfo)
1453 {
1454     FIXME("(%p)->(%p %p): stub\n", This, rowset, errorinfo);
1455     return E_NOTIMPL;
1456 }
1457
1458 HRESULT __RPC_STUB IRowPosition_SetRowPosition_Stub(IRowPosition* This, HCHAPTER chapter, HROW row, DBPOSITIONFLAGS flags, IErrorInfo **errorinfo)
1459 {
1460     FIXME("(%p)->(%lx %lx %d %p): stub\n", This, chapter, row, flags, errorinfo);
1461     return E_NOTIMPL;
1462 }
1463
1464 HRESULT __RPC_STUB IRowPosition_GetRowset_Stub(IRowPosition* This, REFIID riid, IUnknown **rowset, IErrorInfo **errorinfo)
1465 {
1466     FIXME("(%p)->(%s %p %p): stub\n", This, debugstr_guid(riid), rowset, errorinfo);
1467     return E_NOTIMPL;
1468 }
1469
1470 HRESULT __RPC_STUB IRowPosition_GetRowPosition_Stub(IRowPosition* This, HCHAPTER *chapter, HROW *row, DBPOSITIONFLAGS *flags, IErrorInfo **errorinfo)
1471 {
1472     FIXME("(%p)->(%p %p %p %p): stub\n", This, chapter, row, flags, errorinfo);
1473     return E_NOTIMPL;
1474 }
1475
1476 HRESULT __RPC_STUB IRowPosition_ClearRowPosition_Stub(IRowPosition* This, IErrorInfo **errorinfo)
1477 {
1478     FIXME("(%p)->(%p): stub\n", This, errorinfo);
1479     return E_NOTIMPL;
1480 }
1481
1482 HRESULT CALLBACK IRowPosition_ClearRowPosition_Proxy(IRowPosition* This)
1483 {
1484     FIXME("(%p): stub\n", This);
1485     return E_NOTIMPL;
1486 }
1487
1488 HRESULT CALLBACK IRowPosition_GetRowPosition_Proxy(IRowPosition* This, HCHAPTER *chapter, HROW *row, DBPOSITIONFLAGS *flags)
1489 {
1490     FIXME("(%p)->(%p %p %p): stub\n", This, chapter, row, flags);
1491     return E_NOTIMPL;
1492 }
1493
1494 HRESULT CALLBACK IRowPosition_GetRowset_Proxy(IRowPosition* This, REFIID riid, IUnknown **rowset)
1495 {
1496     FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), rowset);
1497     return E_NOTIMPL;
1498 }
1499
1500 HRESULT CALLBACK IRowPosition_Initialize_Proxy(IRowPosition* This, IUnknown *rowset)
1501 {
1502     FIXME("(%p)->(%p): stub\n", This, rowset);
1503     return E_NOTIMPL;
1504 }
1505
1506 HRESULT CALLBACK IRowPosition_SetRowPosition_Proxy(IRowPosition* This, HCHAPTER chapter, HROW row, DBPOSITIONFLAGS flags)
1507 {
1508     FIXME("(%p)->(%lx %lx %d): stub\n", This, chapter, row, flags);
1509     return E_NOTIMPL;
1510 }
1511
1512 HRESULT __RPC_STUB IRowPositionChange_OnRowPositionChange_Stub(IRowPositionChange* This, DBREASON reason, DBEVENTPHASE phase,
1513     BOOL cant_deny, IErrorInfo **errorinfo)
1514 {
1515     FIXME("(%p)->(0x%x 0x%x %d %p): stub\n", This, reason, phase, cant_deny, errorinfo);
1516     return E_NOTIMPL;
1517 }
1518
1519 HRESULT CALLBACK IRowPositionChange_OnRowPositionChange_Proxy(IRowPositionChange* This, DBREASON reason, DBEVENTPHASE phase,
1520     BOOL cant_deny)
1521 {
1522     FIXME("(%p)->(0x%x 0x%x %d): stub\n", This, reason, phase, cant_deny);
1523     return E_NOTIMPL;
1524 }
1525
1526 HRESULT __RPC_STUB IChapteredRowset_ReleaseChapter_Stub(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount, IErrorInfo **errorinfo)
1527 {
1528     FIXME("(%p)->(%lx %p %p): stub\n", This, chapter, refcount, errorinfo);
1529     return E_NOTIMPL;
1530 }
1531
1532 HRESULT __RPC_STUB IChapteredRowset_AddRefChapter_Stub(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount, IErrorInfo **errorinfo)
1533 {
1534     FIXME("(%p)->(%lx %p %p): stub\n", This, chapter, refcount, errorinfo);
1535     return E_NOTIMPL;
1536 }
1537
1538 HRESULT CALLBACK IChapteredRowset_AddRefChapter_Proxy(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount)
1539 {
1540     FIXME("(%p)->(%lx %p): stub\n", This, chapter, refcount);
1541     return E_NOTIMPL;
1542 }
1543
1544 HRESULT CALLBACK IChapteredRowset_ReleaseChapter_Proxy(IChapteredRowset* This, HCHAPTER chapter, DBREFCOUNT *refcount)
1545 {
1546     FIXME("(%p)->(%lx %p): stub\n", This, chapter, refcount);
1547     return E_NOTIMPL;
1548 }
1549
1550 HRESULT CALLBACK IColumnsInfo_GetColumnInfo_Proxy(IColumnsInfo* This, DBORDINAL *columns,
1551         DBCOLUMNINFO **colinfo, OLECHAR **stringsbuffer)
1552 {
1553     FIXME("(%p)->(%p %p %p): stub\n", This, columns, colinfo, stringsbuffer);
1554     return E_NOTIMPL;
1555 }
1556
1557 HRESULT __RPC_STUB IColumnsInfo_GetColumnInfo_Stub(IColumnsInfo* This, DBORDINAL *columns, DBCOLUMNINFO **col_info,
1558     DBBYTEOFFSET **name_offsets, DBBYTEOFFSET **columnid_offsets, DBLENGTH *string_len, OLECHAR **stringsbuffer,
1559     IErrorInfo **error)
1560 {
1561     FIXME("(%p)->(%p %p %p %p %p %p %p): stub\n", This, columns, col_info, name_offsets, columnid_offsets,
1562             string_len, stringsbuffer, error);
1563     return E_NOTIMPL;
1564 }
1565
1566 HRESULT CALLBACK IColumnsInfo_MapColumnIDs_Proxy(IColumnsInfo* This, DBORDINAL column_ids, const DBID *dbids,
1567     DBORDINAL *columns)
1568 {
1569     FIXME("(%p)->(%lu %p %p): stub\n", This, column_ids, dbids, columns);
1570     return E_NOTIMPL;
1571 }
1572
1573 HRESULT __RPC_STUB IColumnsInfo_MapColumnIDs_Stub(IColumnsInfo* This, DBORDINAL column_ids, const DBID *dbids,
1574     DBORDINAL *columns, IErrorInfo **error)
1575 {
1576     FIXME("(%p)->(%lu %p %p %p): stub\n", This, column_ids, dbids, columns, error);
1577     return E_NOTIMPL;
1578 }