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( "%u 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=%d\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%08x): a proxy call failed\n", dwExceptionCode); 596 597 if (FAILED(dwExceptionCode)) 598 return dwExceptionCode; 599 else 600 return HRESULT_FROM_WIN32(dwExceptionCode); 601 } 602