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