rpcrt4: Improve trace in RPCRT4_find_interface to print the interface identifier...
[wine] / dlls / rpcrt4 / cstub.c
1 /*
2  * COM stub (CStdStubBuffer) implementation
3  *
4  * Copyright 2001 Ove Kåven, TransGaming Technologies
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
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winerror.h"
28 #include "excpt.h"
29
30 #include "objbase.h"
31 #include "rpcproxy.h"
32
33 #include "wine/debug.h"
34 #include "wine/exception.h"
35
36 #include "cpsf.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
39
40 #define STUB_HEADER(This) (((const CInterfaceStubHeader*)((This)->lpVtbl))[-1])
41
42 static LONG WINAPI stub_filter(EXCEPTION_POINTERS *eptr)
43 {
44     if (eptr->ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
45         return EXCEPTION_CONTINUE_SEARCH;
46     return EXCEPTION_EXECUTE_HANDLER;
47 }
48
49 typedef struct
50 {
51     IUnknownVtbl *base_obj;
52     IRpcStubBuffer *base_stub;
53     CStdStubBuffer stub_buffer;
54 } cstdstubbuffer_delegating_t;
55
56 static inline cstdstubbuffer_delegating_t *impl_from_delegating( IRpcStubBuffer *iface )
57 {
58     return (cstdstubbuffer_delegating_t*)((char *)iface - FIELD_OFFSET(cstdstubbuffer_delegating_t, stub_buffer));
59 }
60
61 HRESULT WINAPI CStdStubBuffer_Construct(REFIID riid,
62                                        LPUNKNOWN pUnkServer,
63                                        PCInterfaceName name,
64                                        CInterfaceStubVtbl *vtbl,
65                                        LPPSFACTORYBUFFER pPSFactory,
66                                        LPRPCSTUBBUFFER *ppStub)
67 {
68   CStdStubBuffer *This;
69   IUnknown *pvServer;
70   HRESULT r;
71   TRACE("(%p,%p,%p,%p) %s\n", pUnkServer, vtbl, pPSFactory, ppStub, name);
72   TRACE("iid=%s\n", debugstr_guid(vtbl->header.piid));
73   TRACE("vtbl=%p\n", &vtbl->Vtbl);
74
75   if (!IsEqualGUID(vtbl->header.piid, riid)) {
76     ERR("IID mismatch during stub creation\n");
77     return RPC_E_UNEXPECTED;
78   }
79
80   r = IUnknown_QueryInterface(pUnkServer, riid, (void**)&pvServer);
81   if(FAILED(r))
82     return r;
83
84   This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CStdStubBuffer));
85   if (!This) {
86     IUnknown_Release(pvServer);
87     return E_OUTOFMEMORY;
88   }
89
90   This->lpVtbl = &vtbl->Vtbl;
91   This->RefCount = 1;
92   This->pvServerObject = pvServer;
93   This->pPSFactory = pPSFactory;
94   *ppStub = (LPRPCSTUBBUFFER)This;
95
96   IPSFactoryBuffer_AddRef(pPSFactory);
97   return S_OK;
98 }
99
100 static CRITICAL_SECTION delegating_vtbl_section;
101 static CRITICAL_SECTION_DEBUG critsect_debug =
102 {
103     0, 0, &delegating_vtbl_section,
104     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
105       0, 0, { (DWORD_PTR)(__FILE__ ": delegating_vtbl_section") }
106 };
107 static CRITICAL_SECTION delegating_vtbl_section = { &critsect_debug, -1, 0, 0, 0, 0 };
108
109 typedef struct
110 {
111     DWORD ref;
112     DWORD size;
113     void **methods;
114     IUnknownVtbl vtbl;
115     /* remaining entries in vtbl */
116 } ref_counted_vtbl;
117
118 static struct
119 {
120     ref_counted_vtbl *table;
121 } current_vtbl;
122
123
124 static HRESULT WINAPI delegating_QueryInterface(IUnknown *pUnk, REFIID iid, void **ppv)
125 {
126     *ppv = (void *)pUnk;
127     return S_OK;
128 }
129
130 static ULONG WINAPI delegating_AddRef(IUnknown *pUnk)
131 {
132     return 1;
133 }
134
135 static ULONG WINAPI delegating_Release(IUnknown *pUnk)
136 {
137     return 1;
138 }
139
140 #if defined(__i386__)
141
142 /* The idea here is to replace the first param on the stack
143    ie. This (which will point to cstdstubbuffer_delegating_t)
144    with This->stub_buffer.pvServerObject and then jump to the
145    relevant offset in This->stub_buffer.pvServerObject's vtbl.
146 */
147 #include "pshpack1.h"
148 typedef struct {
149     DWORD mov1;    /* mov 0x4(%esp), %eax      8b 44 24 04 */
150     WORD mov2;     /* mov 0x10(%eax), %eax     8b 40 */
151     BYTE sixteen;  /*                          10   */
152     DWORD mov3;    /* mov %eax, 0x4(%esp)      89 44 24 04 */
153     WORD mov4;     /* mov (%eax), %eax         8b 00 */
154     WORD mov5;     /* mov offset(%eax), %eax   8b 80 */
155     DWORD offset;  /*                          xx xx xx xx */
156     WORD jmp;      /* jmp *%eax                ff e0 */
157     BYTE pad[3];   /* lea 0x0(%esi), %esi      8d 76 00 */
158 } vtbl_method_t;
159 #include "poppack.h"
160
161 static void fill_table(IUnknownVtbl *vtbl, void **methods, DWORD num)
162 {
163     vtbl_method_t *method;
164     void **entry;
165     DWORD i;
166
167     vtbl->QueryInterface = delegating_QueryInterface;
168     vtbl->AddRef = delegating_AddRef;
169     vtbl->Release = delegating_Release;
170
171     method = (vtbl_method_t*)methods;
172     entry = (void**)(vtbl + 1);
173
174     for(i = 3; i < num; i++)
175     {
176         *entry = method;
177         method->mov1 = 0x0424448b;
178         method->mov2 = 0x408b;
179         method->sixteen = 0x10;
180         method->mov3 = 0x04244489;
181         method->mov4 = 0x008b;
182         method->mov5 = 0x808b;
183         method->offset = i << 2;
184         method->jmp = 0xe0ff;
185         method->pad[0] = 0x8d;
186         method->pad[1] = 0x76;
187         method->pad[2] = 0x00;
188
189         method++;
190         entry++;
191     }
192 }
193
194 #else  /* __i386__ */
195
196 typedef struct {int dummy;} vtbl_method_t;
197 static void fill_table(IUnknownVtbl *vtbl, DWORD num)
198 {
199     ERR("delegated stubs are not supported on this architecture\n");
200 }
201
202 #endif  /* __i386__ */
203
204 void create_delegating_vtbl(DWORD num_methods)
205 {
206     TRACE("%d\n", num_methods);
207     if(num_methods <= 3)
208     {
209         ERR("should have more than %d methods\n", num_methods);
210         return;
211     }
212
213     EnterCriticalSection(&delegating_vtbl_section);
214     if(!current_vtbl.table || num_methods > current_vtbl.table->size)
215     {
216         DWORD size;
217         DWORD old_protect;
218         if(current_vtbl.table && current_vtbl.table->ref == 0)
219         {
220             TRACE("freeing old table\n");
221             VirtualFree(current_vtbl.table->methods,
222                         (current_vtbl.table->size - 3) * sizeof(vtbl_method_t),
223                         MEM_RELEASE);
224             HeapFree(GetProcessHeap(), 0, current_vtbl.table);
225         }
226         size = (num_methods - 3) * sizeof(vtbl_method_t);
227         current_vtbl.table = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(ref_counted_vtbl, vtbl) + num_methods * sizeof(void*));
228         current_vtbl.table->ref = 0;
229         current_vtbl.table->size = num_methods;
230         current_vtbl.table->methods = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
231         fill_table(&current_vtbl.table->vtbl, current_vtbl.table->methods, num_methods);
232         VirtualProtect(current_vtbl.table->methods, size, PAGE_EXECUTE_READ, &old_protect);
233     }
234     LeaveCriticalSection(&delegating_vtbl_section);
235 }
236
237 static IUnknownVtbl *get_delegating_vtbl(void)
238 {
239     IUnknownVtbl *ret;
240
241     EnterCriticalSection(&delegating_vtbl_section);
242     current_vtbl.table->ref++;
243     ret = &current_vtbl.table->vtbl;
244     LeaveCriticalSection(&delegating_vtbl_section);
245     return ret;
246 }
247
248 static void release_delegating_vtbl(IUnknownVtbl *vtbl)
249 {
250     ref_counted_vtbl *table = (ref_counted_vtbl*)((DWORD *)vtbl - 1);
251
252     EnterCriticalSection(&delegating_vtbl_section);
253     table->ref--;
254     TRACE("ref now %d\n", table->ref);
255     if(table->ref == 0 && table != current_vtbl.table)
256     {
257         TRACE("... and we're not current so free'ing\n");
258         VirtualFree(current_vtbl.table->methods,
259                     (current_vtbl.table->size - 3) * sizeof(vtbl_method_t),
260                     MEM_RELEASE);
261         HeapFree(GetProcessHeap(), 0, table);
262     }
263     LeaveCriticalSection(&delegating_vtbl_section);
264 }
265
266 HRESULT WINAPI CStdStubBuffer_Delegating_Construct(REFIID riid,
267                                                    LPUNKNOWN pUnkServer,
268                                                    PCInterfaceName name,
269                                                    CInterfaceStubVtbl *vtbl,
270                                                    REFIID delegating_iid,
271                                                    LPPSFACTORYBUFFER pPSFactory,
272                                                    LPRPCSTUBBUFFER *ppStub)
273 {
274     cstdstubbuffer_delegating_t *This;
275     IUnknown *pvServer;
276     HRESULT r;
277
278     TRACE("(%p,%p,%p,%p) %s\n", pUnkServer, vtbl, pPSFactory, ppStub, name);
279     TRACE("iid=%s delegating to %s\n", debugstr_guid(vtbl->header.piid), debugstr_guid(delegating_iid));
280     TRACE("vtbl=%p\n", &vtbl->Vtbl);
281
282     if (!IsEqualGUID(vtbl->header.piid, riid))
283     {
284         ERR("IID mismatch during stub creation\n");
285         return RPC_E_UNEXPECTED;
286     }
287
288     r = IUnknown_QueryInterface(pUnkServer, riid, (void**)&pvServer);
289     if(FAILED(r)) return r;
290
291     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
292     if (!This)
293     {
294         IUnknown_Release(pvServer);
295         return E_OUTOFMEMORY;
296     }
297
298     This->base_obj = get_delegating_vtbl();
299     r = create_stub(delegating_iid, (IUnknown*)&This->base_obj, &This->base_stub);
300     if(FAILED(r))
301     {
302         release_delegating_vtbl(This->base_obj);
303         HeapFree(GetProcessHeap(), 0, This);
304         IUnknown_Release(pvServer);
305         return r;
306     }
307
308     This->stub_buffer.lpVtbl = &vtbl->Vtbl;
309     This->stub_buffer.RefCount = 1;
310     This->stub_buffer.pvServerObject = pvServer;
311     This->stub_buffer.pPSFactory = pPSFactory;
312     *ppStub = (LPRPCSTUBBUFFER)&This->stub_buffer;
313
314     IPSFactoryBuffer_AddRef(pPSFactory);
315     return S_OK;
316 }
317
318 HRESULT WINAPI CStdStubBuffer_QueryInterface(LPRPCSTUBBUFFER iface,
319                                             REFIID riid,
320                                             LPVOID *obj)
321 {
322   CStdStubBuffer *This = (CStdStubBuffer *)iface;
323   TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
324
325   if (IsEqualIID(&IID_IUnknown, riid) ||
326       IsEqualIID(&IID_IRpcStubBuffer, riid))
327   {
328     IUnknown_AddRef(iface);
329     *obj = iface;
330     return S_OK;
331   }
332   *obj = NULL;
333   return E_NOINTERFACE;
334 }
335
336 ULONG WINAPI CStdStubBuffer_AddRef(LPRPCSTUBBUFFER iface)
337 {
338   CStdStubBuffer *This = (CStdStubBuffer *)iface;
339   TRACE("(%p)->AddRef()\n",This);
340   return InterlockedIncrement(&This->RefCount);
341 }
342
343 ULONG WINAPI NdrCStdStubBuffer_Release(LPRPCSTUBBUFFER iface,
344                                       LPPSFACTORYBUFFER pPSF)
345 {
346   CStdStubBuffer *This = (CStdStubBuffer *)iface;
347   ULONG refs;
348
349   TRACE("(%p)->Release()\n",This);
350
351   refs = InterlockedDecrement(&This->RefCount);
352   if (!refs)
353   {
354     /* test_Release shows that native doesn't call Disconnect here.
355        We'll leave it in for the time being. */
356     IRpcStubBuffer_Disconnect(iface);
357
358     IPSFactoryBuffer_Release(pPSF);
359     HeapFree(GetProcessHeap(),0,This);
360   }
361   return refs;
362 }
363
364 ULONG WINAPI NdrCStdStubBuffer2_Release(LPRPCSTUBBUFFER iface,
365                                         LPPSFACTORYBUFFER pPSF)
366 {
367     cstdstubbuffer_delegating_t *This = impl_from_delegating( iface );
368     ULONG refs;
369
370     TRACE("(%p)->Release()\n", This);
371
372     refs = InterlockedDecrement(&This->stub_buffer.RefCount);
373     if (!refs)
374     {
375         /* Just like NdrCStdStubBuffer_Release, we shouldn't call
376            Disconnect here */
377         IRpcStubBuffer_Disconnect((IRpcStubBuffer *)&This->stub_buffer);
378
379         IRpcStubBuffer_Release(This->base_stub);
380         release_delegating_vtbl(This->base_obj);
381
382         IPSFactoryBuffer_Release(pPSF);
383         HeapFree(GetProcessHeap(), 0, This);
384     }
385
386     return refs;
387 }
388
389 HRESULT WINAPI CStdStubBuffer_Connect(LPRPCSTUBBUFFER iface,
390                                      LPUNKNOWN lpUnkServer)
391 {
392     CStdStubBuffer *This = (CStdStubBuffer *)iface;
393     HRESULT r;
394     IUnknown *new = NULL;
395
396     TRACE("(%p)->Connect(%p)\n",This,lpUnkServer);
397
398     r = IUnknown_QueryInterface(lpUnkServer, STUB_HEADER(This).piid, (void**)&new);
399     new = InterlockedExchangePointer((void**)&This->pvServerObject, new);
400     if(new)
401         IUnknown_Release(new);
402     return r;
403 }
404
405 void WINAPI CStdStubBuffer_Disconnect(LPRPCSTUBBUFFER iface)
406 {
407     CStdStubBuffer *This = (CStdStubBuffer *)iface;
408     IUnknown *old;
409     TRACE("(%p)->Disconnect()\n",This);
410
411     old = InterlockedExchangePointer((void**)&This->pvServerObject, NULL);
412
413     if(old)
414         IUnknown_Release(old);
415 }
416
417 HRESULT WINAPI CStdStubBuffer_Invoke(LPRPCSTUBBUFFER iface,
418                                     PRPCOLEMESSAGE pMsg,
419                                     LPRPCCHANNELBUFFER pChannel)
420 {
421   CStdStubBuffer *This = (CStdStubBuffer *)iface;
422   DWORD dwPhase = STUB_UNMARSHAL;
423   HRESULT hr = S_OK;
424
425   TRACE("(%p)->Invoke(%p,%p)\n",This,pMsg,pChannel);
426
427   __TRY
428   {
429     if (STUB_HEADER(This).pDispatchTable)
430       STUB_HEADER(This).pDispatchTable[pMsg->iMethod](iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
431     else /* pure interpreted */
432       NdrStubCall2(iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
433   }
434   __EXCEPT(stub_filter)
435   {
436     DWORD dwExceptionCode = GetExceptionCode();
437     WARN("a stub call failed with exception 0x%08x (%d)\n", dwExceptionCode, dwExceptionCode);
438     if (FAILED(dwExceptionCode))
439       hr = dwExceptionCode;
440     else
441       hr = HRESULT_FROM_WIN32(dwExceptionCode);
442   }
443   __ENDTRY
444
445   return hr;
446 }
447
448 LPRPCSTUBBUFFER WINAPI CStdStubBuffer_IsIIDSupported(LPRPCSTUBBUFFER iface,
449                                                     REFIID riid)
450 {
451   CStdStubBuffer *This = (CStdStubBuffer *)iface;
452   TRACE("(%p)->IsIIDSupported(%s)\n",This,debugstr_guid(riid));
453   return IsEqualGUID(STUB_HEADER(This).piid, riid) ? iface : NULL;
454 }
455
456 ULONG WINAPI CStdStubBuffer_CountRefs(LPRPCSTUBBUFFER iface)
457 {
458   CStdStubBuffer *This = (CStdStubBuffer *)iface;
459   TRACE("(%p)->CountRefs()\n",This);
460   return This->RefCount;
461 }
462
463 HRESULT WINAPI CStdStubBuffer_DebugServerQueryInterface(LPRPCSTUBBUFFER iface,
464                                                        LPVOID *ppv)
465 {
466   CStdStubBuffer *This = (CStdStubBuffer *)iface;
467   TRACE("(%p)->DebugServerQueryInterface(%p)\n",This,ppv);
468   return S_OK;
469 }
470
471 void WINAPI CStdStubBuffer_DebugServerRelease(LPRPCSTUBBUFFER iface,
472                                              LPVOID pv)
473 {
474   CStdStubBuffer *This = (CStdStubBuffer *)iface;
475   TRACE("(%p)->DebugServerRelease(%p)\n",This,pv);
476 }
477
478 const IRpcStubBufferVtbl CStdStubBuffer_Vtbl =
479 {
480     CStdStubBuffer_QueryInterface,
481     CStdStubBuffer_AddRef,
482     NULL,
483     CStdStubBuffer_Connect,
484     CStdStubBuffer_Disconnect,
485     CStdStubBuffer_Invoke,
486     CStdStubBuffer_IsIIDSupported,
487     CStdStubBuffer_CountRefs,
488     CStdStubBuffer_DebugServerQueryInterface,
489     CStdStubBuffer_DebugServerRelease
490 };
491
492 static HRESULT WINAPI CStdStubBuffer_Delegating_Connect(LPRPCSTUBBUFFER iface,
493                                                         LPUNKNOWN lpUnkServer)
494 {
495     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
496     HRESULT r;
497     TRACE("(%p)->Connect(%p)\n", This, lpUnkServer);
498
499     r = CStdStubBuffer_Connect(iface, lpUnkServer);
500     if(SUCCEEDED(r))
501         r = IRpcStubBuffer_Connect(This->base_stub, (IUnknown*)&This->base_obj);
502
503     return r;
504 }
505
506 static void WINAPI CStdStubBuffer_Delegating_Disconnect(LPRPCSTUBBUFFER iface)
507 {
508     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
509     TRACE("(%p)->Disconnect()\n", This);
510
511     IRpcStubBuffer_Disconnect(This->base_stub);
512     CStdStubBuffer_Disconnect(iface);
513 }
514
515 static ULONG WINAPI CStdStubBuffer_Delegating_CountRefs(LPRPCSTUBBUFFER iface)
516 {
517     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
518     ULONG ret;
519     TRACE("(%p)->CountRefs()\n", This);
520
521     ret = CStdStubBuffer_CountRefs(iface);
522     ret += IRpcStubBuffer_CountRefs(This->base_stub);
523
524     return ret;
525 }
526
527 const IRpcStubBufferVtbl CStdStubBuffer_Delegating_Vtbl =
528 {
529     CStdStubBuffer_QueryInterface,
530     CStdStubBuffer_AddRef,
531     NULL,
532     CStdStubBuffer_Delegating_Connect,
533     CStdStubBuffer_Delegating_Disconnect,
534     CStdStubBuffer_Invoke,
535     CStdStubBuffer_IsIIDSupported,
536     CStdStubBuffer_Delegating_CountRefs,
537     CStdStubBuffer_DebugServerQueryInterface,
538     CStdStubBuffer_DebugServerRelease
539 };
540
541 const MIDL_SERVER_INFO *CStdStubBuffer_GetServerInfo(IRpcStubBuffer *iface)
542 {
543   CStdStubBuffer *This = (CStdStubBuffer *)iface;
544   return STUB_HEADER(This).pServerInfo;
545 }
546
547 /************************************************************************
548  *           NdrStubForwardingFunction [RPCRT4.@]
549  */
550 void __RPC_STUB NdrStubForwardingFunction( IRpcStubBuffer *iface, IRpcChannelBuffer *pChannel,
551                                            PRPC_MESSAGE pMsg, DWORD *pdwStubPhase )
552 {
553     /* Note pMsg is passed intact since RPCOLEMESSAGE is basically a RPC_MESSAGE. */
554
555     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
556     HRESULT r = IRpcStubBuffer_Invoke(This->base_stub, (RPCOLEMESSAGE*)pMsg, pChannel);
557     if(FAILED(r)) RpcRaiseException(r);
558     return;
559 }
560
561 /***********************************************************************
562  *           NdrStubInitialize [RPCRT4.@]
563  */
564 void WINAPI NdrStubInitialize(PRPC_MESSAGE pRpcMsg,
565                              PMIDL_STUB_MESSAGE pStubMsg,
566                              PMIDL_STUB_DESC pStubDescriptor,
567                              LPRPCCHANNELBUFFER pRpcChannelBuffer)
568 {
569   TRACE("(%p,%p,%p,%p)\n", pRpcMsg, pStubMsg, pStubDescriptor, pRpcChannelBuffer);
570   NdrServerInitializeNew(pRpcMsg, pStubMsg, pStubDescriptor);
571   pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
572   IRpcChannelBuffer_GetDestCtx(pStubMsg->pRpcChannelBuffer,
573                                &pStubMsg->dwDestContext,
574                                &pStubMsg->pvDestContext);
575 }
576
577 /***********************************************************************
578  *           NdrStubGetBuffer [RPCRT4.@]
579  */
580 void WINAPI NdrStubGetBuffer(LPRPCSTUBBUFFER iface,
581                             LPRPCCHANNELBUFFER pRpcChannelBuffer,
582                             PMIDL_STUB_MESSAGE pStubMsg)
583 {
584   CStdStubBuffer *This = (CStdStubBuffer *)iface;
585   HRESULT hr;
586
587   TRACE("(%p, %p, %p)\n", This, pRpcChannelBuffer, pStubMsg);
588
589   pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
590   hr = IRpcChannelBuffer_GetBuffer(pRpcChannelBuffer,
591     (RPCOLEMESSAGE *)pStubMsg->RpcMsg, STUB_HEADER(This).piid);
592   if (FAILED(hr))
593   {
594     RpcRaiseException(hr);
595     return;
596   }
597
598   pStubMsg->Buffer = pStubMsg->RpcMsg->Buffer;
599 }