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 /* 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 #ifdef __i386__
 146
 147 #include "pshpack1.h"
 148 typedef struct {
 149     BYTE mov1[4];    /* mov 0x4(%esp),%eax     8b 44 24 04 */
 150     BYTE mov2[3];    /* mov 0x10(%eax),%eax    8b 40 10 */
 151     BYTE mov3[4];    /* mov %eax,0x4(%esp)     89 44 24 04 */
 152     BYTE mov4[2];    /* mov (%eax),%eax        8b 00 */
 153     BYTE mov5[2];    /* jmp *offset(%eax)      ff a0 offset */
 154     DWORD offset;
 155     BYTE pad[1];     /* nop                    90 */
 156 } vtbl_method_t;
 157 #include "poppack.h"
 158
 159 static const BYTE opcodes[20] = { 0x8b, 0x44, 0x24, 0x04, 0x8b, 0x40, 0x10, 0x89, 0x44, 0x24, 0x04,
 160                                   0x8b, 0x00, 0xff, 0xa0, 0, 0, 0, 0, 0x90 };
 161
 162 #elif defined(__x86_64__)
 163
 164 #include "pshpack1.h"
 165 typedef struct
 166 {
 167     BYTE mov1[4];    /* movq 0x20(%rcx),%rcx   48 8b 49 20 */
 168     BYTE mov2[3];    /* movq (%rcx),%rax       48 8b 01 */
 169     BYTE jmp[2];     /* jmp *offset(%rax)      ff a0 offset */
 170     DWORD offset;
 171     BYTE pad[3];     /* lea 0x0(%rsi),%rsi     48 8d 36 */
 172 } vtbl_method_t;
 173 #include "poppack.h"
 174
 175 static const BYTE opcodes[16] = { 0x48, 0x8b, 0x49, 0x20, 0x48, 0x8b, 0x01,
 176                                   0xff, 0xa0, 0, 0, 0, 0, 0x48, 0x8d, 0x36 };
 177 #else
 178
 179 #warning You must implement delegated proxies/stubs for your CPU
 180 typedef struct
 181 {
 182     DWORD offset;
 183 } vtbl_method_t;
 184 static const BYTE opcodes[1];
 185
 186 #endif
 187
 188 #define BLOCK_SIZE 1024
 189 #define MAX_BLOCKS 64  /* 64k methods should be enough for anybody */
 190
 191 static const vtbl_method_t *method_blocks[MAX_BLOCKS];
 192
 193 static const vtbl_method_t *allocate_block( unsigned int num )
 194 {
 195     unsigned int i;
 196     vtbl_method_t *prev, *block;
 197
 198     block = VirtualAlloc( NULL, BLOCK_SIZE * sizeof(*block),
 199                           MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE );
 200     if (!block) return NULL;
 201
 202     for (i = 0; i < BLOCK_SIZE; i++)
 203     {
 204         memcpy( &block[i], opcodes, sizeof(opcodes) );
 205         block[i].offset = (BLOCK_SIZE * num + i + 3) * sizeof(void *);
 206     }
 207     VirtualProtect( block, BLOCK_SIZE * sizeof(*block), PAGE_EXECUTE_READ, NULL );
 208     prev = InterlockedCompareExchangePointer( (void **)&method_blocks[num], block, NULL );
 209     if (prev) /* someone beat us to it */
 210     {
 211         VirtualFree( block, 0, MEM_RELEASE );
 212         block = prev;
 213     }
 214     return block;
 215 }
 216
 217 static BOOL fill_delegated_stub_table(IUnknownVtbl *vtbl, DWORD num)
 218 {
 219     const void **entry = (const void **)(vtbl + 1);
 220     DWORD i, j;
 221
 222     if (num - 3 > BLOCK_SIZE * MAX_BLOCKS)
 223     {
 224         FIXME( "%u methods not supported\n", num );
 225         return FALSE;
 226     }
 227     vtbl->QueryInterface = delegating_QueryInterface;
 228     vtbl->AddRef = delegating_AddRef;
 229     vtbl->Release = delegating_Release;
 230     for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
 231     {
 232         const vtbl_method_t *block = method_blocks[i];
 233         if (!block && !(block = allocate_block( i ))) return FALSE;
 234         for (j = 0; j < BLOCK_SIZE && j < num - 3 - i * BLOCK_SIZE; j++) *entry++ = &block[j];
 235     }
 236     return TRUE;
 237 }
 238
 239 BOOL fill_delegated_proxy_table(IUnknownVtbl *vtbl, DWORD num)
 240 {
 241     const void **entry = (const void **)(vtbl + 1);
 242     DWORD i, j;
 243
 244     if (num - 3 > BLOCK_SIZE * MAX_BLOCKS)
 245     {
 246         FIXME( "%u methods not supported\n", num );
 247         return FALSE;
 248     }
 249     vtbl->QueryInterface = IUnknown_QueryInterface_Proxy;
 250     vtbl->AddRef = IUnknown_AddRef_Proxy;
 251     vtbl->Release = IUnknown_Release_Proxy;
 252     for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
 253     {
 254         const vtbl_method_t *block = method_blocks[i];
 255         if (!block && !(block = allocate_block( i ))) return FALSE;
 256         for (j = 0; j < BLOCK_SIZE && j < num - 3 - i * BLOCK_SIZE; j++, entry++)
 257             if (!*entry) *entry = &block[j];
 258     }
 259     return TRUE;
 260 }
 261
 262 static IUnknownVtbl *get_delegating_vtbl(DWORD num_methods)
 263 {
 264     IUnknownVtbl *ret;
 265
 266     if (num_methods < 256) num_methods = 256;  /* avoid frequent reallocations */
 267
 268     EnterCriticalSection(&delegating_vtbl_section);
 269
 270     if(!current_vtbl || num_methods > current_vtbl->size)
 271     {
 272         ref_counted_vtbl *table = HeapAlloc(GetProcessHeap(), 0,
 273                                             FIELD_OFFSET(ref_counted_vtbl, vtbl) + num_methods * sizeof(void*));
 274         if (!table)
 275         {
 276             LeaveCriticalSection(&delegating_vtbl_section);
 277             return NULL;
 278         }
 279
 280         table->ref = 0;
 281         table->size = num_methods;
 282         fill_delegated_stub_table(&table->vtbl, num_methods);
 283
 284         if (current_vtbl && current_vtbl->ref == 0)
 285         {
 286             TRACE("freeing old table\n");
 287             HeapFree(GetProcessHeap(), 0, current_vtbl);
 288         }
 289         current_vtbl = table;
 290     }
 291
 292     current_vtbl->ref++;
 293     ret = &current_vtbl->vtbl;
 294     LeaveCriticalSection(&delegating_vtbl_section);
 295     return ret;
 296 }
 297
 298 static void release_delegating_vtbl(IUnknownVtbl *vtbl)
 299 {
 300     ref_counted_vtbl *table = (ref_counted_vtbl*)((DWORD *)vtbl - 1);
 301
 302     EnterCriticalSection(&delegating_vtbl_section);
 303     table->ref--;
 304     TRACE("ref now %d\n", table->ref);
 305     if(table->ref == 0 && table != current_vtbl)
 306     {
 307         TRACE("... and we're not current so free'ing\n");
 308         HeapFree(GetProcessHeap(), 0, table);
 309     }
 310     LeaveCriticalSection(&delegating_vtbl_section);
 311 }
 312
 313 HRESULT CStdStubBuffer_Delegating_Construct(REFIID riid,
 314                                             LPUNKNOWN pUnkServer,
 315                                             PCInterfaceName name,
 316                                             CInterfaceStubVtbl *vtbl,
 317                                             REFIID delegating_iid,
 318                                             LPPSFACTORYBUFFER pPSFactory,
 319                                             LPRPCSTUBBUFFER *ppStub)
 320 {
 321     cstdstubbuffer_delegating_t *This;
 322     IUnknown *pvServer;
 323     HRESULT r;
 324
 325     TRACE("(%p,%p,%p,%p) %s\n", pUnkServer, vtbl, pPSFactory, ppStub, name);
 326     TRACE("iid=%s delegating to %s\n", debugstr_guid(vtbl->header.piid), debugstr_guid(delegating_iid));
 327     TRACE("vtbl=%p\n", &vtbl->Vtbl);
 328
 329     if (!IsEqualGUID(vtbl->header.piid, riid))
 330     {
 331         ERR("IID mismatch during stub creation\n");
 332         return RPC_E_UNEXPECTED;
 333     }
 334
 335     r = IUnknown_QueryInterface(pUnkServer, riid, (void**)&pvServer);
 336     if(FAILED(r)) return r;
 337
 338     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 339     if (!This)
 340     {
 341         IUnknown_Release(pvServer);
 342         return E_OUTOFMEMORY;
 343     }
 344
 345     This->base_obj = get_delegating_vtbl( vtbl->header.DispatchTableCount );
 346     r = create_stub(delegating_iid, (IUnknown*)&This->base_obj, &This->base_stub);
 347     if(FAILED(r))
 348     {
 349         release_delegating_vtbl(This->base_obj);
 350         HeapFree(GetProcessHeap(), 0, This);
 351         IUnknown_Release(pvServer);
 352         return r;
 353     }
 354
 355     This->stub_buffer.lpVtbl = &vtbl->Vtbl;
 356     This->stub_buffer.RefCount = 1;
 357     This->stub_buffer.pvServerObject = pvServer;
 358     This->stub_buffer.pPSFactory = pPSFactory;
 359     *ppStub = (LPRPCSTUBBUFFER)&This->stub_buffer;
 360
 361     IPSFactoryBuffer_AddRef(pPSFactory);
 362     return S_OK;
 363 }
 364
 365 HRESULT WINAPI CStdStubBuffer_QueryInterface(LPRPCSTUBBUFFER iface,
 366                                             REFIID riid,
 367                                             LPVOID *obj)
 368 {
 369   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 370   TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
 371
 372   if (IsEqualIID(&IID_IUnknown, riid) ||
 373       IsEqualIID(&IID_IRpcStubBuffer, riid))
 374   {
 375     IUnknown_AddRef(iface);
 376     *obj = iface;
 377     return S_OK;
 378   }
 379   *obj = NULL;
 380   return E_NOINTERFACE;
 381 }
 382
 383 ULONG WINAPI CStdStubBuffer_AddRef(LPRPCSTUBBUFFER iface)
 384 {
 385   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 386   TRACE("(%p)->AddRef()\n",This);
 387   return InterlockedIncrement(&This->RefCount);
 388 }
 389
 390 ULONG WINAPI NdrCStdStubBuffer_Release(LPRPCSTUBBUFFER iface,
 391                                       LPPSFACTORYBUFFER pPSF)
 392 {
 393   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 394   ULONG refs;
 395
 396   TRACE("(%p)->Release()\n",This);
 397
 398   refs = InterlockedDecrement(&This->RefCount);
 399   if (!refs)
 400   {
 401     /* test_Release shows that native doesn't call Disconnect here.
 402        We'll leave it in for the time being. */
 403     IRpcStubBuffer_Disconnect(iface);
 404
 405     IPSFactoryBuffer_Release(pPSF);
 406     HeapFree(GetProcessHeap(),0,This);
 407   }
 408   return refs;
 409 }
 410
 411 ULONG WINAPI NdrCStdStubBuffer2_Release(LPRPCSTUBBUFFER iface,
 412                                         LPPSFACTORYBUFFER pPSF)
 413 {
 414     cstdstubbuffer_delegating_t *This = impl_from_delegating( iface );
 415     ULONG refs;
 416
 417     TRACE("(%p)->Release()\n", This);
 418
 419     refs = InterlockedDecrement(&This->stub_buffer.RefCount);
 420     if (!refs)
 421     {
 422         /* Just like NdrCStdStubBuffer_Release, we shouldn't call
 423            Disconnect here */
 424         IRpcStubBuffer_Disconnect((IRpcStubBuffer *)&This->stub_buffer);
 425
 426         IRpcStubBuffer_Release(This->base_stub);
 427         release_delegating_vtbl(This->base_obj);
 428
 429         IPSFactoryBuffer_Release(pPSF);
 430         HeapFree(GetProcessHeap(), 0, This);
 431     }
 432
 433     return refs;
 434 }
 435
 436 HRESULT WINAPI CStdStubBuffer_Connect(LPRPCSTUBBUFFER iface,
 437                                      LPUNKNOWN lpUnkServer)
 438 {
 439     CStdStubBuffer *This = (CStdStubBuffer *)iface;
 440     HRESULT r;
 441     IUnknown *new = NULL;
 442
 443     TRACE("(%p)->Connect(%p)\n",This,lpUnkServer);
 444
 445     r = IUnknown_QueryInterface(lpUnkServer, STUB_HEADER(This).piid, (void**)&new);
 446     new = InterlockedExchangePointer((void**)&This->pvServerObject, new);
 447     if(new)
 448         IUnknown_Release(new);
 449     return r;
 450 }
 451
 452 void WINAPI CStdStubBuffer_Disconnect(LPRPCSTUBBUFFER iface)
 453 {
 454     CStdStubBuffer *This = (CStdStubBuffer *)iface;
 455     IUnknown *old;
 456     TRACE("(%p)->Disconnect()\n",This);
 457
 458     old = InterlockedExchangePointer((void**)&This->pvServerObject, NULL);
 459
 460     if(old)
 461         IUnknown_Release(old);
 462 }
 463
 464 HRESULT WINAPI CStdStubBuffer_Invoke(LPRPCSTUBBUFFER iface,
 465                                     PRPCOLEMESSAGE pMsg,
 466                                     LPRPCCHANNELBUFFER pChannel)
 467 {
 468   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 469   DWORD dwPhase = STUB_UNMARSHAL;
 470   HRESULT hr = S_OK;
 471
 472   TRACE("(%p)->Invoke(%p,%p)\n",This,pMsg,pChannel);
 473
 474   __TRY
 475   {
 476     if (STUB_HEADER(This).pDispatchTable)
 477       STUB_HEADER(This).pDispatchTable[pMsg->iMethod](iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
 478     else /* pure interpreted */
 479       NdrStubCall2(iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
 480   }
 481   __EXCEPT(stub_filter)
 482   {
 483     DWORD dwExceptionCode = GetExceptionCode();
 484     WARN("a stub call failed with exception 0x%08x (%d)\n", dwExceptionCode, dwExceptionCode);
 485     if (FAILED(dwExceptionCode))
 486       hr = dwExceptionCode;
 487     else
 488       hr = HRESULT_FROM_WIN32(dwExceptionCode);
 489   }
 490   __ENDTRY
 491
 492   return hr;
 493 }
 494
 495 LPRPCSTUBBUFFER WINAPI CStdStubBuffer_IsIIDSupported(LPRPCSTUBBUFFER iface,
 496                                                     REFIID riid)
 497 {
 498   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 499   TRACE("(%p)->IsIIDSupported(%s)\n",This,debugstr_guid(riid));
 500   return IsEqualGUID(STUB_HEADER(This).piid, riid) ? iface : NULL;
 501 }
 502
 503 ULONG WINAPI CStdStubBuffer_CountRefs(LPRPCSTUBBUFFER iface)
 504 {
 505   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 506   TRACE("(%p)->CountRefs()\n",This);
 507   return This->RefCount;
 508 }
 509
 510 HRESULT WINAPI CStdStubBuffer_DebugServerQueryInterface(LPRPCSTUBBUFFER iface,
 511                                                        LPVOID *ppv)
 512 {
 513   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 514   TRACE("(%p)->DebugServerQueryInterface(%p)\n",This,ppv);
 515   return S_OK;
 516 }
 517
 518 void WINAPI CStdStubBuffer_DebugServerRelease(LPRPCSTUBBUFFER iface,
 519                                              LPVOID pv)
 520 {
 521   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 522   TRACE("(%p)->DebugServerRelease(%p)\n",This,pv);
 523 }
 524
 525 const IRpcStubBufferVtbl CStdStubBuffer_Vtbl =
 526 {
 527     CStdStubBuffer_QueryInterface,
 528     CStdStubBuffer_AddRef,
 529     NULL,
 530     CStdStubBuffer_Connect,
 531     CStdStubBuffer_Disconnect,
 532     CStdStubBuffer_Invoke,
 533     CStdStubBuffer_IsIIDSupported,
 534     CStdStubBuffer_CountRefs,
 535     CStdStubBuffer_DebugServerQueryInterface,
 536     CStdStubBuffer_DebugServerRelease
 537 };
 538
 539 static HRESULT WINAPI CStdStubBuffer_Delegating_Connect(LPRPCSTUBBUFFER iface,
 540                                                         LPUNKNOWN lpUnkServer)
 541 {
 542     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
 543     HRESULT r;
 544     TRACE("(%p)->Connect(%p)\n", This, lpUnkServer);
 545
 546     r = CStdStubBuffer_Connect(iface, lpUnkServer);
 547     if(SUCCEEDED(r))
 548         r = IRpcStubBuffer_Connect(This->base_stub, (IUnknown*)&This->base_obj);
 549
 550     return r;
 551 }
 552
 553 static void WINAPI CStdStubBuffer_Delegating_Disconnect(LPRPCSTUBBUFFER iface)
 554 {
 555     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
 556     TRACE("(%p)->Disconnect()\n", This);
 557
 558     IRpcStubBuffer_Disconnect(This->base_stub);
 559     CStdStubBuffer_Disconnect(iface);
 560 }
 561
 562 static ULONG WINAPI CStdStubBuffer_Delegating_CountRefs(LPRPCSTUBBUFFER iface)
 563 {
 564     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
 565     ULONG ret;
 566     TRACE("(%p)->CountRefs()\n", This);
 567
 568     ret = CStdStubBuffer_CountRefs(iface);
 569     ret += IRpcStubBuffer_CountRefs(This->base_stub);
 570
 571     return ret;
 572 }
 573
 574 const IRpcStubBufferVtbl CStdStubBuffer_Delegating_Vtbl =
 575 {
 576     CStdStubBuffer_QueryInterface,
 577     CStdStubBuffer_AddRef,
 578     NULL,
 579     CStdStubBuffer_Delegating_Connect,
 580     CStdStubBuffer_Delegating_Disconnect,
 581     CStdStubBuffer_Invoke,
 582     CStdStubBuffer_IsIIDSupported,
 583     CStdStubBuffer_Delegating_CountRefs,
 584     CStdStubBuffer_DebugServerQueryInterface,
 585     CStdStubBuffer_DebugServerRelease
 586 };
 587
 588 const MIDL_SERVER_INFO *CStdStubBuffer_GetServerInfo(IRpcStubBuffer *iface)
 589 {
 590   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 591   return STUB_HEADER(This).pServerInfo;
 592 }
 593
 594 /************************************************************************
 595  *           NdrStubForwardingFunction [RPCRT4.@]
 596  */
 597 void __RPC_STUB NdrStubForwardingFunction( IRpcStubBuffer *iface, IRpcChannelBuffer *pChannel,
 598                                            PRPC_MESSAGE pMsg, DWORD *pdwStubPhase )
 599 {
 600     /* Note pMsg is passed intact since RPCOLEMESSAGE is basically a RPC_MESSAGE. */
 601
 602     cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
 603     HRESULT r = IRpcStubBuffer_Invoke(This->base_stub, (RPCOLEMESSAGE*)pMsg, pChannel);
 604     if(FAILED(r)) RpcRaiseException(r);
 605     return;
 606 }
 607
 608 /***********************************************************************
 609  *           NdrStubInitialize [RPCRT4.@]
 610  */
 611 void WINAPI NdrStubInitialize(PRPC_MESSAGE pRpcMsg,
 612                              PMIDL_STUB_MESSAGE pStubMsg,
 613                              PMIDL_STUB_DESC pStubDescriptor,
 614                              LPRPCCHANNELBUFFER pRpcChannelBuffer)
 615 {
 616   TRACE("(%p,%p,%p,%p)\n", pRpcMsg, pStubMsg, pStubDescriptor, pRpcChannelBuffer);
 617   NdrServerInitializeNew(pRpcMsg, pStubMsg, pStubDescriptor);
 618   pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
 619   IRpcChannelBuffer_GetDestCtx(pStubMsg->pRpcChannelBuffer,
 620                                &pStubMsg->dwDestContext,
 621                                &pStubMsg->pvDestContext);
 622 }
 623
 624 /***********************************************************************
 625  *           NdrStubGetBuffer [RPCRT4.@]
 626  */
 627 void WINAPI NdrStubGetBuffer(LPRPCSTUBBUFFER iface,
 628                             LPRPCCHANNELBUFFER pRpcChannelBuffer,
 629                             PMIDL_STUB_MESSAGE pStubMsg)
 630 {
 631   CStdStubBuffer *This = (CStdStubBuffer *)iface;
 632   HRESULT hr;
 633
 634   TRACE("(%p, %p, %p)\n", This, pRpcChannelBuffer, pStubMsg);
 635
 636   pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
 637   hr = IRpcChannelBuffer_GetBuffer(pRpcChannelBuffer,
 638     (RPCOLEMESSAGE *)pStubMsg->RpcMsg, STUB_HEADER(This).piid);
 639   if (FAILED(hr))
 640   {
 641     RpcRaiseException(hr);
 642     return;
 643   }
 644
 645   pStubMsg->Buffer = pStubMsg->RpcMsg->Buffer;
 646 }