amstream: Add IAMMediaStream interface to AudioMediaStream object.
[wine] / 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 #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 HRESULT CALLBACK IDBCreateCommand_CreateCommand_Proxy(IDBCreateCommand* This, IUnknown *pUnkOuter,
43                                                       REFIID riid, IUnknown **ppCommand)
44 {
45     HRESULT hr;
46     IErrorInfo *error;
47
48     TRACE("(%p, %p, %s, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppCommand);
49     hr = IDBCreateCommand_RemoteCreateCommand_Proxy(This, pUnkOuter, riid, ppCommand, &error);
50     if(error)
51     {
52         SetErrorInfo(0, error);
53         IErrorInfo_Release(error);
54     }
55     return hr;
56 }
57
58 HRESULT __RPC_STUB IDBCreateCommand_CreateCommand_Stub(IDBCreateCommand* This, IUnknown *pUnkOuter,
59                                                        REFIID riid, IUnknown **ppCommand, IErrorInfo **ppErrorInfoRem)
60 {
61     HRESULT hr;
62
63     TRACE("(%p, %p, %s, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppCommand, ppErrorInfoRem);
64
65     *ppErrorInfoRem = NULL;
66     hr = IDBCreateCommand_CreateCommand(This, pUnkOuter, riid, ppCommand);
67     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
68
69     return hr;
70 }
71
72 HRESULT CALLBACK IDBCreateSession_CreateSession_Proxy(IDBCreateSession* This, IUnknown *pUnkOuter,
73                                                       REFIID riid, IUnknown **ppDBSession)
74 {
75     HRESULT hr;
76     IErrorInfo *error;
77
78     TRACE("(%p, %p, %s, %p)\n", This, pUnkOuter, debugstr_guid(riid), ppDBSession);
79     hr = IDBCreateSession_RemoteCreateSession_Proxy(This, pUnkOuter, riid, ppDBSession, &error);
80     if(error)
81     {
82         SetErrorInfo(0, error);
83         IErrorInfo_Release(error);
84     }
85     return hr;
86 }
87
88 HRESULT __RPC_STUB IDBCreateSession_CreateSession_Stub(IDBCreateSession* This, IUnknown *pUnkOuter,
89                                                        REFIID riid, IUnknown **ppDBSession, IErrorInfo **ppErrorInfoRem)
90 {
91     HRESULT hr;
92     TRACE("(%p, %p, %s, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid),
93           ppDBSession, ppErrorInfoRem);
94
95     *ppErrorInfoRem = NULL;
96     hr = IDBCreateSession_CreateSession(This, pUnkOuter, riid, ppDBSession);
97     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
98
99     return hr;
100 }
101
102 HRESULT CALLBACK IDBProperties_GetProperties_Proxy(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
103                                                    ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
104 {
105     HRESULT hr;
106     IErrorInfo *error;
107
108     TRACE("(%p, %d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets,
109           prgPropertySets);
110     hr = IDBProperties_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets,
111                                                  pcPropertySets, prgPropertySets, &error);
112     if(error)
113     {
114         SetErrorInfo(0, error);
115         IErrorInfo_Release(error);
116     }
117     return hr;
118 }
119
120 HRESULT __RPC_STUB IDBProperties_GetProperties_Stub(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets,
121                                                     ULONG *pcPropertySets, DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem)
122 {
123     HRESULT hr;
124
125     TRACE("(%p, %d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets,
126           prgPropertySets, ppErrorInfoRem);
127     *pcPropertySets = 0;
128     *ppErrorInfoRem = NULL;
129     hr = IDBProperties_GetProperties(This, cPropertyIDSets, rgPropertyIDSets,
130         pcPropertySets, prgPropertySets);
131     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
132
133     return hr;
134 }
135
136 HRESULT CALLBACK IDBProperties_GetPropertyInfo_Proxy(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
137                                                      ULONG *pcPropertyInfoSets, DBPROPINFOSET **prgPropertyInfoSets,
138                                                      OLECHAR **ppDescBuffer)
139 {
140     FIXME("(%p, %d, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
141           prgPropertyInfoSets, ppDescBuffer);
142     return E_NOTIMPL;
143 }
144
145 HRESULT __RPC_STUB IDBProperties_GetPropertyInfo_Stub(IDBProperties* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets,
146                                                       ULONG *pcPropertyInfoSets, DBPROPINFOSET **prgPropertyInfoSets,
147                                                       ULONG *pcOffsets, DBBYTEOFFSET **prgDescOffsets, ULONG *pcbDescBuffer,
148                                                       OLECHAR **ppDescBuffer, IErrorInfo **ppErrorInfoRem)
149 {
150     FIXME("(%p, %d, %p, %p, %p, %p, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
151           prgPropertyInfoSets, pcOffsets, prgDescOffsets, pcbDescBuffer, ppDescBuffer, ppErrorInfoRem);
152     return E_NOTIMPL;
153 }
154
155 HRESULT CALLBACK IDBProperties_SetProperties_Proxy(IDBProperties* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
156 {
157     ULONG prop_set, prop, total_props = 0;
158     HRESULT hr;
159     IErrorInfo *error;
160     DBPROPSTATUS *status;
161
162     TRACE("(%p, %d, %p)\n", This, cPropertySets, rgPropertySets);
163
164     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
165         total_props += rgPropertySets[prop_set].cProperties;
166
167     if(total_props == 0) return S_OK;
168
169     status = CoTaskMemAlloc(total_props * sizeof(*status));
170     if(!status) return E_OUTOFMEMORY;
171
172     hr = IDBProperties_RemoteSetProperties_Proxy(This, cPropertySets, rgPropertySets,
173                                                  total_props, status, &error);
174     if(error)
175     {
176         SetErrorInfo(0, error);
177         IErrorInfo_Release(error);
178     }
179
180     total_props = 0;
181     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
182         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
183             rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
184
185     CoTaskMemFree(status);
186     return hr;
187 }
188
189 HRESULT __RPC_STUB IDBProperties_SetProperties_Stub(IDBProperties* This, ULONG cPropertySets, DBPROPSET *rgPropertySets,
190                                                     ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem)
191 {
192     ULONG prop_set, prop, total_props = 0;
193     HRESULT hr;
194
195     TRACE("(%p, %d, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, cTotalProps,
196           rgPropStatus, ppErrorInfoRem);
197
198     *ppErrorInfoRem = NULL;
199     hr = IDBProperties_SetProperties(This, cPropertySets, rgPropertySets);
200     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
201
202     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
203         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
204             rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus;
205
206     return hr;
207 }
208
209 HRESULT CALLBACK IDBInitialize_Initialize_Proxy(IDBInitialize* This)
210 {
211     HRESULT hr;
212     IErrorInfo *error;
213
214     TRACE("(%p)\n", This);
215     hr = IDBInitialize_RemoteInitialize_Proxy(This, &error);
216     if(error)
217     {
218         SetErrorInfo(0, error);
219         IErrorInfo_Release(error);
220     }
221     return hr;
222 }
223
224 HRESULT __RPC_STUB IDBInitialize_Initialize_Stub(IDBInitialize* This, IErrorInfo **ppErrorInfoRem)
225 {
226     HRESULT hr;
227     TRACE("(%p, %p)\n", This, ppErrorInfoRem);
228
229     *ppErrorInfoRem = NULL;
230     hr = IDBInitialize_Initialize(This);
231     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
232
233     return hr;
234 }
235
236 HRESULT CALLBACK IDBInitialize_Uninitialize_Proxy(IDBInitialize* This)
237 {
238     FIXME("(%p): stub\n", This);
239     return E_NOTIMPL;
240 }
241
242 HRESULT __RPC_STUB IDBInitialize_Uninitialize_Stub(IDBInitialize* This, IErrorInfo **ppErrorInfoRem)
243 {
244     FIXME("(%p, %p): stub\n", This, ppErrorInfoRem);
245     return E_NOTIMPL;
246 }
247
248 HRESULT CALLBACK IDBDataSourceAdmin_CreateDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets,
249                                                            DBPROPSET rgPropertySets[], IUnknown *pUnkOuter,
250                                                            REFIID riid, IUnknown **ppDBSession)
251 {
252     ULONG prop_set, prop, total_props = 0;
253     HRESULT hr;
254     IErrorInfo *error;
255     DBPROPSTATUS *status;
256
257     TRACE("(%p, %d, %p, %p, %s, %p)\n", This, cPropertySets, rgPropertySets, pUnkOuter,
258           debugstr_guid(riid), ppDBSession);
259
260     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
261         total_props += rgPropertySets[prop_set].cProperties;
262
263     if(total_props == 0) return S_OK;
264
265     status = CoTaskMemAlloc(total_props * sizeof(*status));
266     if(!status) return E_OUTOFMEMORY;
267
268     hr = IDBDataSourceAdmin_RemoteCreateDataSource_Proxy(This, cPropertySets, rgPropertySets, pUnkOuter,
269                                                          riid, ppDBSession, total_props, status, &error);
270     if(error)
271     {
272         SetErrorInfo(0, error);
273         IErrorInfo_Release(error);
274     }
275
276     total_props = 0;
277     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
278         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
279             rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
280
281     CoTaskMemFree(status);
282     return hr;
283 }
284
285 HRESULT __RPC_STUB IDBDataSourceAdmin_CreateDataSource_Stub(IDBDataSourceAdmin* This, ULONG cPropertySets,
286                                                             DBPROPSET *rgPropertySets, IUnknown *pUnkOuter,
287                                                             REFIID riid, IUnknown **ppDBSession, ULONG cTotalProps,
288                                                             DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem)
289 {
290     ULONG prop_set, prop, total_props = 0;
291     HRESULT hr;
292
293     TRACE("(%p, %d, %p, %p, %s, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, pUnkOuter,
294           debugstr_guid(riid), ppDBSession, cTotalProps, rgPropStatus, ppErrorInfoRem);
295
296     *ppErrorInfoRem = NULL;
297     hr = IDBDataSourceAdmin_CreateDataSource(This, cPropertySets, rgPropertySets, pUnkOuter, riid, ppDBSession);
298     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
299
300     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
301         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
302             rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus;
303
304     return hr;
305 }
306
307 HRESULT CALLBACK IDBDataSourceAdmin_DestroyDataSource_Proxy(IDBDataSourceAdmin* This)
308 {
309     FIXME("(%p): stub\n", This);
310     return E_NOTIMPL;
311 }
312
313 HRESULT __RPC_STUB IDBDataSourceAdmin_DestroyDataSource_Stub(IDBDataSourceAdmin* This, IErrorInfo **ppErrorInfoRem)
314 {
315     FIXME("(%p, %p): stub\n", This, ppErrorInfoRem);
316     return E_NOTIMPL;
317 }
318
319 HRESULT CALLBACK IDBDataSourceAdmin_GetCreationProperties_Proxy(IDBDataSourceAdmin* This, ULONG cPropertyIDSets,
320                                                                 const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets,
321                                                                 DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer)
322 {
323     FIXME("(%p, %d, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
324           prgPropertyInfoSets, ppDescBuffer);
325     return E_NOTIMPL;
326 }
327
328 HRESULT __RPC_STUB IDBDataSourceAdmin_GetCreationProperties_Stub(IDBDataSourceAdmin* This, ULONG cPropertyIDSets,
329                                                                  const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertyInfoSets,
330                                                                  DBPROPINFOSET **prgPropertyInfoSets, DBCOUNTITEM *pcOffsets,
331                                                                  DBBYTEOFFSET **prgDescOffsets, ULONG *pcbDescBuffer,
332                                                                  OLECHAR **ppDescBuffer, IErrorInfo **ppErrorInfoRem)
333 {
334     FIXME("(%p, %d, %p, %p, %p, %p, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
335           prgPropertyInfoSets, pcOffsets, prgDescOffsets, pcbDescBuffer, ppDescBuffer, ppErrorInfoRem);
336     return E_NOTIMPL;
337 }
338
339 HRESULT CALLBACK IDBDataSourceAdmin_ModifyDataSource_Proxy(IDBDataSourceAdmin* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
340 {
341     FIXME("(%p, %d, %p): stub\n", This, cPropertySets, rgPropertySets);
342     return E_NOTIMPL;
343 }
344
345 HRESULT __RPC_STUB IDBDataSourceAdmin_ModifyDataSource_Stub(IDBDataSourceAdmin* This, ULONG cPropertySets,
346                                                             DBPROPSET *rgPropertySets, IErrorInfo **ppErrorInfoRem)
347 {
348     FIXME("(%p, %d, %p, %p): stub\n", This, cPropertySets, rgPropertySets, ppErrorInfoRem);
349     return E_NOTIMPL;
350 }
351
352 HRESULT CALLBACK ISessionProperties_GetProperties_Proxy(ISessionProperties* This, ULONG cPropertyIDSets,
353                                                         const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets,
354                                                         DBPROPSET **prgPropertySets)
355 {
356     FIXME("(%p, %d, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets,
357           pcPropertySets, prgPropertySets);
358     return E_NOTIMPL;
359 }
360
361 HRESULT __RPC_STUB ISessionProperties_GetProperties_Stub(ISessionProperties* This, ULONG cPropertyIDSets,
362                                                          const DBPROPIDSET *rgPropertyIDSets, ULONG *pcPropertySets,
363                                                          DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem)
364 {
365     FIXME("(%p, %d, %p, %p, %p, %p): stub\n", This, cPropertyIDSets, rgPropertyIDSets,
366           pcPropertySets, prgPropertySets, ppErrorInfoRem);
367     return E_NOTIMPL;
368 }
369
370 HRESULT CALLBACK ISessionProperties_SetProperties_Proxy(ISessionProperties* This, ULONG cPropertySets, DBPROPSET rgPropertySets[])
371 {
372     ULONG prop_set, prop, total_props = 0;
373     HRESULT hr;
374     IErrorInfo *error;
375     DBPROPSTATUS *status;
376
377     TRACE("(%p, %d, %p)\n", This, cPropertySets, rgPropertySets);
378
379     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
380         total_props += rgPropertySets[prop_set].cProperties;
381
382     if(total_props == 0) return S_OK;
383
384     status = CoTaskMemAlloc(total_props * sizeof(*status));
385     if(!status) return E_OUTOFMEMORY;
386
387     hr = ISessionProperties_RemoteSetProperties_Proxy(This, cPropertySets, rgPropertySets,
388                                                       total_props, status, &error);
389     if(error)
390     {
391         SetErrorInfo(0, error);
392         IErrorInfo_Release(error);
393     }
394
395     total_props = 0;
396     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
397         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
398             rgPropertySets[prop_set].rgProperties[prop].dwStatus = status[total_props++];
399
400     CoTaskMemFree(status);
401     return hr;
402 }
403
404 HRESULT __RPC_STUB ISessionProperties_SetProperties_Stub(ISessionProperties* This, ULONG cPropertySets, DBPROPSET *rgPropertySets,
405                                                          ULONG cTotalProps, DBPROPSTATUS *rgPropStatus, IErrorInfo **ppErrorInfoRem)
406 {
407     ULONG prop_set, prop, total_props = 0;
408     HRESULT hr;
409
410     TRACE("(%p, %d, %p, %d, %p, %p)\n", This, cPropertySets, rgPropertySets, cTotalProps,
411           rgPropStatus, ppErrorInfoRem);
412
413     *ppErrorInfoRem = NULL;
414     hr = ISessionProperties_SetProperties(This, cPropertySets, rgPropertySets);
415     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
416
417     for(prop_set = 0; prop_set < cPropertySets; prop_set++)
418         for(prop = 0; prop < rgPropertySets[prop_set].cProperties; prop++)
419             rgPropStatus[total_props++] = rgPropertySets[prop_set].rgProperties[prop].dwStatus;
420
421     return hr;
422 }
423
424 HRESULT CALLBACK IOpenRowset_OpenRowset_Proxy(IOpenRowset* This, IUnknown *pUnkOuter, DBID *pTableID, DBID *pIndexID,
425                                               REFIID riid, ULONG cPropertySets, DBPROPSET rgPropertySets[], IUnknown **ppRowset)
426 {
427     FIXME("(%p, %p, %p, %p, %s, %d, %p, %p): stub\n", This, pUnkOuter, pTableID, pIndexID, debugstr_guid(riid),
428           cPropertySets, rgPropertySets, ppRowset);
429     return E_NOTIMPL;
430 }
431
432 HRESULT __RPC_STUB IOpenRowset_OpenRowset_Stub(IOpenRowset* This, IUnknown *pUnkOuter, DBID *pTableID, DBID *pIndexID,
433                                                REFIID riid, ULONG cPropertySets, DBPROPSET *rgPropertySets,
434                                                IUnknown **ppRowset, ULONG cTotalProps, DBPROPSTATUS *rgPropStatus,
435                                                IErrorInfo **ppErrorInfoRem)
436 {
437     FIXME("(%p, %p, %p, %p, %s, %d, %p, %p, %d, %p, %p): stub\n", This, pUnkOuter, pTableID, pIndexID, debugstr_guid(riid),
438           cPropertySets, rgPropertySets, ppRowset, cTotalProps, rgPropStatus, ppErrorInfoRem);
439     return E_NOTIMPL;
440 }
441
442 HRESULT CALLBACK IBindResource_Bind_Proxy(IBindResource* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
443                                           REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, DBIMPLICITSESSION *pImplSession,
444                                           DBBINDURLSTATUS *pdwBindStatus, IUnknown **ppUnk)
445 {
446     HRESULT hr;
447
448     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
449           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pImplSession, pdwBindStatus, ppUnk);
450
451     if(pUnkOuter)
452     {
453         FIXME("Aggregation not supported\n");
454         return CLASS_E_NOAGGREGATION;
455     }
456
457     hr = IBindResource_RemoteBind_Proxy(This, pUnkOuter, pwszURL, dwBindURLFlags, rguid, riid, pAuthenticate,
458                                         pImplSession ? pImplSession->pUnkOuter : NULL, pImplSession ? pImplSession->piid : NULL,
459                                         pImplSession ? &pImplSession->pSession : NULL, pdwBindStatus, ppUnk);
460     return hr;
461 }
462
463 HRESULT __RPC_STUB IBindResource_Bind_Stub(IBindResource* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
464                                            REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, IUnknown *pSessionUnkOuter,
465                                            IID *piid, IUnknown **ppSession, DBBINDURLSTATUS *pdwBindStatus, IUnknown **ppUnk)
466 {
467     HRESULT hr;
468     DBIMPLICITSESSION impl_session;
469     IWineRowServer *server;
470     IMarshal *marshal;
471     IUnknown *obj;
472
473     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
474           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pSessionUnkOuter, piid, ppSession, pdwBindStatus, ppUnk);
475
476     *ppUnk = NULL;
477
478     if(IsEqualGUID(rguid, &DBGUID_ROWSET))
479         hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&server);
480     else if(IsEqualGUID(rguid, &DBGUID_ROW))
481         hr = CoCreateInstance(&CLSID_wine_row_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&server);
482     else
483     {
484         hr = E_NOTIMPL;
485         FIXME("Unhandled object %s\n", debugstr_guid(rguid));
486     }
487
488     if(FAILED(hr)) return hr;
489
490     impl_session.pUnkOuter = pSessionUnkOuter;
491     impl_session.piid = piid;
492     impl_session.pSession = NULL;
493
494     IWineRowServer_GetMarshal(server, &marshal);
495
496     hr = IBindResource_Bind(This, (IUnknown*)marshal, pwszURL, dwBindURLFlags, rguid, &IID_IUnknown, pAuthenticate,
497                             ppSession ? &impl_session : NULL, pdwBindStatus, &obj);
498
499     IMarshal_Release(marshal);
500     if(FAILED(hr))
501     {
502         IWineRowServer_Release(server);
503         return hr;
504     }
505
506     IWineRowServer_SetInnerUnk(server, obj);
507     hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk);
508     IUnknown_Release(obj);
509
510     if(ppSession) *ppSession = impl_session.pSession;
511     return hr;
512 }
513
514 HRESULT CALLBACK ICreateRow_CreateRow_Proxy(ICreateRow* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
515                                             REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, DBIMPLICITSESSION *pImplSession,
516                                             DBBINDURLSTATUS *pdwBindStatus, LPOLESTR *ppwszNewURL, IUnknown **ppUnk)
517 {
518     HRESULT hr;
519
520     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
521           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pImplSession, pdwBindStatus, ppwszNewURL, ppUnk);
522
523     if(pUnkOuter)
524     {
525         FIXME("Aggregation not supported\n");
526         return CLASS_E_NOAGGREGATION;
527     }
528
529     hr = ICreateRow_RemoteCreateRow_Proxy(This, pUnkOuter, pwszURL, dwBindURLFlags, rguid, riid, pAuthenticate,
530                                           pImplSession ? pImplSession->pUnkOuter : NULL, pImplSession ? pImplSession->piid : NULL,
531                                           pImplSession ? &pImplSession->pSession : NULL, pdwBindStatus, ppwszNewURL, ppUnk);
532     return hr;
533 }
534
535 HRESULT __RPC_STUB ICreateRow_CreateRow_Stub(ICreateRow* This, IUnknown *pUnkOuter, LPCOLESTR pwszURL, DBBINDURLFLAG dwBindURLFlags,
536                                              REFGUID rguid, REFIID riid, IAuthenticate *pAuthenticate, IUnknown *pSessionUnkOuter,
537                                              IID *piid, IUnknown **ppSession, DBBINDURLSTATUS *pdwBindStatus,
538                                              LPOLESTR *ppwszNewURL, IUnknown **ppUnk)
539 {
540     HRESULT hr;
541     DBIMPLICITSESSION impl_session;
542     IWineRowServer *row_server;
543     IMarshal *marshal;
544     IUnknown *obj;
545
546     TRACE("(%p, %p, %s, %08x, %s, %s, %p, %p, %p, %p, %p, %p, %p)\n", This, pUnkOuter, debugstr_w(pwszURL), dwBindURLFlags,
547           debugstr_guid(rguid), debugstr_guid(riid), pAuthenticate, pSessionUnkOuter, piid, ppSession, pdwBindStatus, ppwszNewURL,
548           ppUnk);
549
550     *ppUnk = NULL;
551
552     hr = CoCreateInstance(&CLSID_wine_row_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&row_server);
553     if(FAILED(hr)) return hr;
554
555     impl_session.pUnkOuter = pSessionUnkOuter;
556     impl_session.piid = piid;
557     impl_session.pSession = NULL;
558
559     IWineRowServer_GetMarshal(row_server, &marshal);
560
561     hr = ICreateRow_CreateRow(This, (IUnknown*) marshal, pwszURL, dwBindURLFlags, rguid, &IID_IUnknown, pAuthenticate,
562                               ppSession ? &impl_session : NULL, pdwBindStatus, ppwszNewURL, &obj);
563     IMarshal_Release(marshal);
564
565     if(FAILED(hr))
566     {
567         IWineRowServer_Release(row_server);
568         return hr;
569     }
570
571     IWineRowServer_SetInnerUnk(row_server, obj);
572     hr = IUnknown_QueryInterface(obj, riid, (void**)ppUnk);
573     IUnknown_Release(obj);
574
575     if(ppSession) *ppSession = impl_session.pSession;
576     return hr;
577 }
578
579 HRESULT CALLBACK IAccessor_AddRefAccessor_Proxy(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
580 {
581     FIXME("(%p)->(%08lx, %p): stub\n", This, hAccessor, pcRefCount);
582     return E_NOTIMPL;
583 }
584
585 HRESULT __RPC_STUB IAccessor_AddRefAccessor_Stub(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount,
586                                                  IErrorInfo **ppErrorInfoRem)
587 {
588     FIXME("(%p)->(%08lx, %p, %p): stub\n", This, hAccessor, pcRefCount, ppErrorInfoRem);
589     return E_NOTIMPL;
590 }
591
592 HRESULT CALLBACK IAccessor_CreateAccessor_Proxy(IAccessor* This, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings,
593                                                 const DBBINDING rgBindings[], DBLENGTH cbRowSize, HACCESSOR *phAccessor,
594                                                 DBBINDSTATUS rgStatus[])
595 {
596     HRESULT hr;
597     IErrorInfo *error;
598     DBCOUNTITEM i;
599
600     TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings,
601           cbRowSize, phAccessor, rgStatus);
602
603     for(i = 0; i < cBindings; i++)
604     {
605         TRACE("%ld: ord %ld val off %ld len off %ld stat off %ld part %04x mem_owner %d max_len %ld type %04x\n",
606               i, rgBindings[i].iOrdinal, rgBindings[i].obValue, rgBindings[i].obLength, rgBindings[i].obStatus,
607               rgBindings[i].dwPart, rgBindings[i].dwMemOwner, rgBindings[i].cbMaxLen, rgBindings[i].wType);
608     }
609
610     hr = IAccessor_RemoteCreateAccessor_Proxy(This, dwAccessorFlags, cBindings, (DBBINDING *)rgBindings,
611                                               cbRowSize, phAccessor, rgStatus, &error);
612     if(error)
613     {
614         SetErrorInfo(0, error);
615         IErrorInfo_Release(error);
616     }
617
618     TRACE("returning %08x accessor %lx\n", hr, *phAccessor);
619     return hr;
620 }
621
622 HRESULT __RPC_STUB IAccessor_CreateAccessor_Stub(IAccessor* This, DBACCESSORFLAGS dwAccessorFlags, DBCOUNTITEM cBindings,
623                                                  DBBINDING *rgBindings, DBLENGTH cbRowSize, HACCESSOR *phAccessor,
624                                                  DBBINDSTATUS *rgStatus, IErrorInfo **ppErrorInfoRem)
625 {
626     HRESULT hr;
627
628     TRACE("(%p)->(%08x, %ld, %p, %ld, %p, %p, %p)\n", This, dwAccessorFlags, cBindings, rgBindings,
629           cbRowSize, phAccessor, rgStatus, ppErrorInfoRem);
630
631     *ppErrorInfoRem = NULL;
632     hr = IAccessor_CreateAccessor(This, dwAccessorFlags, cBindings, rgBindings,
633                                   cbRowSize, phAccessor, rgStatus);
634     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
635
636     return hr;
637 }
638
639 HRESULT CALLBACK IAccessor_GetBindings_Proxy(IAccessor* This, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags,
640                                              DBCOUNTITEM *pcBindings, DBBINDING **prgBindings)
641 {
642     FIXME("(%p): stub\n", This);
643     return E_NOTIMPL;
644 }
645
646 HRESULT __RPC_STUB IAccessor_GetBindings_Stub(IAccessor* This, HACCESSOR hAccessor, DBACCESSORFLAGS *pdwAccessorFlags,
647                                               DBCOUNTITEM *pcBindings, DBBINDING **prgBindings, IErrorInfo **ppErrorInfoRem)
648 {
649     FIXME("(%p): stub\n", This);
650     return E_NOTIMPL;
651 }
652
653 HRESULT CALLBACK IAccessor_ReleaseAccessor_Proxy(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount)
654 {
655     HRESULT hr;
656     IErrorInfo *error;
657     DBREFCOUNT ref;
658
659     TRACE("(%p)->(%lx, %p)\n", This, hAccessor, pcRefCount);
660
661     hr = IAccessor_RemoteReleaseAccessor_Proxy(This, hAccessor, &ref, &error);
662
663     if(pcRefCount) *pcRefCount = ref;
664     if(error)
665     {
666         SetErrorInfo(0, error);
667         IErrorInfo_Release(error);
668     }
669     return hr;
670 }
671
672 HRESULT __RPC_STUB IAccessor_ReleaseAccessor_Stub(IAccessor* This, HACCESSOR hAccessor, DBREFCOUNT *pcRefCount,
673                                                   IErrorInfo **ppErrorInfoRem)
674 {
675     HRESULT hr;
676
677     TRACE("(%p)->(%lx, %p, %p)\n", This, hAccessor, pcRefCount, ppErrorInfoRem);
678
679     *ppErrorInfoRem = NULL;
680
681     hr = IAccessor_ReleaseAccessor(This, hAccessor, pcRefCount);
682
683     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
684     return hr;
685 }
686
687 HRESULT CALLBACK IRowsetInfo_GetProperties_Proxy(IRowsetInfo* This, const ULONG cPropertyIDSets, const DBPROPIDSET rgPropertyIDSets[],
688                                                  ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
689 {
690     HRESULT hr;
691     IErrorInfo *error;
692     ULONG i;
693
694     TRACE("(%p)->(%d, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
695
696     for(i = 0; i < cPropertyIDSets; i++)
697     {
698         int j;
699         TRACE("%d: %s %d props\n", i, debugstr_guid(&rgPropertyIDSets[i].guidPropertySet), rgPropertyIDSets[i].cPropertyIDs);
700         for(j = 0; j < rgPropertyIDSets[i].cPropertyIDs; j++)
701             TRACE("\t%d: prop id %d\n", j, rgPropertyIDSets[i].rgPropertyIDs[j]);
702     }
703
704     hr = IRowsetInfo_RemoteGetProperties_Proxy(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets, &error);
705
706     if(error)
707     {
708         SetErrorInfo(0, error);
709         IErrorInfo_Release(error);
710     }
711     return hr;
712 }
713
714 HRESULT __RPC_STUB IRowsetInfo_GetProperties_Stub(IRowsetInfo* This, ULONG cPropertyIDSets, const DBPROPIDSET *rgPropertyIDSets,
715                                                   ULONG *pcPropertySets, DBPROPSET **prgPropertySets, IErrorInfo **ppErrorInfoRem)
716 {
717     HRESULT hr;
718
719     TRACE("(%p)->(%d, %p, %p, %p, %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets, ppErrorInfoRem);
720
721     *ppErrorInfoRem = NULL;
722
723     hr = IRowsetInfo_GetProperties(This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
724     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
725     TRACE("returning %08x\n", hr);
726     return hr;
727 }
728
729 HRESULT CALLBACK IRowsetInfo_GetReferencedRowset_Proxy(IRowsetInfo* This, DBORDINAL iOrdinal, REFIID riid, IUnknown **ppReferencedRowset)
730 {
731     FIXME("(%p)->(%ld, %s, %p): stub\n", This, iOrdinal, debugstr_guid(riid), ppReferencedRowset);
732     return E_NOTIMPL;
733 }
734
735 HRESULT __RPC_STUB IRowsetInfo_GetReferencedRowset_Stub(IRowsetInfo* This, DBORDINAL iOrdinal, REFIID riid, IUnknown **ppReferencedRowset,
736                                                         IErrorInfo **ppErrorInfoRem)
737 {
738     FIXME("(%p)->(%ld, %s, %p, %p): stub\n", This, iOrdinal, debugstr_guid(riid), ppReferencedRowset, ppErrorInfoRem);
739     return E_NOTIMPL;
740 }
741
742 HRESULT CALLBACK IRowsetInfo_GetSpecification_Proxy(IRowsetInfo* This, REFIID riid, IUnknown **ppSpecification)
743 {
744     FIXME("(%p)->(%s, %p): stub\n", This, debugstr_guid(riid), ppSpecification);
745     return E_NOTIMPL;
746 }
747
748 HRESULT __RPC_STUB IRowsetInfo_GetSpecification_Stub(IRowsetInfo* This, REFIID riid, IUnknown **ppSpecification, IErrorInfo **ppErrorInfoRem)
749 {
750     FIXME("(%p)->(%s, %p, %p): stub\n", This, debugstr_guid(riid), ppSpecification, ppErrorInfoRem);
751     return E_NOTIMPL;
752 }
753
754 HRESULT CALLBACK ICommand_Cancel_Proxy(ICommand* This)
755 {
756     FIXME("(%p): stub\n", This);
757     return E_NOTIMPL;
758 }
759
760 HRESULT __RPC_STUB ICommand_Cancel_Stub(ICommand* This, IErrorInfo **ppErrorInfoRem)
761 {
762     FIXME("(%p)->(%p): stub\n", This, ppErrorInfoRem);
763     return E_NOTIMPL;
764 }
765
766 HRESULT CALLBACK ICommand_Execute_Proxy(ICommand* This, IUnknown *pUnkOuter, REFIID riid,
767                                         DBPARAMS *pParams, DBROWCOUNT *pcRowsAffected, IUnknown **ppRowset)
768 {
769     HRESULT hr;
770     DBROWCOUNT affected;
771
772     *ppRowset = NULL;
773
774     TRACE("(%p)->(%p, %s, %p, %p, %p)\n", This, pUnkOuter, debugstr_guid(riid), pParams,
775           pcRowsAffected, ppRowset);
776
777     if(pParams)
778     {
779         FIXME("Unhandled params {%p, %ld, %08lx}\n", pParams->pData, pParams->cParamSets, pParams->hAccessor);
780         return E_NOTIMPL;
781     }
782
783     if(pUnkOuter)
784     {
785         FIXME("Aggregation not supported\n");
786         return CLASS_E_NOAGGREGATION;
787     }
788
789     hr = ICommand_RemoteExecute_Proxy(This, pUnkOuter, riid, 0, 0, NULL, 0, NULL, NULL, 0, NULL, NULL, &affected,
790                                       ppRowset);
791
792     TRACE("Execute returns %08x\n", hr);
793
794     if(pcRowsAffected) *pcRowsAffected = affected;
795
796     return hr;
797 }
798
799 HRESULT __RPC_STUB ICommand_Execute_Stub(ICommand* This, IUnknown *pUnkOuter, REFIID riid, HACCESSOR hAccessor,
800                                          DB_UPARAMS cParamSets, GUID *pGuid, ULONG ulGuidOffset, RMTPACK *pInputParams,
801                                          RMTPACK *pOutputParams, DBCOUNTITEM cBindings, DBBINDING *rgBindings,
802                                          DBSTATUS *rgStatus, DBROWCOUNT *pcRowsAffected, IUnknown **ppRowset)
803 {
804     IWineRowServer *rowset_server;
805     IMarshal *marshal;
806     IUnknown *obj = NULL;
807     HRESULT hr;
808
809     TRACE("(%p)->(%p, %s, %08lx, %ld, %p, %d, %p, %p, %ld, %p, %p, %p, %p): stub\n", This, pUnkOuter, debugstr_guid(riid),
810           hAccessor, cParamSets, pGuid, ulGuidOffset, pInputParams, pOutputParams, cBindings, rgBindings, rgStatus,
811           pcRowsAffected, ppRowset);
812
813     *ppRowset = NULL;
814
815     hr = CoCreateInstance(&CLSID_wine_rowset_server, NULL, CLSCTX_INPROC_SERVER, &IID_IWineRowServer, (void**)&rowset_server);
816     if(FAILED(hr)) return hr;
817
818     IWineRowServer_GetMarshal(rowset_server, &marshal);
819
820     hr = ICommand_Execute(This, (IUnknown*)marshal, &IID_IUnknown, NULL, pcRowsAffected, &obj);
821
822     IMarshal_Release(marshal);
823
824     if(FAILED(hr))
825     {
826         IWineRowServer_Release(rowset_server);
827         return hr;
828     }
829
830     IWineRowServer_SetInnerUnk(rowset_server, obj);
831     hr = IUnknown_QueryInterface(obj, riid, (void**)ppRowset);
832     IUnknown_Release(obj);
833
834     return hr;
835 }
836
837 HRESULT CALLBACK ICommand_GetDBSession_Proxy(ICommand* This, REFIID riid, IUnknown **ppSession)
838 {
839     FIXME("(%p)->(%s, %p): stub\n", This, debugstr_guid(riid), ppSession);
840     return E_NOTIMPL;
841 }
842
843 HRESULT __RPC_STUB ICommand_GetDBSession_Stub(ICommand* This, REFIID riid, IUnknown **ppSession, IErrorInfo **ppErrorInfoRem)
844 {
845     FIXME("(%p)->(%s, %p, %p): stub\n", This, debugstr_guid(riid), ppSession, ppErrorInfoRem);
846     return E_NOTIMPL;
847 }
848
849 HRESULT CALLBACK ICommandText_GetCommandText_Proxy(ICommandText* This, GUID *pguidDialect, LPOLESTR *ppwszCommand)
850 {
851     FIXME("(%p)->(%p, %p): stub\n", This, pguidDialect, ppwszCommand);
852     return E_NOTIMPL;
853 }
854
855 HRESULT __RPC_STUB ICommandText_GetCommandText_Stub(ICommandText* This, GUID *pguidDialect,
856                                                     LPOLESTR *ppwszCommand, IErrorInfo **ppErrorInfoRem)
857 {
858     FIXME("(%p)->(%p, %p, %p): stub\n", This, pguidDialect, ppwszCommand, ppErrorInfoRem);
859     return E_NOTIMPL;
860 }
861
862 HRESULT CALLBACK ICommandText_SetCommandText_Proxy(ICommandText* This, REFGUID rguidDialect, LPCOLESTR pwszCommand)
863 {
864     HRESULT hr;
865     IErrorInfo *error;
866
867     TRACE("(%p)->(%s, %s)\n", This, debugstr_guid(rguidDialect), debugstr_w(pwszCommand));
868
869     hr = ICommandText_RemoteSetCommandText_Proxy(This, rguidDialect, pwszCommand, &error);
870     if(error)
871     {
872         SetErrorInfo(0, error);
873         IErrorInfo_Release(error);
874     }
875     return hr;
876 }
877
878 HRESULT __RPC_STUB ICommandText_SetCommandText_Stub(ICommandText* This, REFGUID rguidDialect, LPCOLESTR pwszCommand,
879                                                     IErrorInfo **ppErrorInfoRem)
880 {
881     HRESULT hr;
882
883     TRACE("(%p)->(%s, %s, %p)\n", This, debugstr_guid(rguidDialect), debugstr_w(pwszCommand),
884           ppErrorInfoRem);
885
886     *ppErrorInfoRem = NULL;
887     hr = ICommandText_SetCommandText(This, rguidDialect, pwszCommand);
888     if(FAILED(hr)) GetErrorInfo(0, ppErrorInfoRem);
889
890     return hr;
891 }
892
893 HRESULT CALLBACK IDBAsynchNotify_OnLowResource_Proxy(IDBAsynchNotify* This, DB_DWRESERVE dwReserved)
894 {
895     FIXME("(%p)->(%08lx): stub\n", This, dwReserved);
896     return E_NOTIMPL;
897 }
898
899 HRESULT __RPC_STUB IDBAsynchNotify_OnLowResource_Stub(IDBAsynchNotify* This, DB_DWRESERVE dwReserved)
900 {
901     FIXME("(%p)->(%08lx): stub\n", This, dwReserved);
902     return E_NOTIMPL;
903 }
904
905 HRESULT CALLBACK IDBAsynchNotify_OnProgress_Proxy(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
906                                                   DBCOUNTITEM ulProgress, DBCOUNTITEM ulProgressMax, DBASYNCHPHASE eAsynchPhase,
907                                                   LPOLESTR pwszStatusText)
908 {
909     TRACE("(%p)->(%lx, %d, %ld, %ld, %d, %s)\n", This, hChapter, eOperation, ulProgress, ulProgressMax,
910           eAsynchPhase, debugstr_w(pwszStatusText));
911
912     return IDBAsynchNotify_RemoteOnProgress_Proxy(This, hChapter, eOperation, ulProgress, ulProgressMax, eAsynchPhase,
913                                                   pwszStatusText);
914 }
915
916 HRESULT __RPC_STUB IDBAsynchNotify_OnProgress_Stub(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
917                                                    DBCOUNTITEM ulProgress, DBCOUNTITEM ulProgressMax, DBASYNCHPHASE eAsynchPhase,
918                                                    LPOLESTR pwszStatusText)
919 {
920     TRACE("(%p)->(%lx, %d, %ld, %ld, %d, %s)\n", This, hChapter, eOperation, ulProgress, ulProgressMax,
921           eAsynchPhase, debugstr_w(pwszStatusText));
922     return IDBAsynchNotify_OnProgress(This, hChapter, eOperation, ulProgress, ulProgressMax, eAsynchPhase,
923                                       pwszStatusText);
924 }
925
926 HRESULT CALLBACK IDBAsynchNotify_OnStop_Proxy(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
927                                               HRESULT hrStatus, LPOLESTR pwszStatusText)
928 {
929     TRACE("(%p)->(%lx, %d, %08x, %s)\n", This, hChapter, eOperation, hrStatus, debugstr_w(pwszStatusText));
930     return IDBAsynchNotify_RemoteOnStop_Proxy(This, hChapter, eOperation, hrStatus, pwszStatusText);
931 }
932
933 HRESULT __RPC_STUB IDBAsynchNotify_OnStop_Stub(IDBAsynchNotify* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
934                                                HRESULT hrStatus, LPOLESTR pwszStatusText)
935 {
936     TRACE("(%p)->(%lx, %d, %08x, %s)\n", This, hChapter, eOperation, hrStatus, debugstr_w(pwszStatusText));
937     return IDBAsynchNotify_OnStop(This, hChapter, eOperation, hrStatus, pwszStatusText);
938 }
939
940 HRESULT CALLBACK IDBAsynchStatus_Abort_Proxy(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation)
941 {
942     FIXME("(%p)->(%lx, %d): stub\n", This, hChapter, eOperation);
943     return E_NOTIMPL;
944 }
945
946 HRESULT __RPC_STUB IDBAsynchStatus_Abort_Stub(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
947                                               IErrorInfo **ppErrorInfoRem)
948 {
949     FIXME("(%p)->(%lx, %d, %p): stub\n", This, hChapter, eOperation, ppErrorInfoRem);
950     return E_NOTIMPL;
951 }
952
953 HRESULT CALLBACK IDBAsynchStatus_GetStatus_Proxy(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
954                                                  DBCOUNTITEM *pulProgress, DBCOUNTITEM *pulProgressMax, DBASYNCHPHASE *peAsynchPhase,
955                                                  LPOLESTR *ppwszStatusText)
956 {
957     FIXME("(%p)->(%lx, %d, %p, %p, %p, %p): stub\n", This, hChapter, eOperation, pulProgress, pulProgressMax,
958           peAsynchPhase, ppwszStatusText);
959     return E_NOTIMPL;
960 }
961
962 HRESULT __RPC_STUB IDBAsynchStatus_GetStatus_Stub(IDBAsynchStatus* This, HCHAPTER hChapter, DBASYNCHOP eOperation,
963                                                   DBCOUNTITEM *pulProgress, DBCOUNTITEM *pulProgressMax, DBASYNCHPHASE *peAsynchPhase,
964                                                   LPOLESTR *ppwszStatusText, IErrorInfo **ppErrorInfoRem)
965 {
966     FIXME("(%p)->(%lx, %d, %p, %p, %p, %p, %p): stub\n", This, hChapter, eOperation, pulProgress, pulProgressMax,
967           peAsynchPhase, ppwszStatusText, ppErrorInfoRem);
968     return E_NOTIMPL;
969 }