95ac1d89af2279ef8da94956235299bed418f893
[reactos.git] / reactos / dll / win32 / rpcrt4 / cstub.c
1 /*
2 * COM stub (CStdStubBuffer) implementation
3 *
4 * Copyright 2001 Ove Kåven, TransGaming Technologies
5 * Copyright 2009 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26
27 #define COBJMACROS
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winerror.h"
32 #include "excpt.h"
33
34 #include "objbase.h"
35 #include "rpcproxy.h"
36
37 #include "wine/debug.h"
38 #include "wine/exception.h"
39
40 #include "cpsf.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(ole);
43
44 #define STUB_HEADER(This) (((const CInterfaceStubHeader*)((This)->lpVtbl))[-1])
45
46 static LONG WINAPI stub_filter(EXCEPTION_POINTERS *eptr)
47 {
48 if (eptr->ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
49 return EXCEPTION_CONTINUE_SEARCH;
50 return EXCEPTION_EXECUTE_HANDLER;
51 }
52
53 typedef struct
54 {
55 IUnknownVtbl *base_obj;
56 IRpcStubBuffer *base_stub;
57 CStdStubBuffer stub_buffer;
58 } cstdstubbuffer_delegating_t;
59
60 static inline cstdstubbuffer_delegating_t *impl_from_delegating( IRpcStubBuffer *iface )
61 {
62 return (cstdstubbuffer_delegating_t*)((char *)iface - FIELD_OFFSET(cstdstubbuffer_delegating_t, stub_buffer));
63 }
64
65 HRESULT CStdStubBuffer_Construct(REFIID riid,
66 LPUNKNOWN pUnkServer,
67 PCInterfaceName name,
68 CInterfaceStubVtbl *vtbl,
69 LPPSFACTORYBUFFER pPSFactory,
70 LPRPCSTUBBUFFER *ppStub)
71 {
72 CStdStubBuffer *This;
73 IUnknown *pvServer;
74 HRESULT r;
75 TRACE("(%p,%p,%p,%p) %s\n", pUnkServer, vtbl, pPSFactory, ppStub, name);
76 TRACE("iid=%s\n", debugstr_guid(vtbl->header.piid));
77 TRACE("vtbl=%p\n", &vtbl->Vtbl);
78
79 if (!IsEqualGUID(vtbl->header.piid, riid)) {
80 ERR("IID mismatch during stub creation\n");
81 return RPC_E_UNEXPECTED;
82 }
83
84 r = IUnknown_QueryInterface(pUnkServer, riid, (void**)&pvServer);
85 if(FAILED(r))
86 return r;
87
88 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CStdStubBuffer));
89 if (!This) {
90 IUnknown_Release(pvServer);
91 return E_OUTOFMEMORY;
92 }
93
94 This->lpVtbl = &vtbl->Vtbl;
95 This->RefCount = 1;
96 This->pvServerObject = pvServer;
97 This->pPSFactory = pPSFactory;
98 *ppStub = (LPRPCSTUBBUFFER)This;
99
100 IPSFactoryBuffer_AddRef(pPSFactory);
101 return S_OK;
102 }
103
104 static CRITICAL_SECTION delegating_vtbl_section;
105 static CRITICAL_SECTION_DEBUG critsect_debug =
106 {
107 0, 0, &delegating_vtbl_section,
108 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
109 0, 0, { (DWORD_PTR)(__FILE__ ": delegating_vtbl_section") }
110 };
111 static CRITICAL_SECTION delegating_vtbl_section = { &critsect_debug, -1, 0, 0, 0, 0 };
112
113 typedef struct
114 {
115 DWORD ref;
116 DWORD size;
117 IUnknownVtbl vtbl;
118 /* remaining entries in vtbl */
119 } ref_counted_vtbl;
120
121 static ref_counted_vtbl *current_vtbl;
122
123
124 static HRESULT WINAPI delegating_QueryInterface(IUnknown *pUnk, REFIID iid, void **ppv)
125 {
126 *ppv = 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 #define BLOCK_SIZE 1024
162 #define MAX_BLOCKS 64 /* 64k methods should be enough for anybody */
163
164 static const vtbl_method_t *method_blocks[MAX_BLOCKS];
165
166 static const vtbl_method_t *allocate_block( unsigned int num )
167 {
168 unsigned int i;
169 vtbl_method_t *prev, *block;
170
171 block = VirtualAlloc( NULL, BLOCK_SIZE * sizeof(*block),
172 MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE );
173 if (!block) return NULL;
174
175 for (i = 0; i < BLOCK_SIZE; i++)
176 {
177 block[i].mov1 = 0x0424448b;
178 block[i].mov2 = 0x408b;
179 block[i].sixteen = 0x10;
180 block[i].mov3 = 0x04244489;
181 block[i].mov4 = 0x008b;
182 block[i].mov5 = 0x808b;
183 block[i].offset = (BLOCK_SIZE * num + i + 3) << 2;
184 block[i].jmp = 0xe0ff;
185 block[i].pad[0] = 0x8d;
186 block[i].pad[1] = 0x76;
187 block[i].pad[2] = 0x00;
188 }
189 VirtualProtect( block, BLOCK_SIZE * sizeof(*block), PAGE_EXECUTE_READ, NULL );
190 prev = InterlockedCompareExchangePointer( (void **)&method_blocks[num], block, NULL );
191 if (prev) /* someone beat us to it */
192 {
193 VirtualFree( block, 0, MEM_RELEASE );
194 block = prev;
195 }
196 return block;
197 }
198
199 static BOOL fill_delegated_stub_table(IUnknownVtbl *vtbl, DWORD num)
200 {
201 const void **entry = (const void **)(vtbl + 1);
202 DWORD i, j;
203
204 if (num - 3 > BLOCK_SIZE * MAX_BLOCKS)
205 {
206 FIXME( "%u methods not supported\n", num );
207 return FALSE;
208 }
209 vtbl->QueryInterface = delegating_QueryInterface;
210 vtbl->AddRef = delegating_AddRef;
211 vtbl->Release = delegating_Release;
212 for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
213 {
214 const vtbl_method_t *block = method_blocks[i];
215 if (!block && !(block = allocate_block( i ))) return FALSE;
216 for (j = 0; j < BLOCK_SIZE && j < num - 3 - i * BLOCK_SIZE; j++) *entry++ = &block[j];
217 }
218 return TRUE;
219 }
220
221 BOOL fill_delegated_proxy_table(IUnknownVtbl *vtbl, DWORD num)
222 {
223 const void **entry = (const void **)(vtbl + 1);
224 DWORD i, j;
225
226 if (num - 3 > BLOCK_SIZE * MAX_BLOCKS)
227 {
228 FIXME( "%u methods not supported\n", num );
229 return FALSE;
230 }
231 vtbl->QueryInterface = IUnknown_QueryInterface_Proxy;
232 vtbl->AddRef = IUnknown_AddRef_Proxy;
233 vtbl->Release = IUnknown_Release_Proxy;
234 for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
235 {
236 const vtbl_method_t *block = method_blocks[i];
237 if (!block && !(block = allocate_block( i ))) return FALSE;
238 for (j = 0; j < BLOCK_SIZE && j < num - 3 - i * BLOCK_SIZE; j++, entry++)
239 if (!*entry) *entry = &block[j];
240 }
241 return TRUE;
242 }
243
244 #else /* __i386__ */
245
246 static BOOL fill_delegated_stub_table(IUnknownVtbl *vtbl, DWORD num)
247 {
248 ERR("delegated stubs are not supported on this architecture\n");
249 return FALSE;
250 }
251
252 BOOL fill_delegated_proxy_table(IUnknownVtbl *vtbl, DWORD num)
253 {
254 ERR("delegated proxies are not supported on this architecture\n");
255 return FALSE;
256 }
257
258 #endif /* __i386__ */
259
260 static IUnknownVtbl *get_delegating_vtbl(DWORD num_methods)
261 {
262 IUnknownVtbl *ret;
263
264 if (num_methods < 256) num_methods = 256; /* avoid frequent reallocations */
265
266 EnterCriticalSection(&delegating_vtbl_section);
267
268 if(!current_vtbl || num_methods > current_vtbl->size)
269 {
270 ref_counted_vtbl *table = HeapAlloc(GetProcessHeap(), 0,
271 FIELD_OFFSET(ref_counted_vtbl, vtbl) + num_methods * sizeof(void*));
272 if (!table)
273 {
274 LeaveCriticalSection(&delegating_vtbl_section);
275 return NULL;
276 }
277
278 table->ref = 0;
279 table->size = num_methods;
280 fill_delegated_stub_table(&table->vtbl, num_methods);
281
282 if (current_vtbl && current_vtbl->ref == 0)
283 {
284 TRACE("freeing old table\n");
285 HeapFree(GetProcessHeap(), 0, current_vtbl);
286 }
287 current_vtbl = table;
288 }
289
290 current_vtbl->ref++;
291 ret = &current_vtbl->vtbl;
292 LeaveCriticalSection(&delegating_vtbl_section);
293 return ret;
294 }
295
296 static void release_delegating_vtbl(IUnknownVtbl *vtbl)
297 {
298 ref_counted_vtbl *table = (ref_counted_vtbl*)((DWORD *)vtbl - 1);
299
300 EnterCriticalSection(&delegating_vtbl_section);
301 table->ref--;
302 TRACE("ref now %d\n", table->ref);
303 if(table->ref == 0 && table != current_vtbl)
304 {
305 TRACE("... and we're not current so free'ing\n");
306 HeapFree(GetProcessHeap(), 0, table);
307 }
308 LeaveCriticalSection(&delegating_vtbl_section);
309 }
310
311 HRESULT CStdStubBuffer_Delegating_Construct(REFIID riid,
312 LPUNKNOWN pUnkServer,
313 PCInterfaceName name,
314 CInterfaceStubVtbl *vtbl,
315 REFIID delegating_iid,
316 LPPSFACTORYBUFFER pPSFactory,
317 LPRPCSTUBBUFFER *ppStub)
318 {
319 cstdstubbuffer_delegating_t *This;
320 IUnknown *pvServer;
321 HRESULT r;
322
323 TRACE("(%p,%p,%p,%p) %s\n", pUnkServer, vtbl, pPSFactory, ppStub, name);
324 TRACE("iid=%s delegating to %s\n", debugstr_guid(vtbl->header.piid), debugstr_guid(delegating_iid));
325 TRACE("vtbl=%p\n", &vtbl->Vtbl);
326
327 if (!IsEqualGUID(vtbl->header.piid, riid))
328 {
329 ERR("IID mismatch during stub creation\n");
330 return RPC_E_UNEXPECTED;
331 }
332
333 r = IUnknown_QueryInterface(pUnkServer, riid, (void**)&pvServer);
334 if(FAILED(r)) return r;
335
336 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
337 if (!This)
338 {
339 IUnknown_Release(pvServer);
340 return E_OUTOFMEMORY;
341 }
342
343 This->base_obj = get_delegating_vtbl( vtbl->header.DispatchTableCount );
344 r = create_stub(delegating_iid, (IUnknown*)&This->base_obj, &This->base_stub);
345 if(FAILED(r))
346 {
347 release_delegating_vtbl(This->base_obj);
348 HeapFree(GetProcessHeap(), 0, This);
349 IUnknown_Release(pvServer);
350 return r;
351 }
352
353 This->stub_buffer.lpVtbl = &vtbl->Vtbl;
354 This->stub_buffer.RefCount = 1;
355 This->stub_buffer.pvServerObject = pvServer;
356 This->stub_buffer.pPSFactory = pPSFactory;
357 *ppStub = (LPRPCSTUBBUFFER)&This->stub_buffer;
358
359 IPSFactoryBuffer_AddRef(pPSFactory);
360 return S_OK;
361 }
362
363 HRESULT WINAPI CStdStubBuffer_QueryInterface(LPRPCSTUBBUFFER iface,
364 REFIID riid,
365 LPVOID *obj)
366 {
367 CStdStubBuffer *This = (CStdStubBuffer *)iface;
368 TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
369
370 if (IsEqualIID(&IID_IUnknown, riid) ||
371 IsEqualIID(&IID_IRpcStubBuffer, riid))
372 {
373 IUnknown_AddRef(iface);
374 *obj = iface;
375 return S_OK;
376 }
377 *obj = NULL;
378 return E_NOINTERFACE;
379 }
380
381 ULONG WINAPI CStdStubBuffer_AddRef(LPRPCSTUBBUFFER iface)
382 {
383 CStdStubBuffer *This = (CStdStubBuffer *)iface;
384 TRACE("(%p)->AddRef()\n",This);
385 return InterlockedIncrement(&This->RefCount);
386 }
387
388 ULONG WINAPI NdrCStdStubBuffer_Release(LPRPCSTUBBUFFER iface,
389 LPPSFACTORYBUFFER pPSF)
390 {
391 CStdStubBuffer *This = (CStdStubBuffer *)iface;
392 ULONG refs;
393
394 TRACE("(%p)->Release()\n",This);
395
396 refs = InterlockedDecrement(&This->RefCount);
397 if (!refs)
398 {
399 /* test_Release shows that native doesn't call Disconnect here.
400 We'll leave it in for the time being. */
401 IRpcStubBuffer_Disconnect(iface);
402
403 IPSFactoryBuffer_Release(pPSF);
404 HeapFree(GetProcessHeap(),0,This);
405 }
406 return refs;
407 }
408
409 ULONG WINAPI NdrCStdStubBuffer2_Release(LPRPCSTUBBUFFER iface,
410 LPPSFACTORYBUFFER pPSF)
411 {
412 cstdstubbuffer_delegating_t *This = impl_from_delegating( iface );
413 ULONG refs;
414
415 TRACE("(%p)->Release()\n", This);
416
417 refs = InterlockedDecrement(&This->stub_buffer.RefCount);
418 if (!refs)
419 {
420 /* Just like NdrCStdStubBuffer_Release, we shouldn't call
421 Disconnect here */
422 IRpcStubBuffer_Disconnect((IRpcStubBuffer *)&This->stub_buffer);
423
424 IRpcStubBuffer_Release(This->base_stub);
425 release_delegating_vtbl(This->base_obj);
426
427 IPSFactoryBuffer_Release(pPSF);
428 HeapFree(GetProcessHeap(), 0, This);
429 }
430
431 return refs;
432 }
433
434 HRESULT WINAPI CStdStubBuffer_Connect(LPRPCSTUBBUFFER iface,
435 LPUNKNOWN lpUnkServer)
436 {
437 CStdStubBuffer *This = (CStdStubBuffer *)iface;
438 HRESULT r;
439 IUnknown *new = NULL;
440
441 TRACE("(%p)->Connect(%p)\n",This,lpUnkServer);
442
443 r = IUnknown_QueryInterface(lpUnkServer, STUB_HEADER(This).piid, (void**)&new);
444 new = InterlockedExchangePointer((void**)&This->pvServerObject, new);
445 if(new)
446 IUnknown_Release(new);
447 return r;
448 }
449
450 void WINAPI CStdStubBuffer_Disconnect(LPRPCSTUBBUFFER iface)
451 {
452 CStdStubBuffer *This = (CStdStubBuffer *)iface;
453 IUnknown *old;
454 TRACE("(%p)->Disconnect()\n",This);
455
456 old = InterlockedExchangePointer((void**)&This->pvServerObject, NULL);
457
458 if(old)
459 IUnknown_Release(old);
460 }
461
462 HRESULT WINAPI CStdStubBuffer_Invoke(LPRPCSTUBBUFFER iface,
463 PRPCOLEMESSAGE pMsg,
464 LPRPCCHANNELBUFFER pChannel)
465 {
466 CStdStubBuffer *This = (CStdStubBuffer *)iface;
467 DWORD dwPhase = STUB_UNMARSHAL;
468 HRESULT hr = S_OK;
469
470 TRACE("(%p)->Invoke(%p,%p)\n",This,pMsg,pChannel);
471
472 __TRY
473 {
474 if (STUB_HEADER(This).pDispatchTable)
475 STUB_HEADER(This).pDispatchTable[pMsg->iMethod](iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
476 else /* pure interpreted */
477 NdrStubCall2(iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
478 }
479 __EXCEPT(stub_filter)
480 {
481 DWORD dwExceptionCode = GetExceptionCode();
482 WARN("a stub call failed with exception 0x%08x (%d)\n", dwExceptionCode, dwExceptionCode);
483 if (FAILED(dwExceptionCode))
484 hr = dwExceptionCode;
485 else
486 hr = HRESULT_FROM_WIN32(dwExceptionCode);
487 }
488 __ENDTRY
489
490 return hr;
491 }
492
493 LPRPCSTUBBUFFER WINAPI CStdStubBuffer_IsIIDSupported(LPRPCSTUBBUFFER iface,
494 REFIID riid)
495 {
496 CStdStubBuffer *This = (CStdStubBuffer *)iface;
497 TRACE("(%p)->IsIIDSupported(%s)\n",This,debugstr_guid(riid));
498 return IsEqualGUID(STUB_HEADER(This).piid, riid) ? iface : NULL;
499 }
500
501 ULONG WINAPI CStdStubBuffer_CountRefs(LPRPCSTUBBUFFER iface)
502 {
503 CStdStubBuffer *This = (CStdStubBuffer *)iface;
504 TRACE("(%p)->CountRefs()\n",This);
505 return This->RefCount;
506 }
507
508 HRESULT WINAPI CStdStubBuffer_DebugServerQueryInterface(LPRPCSTUBBUFFER iface,
509 LPVOID *ppv)
510 {
511 CStdStubBuffer *This = (CStdStubBuffer *)iface;
512 TRACE("(%p)->DebugServerQueryInterface(%p)\n",This,ppv);
513 return S_OK;
514 }
515
516 void WINAPI CStdStubBuffer_DebugServerRelease(LPRPCSTUBBUFFER iface,
517 LPVOID pv)
518 {
519 CStdStubBuffer *This = (CStdStubBuffer *)iface;
520 TRACE("(%p)->DebugServerRelease(%p)\n",This,pv);
521 }
522
523 const IRpcStubBufferVtbl CStdStubBuffer_Vtbl =
524 {
525 CStdStubBuffer_QueryInterface,
526 CStdStubBuffer_AddRef,
527 NULL,
528 CStdStubBuffer_Connect,
529 CStdStubBuffer_Disconnect,
530 CStdStubBuffer_Invoke,
531 CStdStubBuffer_IsIIDSupported,
532 CStdStubBuffer_CountRefs,
533 CStdStubBuffer_DebugServerQueryInterface,
534 CStdStubBuffer_DebugServerRelease
535 };
536
537 static HRESULT WINAPI CStdStubBuffer_Delegating_Connect(LPRPCSTUBBUFFER iface,
538 LPUNKNOWN lpUnkServer)
539 {
540 cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
541 HRESULT r;
542 TRACE("(%p)->Connect(%p)\n", This, lpUnkServer);
543
544 r = CStdStubBuffer_Connect(iface, lpUnkServer);
545 if(SUCCEEDED(r))
546 r = IRpcStubBuffer_Connect(This->base_stub, (IUnknown*)&This->base_obj);
547
548 return r;
549 }
550
551 static void WINAPI CStdStubBuffer_Delegating_Disconnect(LPRPCSTUBBUFFER iface)
552 {
553 cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
554 TRACE("(%p)->Disconnect()\n", This);
555
556 IRpcStubBuffer_Disconnect(This->base_stub);
557 CStdStubBuffer_Disconnect(iface);
558 }
559
560 static ULONG WINAPI CStdStubBuffer_Delegating_CountRefs(LPRPCSTUBBUFFER iface)
561 {
562 cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
563 ULONG ret;
564 TRACE("(%p)->CountRefs()\n", This);
565
566 ret = CStdStubBuffer_CountRefs(iface);
567 ret += IRpcStubBuffer_CountRefs(This->base_stub);
568
569 return ret;
570 }
571
572 const IRpcStubBufferVtbl CStdStubBuffer_Delegating_Vtbl =
573 {
574 CStdStubBuffer_QueryInterface,
575 CStdStubBuffer_AddRef,
576 NULL,
577 CStdStubBuffer_Delegating_Connect,
578 CStdStubBuffer_Delegating_Disconnect,
579 CStdStubBuffer_Invoke,
580 CStdStubBuffer_IsIIDSupported,
581 CStdStubBuffer_Delegating_CountRefs,
582 CStdStubBuffer_DebugServerQueryInterface,
583 CStdStubBuffer_DebugServerRelease
584 };
585
586 const MIDL_SERVER_INFO *CStdStubBuffer_GetServerInfo(IRpcStubBuffer *iface)
587 {
588 CStdStubBuffer *This = (CStdStubBuffer *)iface;
589 return STUB_HEADER(This).pServerInfo;
590 }
591
592 /************************************************************************
593 * NdrStubForwardingFunction [RPCRT4.@]
594 */
595 void __RPC_STUB NdrStubForwardingFunction( IRpcStubBuffer *iface, IRpcChannelBuffer *pChannel,
596 PRPC_MESSAGE pMsg, DWORD *pdwStubPhase )
597 {
598 /* Note pMsg is passed intact since RPCOLEMESSAGE is basically a RPC_MESSAGE. */
599
600 cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
601 HRESULT r = IRpcStubBuffer_Invoke(This->base_stub, (RPCOLEMESSAGE*)pMsg, pChannel);
602 if(FAILED(r)) RpcRaiseException(r);
603 return;
604 }
605
606 /***********************************************************************
607 * NdrStubInitialize [RPCRT4.@]
608 */
609 void WINAPI NdrStubInitialize(PRPC_MESSAGE pRpcMsg,
610 PMIDL_STUB_MESSAGE pStubMsg,
611 PMIDL_STUB_DESC pStubDescriptor,
612 LPRPCCHANNELBUFFER pRpcChannelBuffer)
613 {
614 TRACE("(%p,%p,%p,%p)\n", pRpcMsg, pStubMsg, pStubDescriptor, pRpcChannelBuffer);
615 NdrServerInitializeNew(pRpcMsg, pStubMsg, pStubDescriptor);
616 pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
617 IRpcChannelBuffer_GetDestCtx(pStubMsg->pRpcChannelBuffer,
618 &pStubMsg->dwDestContext,
619 &pStubMsg->pvDestContext);
620 }
621
622 /***********************************************************************
623 * NdrStubGetBuffer [RPCRT4.@]
624 */
625 void WINAPI NdrStubGetBuffer(LPRPCSTUBBUFFER iface,
626 LPRPCCHANNELBUFFER pRpcChannelBuffer,
627 PMIDL_STUB_MESSAGE pStubMsg)
628 {
629 CStdStubBuffer *This = (CStdStubBuffer *)iface;
630 HRESULT hr;
631
632 TRACE("(%p, %p, %p)\n", This, pRpcChannelBuffer, pStubMsg);
633
634 pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
635 hr = IRpcChannelBuffer_GetBuffer(pRpcChannelBuffer,
636 (RPCOLEMESSAGE *)pStubMsg->RpcMsg, STUB_HEADER(This).piid);
637 if (FAILED(hr))
638 {
639 RpcRaiseException(hr);
640 return;
641 }
642
643 pStubMsg->Buffer = pStubMsg->RpcMsg->Buffer;
644 }