dlls/ole32/oleproxy.c

   1 /*
   2  *      OLE32 proxy/stub handler
   3  *
   4  *  Copyright 2002  Marcus Meissner
   5  *  Copyright 2001  Ove Kåven, TransGaming Technologies
   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 /* Documentation on MSDN:
  23  *
  24  * (Top level COM documentation)
  25  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnanchor/html/componentdevelopmentank.asp
  26  *
  27  * (COM Proxy)
  28  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1q0p.asp
  29  *
  30  * (COM Stub)
  31  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1lia.asp
  32  *
  33  * (Marshal)
  34  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1gfn.asp
  35  *
  36  */
  37
  38 #include "config.h"
  39
  40 #include <stdlib.h>
  41 #include <stdarg.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44
  45 #define COBJMACROS
  46 #define NONAMELESSUNION
  47 #define NONAMELESSSTRUCT
  48
  49 #include "windef.h"
  50 #include "winbase.h"
  51 #include "winuser.h"
  52 #include "objbase.h"
  53 #include "ole2.h"
  54 #include "rpc.h"
  55 #include "winerror.h"
  56 #include "winreg.h"
  57 #include "wtypes.h"
  58
  59 #include "compobj_private.h"
  60 #include "moniker.h"
  61
  62 #include "comcat.h" /* FOR HACK BELOW */
  63
  64 #include "wine/debug.h"
  65
  66 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  67
  68 #if 0
  69
  70 static ULONG WINAPI RURpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface);
  71
  72 /* From: http://msdn.microsoft.com/library/en-us/com/cmi_m_4lda.asp
  73  *
  74  * The first time a client requests a pointer to an interface on a
  75  * particular object, COM loads an IClassFactory stub in the server
  76  * process and uses it to marshal the first pointer back to the
  77  * client. In the client process, COM loads the generic proxy for the
  78  * class factory object and calls its implementation of IMarshal to
  79  * unmarshal that first pointer. COM then creates the first interface
  80  * proxy and hands it a pointer to the RPC channel. Finally, COM returns
  81  * the IClassFactory pointer to the client, which uses it to call
  82  * IClassFactory::CreateInstance, passing it a reference to the interface.
  83  *
  84  * Back in the server process, COM now creates a new instance of the
  85  * object, along with a stub for the requested interface. This stub marshals
  86  * the interface pointer back to the client process, where another object
  87  * proxy is created, this time for the object itself. Also created is a
  88  * proxy for the requested interface, a pointer to which is returned to
  89  * the client. With subsequent calls to other interfaces on the object,
  90  * COM will load the appropriate interface stubs and proxies as needed.
  91  */
  92 typedef struct _CFStub {
  93     const IRpcStubBufferVtbl   *lpvtbl;
  94     LONG                        ref;
  95
  96     LPUNKNOWN                   pUnkServer;
  97 } CFStub;
  98
  99 static HRESULT WINAPI
 100 CFStub_QueryInterface(LPRPCSTUBBUFFER iface, REFIID riid, LPVOID *ppv) {
 101     if (IsEqualIID(&IID_IUnknown,riid)||IsEqualIID(&IID_IRpcStubBuffer,riid)) {
 102         *ppv = (LPVOID)iface;
 103         IUnknown_AddRef(iface);
 104         return S_OK;
 105     }
 106     FIXME("(%s), interface not supported.\n",debugstr_guid(riid));
 107     return E_NOINTERFACE;
 108 }
 109
 110 static ULONG WINAPI
 111 CFStub_AddRef(LPRPCSTUBBUFFER iface) {
 112     CFStub *This = (CFStub *)iface;
 113     return InterlockedIncrement(&This->ref);
 114 }
 115
 116 static ULONG WINAPI
 117 CFStub_Release(LPRPCSTUBBUFFER iface) {
 118     CFStub *This = (CFStub *)iface;
 119     ULONG ref;
 120
 121     ref = InterlockedDecrement(&This->ref);
 122     if (!ref) {
 123         IRpcStubBuffer_Disconnect(iface);
 124         HeapFree(GetProcessHeap(),0,This);
 125     }
 126     return ref;
 127 }
 128
 129 static HRESULT WINAPI
 130 CFStub_Connect(LPRPCSTUBBUFFER iface, IUnknown *pUnkServer) {
 131     CFStub *This = (CFStub *)iface;
 132
 133     This->pUnkServer = pUnkServer;
 134     IUnknown_AddRef(pUnkServer);
 135     return S_OK;
 136 }
 137
 138 static void WINAPI
 139 CFStub_Disconnect(LPRPCSTUBBUFFER iface) {
 140     CFStub *This = (CFStub *)iface;
 141
 142     if (This->pUnkServer) {
 143         IUnknown_Release(This->pUnkServer);
 144         This->pUnkServer = NULL;
 145     }
 146 }
 147
 148 static HRESULT WINAPI
 149 CFStub_Invoke(
 150     LPRPCSTUBBUFFER iface,RPCOLEMESSAGE* msg,IRpcChannelBuffer* chanbuf
 151 ) {
 152     CFStub *This = (CFStub *)iface;
 153     HRESULT hres;
 154
 155     if (msg->iMethod == 3) { /* CreateInstance */
 156         IID iid;
 157         IClassFactory   *classfac;
 158         IUnknown        *ppv;
 159         IStream         *pStm;
 160         STATSTG         ststg;
 161         ULARGE_INTEGER  newpos;
 162         LARGE_INTEGER   seekto;
 163         ULONG           res;
 164
 165         if (msg->cbBuffer < sizeof(IID)) {
 166             FIXME("Not enough bytes in buffer (%d)?\n",msg->cbBuffer);
 167             return E_FAIL;
 168         }
 169         memcpy(&iid,msg->Buffer,sizeof(iid));
 170         TRACE("->CreateInstance(%s)\n",debugstr_guid(&iid));
 171         hres = IUnknown_QueryInterface(This->pUnkServer,&IID_IClassFactory,(LPVOID*)&classfac);
 172         if (hres) {
 173             FIXME("Ole server does not provide an IClassFactory?\n");
 174             return hres;
 175         }
 176         hres = IClassFactory_CreateInstance(classfac,NULL,&iid,(LPVOID*)&ppv);
 177         IClassFactory_Release(classfac);
 178         msg->cbBuffer = 0;
 179         if (hres) {
 180             FIXME("Failed to create an instance of %s\n",debugstr_guid(&iid));
 181             goto getbuffer;
 182         }
 183         hres = CreateStreamOnHGlobal(0,TRUE,&pStm);
 184         if (hres) {
 185             FIXME("Failed to create stream on hglobal\n");
 186             goto getbuffer;
 187         }
 188         hres = IStream_Write(pStm, &ppv, sizeof(ppv), NULL);
 189         if (hres) {
 190            ERR("IStream_Write failed, 0x%08x\n", hres);
 191            goto getbuffer;
 192         }
 193         if (ppv) {
 194         hres = CoMarshalInterface(pStm,&iid,ppv,0,NULL,0);
 195         IUnknown_Release(ppv);
 196         if (hres) {
 197             FIXME("CoMarshalInterface failed, %x!\n",hres);
 198             goto getbuffer;
 199         }
 200     }
 201         hres = IStream_Stat(pStm,&ststg,0);
 202         if (hres) {
 203             FIXME("Stat failed.\n");
 204             goto getbuffer;
 205         }
 206
 207         msg->cbBuffer = ststg.cbSize.u.LowPart;
 208
 209 getbuffer:
 210         IRpcChannelBuffer_GetBuffer(chanbuf, msg, &IID_IClassFactory);
 211         if (hres) return hres;
 212
 213         seekto.u.LowPart = 0;seekto.u.HighPart = 0;
 214         hres = IStream_Seek(pStm,seekto,SEEK_SET,&newpos);
 215         if (hres) {
 216             FIXME("IStream_Seek failed, %x\n",hres);
 217             return hres;
 218         }
 219         hres = IStream_Read(pStm,msg->Buffer,msg->cbBuffer,&res);
 220         if (hres) {
 221             FIXME("Stream Read failed, %x\n",hres);
 222             return hres;
 223         }
 224         IStream_Release(pStm);
 225         return S_OK;
 226     }
 227     FIXME("(%p,%p), stub!\n",msg,chanbuf);
 228     FIXME("iMethod is %d\n",msg->iMethod);
 229     FIXME("cbBuffer is %d\n",msg->cbBuffer);
 230     return E_FAIL;
 231 }
 232
 233 static LPRPCSTUBBUFFER WINAPI
 234 CFStub_IsIIDSupported(LPRPCSTUBBUFFER iface,REFIID riid) {
 235     FIXME("(%s), stub!\n",debugstr_guid(riid));
 236     return NULL;
 237 }
 238
 239 static ULONG WINAPI
 240 CFStub_CountRefs(LPRPCSTUBBUFFER iface) {
 241     FIXME("(), stub!\n");
 242     return 1;
 243 }
 244
 245 static HRESULT WINAPI
 246 CFStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface,void** ppv) {
 247     FIXME("(%p), stub!\n",ppv);
 248     return E_FAIL;
 249 }
 250 static void    WINAPI
 251 CFStub_DebugServerRelease(LPRPCSTUBBUFFER iface,void *pv) {
 252     FIXME("(%p), stub!\n",pv);
 253 }
 254
 255 static const IRpcStubBufferVtbl cfstubvt = {
 256     CFStub_QueryInterface,
 257     CFStub_AddRef,
 258     CFStub_Release,
 259     CFStub_Connect,
 260     CFStub_Disconnect,
 261     CFStub_Invoke,
 262     CFStub_IsIIDSupported,
 263     CFStub_CountRefs,
 264     CFStub_DebugServerQueryInterface,
 265     CFStub_DebugServerRelease
 266 };
 267
 268 static HRESULT
 269 CFStub_Construct(LPRPCSTUBBUFFER *ppv) {
 270     CFStub *cfstub;
 271     cfstub = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CFStub));
 272     if (!cfstub)
 273         return E_OUTOFMEMORY;
 274     *ppv = (LPRPCSTUBBUFFER)cfstub;
 275     cfstub->lpvtbl      = &cfstubvt;
 276     cfstub->ref         = 1;
 277     return S_OK;
 278 }
 279
 280 /* Since we create proxy buffers and classfactory in a pair, there is
 281  * no need for 2 separate structs. Just put them in one, but remember
 282  * the refcount.
 283  */
 284 typedef struct _CFProxy {
 285     const IClassFactoryVtbl             *lpvtbl_cf;
 286     const IRpcProxyBufferVtbl   *lpvtbl_proxy;
 287     LONG                                ref;
 288
 289     IRpcChannelBuffer                   *chanbuf;
 290     IUnknown *outer_unknown;
 291 } CFProxy;
 292
 293 static HRESULT WINAPI IRpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface,REFIID riid,LPVOID *ppv) {
 294     *ppv = NULL;
 295     if (IsEqualIID(riid,&IID_IRpcProxyBuffer)||IsEqualIID(riid,&IID_IUnknown)) {
 296         IRpcProxyBuffer_AddRef(iface);
 297         *ppv = (LPVOID)iface;
 298         return S_OK;
 299     }
 300     FIXME("(%s), no interface.\n",debugstr_guid(riid));
 301     return E_NOINTERFACE;
 302 }
 303
 304 static ULONG WINAPI IRpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface) {
 305     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 306     return InterlockedIncrement(&This->ref);
 307 }
 308
 309 static ULONG WINAPI IRpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface) {
 310     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 311     ULONG ref = InterlockedDecrement(&This->ref);
 312
 313     if (!ref) {
 314         IRpcProxyBuffer_Disconnect(iface);
 315         HeapFree(GetProcessHeap(),0,This);
 316     }
 317     return ref;
 318 }
 319
 320 static HRESULT WINAPI IRpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface,IRpcChannelBuffer* pRpcChannelBuffer) {
 321     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 322
 323     This->chanbuf = pRpcChannelBuffer;
 324     IRpcChannelBuffer_AddRef(This->chanbuf);
 325     return S_OK;
 326 }
 327 static void WINAPI IRpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface) {
 328     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 329     if (This->chanbuf) {
 330         IRpcChannelBuffer_Release(This->chanbuf);
 331         This->chanbuf = NULL;
 332     }
 333 }
 334
 335 static HRESULT WINAPI
 336 CFProxy_QueryInterface(LPCLASSFACTORY iface,REFIID riid, LPVOID *ppv) {
 337     ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);
 338     if (This->outer_unknown) return IUnknown_QueryInterface(This->outer_unknown, riid, ppv);
 339     *ppv = NULL;
 340     if (IsEqualIID(&IID_IClassFactory,riid) || IsEqualIID(&IID_IUnknown,riid)) {
 341         *ppv = (LPVOID)iface;
 342         IClassFactory_AddRef(iface);
 343         return S_OK;
 344     }
 345     if (IsEqualIID(riid,&IID_IMarshal)) /* just to avoid debug output */
 346         return E_NOINTERFACE;
 347     FIXME("Unhandled interface: %s\n",debugstr_guid(riid));
 348     return E_NOINTERFACE;
 349 }
 350
 351 static ULONG   WINAPI CFProxy_AddRef(LPCLASSFACTORY iface) {
 352     ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);
 353     if (This->outer_unknown) return IUnknown_AddRef(This->outer_unknown);
 354     return InterlockedIncrement(&This->ref);
 355 }
 356
 357 static ULONG   WINAPI CFProxy_Release(LPCLASSFACTORY iface) {
 358     ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);
 359     if (This->outer_unknown)
 360         return IUnknown_Release(This->outer_unknown);
 361     else
 362         return IRpcProxyBufferImpl_Release((IRpcProxyBuffer *)&This->lpvtbl_proxy);
 363 }
 364
 365 static HRESULT WINAPI CFProxy_CreateInstance(
 366     LPCLASSFACTORY iface,
 367     LPUNKNOWN pUnkOuter,/* [in] */
 368     REFIID riid,        /* [in] */
 369     LPVOID *ppv         /* [out] */
 370 ) {
 371     ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);
 372     HRESULT             hres;
 373     LPSTREAM            pStream;
 374     HGLOBAL             hGlobal;
 375     ULONG               srstatus;
 376     RPCOLEMESSAGE       msg;
 377
 378     TRACE("(%p,%s,%p)\n",pUnkOuter,debugstr_guid(riid),ppv);
 379
 380     /* Send CreateInstance to the remote classfactory.
 381      *
 382      * Data: Only the 'IID'.
 383      */
 384     msg.iMethod  = 3;
 385     msg.cbBuffer = sizeof(*riid);
 386     msg.Buffer   = NULL;
 387     hres = IRpcChannelBuffer_GetBuffer(This->chanbuf,&msg,&IID_IClassFactory);
 388     if (hres) {
 389         FIXME("IRpcChannelBuffer_GetBuffer failed with %x?\n",hres);
 390         return hres;
 391     }
 392     memcpy(msg.Buffer,riid,sizeof(*riid));
 393     hres = IRpcChannelBuffer_SendReceive(This->chanbuf,&msg,&srstatus);
 394     if (hres) {
 395         FIXME("IRpcChannelBuffer_SendReceive failed with %x?\n",hres);
 396         IRpcChannelBuffer_FreeBuffer(This->chanbuf,&msg);
 397         return hres;
 398     }
 399
 400     if (!msg.cbBuffer) { /* interface not found on remote */
 401         IRpcChannelBuffer_FreeBuffer(This->chanbuf,&msg);
 402         return srstatus;
 403     }
 404
 405     /* We got back: [Marshalled Interface data] */
 406     TRACE("got %d bytes data.\n",msg.cbBuffer);
 407     hGlobal = GlobalAlloc(GMEM_MOVEABLE|GMEM_NODISCARD|GMEM_SHARE,msg.cbBuffer);
 408     memcpy(GlobalLock(hGlobal),msg.Buffer,msg.cbBuffer);
 409     hres = CreateStreamOnHGlobal(hGlobal,TRUE,&pStream);
 410     if (hres) {
 411         FIXME("CreateStreamOnHGlobal failed with %x\n",hres);
 412         IRpcChannelBuffer_FreeBuffer(This->chanbuf,&msg);
 413         return hres;
 414     }
 415     hres = IStream_Read(pStream, ppv, sizeof(*ppv), NULL);
 416     if (hres != S_OK)
 417         hres = E_FAIL;
 418     else if (*ppv) {
 419         hres = CoUnmarshalInterface(
 420                pStream,
 421                riid,
 422                ppv
 423         );
 424     }
 425     IStream_Release(pStream); /* Does GlobalFree hGlobal too. */
 426
 427     IRpcChannelBuffer_FreeBuffer(This->chanbuf,&msg);
 428
 429     if (hres) {
 430         FIXME("CoMarshalInterface failed, %x\n",hres);
 431         return hres;
 432     }
 433     return S_OK;
 434 }
 435
 436 static HRESULT WINAPI CFProxy_LockServer(LPCLASSFACTORY iface,BOOL fLock) {
 437     /*ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);*/
 438     FIXME("(%d), stub!\n",fLock);
 439     /* basically: write BOOL, read empty */
 440     return S_OK;
 441 }
 442
 443 static const IRpcProxyBufferVtbl pspbvtbl = {
 444     IRpcProxyBufferImpl_QueryInterface,
 445     IRpcProxyBufferImpl_AddRef,
 446     IRpcProxyBufferImpl_Release,
 447     IRpcProxyBufferImpl_Connect,
 448     IRpcProxyBufferImpl_Disconnect
 449 };
 450 static const IClassFactoryVtbl cfproxyvt = {
 451     CFProxy_QueryInterface,
 452     CFProxy_AddRef,
 453     CFProxy_Release,
 454     CFProxy_CreateInstance,
 455     CFProxy_LockServer
 456 };
 457
 458 static HRESULT
 459 CFProxy_Construct(IUnknown *pUnkOuter, LPVOID *ppv,LPVOID *ppProxy) {
 460     CFProxy *cf;
 461
 462     cf = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CFProxy));
 463     if (!cf)
 464         return E_OUTOFMEMORY;
 465
 466     cf->lpvtbl_cf       = &cfproxyvt;
 467     cf->lpvtbl_proxy    = &pspbvtbl;
 468     /* one reference for the proxy buffer */
 469     cf->ref             = 1;
 470     cf->outer_unknown = pUnkOuter;
 471     *ppv                = &(cf->lpvtbl_cf);
 472     *ppProxy            = &(cf->lpvtbl_proxy);
 473     /* and one reference for the object */
 474     IUnknown_AddRef((IUnknown *)*ppv);
 475     return S_OK;
 476 }
 477
 478
 479 /********************* IRemUnknown Proxy/Stub ********************************/
 480
 481 typedef struct
 482 {
 483     const IRpcStubBufferVtbl *lpVtbl;
 484     LONG refs;
 485     IRemUnknown *iface;
 486 } RemUnkStub;
 487
 488 static HRESULT WINAPI RemUnkStub_QueryInterface(LPRPCSTUBBUFFER iface,
 489                                              REFIID riid,
 490                                              LPVOID *obj)
 491 {
 492   RemUnkStub *This = (RemUnkStub *)iface;
 493   TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
 494   if (IsEqualGUID(&IID_IUnknown,riid) ||
 495       IsEqualGUID(&IID_IRpcStubBuffer,riid)) {
 496     *obj = This;
 497     return S_OK;
 498   }
 499   return E_NOINTERFACE;
 500 }
 501
 502 static ULONG WINAPI RemUnkStub_AddRef(LPRPCSTUBBUFFER iface)
 503 {
 504   RemUnkStub *This = (RemUnkStub *)iface;
 505   TRACE("(%p)->AddRef()\n",This);
 506   return InterlockedIncrement(&This->refs);
 507 }
 508
 509 static ULONG WINAPI RemUnkStub_Release(LPRPCSTUBBUFFER iface)
 510 {
 511   RemUnkStub *This = (RemUnkStub *)iface;
 512   ULONG refs;
 513   TRACE("(%p)->Release()\n",This);
 514   refs = InterlockedDecrement(&This->refs);
 515   if (!refs)
 516     HeapFree(GetProcessHeap(), 0, This);
 517   return refs;
 518 }
 519
 520 static HRESULT WINAPI RemUnkStub_Connect(LPRPCSTUBBUFFER iface,
 521                                       LPUNKNOWN lpUnkServer)
 522 {
 523   RemUnkStub *This = (RemUnkStub *)iface;
 524   TRACE("(%p)->Connect(%p)\n",This,lpUnkServer);
 525   This->iface = (IRemUnknown*)lpUnkServer;
 526   IRemUnknown_AddRef(This->iface);
 527   return S_OK;
 528 }
 529
 530 static void WINAPI RemUnkStub_Disconnect(LPRPCSTUBBUFFER iface)
 531 {
 532   RemUnkStub *This = (RemUnkStub *)iface;
 533   TRACE("(%p)->Disconnect()\n",This);
 534   IUnknown_Release(This->iface);
 535   This->iface = NULL;
 536 }
 537
 538 static HRESULT WINAPI RemUnkStub_Invoke(LPRPCSTUBBUFFER iface,
 539                                      PRPCOLEMESSAGE pMsg,
 540                                      LPRPCCHANNELBUFFER pChannel)
 541 {
 542   RemUnkStub *This = (RemUnkStub *)iface;
 543   ULONG iMethod = pMsg->iMethod;
 544   LPBYTE buf = pMsg->Buffer;
 545   HRESULT hr = RPC_E_INVALIDMETHOD;
 546
 547   TRACE("(%p)->Invoke(%p,%p) method %d\n", This, pMsg, pChannel, iMethod);
 548   switch (iMethod)
 549   {
 550   case 3: /* RemQueryInterface */
 551   {
 552     IPID ipid;
 553     ULONG cRefs;
 554     USHORT cIids;
 555     IID *iids;
 556     REMQIRESULT *pQIResults = NULL;
 557
 558     /* in */
 559     memcpy(&ipid, buf, sizeof(ipid));
 560     buf += sizeof(ipid);
 561     memcpy(&cRefs, buf, sizeof(cRefs));
 562     buf += sizeof(cRefs);
 563     memcpy(&cIids, buf, sizeof(cIids));
 564     buf += sizeof(cIids);
 565     iids = (IID *)buf;
 566
 567     hr = IRemUnknown_RemQueryInterface(This->iface, &ipid, cRefs, cIids, iids, &pQIResults);
 568
 569     /* out */
 570     pMsg->cbBuffer = cIids * sizeof(REMQIRESULT) + sizeof(HRESULT);
 571
 572     IRpcChannelBuffer_GetBuffer(pChannel, pMsg, &IID_IRemUnknown);
 573
 574     buf = pMsg->Buffer;
 575     *(HRESULT *)buf = hr;
 576     buf += sizeof(HRESULT);
 577
 578     if (hr) return hr;
 579     /* FIXME: pQIResults is a unique pointer so pQIResults can be NULL! */
 580     memcpy(buf, pQIResults, cIids * sizeof(REMQIRESULT));
 581
 582     break;
 583   }
 584   case 4: /* RemAddRef */
 585   {
 586     USHORT cIids;
 587     REMINTERFACEREF *ir;
 588     HRESULT *pResults;
 589
 590     /* in */
 591     memcpy(&cIids, buf, sizeof(USHORT));
 592     buf += sizeof(USHORT);
 593     ir = (REMINTERFACEREF*)buf;
 594     pResults = CoTaskMemAlloc(cIids * sizeof(HRESULT));
 595     if (!pResults) return E_OUTOFMEMORY;
 596
 597     hr = IRemUnknown_RemAddRef(This->iface, cIids, ir, pResults);
 598
 599     /* out */
 600     pMsg->cbBuffer = cIids * sizeof(HRESULT);
 601
 602     IRpcChannelBuffer_GetBuffer(pChannel, pMsg, &IID_IRemUnknown);
 603     if (!hr)
 604     {
 605         buf = pMsg->Buffer;
 606         memcpy(buf, pResults, cIids * sizeof(HRESULT));
 607     }
 608
 609     CoTaskMemFree(pResults);
 610
 611     break;
 612   }
 613   case 5: /* RemRelease */
 614   {
 615     USHORT cIids;
 616     REMINTERFACEREF *ir;
 617
 618     /* in */
 619     memcpy(&cIids, buf, sizeof(USHORT));
 620     buf += sizeof(USHORT);
 621     ir = (REMINTERFACEREF*)buf;
 622
 623     hr = IRemUnknown_RemRelease(This->iface, cIids, ir);
 624
 625     /* out */
 626     pMsg->cbBuffer = 0;
 627     IRpcChannelBuffer_GetBuffer(pChannel, pMsg, &IID_IRemUnknown);
 628     break;
 629   }
 630   }
 631   return hr;
 632 }
 633
 634 static LPRPCSTUBBUFFER WINAPI RemUnkStub_IsIIDSupported(LPRPCSTUBBUFFER iface,
 635                                                      REFIID riid)
 636 {
 637   RemUnkStub *This = (RemUnkStub *)iface;
 638   TRACE("(%p)->IsIIDSupported(%s)\n", This, debugstr_guid(riid));
 639   return IsEqualGUID(&IID_IRemUnknown, riid) ? iface : NULL;
 640 }
 641
 642 static ULONG WINAPI RemUnkStub_CountRefs(LPRPCSTUBBUFFER iface)
 643 {
 644   RemUnkStub *This = (RemUnkStub *)iface;
 645   FIXME("(%p)->CountRefs()\n", This);
 646   return 1;
 647 }
 648
 649 static HRESULT WINAPI RemUnkStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface,
 650                                                         LPVOID *ppv)
 651 {
 652   RemUnkStub *This = (RemUnkStub *)iface;
 653   FIXME("(%p)->DebugServerQueryInterface(%p)\n",This,ppv);
 654   return E_NOINTERFACE;
 655 }
 656
 657 static void WINAPI RemUnkStub_DebugServerRelease(LPRPCSTUBBUFFER iface,
 658                                               LPVOID pv)
 659 {
 660   RemUnkStub *This = (RemUnkStub *)iface;
 661   FIXME("(%p)->DebugServerRelease(%p)\n", This, pv);
 662 }
 663
 664 static const IRpcStubBufferVtbl RemUnkStub_VTable =
 665 {
 666   RemUnkStub_QueryInterface,
 667   RemUnkStub_AddRef,
 668   RemUnkStub_Release,
 669   RemUnkStub_Connect,
 670   RemUnkStub_Disconnect,
 671   RemUnkStub_Invoke,
 672   RemUnkStub_IsIIDSupported,
 673   RemUnkStub_CountRefs,
 674   RemUnkStub_DebugServerQueryInterface,
 675   RemUnkStub_DebugServerRelease
 676 };
 677
 678 static HRESULT RemUnkStub_Construct(IRpcStubBuffer **ppStub)
 679 {
 680     RemUnkStub *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 681     if (!This) return E_OUTOFMEMORY;
 682     This->lpVtbl = &RemUnkStub_VTable;
 683     This->refs = 1;
 684     This->iface = NULL;
 685     *ppStub = (IRpcStubBuffer*)This;
 686     return S_OK;
 687 }
 688
 689
 690 typedef struct _RemUnkProxy {
 691     const IRemUnknownVtbl               *lpvtbl_remunk;
 692     const IRpcProxyBufferVtbl   *lpvtbl_proxy;
 693     LONG                                refs;
 694
 695     IRpcChannelBuffer                   *chan;
 696     IUnknown *outer_unknown;
 697 } RemUnkProxy;
 698
 699 static HRESULT WINAPI RemUnkProxy_QueryInterface(LPREMUNKNOWN iface, REFIID riid, void **ppv)
 700 {
 701     RemUnkProxy *This = (RemUnkProxy *)iface;
 702     if (This->outer_unknown)
 703         return IUnknown_QueryInterface(This->outer_unknown, riid, ppv);
 704     if (IsEqualIID(riid, &IID_IUnknown) ||
 705         IsEqualIID(riid, &IID_IRemUnknown))
 706     {
 707         IRemUnknown_AddRef(iface);
 708         *ppv = (LPVOID)iface;
 709         return S_OK;
 710     }
 711     return E_NOINTERFACE;
 712 }
 713
 714 static ULONG WINAPI RemUnkProxy_AddRef(LPREMUNKNOWN iface)
 715 {
 716   RemUnkProxy *This = (RemUnkProxy *)iface;
 717   ULONG refs;
 718
 719   TRACE("(%p)->AddRef()\n",This);
 720
 721   if (This->outer_unknown)
 722       refs = IUnknown_AddRef(This->outer_unknown);
 723   else
 724       refs = InterlockedIncrement(&This->refs);
 725   return refs;
 726 }
 727
 728 static ULONG WINAPI RemUnkProxy_Release(LPREMUNKNOWN iface)
 729 {
 730   RemUnkProxy *This = (RemUnkProxy *)iface;
 731
 732   TRACE("(%p)->Release()\n",This);
 733   if (This->outer_unknown)
 734       return IUnknown_Release(This->outer_unknown);
 735   else
 736       return IRpcProxyBufferImpl_Release((IRpcProxyBuffer *)&This->lpvtbl_proxy);
 737 }
 738
 739 static HRESULT WINAPI RemUnkProxy_RemQueryInterface(LPREMUNKNOWN iface,
 740                                                  REFIPID ripid,
 741                                                  ULONG cRefs,
 742                                                  USHORT cIids,
 743                                                  IID* iids,
 744                                                  REMQIRESULT** ppQIResults)
 745 {
 746   RemUnkProxy *This = (RemUnkProxy *)iface;
 747   RPCOLEMESSAGE msg;
 748   HRESULT hr = S_OK;
 749   ULONG status;
 750
 751   TRACE("(%p)->(%s,%d,%d,%p,%p)\n",This,
 752         debugstr_guid(ripid),cRefs,cIids,iids,ppQIResults);
 753
 754   *ppQIResults = NULL;
 755   memset(&msg, 0, sizeof(msg));
 756   msg.iMethod = 3;
 757   msg.cbBuffer = sizeof(IPID) + sizeof(ULONG) +
 758     sizeof(USHORT) + cIids*sizeof(IID);
 759   hr = IRpcChannelBuffer_GetBuffer(This->chan, &msg, &IID_IRemUnknown);
 760   if (SUCCEEDED(hr)) {
 761     LPBYTE buf = msg.Buffer;
 762     memcpy(buf, ripid, sizeof(IPID));
 763     buf += sizeof(IPID);
 764     memcpy(buf, &cRefs, sizeof(ULONG));
 765     buf += sizeof(ULONG);
 766     memcpy(buf, &cIids, sizeof(USHORT));
 767     buf += sizeof(USHORT);
 768     memcpy(buf, iids, cIids*sizeof(IID));
 769
 770     hr = IRpcChannelBuffer_SendReceive(This->chan, &msg, &status);
 771
 772     buf = msg.Buffer;
 773
 774     if (SUCCEEDED(hr)) {
 775         hr = *(HRESULT *)buf;
 776         buf += sizeof(HRESULT);
 777     }
 778
 779     if (SUCCEEDED(hr)) {
 780       *ppQIResults = CoTaskMemAlloc(cIids*sizeof(REMQIRESULT));
 781       memcpy(*ppQIResults, buf, cIids*sizeof(REMQIRESULT));
 782     }
 783
 784     IRpcChannelBuffer_FreeBuffer(This->chan, &msg);
 785   }
 786
 787   return hr;
 788 }
 789
 790 static HRESULT WINAPI RemUnkProxy_RemAddRef(LPREMUNKNOWN iface,
 791                                          USHORT cInterfaceRefs,
 792                                          REMINTERFACEREF* InterfaceRefs,
 793                                          HRESULT* pResults)
 794 {
 795   RemUnkProxy *This = (RemUnkProxy *)iface;
 796   RPCOLEMESSAGE msg;
 797   HRESULT hr = S_OK;
 798   ULONG status;
 799
 800   TRACE("(%p)->(%d,%p,%p)\n",This,
 801         cInterfaceRefs,InterfaceRefs,pResults);
 802
 803   memset(&msg, 0, sizeof(msg));
 804   msg.iMethod = 4;
 805   msg.cbBuffer = sizeof(USHORT) + cInterfaceRefs*sizeof(REMINTERFACEREF);
 806   hr = IRpcChannelBuffer_GetBuffer(This->chan, &msg, &IID_IRemUnknown);
 807   if (SUCCEEDED(hr)) {
 808     LPBYTE buf = msg.Buffer;
 809     memcpy(buf, &cInterfaceRefs, sizeof(USHORT));
 810     buf += sizeof(USHORT);
 811     memcpy(buf, InterfaceRefs, cInterfaceRefs*sizeof(REMINTERFACEREF));
 812
 813     hr = IRpcChannelBuffer_SendReceive(This->chan, &msg, &status);
 814
 815     if (SUCCEEDED(hr)) {
 816       buf = msg.Buffer;
 817       memcpy(pResults, buf, cInterfaceRefs*sizeof(HRESULT));
 818     }
 819
 820     IRpcChannelBuffer_FreeBuffer(This->chan, &msg);
 821   }
 822
 823   return hr;
 824 }
 825
 826 static HRESULT WINAPI RemUnkProxy_RemRelease(LPREMUNKNOWN iface,
 827                                           USHORT cInterfaceRefs,
 828                                           REMINTERFACEREF* InterfaceRefs)
 829 {
 830   RemUnkProxy *This = (RemUnkProxy *)iface;
 831   RPCOLEMESSAGE msg;
 832   HRESULT hr = S_OK;
 833   ULONG status;
 834
 835   TRACE("(%p)->(%d,%p)\n",This,
 836         cInterfaceRefs,InterfaceRefs);
 837
 838   memset(&msg, 0, sizeof(msg));
 839   msg.iMethod = 5;
 840   msg.cbBuffer = sizeof(USHORT) + cInterfaceRefs*sizeof(REMINTERFACEREF);
 841   hr = IRpcChannelBuffer_GetBuffer(This->chan, &msg, &IID_IRemUnknown);
 842   if (SUCCEEDED(hr)) {
 843     LPBYTE buf = msg.Buffer;
 844     memcpy(buf, &cInterfaceRefs, sizeof(USHORT));
 845     buf += sizeof(USHORT);
 846     memcpy(buf, InterfaceRefs, cInterfaceRefs*sizeof(REMINTERFACEREF));
 847
 848     hr = IRpcChannelBuffer_SendReceive(This->chan, &msg, &status);
 849
 850     IRpcChannelBuffer_FreeBuffer(This->chan, &msg);
 851   }
 852
 853   return hr;
 854 }
 855
 856 static const IRemUnknownVtbl RemUnkProxy_VTable =
 857 {
 858   RemUnkProxy_QueryInterface,
 859   RemUnkProxy_AddRef,
 860   RemUnkProxy_Release,
 861   RemUnkProxy_RemQueryInterface,
 862   RemUnkProxy_RemAddRef,
 863   RemUnkProxy_RemRelease
 864 };
 865
 866
 867 static HRESULT WINAPI RURpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface,REFIID riid,LPVOID *ppv) {
 868     *ppv = NULL;
 869     if (IsEqualIID(riid,&IID_IRpcProxyBuffer)||IsEqualIID(riid,&IID_IUnknown)) {
 870         IRpcProxyBuffer_AddRef(iface);
 871         *ppv = (LPVOID)iface;
 872         return S_OK;
 873     }
 874     FIXME("(%s), no interface.\n",debugstr_guid(riid));
 875     return E_NOINTERFACE;
 876 }
 877
 878 static ULONG WINAPI RURpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface) {
 879     ICOM_THIS_MULTI(RemUnkProxy,lpvtbl_proxy,iface);
 880     TRACE("%p, %d\n", iface, This->refs + 1);
 881     return InterlockedIncrement(&This->refs);
 882 }
 883
 884 static ULONG WINAPI RURpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface) {
 885     ICOM_THIS_MULTI(RemUnkProxy,lpvtbl_proxy,iface);
 886     ULONG ref = InterlockedDecrement(&This->refs);
 887     TRACE("%p, %d\n", iface, ref);
 888     if (!ref) {
 889         IRpcProxyBuffer_Disconnect(iface);
 890         HeapFree(GetProcessHeap(),0,This);
 891     }
 892     return ref;
 893 }
 894
 895 static HRESULT WINAPI RURpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface,IRpcChannelBuffer* pRpcChannelBuffer) {
 896     ICOM_THIS_MULTI(RemUnkProxy,lpvtbl_proxy,iface);
 897
 898     TRACE("%p, %p\n", iface, pRpcChannelBuffer);
 899     This->chan = pRpcChannelBuffer;
 900     IRpcChannelBuffer_AddRef(This->chan);
 901     return S_OK;
 902 }
 903 static void WINAPI RURpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface) {
 904     ICOM_THIS_MULTI(RemUnkProxy,lpvtbl_proxy,iface);
 905     TRACE("%p, %p\n", iface, This->chan);
 906     if (This->chan) {
 907         IRpcChannelBuffer_Release(This->chan);
 908         This->chan = NULL;
 909     }
 910 }
 911
 912
 913 static const IRpcProxyBufferVtbl RURpcProxyBuffer_VTable = {
 914     RURpcProxyBufferImpl_QueryInterface,
 915     RURpcProxyBufferImpl_AddRef,
 916     RURpcProxyBufferImpl_Release,
 917     RURpcProxyBufferImpl_Connect,
 918     RURpcProxyBufferImpl_Disconnect
 919 };
 920
 921 static HRESULT
 922 RemUnkProxy_Construct(IUnknown *pUnkOuter, LPVOID *ppv,LPVOID *ppProxy) {
 923     RemUnkProxy *This;
 924
 925     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*This));
 926     if (!This)
 927         return E_OUTOFMEMORY;
 928
 929     This->lpvtbl_remunk = &RemUnkProxy_VTable;
 930     This->lpvtbl_proxy  = &RURpcProxyBuffer_VTable;
 931     /* only one reference for the proxy buffer */
 932     This->refs          = 1;
 933     This->outer_unknown = pUnkOuter;
 934     *ppv                = &(This->lpvtbl_remunk);
 935     *ppProxy            = &(This->lpvtbl_proxy);
 936     /* and one reference for the object */
 937     IUnknown_AddRef((IUnknown *)*ppv);
 938     return S_OK;
 939 }
 940
 941
 942 /********************* OLE Proxy/Stub Factory ********************************/
 943 static HRESULT WINAPI
 944 PSFacBuf_QueryInterface(LPPSFACTORYBUFFER iface, REFIID iid, LPVOID *ppv) {
 945     if (IsEqualIID(iid,&IID_IPSFactoryBuffer)||IsEqualIID(iid,&IID_IUnknown)) {
 946         *ppv = (LPVOID)iface;
 947         /* No ref counting, static class */
 948         return S_OK;
 949     }
 950     FIXME("(%s) unknown IID?\n",debugstr_guid(iid));
 951     return E_NOINTERFACE;
 952 }
 953
 954 static ULONG WINAPI PSFacBuf_AddRef(LPPSFACTORYBUFFER iface) { return 2; }
 955 static ULONG WINAPI PSFacBuf_Release(LPPSFACTORYBUFFER iface) { return 1; }
 956
 957 static HRESULT WINAPI
 958 PSFacBuf_CreateProxy(
 959     LPPSFACTORYBUFFER iface, IUnknown* pUnkOuter, REFIID riid,
 960     IRpcProxyBuffer **ppProxy, LPVOID *ppv
 961 ) {
 962     if (IsEqualIID(&IID_IClassFactory,riid))
 963         return CFProxy_Construct(pUnkOuter, ppv,(LPVOID*)ppProxy);
 964     else if (IsEqualIID(&IID_IRemUnknown,riid))
 965         return RemUnkProxy_Construct(pUnkOuter, ppv,(LPVOID*)ppProxy);
 966     FIXME("proxying not implemented for (%s) yet!\n",debugstr_guid(riid));
 967     return E_FAIL;
 968 }
 969
 970 static HRESULT WINAPI
 971 PSFacBuf_CreateStub(
 972     LPPSFACTORYBUFFER iface, REFIID riid,IUnknown *pUnkServer,
 973     IRpcStubBuffer** ppStub
 974 ) {
 975     HRESULT hres;
 976
 977     TRACE("(%s,%p,%p)\n",debugstr_guid(riid),pUnkServer,ppStub);
 978
 979     if (IsEqualIID(&IID_IClassFactory, riid) ||
 980         IsEqualIID(&IID_IUnknown, riid) /* FIXME: fixup stub manager and remove this*/) {
 981         hres = CFStub_Construct(ppStub);
 982         if (!hres)
 983             IRpcStubBuffer_Connect((*ppStub),pUnkServer);
 984         return hres;
 985     } else if (IsEqualIID(&IID_IRemUnknown,riid)) {
 986         hres = RemUnkStub_Construct(ppStub);
 987         if (!hres)
 988             IRpcStubBuffer_Connect((*ppStub),pUnkServer);
 989         return hres;
 990     }
 991     FIXME("stubbing not implemented for (%s) yet!\n",debugstr_guid(riid));
 992     return E_FAIL;
 993 }
 994
 995 static const IPSFactoryBufferVtbl psfacbufvtbl = {
 996     PSFacBuf_QueryInterface,
 997     PSFacBuf_AddRef,
 998     PSFacBuf_Release,
 999     PSFacBuf_CreateProxy,
1000     PSFacBuf_CreateStub
1001 };
1002
1003 /* This is the whole PSFactoryBuffer object, just the vtableptr */
1004 static const IPSFactoryBufferVtbl *lppsfac = &psfacbufvtbl;
1005 #endif
1006
1007 #include "rpcproxy.h"
1008
1009 static CStdPSFactoryBuffer PSFactoryBuffer;
1010
1011 CSTDSTUBBUFFERRELEASE(&PSFactoryBuffer)
1012
1013 extern const ExtendedProxyFileInfo dcom_ProxyFileInfo;
1014 extern const ExtendedProxyFileInfo objidl_ProxyFileInfo;
1015 extern const ExtendedProxyFileInfo oleidl_ProxyFileInfo;
1016 extern const ExtendedProxyFileInfo unknwn_ProxyFileInfo;
1017
1018 const ProxyFileInfo* aProxyFileList[] =
1019 {
1020     &dcom_ProxyFileInfo,
1021     &objidl_ProxyFileInfo,
1022     &oleidl_ProxyFileInfo,
1023     &unknwn_ProxyFileInfo,
1024     NULL
1025 };
1026
1027 /***********************************************************************
1028  *           DllGetClassObject [OLE32.@]
1029  */
1030 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
1031 {
1032     *ppv = NULL;
1033     if (IsEqualIID(rclsid, &CLSID_PSFactoryBuffer))
1034         return NdrDllGetClassObject(rclsid, iid, ppv, aProxyFileList,
1035                                     &CLSID_PSFactoryBuffer, &PSFactoryBuffer);
1036     if (IsEqualIID(rclsid,&CLSID_DfMarshal)&&(
1037                 IsEqualIID(iid,&IID_IClassFactory) ||
1038                 IsEqualIID(iid,&IID_IUnknown)
1039         )
1040     )
1041         return MARSHAL_GetStandardMarshalCF(ppv);
1042     if (IsEqualIID(rclsid,&CLSID_StdGlobalInterfaceTable) && (IsEqualIID(iid,&IID_IClassFactory) || IsEqualIID(iid,&IID_IUnknown)))
1043         return StdGlobalInterfaceTable_GetFactory(ppv);
1044     if (IsEqualCLSID(rclsid, &CLSID_FileMoniker))
1045         return FileMonikerCF_Create(iid, ppv);
1046     if (IsEqualCLSID(rclsid, &CLSID_ItemMoniker))
1047         return ItemMonikerCF_Create(iid, ppv);
1048     if (IsEqualCLSID(rclsid, &CLSID_AntiMoniker))
1049         return AntiMonikerCF_Create(iid, ppv);
1050     if (IsEqualCLSID(rclsid, &CLSID_CompositeMoniker))
1051         return CompositeMonikerCF_Create(iid, ppv);
1052     if (IsEqualCLSID(rclsid, &CLSID_ClassMoniker))
1053         return ClassMonikerCF_Create(iid, ppv);
1054
1055     /* CODEWEAVERS HACK: Fix up native implementing Component Categories
1056      * Manager in ole32 and us in comcat - we should remove this hack when
1057      * we get around to moving our comcat implementation to ole32 */
1058     if (IsEqualCLSID(rclsid, &CLSID_StdComponentCategoriesMgr))
1059     {
1060         HMODULE hComCat = LoadLibraryA("comcat");
1061         typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
1062         DllGetClassObjectFunc DllGetClassObject =
1063             (DllGetClassObjectFunc)GetProcAddress(hComCat, "DllGetClassObject");
1064         if (DllGetClassObject) return DllGetClassObject(rclsid, iid, ppv);
1065     }
1066
1067     FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid));
1068     return CLASS_E_CLASSNOTAVAILABLE;
1069 }