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