dlls/ole32/oleproxy.c

   1 /*
   2  *      OLE32 proxy/stub handler
   3  *
   4  *  Copyright 2002  Marcus Meissner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /* Documentation on MSDN:
  22  *
  23  * (Top level COM documentation)
  24  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnanchor/html/componentdevelopmentank.asp
  25  *
  26  * (COM Proxy)
  27  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1q0p.asp
  28  *
  29  * (COM Stub)
  30  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1lia.asp
  31  *
  32  * (Marshal)
  33  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1gfn.asp
  34  *
  35  */
  36
  37 #include "config.h"
  38
  39 #include <stdlib.h>
  40 #include <stdarg.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43
  44 #define COBJMACROS
  45 #define NONAMELESSUNION
  46 #define NONAMELESSSTRUCT
  47
  48 #include "windef.h"
  49 #include "winbase.h"
  50 #include "winuser.h"
  51 #include "objbase.h"
  52 #include "ole2.h"
  53 #include "rpc.h"
  54 #include "winerror.h"
  55 #include "winreg.h"
  56 #include "wtypes.h"
  57
  58 #include "compobj_private.h"
  59
  60 #include "wine/debug.h"
  61
  62 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  63
  64 const CLSID CLSID_DfMarshal       = { 0x0000030b, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
  65 const CLSID CLSID_PSFactoryBuffer = { 0x00000320, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
  66
  67 /* From: http://msdn.microsoft.com/library/en-us/com/cmi_m_4lda.asp
  68  *
  69  * The first time a client requests a pointer to an interface on a
  70  * particular object, COM loads an IClassFactory stub in the server
  71  * process and uses it to marshal the first pointer back to the
  72  * client. In the client process, COM loads the generic proxy for the
  73  * class factory object and calls its implementation of IMarshal to
  74  * unmarshal that first pointer. COM then creates the first interface
  75  * proxy and hands it a pointer to the RPC channel. Finally, COM returns
  76  * the IClassFactory pointer to the client, which uses it to call
  77  * IClassFactory::CreateInstance, passing it a reference to the interface.
  78  *
  79  * Back in the server process, COM now creates a new instance of the
  80  * object, along with a stub for the requested interface. This stub marshals
  81  * the interface pointer back to the client process, where another object
  82  * proxy is created, this time for the object itself. Also created is a
  83  * proxy for the requested interface, a pointer to which is returned to
  84  * the client. With subsequent calls to other interfaces on the object,
  85  * COM will load the appropriate interface stubs and proxies as needed.
  86  */
  87 typedef struct _CFStub {
  88     IRpcStubBufferVtbl  *lpvtbl;
  89     DWORD                       ref;
  90
  91     LPUNKNOWN                   pUnkServer;
  92 } CFStub;
  93
  94 static HRESULT WINAPI
  95 CFStub_QueryInterface(LPRPCSTUBBUFFER iface, REFIID riid, LPVOID *ppv) {
  96     if (IsEqualIID(&IID_IUnknown,riid)||IsEqualIID(&IID_IRpcStubBuffer,riid)) {
  97         *ppv = (LPVOID)iface;
  98         IUnknown_AddRef(iface);
  99         return S_OK;
 100     }
 101     FIXME("(%s), interface not supported.\n",debugstr_guid(riid));
 102     return E_NOINTERFACE;
 103 }
 104
 105 static ULONG WINAPI
 106 CFStub_AddRef(LPRPCSTUBBUFFER iface) {
 107     CFStub *This = (CFStub *)iface;
 108     return InterlockedIncrement(&This->ref);
 109 }
 110
 111 static ULONG WINAPI
 112 CFStub_Release(LPRPCSTUBBUFFER iface) {
 113     CFStub *This = (CFStub *)iface;
 114     ULONG ref;
 115
 116     ref = InterlockedDecrement(&This->ref);
 117     if (!ref) HeapFree(GetProcessHeap(),0,This);
 118     return ref;
 119 }
 120
 121 static HRESULT WINAPI
 122 CFStub_Connect(LPRPCSTUBBUFFER iface, IUnknown *pUnkServer) {
 123     CFStub *This = (CFStub *)iface;
 124
 125     This->pUnkServer = pUnkServer;
 126     IUnknown_AddRef(pUnkServer);
 127     return S_OK;
 128 }
 129
 130 static void WINAPI
 131 CFStub_Disconnect(LPRPCSTUBBUFFER iface) {
 132     CFStub *This = (CFStub *)iface;
 133
 134     IUnknown_Release(This->pUnkServer);
 135     This->pUnkServer = NULL;
 136 }
 137 static HRESULT WINAPI
 138 CFStub_Invoke(
 139     LPRPCSTUBBUFFER iface,RPCOLEMESSAGE* msg,IRpcChannelBuffer* chanbuf
 140 ) {
 141     CFStub *This = (CFStub *)iface;
 142     HRESULT hres;
 143
 144     if (msg->iMethod == 3) { /* CreateInstance */
 145         IID iid;
 146         IClassFactory   *classfac;
 147         IUnknown        *ppv;
 148         IStream         *pStm;
 149         STATSTG         ststg;
 150         ULARGE_INTEGER  newpos;
 151         LARGE_INTEGER   seekto;
 152         ULONG           res;
 153
 154         if (msg->cbBuffer < sizeof(IID)) {
 155             FIXME("Not enough bytes in buffer (%ld instead of %d)?\n",msg->cbBuffer,sizeof(IID));
 156             return E_FAIL;
 157         }
 158         memcpy(&iid,msg->Buffer,sizeof(iid));
 159         TRACE("->CreateInstance(%s)\n",debugstr_guid(&iid));
 160         hres = IUnknown_QueryInterface(This->pUnkServer,&IID_IClassFactory,(LPVOID*)&classfac);
 161         if (hres) {
 162             FIXME("Ole server does not provide a IClassFactory?\n");
 163             return hres;
 164         }
 165         hres = IClassFactory_CreateInstance(classfac,NULL,&iid,(LPVOID*)&ppv);
 166         IClassFactory_Release(classfac);
 167         if (hres) {
 168             msg->cbBuffer = 0;
 169             FIXME("Failed to create an instance of %s\n",debugstr_guid(&iid));
 170             return hres;
 171         }
 172         hres = CreateStreamOnHGlobal(0,TRUE,&pStm);
 173         if (hres) {
 174             FIXME("Failed to create stream on hglobal\n");
 175             return hres;
 176         }
 177         hres = CoMarshalInterface(pStm,&iid,ppv,0,NULL,0);
 178         if (hres) {
 179             FIXME("CoMarshalInterface failed, %lx!\n",hres);
 180             msg->cbBuffer = 0;
 181             return hres;
 182         }
 183         hres = IStream_Stat(pStm,&ststg,0);
 184         if (hres) {
 185             FIXME("Stat failed.\n");
 186             return hres;
 187         }
 188
 189         msg->cbBuffer = ststg.cbSize.u.LowPart;
 190
 191         if (msg->Buffer)
 192             msg->Buffer = HeapReAlloc(GetProcessHeap(),0,msg->Buffer,ststg.cbSize.u.LowPart);
 193         else
 194             msg->Buffer = HeapAlloc(GetProcessHeap(),0,ststg.cbSize.u.LowPart);
 195
 196         seekto.u.LowPart = 0;seekto.u.HighPart = 0;
 197         hres = IStream_Seek(pStm,seekto,SEEK_SET,&newpos);
 198         if (hres) {
 199             FIXME("IStream_Seek failed, %lx\n",hres);
 200             return hres;
 201         }
 202         hres = IStream_Read(pStm,msg->Buffer,msg->cbBuffer,&res);
 203         if (hres) {
 204             FIXME("Stream Read failed, %lx\n",hres);
 205             return hres;
 206         }
 207         IStream_Release(pStm);
 208         return S_OK;
 209     }
 210     FIXME("(%p,%p), stub!\n",msg,chanbuf);
 211     FIXME("iMethod is %ld\n",msg->iMethod);
 212     FIXME("cbBuffer is %ld\n",msg->cbBuffer);
 213     return E_FAIL;
 214 }
 215
 216 static LPRPCSTUBBUFFER WINAPI
 217 CFStub_IsIIDSupported(LPRPCSTUBBUFFER iface,REFIID riid) {
 218     FIXME("(%s), stub!\n",debugstr_guid(riid));
 219     return NULL;
 220 }
 221
 222 static ULONG WINAPI
 223 CFStub_CountRefs(LPRPCSTUBBUFFER iface) {
 224     FIXME("(), stub!\n");
 225     return 1;
 226 }
 227
 228 static HRESULT WINAPI
 229 CFStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface,void** ppv) {
 230     FIXME("(%p), stub!\n",ppv);
 231     return E_FAIL;
 232 }
 233 static void    WINAPI
 234 CFStub_DebugServerRelease(LPRPCSTUBBUFFER iface,void *pv) {
 235     FIXME("(%p), stub!\n",pv);
 236 }
 237
 238 static IRpcStubBufferVtbl cfstubvt = {
 239     CFStub_QueryInterface,
 240     CFStub_AddRef,
 241     CFStub_Release,
 242     CFStub_Connect,
 243     CFStub_Disconnect,
 244     CFStub_Invoke,
 245     CFStub_IsIIDSupported,
 246     CFStub_CountRefs,
 247     CFStub_DebugServerQueryInterface,
 248     CFStub_DebugServerRelease
 249 };
 250
 251 static HRESULT
 252 CFStub_Construct(LPRPCSTUBBUFFER *ppv) {
 253     CFStub *cfstub;
 254     cfstub = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CFStub));
 255     if (!cfstub)
 256         return E_OUTOFMEMORY;
 257     *ppv = (LPRPCSTUBBUFFER)cfstub;
 258     cfstub->lpvtbl      = &cfstubvt;
 259     cfstub->ref         = 1;
 260     return S_OK;
 261 }
 262
 263 /* Since we create proxy buffers and classfactory in a pair, there is
 264  * no need for 2 separate structs. Just put them in one, but remember
 265  * the refcount.
 266  */
 267 typedef struct _CFProxy {
 268     IClassFactoryVtbl           *lpvtbl_cf;
 269     IRpcProxyBufferVtbl *lpvtbl_proxy;
 270     DWORD                               ref;
 271
 272     IRpcChannelBuffer                   *chanbuf;
 273     IUnknown *outer_unknown;
 274 } CFProxy;
 275
 276 static HRESULT WINAPI IRpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface,REFIID riid,LPVOID *ppv) {
 277     *ppv = NULL;
 278     if (IsEqualIID(riid,&IID_IRpcProxyBuffer)||IsEqualIID(riid,&IID_IUnknown)) {
 279         IRpcProxyBuffer_AddRef(iface);
 280         *ppv = (LPVOID)iface;
 281         return S_OK;
 282     }
 283     FIXME("(%s), no interface.\n",debugstr_guid(riid));
 284     return E_NOINTERFACE;
 285 }
 286
 287 static ULONG WINAPI IRpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface) {
 288     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 289     return InterlockedIncrement(&This->ref);
 290 }
 291
 292 static ULONG WINAPI IRpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface) {
 293     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 294     ULONG ref = InterlockedDecrement(&This->ref);
 295
 296     if (!ref) {
 297         IRpcChannelBuffer_Release(This->chanbuf);This->chanbuf = NULL;
 298         HeapFree(GetProcessHeap(),0,This);
 299     }
 300     return ref;
 301 }
 302
 303 static HRESULT WINAPI IRpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface,IRpcChannelBuffer* pRpcChannelBuffer) {
 304     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 305
 306     This->chanbuf = pRpcChannelBuffer;
 307     IRpcChannelBuffer_AddRef(This->chanbuf);
 308     return S_OK;
 309 }
 310 static void WINAPI IRpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface) {
 311     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 312     if (This->chanbuf) {
 313         IRpcChannelBuffer_Release(This->chanbuf);
 314         This->chanbuf = NULL;
 315     }
 316 }
 317
 318 static HRESULT WINAPI
 319 CFProxy_QueryInterface(LPCLASSFACTORY iface,REFIID riid, LPVOID *ppv) {
 320     ICOM_THIS_MULTI(CFProxy,lpvtbl_proxy,iface);
 321     if (This->outer_unknown) return IUnknown_QueryInterface(This->outer_unknown, riid, ppv);
 322     *ppv = NULL;
 323     if (IsEqualIID(&IID_IClassFactory,riid) || IsEqualIID(&IID_IUnknown,riid)) {
 324         *ppv = (LPVOID)iface;
 325         IClassFactory_AddRef(iface);
 326         return S_OK;
 327     }
 328     if (IsEqualIID(riid,&IID_IMarshal)) /* just to avoid debug output */
 329         return E_NOINTERFACE;
 330     FIXME("Unhandled interface: %s\n",debugstr_guid(riid));
 331     return E_NOINTERFACE;
 332 }
 333
 334 static ULONG   WINAPI CFProxy_AddRef(LPCLASSFACTORY iface) {
 335     ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);
 336     if (This->outer_unknown) return IUnknown_AddRef(This->outer_unknown);
 337     return InterlockedIncrement(&This->ref);
 338 }
 339
 340 static ULONG   WINAPI CFProxy_Release(LPCLASSFACTORY iface) {
 341     ULONG ref;
 342     ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);
 343     if (This->outer_unknown)
 344         ref = IUnknown_Release(This->outer_unknown);
 345     else
 346         ref = InterlockedDecrement(&This->ref);
 347
 348     if (!ref) {
 349         IRpcChannelBuffer_Release(This->chanbuf);
 350         HeapFree(GetProcessHeap(),0,This);
 351     }
 352     return ref;
 353 }
 354
 355 static HRESULT WINAPI CFProxy_CreateInstance(
 356     LPCLASSFACTORY iface,
 357     LPUNKNOWN pUnkOuter,/* [in] */
 358     REFIID riid,        /* [in] */
 359     LPVOID *ppv         /* [out] */
 360 ) {
 361     ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);
 362     HRESULT             hres;
 363     LPSTREAM            pStream;
 364     HGLOBAL             hGlobal;
 365     ULONG               srstatus;
 366     RPCOLEMESSAGE       msg;
 367
 368     TRACE("(%p,%s,%p)\n",pUnkOuter,debugstr_guid(riid),ppv);
 369
 370     /* Send CreateInstance to the remote classfactory.
 371      *
 372      * Data: Only the 'IID'.
 373      */
 374     msg.iMethod  = 3;
 375     msg.cbBuffer = sizeof(*riid);
 376     msg.Buffer   = NULL;
 377     hres = IRpcChannelBuffer_GetBuffer(This->chanbuf,&msg,&IID_IClassFactory);
 378     if (hres) {
 379         FIXME("IRpcChannelBuffer_GetBuffer failed with %lx?\n",hres);
 380         return hres;
 381     }
 382     memcpy(msg.Buffer,riid,sizeof(*riid));
 383     hres = IRpcChannelBuffer_SendReceive(This->chanbuf,&msg,&srstatus);
 384     if (hres) {
 385         FIXME("IRpcChannelBuffer_SendReceive failed with %lx?\n",hres);
 386         return hres;
 387     }
 388
 389     if (!msg.cbBuffer) /* interface not found on remote */
 390         return srstatus;
 391
 392     /* We got back: [Marshalled Interface data] */
 393     TRACE("got %ld bytes data.\n",msg.cbBuffer);
 394     hGlobal = GlobalAlloc(GMEM_MOVEABLE|GMEM_NODISCARD|GMEM_SHARE,msg.cbBuffer);
 395     memcpy(GlobalLock(hGlobal),msg.Buffer,msg.cbBuffer);
 396     hres = CreateStreamOnHGlobal(hGlobal,TRUE,&pStream);
 397     if (hres) {
 398         FIXME("CreateStreamOnHGlobal failed with %lx\n",hres);
 399         return hres;
 400     }
 401     hres = CoUnmarshalInterface(
 402             pStream,
 403             riid,
 404             ppv
 405     );
 406     IStream_Release(pStream); /* Does GlobalFree hGlobal too. */
 407     if (hres) {
 408         FIXME("CoMarshalInterface failed, %lx\n",hres);
 409         return hres;
 410     }
 411     return S_OK;
 412 }
 413
 414 static HRESULT WINAPI CFProxy_LockServer(LPCLASSFACTORY iface,BOOL fLock) {
 415     /*ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);*/
 416     FIXME("(%d), stub!\n",fLock);
 417     /* basically: write BOOL, read empty */
 418     return S_OK;
 419 }
 420
 421 static IRpcProxyBufferVtbl pspbvtbl = {
 422     IRpcProxyBufferImpl_QueryInterface,
 423     IRpcProxyBufferImpl_AddRef,
 424     IRpcProxyBufferImpl_Release,
 425     IRpcProxyBufferImpl_Connect,
 426     IRpcProxyBufferImpl_Disconnect
 427 };
 428 static IClassFactoryVtbl cfproxyvt = {
 429     CFProxy_QueryInterface,
 430     CFProxy_AddRef,
 431     CFProxy_Release,
 432     CFProxy_CreateInstance,
 433     CFProxy_LockServer
 434 };
 435
 436 static HRESULT
 437 CFProxy_Construct(IUnknown *pUnkOuter, LPVOID *ppv,LPVOID *ppProxy) {
 438     CFProxy *cf;
 439
 440     cf = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CFProxy));
 441     if (!cf)
 442         return E_OUTOFMEMORY;
 443
 444     cf->lpvtbl_cf       = &cfproxyvt;
 445     cf->lpvtbl_proxy    = &pspbvtbl;
 446     /* 1 reference for the proxy... */
 447     cf->ref             = 1;
 448     cf->outer_unknown = pUnkOuter;
 449     *ppv                = &(cf->lpvtbl_cf);
 450     *ppProxy            = &(cf->lpvtbl_proxy);
 451     /* ...and 1 for the object */
 452     IUnknown_AddRef((IUnknown *)*ppv);
 453     return S_OK;
 454 }
 455
 456
 457 /********************* OLE Proxy/Stub Factory ********************************/
 458 static HRESULT WINAPI
 459 PSFacBuf_QueryInterface(LPPSFACTORYBUFFER iface, REFIID iid, LPVOID *ppv) {
 460     if (IsEqualIID(iid,&IID_IPSFactoryBuffer)||IsEqualIID(iid,&IID_IUnknown)) {
 461         *ppv = (LPVOID)iface;
 462         /* No ref counting, static class */
 463         return S_OK;
 464     }
 465     FIXME("(%s) unknown IID?\n",debugstr_guid(iid));
 466     return E_NOINTERFACE;
 467 }
 468
 469 static ULONG WINAPI PSFacBuf_AddRef(LPPSFACTORYBUFFER iface) { return 2; }
 470 static ULONG WINAPI PSFacBuf_Release(LPPSFACTORYBUFFER iface) { return 1; }
 471
 472 static HRESULT WINAPI
 473 PSFacBuf_CreateProxy(
 474     LPPSFACTORYBUFFER iface, IUnknown* pUnkOuter, REFIID riid,
 475     IRpcProxyBuffer **ppProxy, LPVOID *ppv
 476 ) {
 477     if (IsEqualIID(&IID_IClassFactory,riid) ||
 478         IsEqualIID(&IID_IUnknown,riid)
 479     )
 480         return CFProxy_Construct(pUnkOuter, ppv,(LPVOID*)ppProxy);
 481     FIXME("proxying not implemented for (%s) yet!\n",debugstr_guid(riid));
 482     return E_FAIL;
 483 }
 484
 485 static HRESULT WINAPI
 486 PSFacBuf_CreateStub(
 487     LPPSFACTORYBUFFER iface, REFIID riid,IUnknown *pUnkServer,
 488     IRpcStubBuffer** ppStub
 489 ) {
 490     HRESULT hres;
 491
 492     TRACE("(%s,%p,%p)\n",debugstr_guid(riid),pUnkServer,ppStub);
 493
 494     if (IsEqualIID(&IID_IClassFactory,riid) ||
 495         IsEqualIID(&IID_IUnknown,riid)
 496     ) {
 497         hres = CFStub_Construct(ppStub);
 498         if (!hres)
 499             IRpcStubBuffer_Connect((*ppStub),pUnkServer);
 500         return hres;
 501     }
 502     FIXME("stubbing not implemented for (%s) yet!\n",debugstr_guid(riid));
 503     return E_FAIL;
 504 }
 505
 506 static IPSFactoryBufferVtbl psfacbufvtbl = {
 507     PSFacBuf_QueryInterface,
 508     PSFacBuf_AddRef,
 509     PSFacBuf_Release,
 510     PSFacBuf_CreateProxy,
 511     PSFacBuf_CreateStub
 512 };
 513
 514 /* This is the whole PSFactoryBuffer object, just the vtableptr */
 515 static IPSFactoryBufferVtbl *lppsfac = &psfacbufvtbl;
 516
 517 /***********************************************************************
 518  *           DllGetClassObject [OLE32.@]
 519  */
 520 HRESULT WINAPI OLE32_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv)
 521 {
 522     *ppv = NULL;
 523     if (IsEqualIID(rclsid,&CLSID_PSFactoryBuffer)) {
 524         *ppv = &lppsfac;
 525         return S_OK;
 526     }
 527     if (IsEqualIID(rclsid,&CLSID_DfMarshal)&&(
 528                 IsEqualIID(iid,&IID_IClassFactory) ||
 529                 IsEqualIID(iid,&IID_IUnknown)
 530         )
 531     )
 532         return MARSHAL_GetStandardMarshalCF(ppv);
 533     if (IsEqualIID(rclsid,&CLSID_StdGlobalInterfaceTable) && (IsEqualIID(iid,&IID_IClassFactory) || IsEqualIID(iid,&IID_IUnknown)))
 534         return StdGlobalInterfaceTable_GetFactory(ppv);
 535
 536     FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid));
 537     return CLASS_E_CLASSNOTAVAILABLE;
 538 }