?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ia2comproxy: Introduce new proxy stub DLL for IAccessible2.
[wine.git] / dlls / rpcrt4 / cproxy.c
blobda3e19e50f38a864cca81b620341a77543ca0be0
1 /*
2 * COM proxy 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 <stdarg.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winerror.h"
29
30 #include "objbase.h"
31 #include "rpcproxy.h"
32
33 #include "cpsf.h"
34 #include "ndr_misc.h"
35 #include "ndr_stubless.h"
36 #include "wine/asm.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(ole);
40
41 static const IRpcProxyBufferVtbl StdProxy_Vtbl;
42
43 static inline StdProxyImpl *impl_from_IRpcProxyBuffer(IRpcProxyBuffer *iface)
44 {
45 return CONTAINING_RECORD(iface, StdProxyImpl, IRpcProxyBuffer_iface);
46 }
47
48 static inline StdProxyImpl *impl_from_proxy_obj( void *iface )
49 {
50 return CONTAINING_RECORD(iface, StdProxyImpl, PVtbl);
51 }
52
53 #ifdef __i386__
54
55 extern void call_stubless_func(void);
56 __ASM_GLOBAL_FUNC(call_stubless_func,
57 "movl 4(%esp),%ecx\n\t" /* This pointer */
58 "movl (%ecx),%ecx\n\t" /* This->lpVtbl */
59 "movl -8(%ecx),%ecx\n\t" /* MIDL_STUBLESS_PROXY_INFO */
60 "movl 8(%ecx),%edx\n\t" /* info->FormatStringOffset */
61 "movzwl (%edx,%eax,2),%edx\n\t" /* FormatStringOffset[index] */
62 "addl 4(%ecx),%edx\n\t" /* info->ProcFormatString + offset */
63 "movzbl 1(%edx),%eax\n\t" /* Oi_flags */
64 "andl $0x08,%eax\n\t" /* Oi_HAS_RPCFLAGS */
65 "shrl $1,%eax\n\t"
66 "movzwl 4(%edx,%eax),%eax\n\t" /* arguments size */
67 "pushl %eax\n\t"
68 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
69 "leal 8(%esp),%eax\n\t" /* &This */
70 "pushl %eax\n\t"
71 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
72 "pushl %edx\n\t" /* format string */
73 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
74 "pushl (%ecx)\n\t" /* info->pStubDesc */
75 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
76 "call " __ASM_NAME("ndr_client_call") "\n\t"
77 "leal 12(%esp),%esp\n\t"
78 __ASM_CFI(".cfi_adjust_cfa_offset -12\n\t")
79 "popl %edx\n\t" /* arguments size */
80 __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
81 "movl (%esp),%ecx\n\t" /* return address */
82 "addl %edx,%esp\n\t"
83 "jmp *%ecx" );
84
85 #include "pshpack1.h"
86 struct thunk
87 {
88 BYTE mov_eax;
89 DWORD index;
90 BYTE jmp;
91 LONG handler;
92 };
93 #include "poppack.h"
94
95 static inline void init_thunk( struct thunk *thunk, unsigned int index )
96 {
97 thunk->mov_eax = 0xb8; /* movl $n,%eax */
98 thunk->index = index;
99 thunk->jmp = 0xe9; /* jmp */
100 thunk->handler = (char *)call_stubless_func - (char *)(&thunk->handler + 1);
101 }
102
103 #elif defined(__x86_64__)
104
105 extern void call_stubless_func(void);
106 __ASM_GLOBAL_FUNC(call_stubless_func,
107 "subq $0x38,%rsp\n\t"
108 __ASM_SEH(".seh_stackalloc 0x38\n\t")
109 __ASM_SEH(".seh_endprologue\n\t")
110 __ASM_CFI(".cfi_adjust_cfa_offset 0x38\n\t")
111 "movq %rcx,0x40(%rsp)\n\t"
112 "movq %rdx,0x48(%rsp)\n\t"
113 "movq %r8,0x50(%rsp)\n\t"
114 "movq %r9,0x58(%rsp)\n\t"
115 "leaq 0x40(%rsp),%r8\n\t" /* &This */
116 "movq (%rcx),%rcx\n\t" /* This->lpVtbl */
117 "movq -0x10(%rcx),%rcx\n\t" /* MIDL_STUBLESS_PROXY_INFO */
118 "movq 0x10(%rcx),%rdx\n\t" /* info->FormatStringOffset */
119 "movzwq (%rdx,%r10,2),%rdx\n\t" /* FormatStringOffset[index] */
120 "addq 8(%rcx),%rdx\n\t" /* info->ProcFormatString + offset */
121 "movq (%rcx),%rcx\n\t" /* info->pStubDesc */
122 "movq %xmm1,0x20(%rsp)\n\t"
123 "movq %xmm2,0x28(%rsp)\n\t"
124 "movq %xmm3,0x30(%rsp)\n\t"
125 "leaq 0x18(%rsp),%r9\n\t" /* fpu_args */
126 "call " __ASM_NAME("ndr_client_call") "\n\t"
127 "addq $0x38,%rsp\n\t"
128 __ASM_CFI(".cfi_adjust_cfa_offset -0x38\n\t")
129 "ret" );
130
131 #include "pshpack1.h"
132 struct thunk
133 {
134 BYTE mov_r10[3];
135 DWORD index;
136 BYTE mov_rax[2];
137 void *call_stubless;
138 BYTE jmp_rax[2];
139 };
140 #include "poppack.h"
141
142 static const struct thunk thunk_template =
143 {
144 { 0x49, 0xc7, 0xc2 }, 0, /* movq $index,%r10 */
145 { 0x48, 0xb8 }, 0, /* movq $call_stubless_func,%rax */
146 { 0xff, 0xe0 } /* jmp *%rax */
147 };
148
149 static inline void init_thunk( struct thunk *thunk, unsigned int index )
150 {
151 *thunk = thunk_template;
152 thunk->index = index;
153 thunk->call_stubless = call_stubless_func;
154 }
155
156 #elif defined(__arm__)
157
158 extern void call_stubless_func(void);
159 __ASM_GLOBAL_FUNC(call_stubless_func,
160 "push {r0-r3}\n\t"
161 "mov r2, sp\n\t" /* stack_top */
162 "push {fp,lr}\n\t"
163 "mov fp, sp\n\t"
164 "ldr r0, [r0]\n\t" /* This->lpVtbl */
165 "ldr r0, [r0,#-8]\n\t" /* MIDL_STUBLESS_PROXY_INFO */
166 "ldr r1, [r0,#8]\n\t" /* info->FormatStringOffset */
167 "ldrh r1, [r1,ip]\n\t" /* info->FormatStringOffset[index] */
168 "ldr ip, [r0,#4]\n\t" /* info->ProcFormatString */
169 "add r1, ip\n\t" /* info->ProcFormatString + offset */
170 "ldr r0, [r0]\n\t" /* info->pStubDesc */
171 #ifdef __SOFTFP__
172 "mov r3, #0\n\t"
173 #else
174 "vpush {s0-s15}\n\t" /* store the s0-s15/d0-d7 arguments */
175 "mov r3, sp\n\t" /* fpu_stack */
176 #endif
177 "bl " __ASM_NAME("ndr_client_call") "\n\t"
178 "mov sp, fp\n\t"
179 "pop {fp,lr}\n\t"
180 "add sp, #16\n\t"
181 "bx lr" );
182
183 struct thunk
184 {
185 DWORD ldr_ip; /* ldr ip,[pc] */
186 DWORD ldr_pc; /* ldr pc,[pc] */
187 DWORD index;
188 void *func;
189 };
190
191 static inline void init_thunk( struct thunk *thunk, unsigned int index )
192 {
193 thunk->ldr_ip = 0xe59fc000; /* ldr ip,[pc] */
194 thunk->ldr_pc = 0xe59ff000; /* ldr pc,[pc] */
195 thunk->index = index * sizeof(unsigned short);
196 thunk->func = call_stubless_func;
197 }
198
199 #elif defined(__aarch64__)
200
201 extern void call_stubless_func(void);
202 __ASM_GLOBAL_FUNC( call_stubless_func,
203 "stp x29, x30, [sp, #-0x90]!\n\t"
204 "mov x29, sp\n\t"
205 "stp d0, d1, [sp, #0x10]\n\t"
206 "stp d2, d3, [sp, #0x20]\n\t"
207 "stp d4, d5, [sp, #0x30]\n\t"
208 "stp d6, d7, [sp, #0x40]\n\t"
209 "stp x0, x1, [sp, #0x50]\n\t"
210 "stp x2, x3, [sp, #0x60]\n\t"
211 "stp x4, x5, [sp, #0x70]\n\t"
212 "stp x6, x7, [sp, #0x80]\n\t"
213 "ldr x0, [x0]\n\t" /* This->lpVtbl */
214 "ldr x0, [x0, #-16]\n\t" /* MIDL_STUBLESS_PROXY_INFO */
215 "ldp x1, x4, [x0, #8]\n\t" /* info->ProcFormatString, FormatStringOffset */
216 "ldrh w4, [x4, x16, lsl #1]\n\t" /* info->FormatStringOffset[index] */
217 "add x1, x1, x4\n\t" /* info->ProcFormatString + offset */
218 "ldr x0, [x0]\n\t" /* info->pStubDesc */
219 "add x2, sp, #0x50\n\t" /* stack */
220 "add x3, sp, #0x10\n\t" /* fpu_stack */
221 "bl " __ASM_NAME("ndr_client_call") "\n\t"
222 "ldp x29, x30, [sp], #0x90\n\t"
223 "ret" )
224
225 struct thunk
226 {
227 DWORD ldr_index; /* ldr w16, index */
228 DWORD ldr_func; /* ldr x17, func */
229 DWORD br; /* br x17 */
230 DWORD index;
231 void *func;
232 };
233
234 static inline void init_thunk( struct thunk *thunk, unsigned int index )
235 {
236 thunk->ldr_index = 0x18000070; /* ldr w16,index */
237 thunk->ldr_func = 0x58000071; /* ldr x17,func */
238 thunk->br = 0xd61f0220; /* br x17 */
239 thunk->index = index;
240 thunk->func = call_stubless_func;
241 }
242
243 #else /* __i386__ */
244
245 #warning You must implement stubless proxies for your CPU
246
247 struct thunk
248 {
249 DWORD index;
250 };
251
252 static inline void init_thunk( struct thunk *thunk, unsigned int index )
253 {
254 thunk->index = index;
255 }
256
257 #endif /* __i386__ */
258
259 #define BLOCK_SIZE 1024
260 #define MAX_BLOCKS 64 /* 64k methods should be enough for anybody */
261
262 static const struct thunk *method_blocks[MAX_BLOCKS];
263
264 static const struct thunk *allocate_block( unsigned int num )
265 {
266 unsigned int i;
267 struct thunk *prev, *block;
268 DWORD oldprot;
269
270 block = VirtualAlloc( NULL, BLOCK_SIZE * sizeof(*block),
271 MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE );
272 if (!block) return NULL;
273
274 for (i = 0; i < BLOCK_SIZE; i++) init_thunk( &block[i], BLOCK_SIZE * num + i + 3 );
275 VirtualProtect( block, BLOCK_SIZE * sizeof(*block), PAGE_EXECUTE_READ, &oldprot );
276 prev = InterlockedCompareExchangePointer( (void **)&method_blocks[num], block, NULL );
277 if (prev) /* someone beat us to it */
278 {
279 VirtualFree( block, 0, MEM_RELEASE );
280 block = prev;
281 }
282 return block;
283 }
284
285 BOOL fill_stubless_table( IUnknownVtbl *vtbl, DWORD num )
286 {
287 const void **entry = (const void **)(vtbl + 1);
288 DWORD i, j;
289
290 if (num - 3 > BLOCK_SIZE * MAX_BLOCKS)
291 {
292 FIXME( "%lu methods not supported\n", num );
293 return FALSE;
294 }
295 for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
296 {
297 const struct thunk *block = method_blocks[i];
298 if (!block && !(block = allocate_block( i ))) return FALSE;
299 for (j = 0; j < BLOCK_SIZE && j < num - 3 - i * BLOCK_SIZE; j++, entry++)
300 if (*entry == (LPVOID)-1) *entry = &block[j];
301 }
302 return TRUE;
303 }
304
305 HRESULT StdProxy_Construct(REFIID riid,
306 LPUNKNOWN pUnkOuter,
307 const ProxyFileInfo *ProxyInfo,
308 int Index,
309 LPPSFACTORYBUFFER pPSFactory,
310 LPRPCPROXYBUFFER *ppProxy,
311 LPVOID *ppvObj)
312 {
313 StdProxyImpl *This;
314 PCInterfaceName name = ProxyInfo->pNamesArray[Index];
315 CInterfaceProxyVtbl *vtbl = ProxyInfo->pProxyVtblList[Index];
316
317 TRACE("(%p,%p,%p,%p,%p) %s\n", pUnkOuter, vtbl, pPSFactory, ppProxy, ppvObj, name);
318
319 /* TableVersion = 2 means it is the stubless version of CInterfaceProxyVtbl */
320 if (ProxyInfo->TableVersion > 1) {
321 ULONG count = ProxyInfo->pStubVtblList[Index]->header.DispatchTableCount;
322 vtbl = (CInterfaceProxyVtbl *)((const void **)vtbl + 1);
323 TRACE("stubless vtbl %p: count=%ld\n", vtbl->Vtbl, count );
324 fill_stubless_table( (IUnknownVtbl *)vtbl->Vtbl, count );
325 }
326
327 if (!IsEqualGUID(vtbl->header.piid, riid)) {
328 ERR("IID mismatch during proxy creation\n");
329 return RPC_E_UNEXPECTED;
330 }
331
332 This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(StdProxyImpl));
333 if (!This) return E_OUTOFMEMORY;
334
335 if (!pUnkOuter) pUnkOuter = (IUnknown *)This;
336 This->IRpcProxyBuffer_iface.lpVtbl = &StdProxy_Vtbl;
337 This->PVtbl = vtbl->Vtbl;
338 /* one reference for the proxy */
339 This->RefCount = 1;
340 This->piid = vtbl->header.piid;
341 This->base_object = NULL;
342 This->base_proxy = NULL;
343 This->pUnkOuter = pUnkOuter;
344 This->name = name;
345 This->pPSFactory = pPSFactory;
346 This->pChannel = NULL;
347
348 if(ProxyInfo->pDelegatedIIDs && ProxyInfo->pDelegatedIIDs[Index])
349 {
350 HRESULT r = create_proxy( ProxyInfo->pDelegatedIIDs[Index], NULL,
351 &This->base_proxy, (void **)&This->base_object );
352 if (FAILED(r))
353 {
354 HeapFree( GetProcessHeap(), 0, This );
355 return r;
356 }
357 }
358
359 *ppProxy = &This->IRpcProxyBuffer_iface;
360 *ppvObj = &This->PVtbl;
361 IUnknown_AddRef((IUnknown *)*ppvObj);
362 IPSFactoryBuffer_AddRef(pPSFactory);
363
364 TRACE( "iid=%s this %p proxy %p obj %p vtbl %p base proxy %p base obj %p\n",
365 debugstr_guid(riid), This, *ppProxy, *ppvObj, This->PVtbl, This->base_proxy, This->base_object );
366 return S_OK;
367 }
368
369 HRESULT WINAPI StdProxy_QueryInterface(IRpcProxyBuffer *iface, REFIID riid, void **obj)
370 {
371 StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
372 TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
373
374 if (IsEqualGUID(&IID_IUnknown,riid) ||
375 IsEqualGUID(This->piid,riid)) {
376 *obj = &This->PVtbl;
377 InterlockedIncrement(&This->RefCount);
378 return S_OK;
379 }
380
381 if (IsEqualGUID(&IID_IRpcProxyBuffer,riid)) {
382 *obj = &This->IRpcProxyBuffer_iface;
383 InterlockedIncrement(&This->RefCount);
384 return S_OK;
385 }
386
387 return E_NOINTERFACE;
388 }
389
390 ULONG WINAPI StdProxy_AddRef(IRpcProxyBuffer *iface)
391 {
392 StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
393 TRACE("(%p)->AddRef()\n",This);
394
395 return InterlockedIncrement(&This->RefCount);
396 }
397
398 static ULONG WINAPI StdProxy_Release(LPRPCPROXYBUFFER iface)
399 {
400 ULONG refs;
401 StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
402 TRACE("(%p)->Release()\n",This);
403
404 refs = InterlockedDecrement(&This->RefCount);
405 if (!refs)
406 {
407 if (This->pChannel)
408 IRpcProxyBuffer_Disconnect(&This->IRpcProxyBuffer_iface);
409
410 if (This->base_object) IUnknown_Release( This->base_object );
411 if (This->base_proxy) IRpcProxyBuffer_Release( This->base_proxy );
412
413 IPSFactoryBuffer_Release(This->pPSFactory);
414 HeapFree(GetProcessHeap(),0,This);
415 }
416
417 return refs;
418 }
419
420 HRESULT WINAPI StdProxy_Connect(IRpcProxyBuffer *iface, IRpcChannelBuffer *pChannel)
421 {
422 StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
423 TRACE("(%p)->Connect(%p)\n",This,pChannel);
424
425 This->pChannel = pChannel;
426 IRpcChannelBuffer_AddRef(pChannel);
427 if (This->base_proxy) IRpcProxyBuffer_Connect( This->base_proxy, pChannel );
428 return S_OK;
429 }
430
431 void WINAPI StdProxy_Disconnect(IRpcProxyBuffer *iface)
432 {
433 StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
434 TRACE("(%p)->Disconnect()\n",This);
435
436 if (This->base_proxy) IRpcProxyBuffer_Disconnect( This->base_proxy );
437
438 IRpcChannelBuffer_Release(This->pChannel);
439 This->pChannel = NULL;
440 }
441
442 static const IRpcProxyBufferVtbl StdProxy_Vtbl =
443 {
444 StdProxy_QueryInterface,
445 StdProxy_AddRef,
446 StdProxy_Release,
447 StdProxy_Connect,
448 StdProxy_Disconnect
449 };
450
451 static void StdProxy_GetChannel(LPVOID iface,
452 LPRPCCHANNELBUFFER *ppChannel)
453 {
454 StdProxyImpl *This = impl_from_proxy_obj( iface );
455 TRACE("(%p)->GetChannel(%p) %s\n",This,ppChannel,This->name);
456
457 *ppChannel = This->pChannel;
458 }
459
460 static void StdProxy_GetIID(LPVOID iface,
461 const IID **ppiid)
462 {
463 StdProxyImpl *This = impl_from_proxy_obj( iface );
464 TRACE("(%p)->GetIID(%p) %s\n",This,ppiid,This->name);
465
466 *ppiid = This->piid;
467 }
468
469 HRESULT WINAPI IUnknown_QueryInterface_Proxy(LPUNKNOWN iface,
470 REFIID riid,
471 LPVOID *ppvObj)
472 {
473 StdProxyImpl *This = impl_from_proxy_obj( iface );
474 TRACE("(%p)->QueryInterface(%s,%p) %s\n",This,debugstr_guid(riid),ppvObj,This->name);
475 return IUnknown_QueryInterface(This->pUnkOuter,riid,ppvObj);
476 }
477
478 ULONG WINAPI IUnknown_AddRef_Proxy(LPUNKNOWN iface)
479 {
480 StdProxyImpl *This = impl_from_proxy_obj( iface );
481 TRACE("(%p)->AddRef() %s\n",This,This->name);
482 return IUnknown_AddRef(This->pUnkOuter);
483 }
484
485 ULONG WINAPI IUnknown_Release_Proxy(LPUNKNOWN iface)
486 {
487 StdProxyImpl *This = impl_from_proxy_obj( iface );
488 TRACE("(%p)->Release() %s\n",This,This->name);
489 return IUnknown_Release(This->pUnkOuter);
490 }
491
492 /***********************************************************************
493 * NdrProxyInitialize [RPCRT4.@]
494 */
495 void WINAPI NdrProxyInitialize(void *This,
496 PRPC_MESSAGE pRpcMsg,
497 PMIDL_STUB_MESSAGE pStubMsg,
498 PMIDL_STUB_DESC pStubDescriptor,
499 unsigned int ProcNum)
500 {
501 TRACE("(%p,%p,%p,%p,%d)\n", This, pRpcMsg, pStubMsg, pStubDescriptor, ProcNum);
502 NdrClientInitializeNew(pRpcMsg, pStubMsg, pStubDescriptor, ProcNum);
503 StdProxy_GetChannel(This, &pStubMsg->pRpcChannelBuffer);
504 if (!pStubMsg->pRpcChannelBuffer)
505 RpcRaiseException(CO_E_OBJNOTCONNECTED);
506 IRpcChannelBuffer_GetDestCtx(pStubMsg->pRpcChannelBuffer,
507 &pStubMsg->dwDestContext,
508 &pStubMsg->pvDestContext);
509 TRACE("channel=%p\n", pStubMsg->pRpcChannelBuffer);
510 }
511
512 /***********************************************************************
513 * NdrProxyGetBuffer [RPCRT4.@]
514 */
515 void WINAPI NdrProxyGetBuffer(void *This,
516 PMIDL_STUB_MESSAGE pStubMsg)
517 {
518 HRESULT hr;
519 const IID *riid = NULL;
520
521 TRACE("(%p,%p)\n", This, pStubMsg);
522 pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
523 pStubMsg->dwStubPhase = PROXY_GETBUFFER;
524 StdProxy_GetIID(This, &riid);
525 hr = IRpcChannelBuffer_GetBuffer(pStubMsg->pRpcChannelBuffer,
526 (RPCOLEMESSAGE*)pStubMsg->RpcMsg,
527 riid);
528 if (FAILED(hr))
529 {
530 RpcRaiseException(hr);
531 return;
532 }
533 pStubMsg->fBufferValid = TRUE;
534 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
535 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
536 pStubMsg->Buffer = pStubMsg->BufferStart;
537 pStubMsg->dwStubPhase = PROXY_MARSHAL;
538 }
539
540 /***********************************************************************
541 * NdrProxySendReceive [RPCRT4.@]
542 */
543 void WINAPI NdrProxySendReceive(void *This,
544 PMIDL_STUB_MESSAGE pStubMsg)
545 {
546 ULONG Status = 0;
547 HRESULT hr;
548
549 TRACE("(%p,%p)\n", This, pStubMsg);
550
551 if (!pStubMsg->pRpcChannelBuffer)
552 {
553 WARN("Trying to use disconnected proxy %p\n", This);
554 RpcRaiseException(RPC_E_DISCONNECTED);
555 }
556
557 pStubMsg->dwStubPhase = PROXY_SENDRECEIVE;
558 /* avoid sending uninitialised parts of the buffer on the wire */
559 pStubMsg->RpcMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
560 hr = IRpcChannelBuffer_SendReceive(pStubMsg->pRpcChannelBuffer,
561 (RPCOLEMESSAGE*)pStubMsg->RpcMsg,
562 &Status);
563 pStubMsg->dwStubPhase = PROXY_UNMARSHAL;
564 pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
565 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
566 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
567 pStubMsg->Buffer = pStubMsg->BufferStart;
568
569 /* raise exception if call failed */
570 if (hr == RPC_S_CALL_FAILED) RpcRaiseException(*(DWORD*)pStubMsg->Buffer);
571 else if (FAILED(hr)) RpcRaiseException(hr);
572 }
573
574 /***********************************************************************
575 * NdrProxyFreeBuffer [RPCRT4.@]
576 */
577 void WINAPI NdrProxyFreeBuffer(void *This,
578 PMIDL_STUB_MESSAGE pStubMsg)
579 {
580 TRACE("(%p,%p)\n", This, pStubMsg);
581
582 if (pStubMsg->fBufferValid)
583 {
584 IRpcChannelBuffer_FreeBuffer(pStubMsg->pRpcChannelBuffer,
585 (RPCOLEMESSAGE*)pStubMsg->RpcMsg);
586 pStubMsg->fBufferValid = TRUE;
587 }
588 }
589
590 /***********************************************************************
591 * NdrProxyErrorHandler [RPCRT4.@]
592 */
593 HRESULT WINAPI NdrProxyErrorHandler(DWORD dwExceptionCode)
594 {
595 WARN("(0x%08lx): a proxy call failed\n", dwExceptionCode);
596
597 if (FAILED(dwExceptionCode))
598 return dwExceptionCode;
599 else
600 return HRESULT_FROM_WIN32(dwExceptionCode);
601 }
Windows API implementation