2 * OLE32 proxy/stub handler
4 * Copyright 2002 Marcus Meissner
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.
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.
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
21 /* Documentation on MSDN:
24 * http://msdn.microsoft.com/library/en-us/com/comext_1q0p.asp
27 * http://msdn.microsoft.com/library/en-us/com/comext_1lia.asp
30 * http://msdn.microsoft.com/library/en-us/com/comext_1gfn.asp
41 #define NONAMELESSUNION
42 #define NONAMELESSSTRUCT
53 #include "compobj_private.h"
55 #include "wine/debug.h"
57 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
59 const CLSID CLSID_DfMarshal
= { 0x0000030b, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
60 const CLSID CLSID_PSFactoryBuffer
= { 0x00000320, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
62 /* From: http://msdn.microsoft.com/library/en-us/com/cmi_m_4lda.asp
64 * The first time a client requests a pointer to an interface on a
65 * particular object, COM loads an IClassFactory stub in the server
66 * process and uses it to marshal the first pointer back to the
67 * client. In the client process, COM loads the generic proxy for the
68 * class factory object and calls its implementation of IMarshal to
69 * unmarshal that first pointer. COM then creates the first interface
70 * proxy and hands it a pointer to the RPC channel. Finally, COM returns
71 * the IClassFactory pointer to the client, which uses it to call
72 * IClassFactory::CreateInstance, passing it a reference to the interface.
74 * Back in the server process, COM now creates a new instance of the
75 * object, along with a stub for the requested interface. This stub marshals
76 * the interface pointer back to the client process, where another object
77 * proxy is created, this time for the object itself. Also created is a
78 * proxy for the requested interface, a pointer to which is returned to
79 * the client. With subsequent calls to other interfaces on the object,
80 * COM will load the appropriate interface stubs and proxies as needed.
82 typedef struct _CFStub
{
83 ICOM_VTABLE(IRpcStubBuffer
) *lpvtbl
;
90 CFStub_QueryInterface(LPRPCSTUBBUFFER iface
, REFIID riid
, LPVOID
*ppv
) {
91 if (IsEqualIID(&IID_IUnknown
,riid
)||IsEqualIID(&IID_IRpcStubBuffer
,riid
)) {
93 IUnknown_AddRef(iface
);
96 FIXME("(%s), interface not supported.\n",debugstr_guid(riid
));
101 CFStub_AddRef(LPRPCSTUBBUFFER iface
) {
102 ICOM_THIS(CFStub
,iface
);
109 CFStub_Release(LPRPCSTUBBUFFER iface
) {
110 ICOM_THIS(CFStub
,iface
);
115 HeapFree(GetProcessHeap(),0,This
);
119 static HRESULT WINAPI
120 CFStub_Connect(LPRPCSTUBBUFFER iface
, IUnknown
*pUnkServer
) {
121 ICOM_THIS(CFStub
,iface
);
123 This
->pUnkServer
= pUnkServer
;
124 IUnknown_AddRef(pUnkServer
);
129 CFStub_Disconnect(LPRPCSTUBBUFFER iface
) {
130 ICOM_THIS(CFStub
,iface
);
132 IUnknown_Release(This
->pUnkServer
);
133 This
->pUnkServer
= NULL
;
135 static HRESULT WINAPI
137 LPRPCSTUBBUFFER iface
,RPCOLEMESSAGE
* msg
,IRpcChannelBuffer
* chanbuf
139 ICOM_THIS(CFStub
,iface
);
142 if (msg
->iMethod
== 3) { /* CreateInstance */
144 IClassFactory
*classfac
;
148 ULARGE_INTEGER newpos
;
149 LARGE_INTEGER seekto
;
152 if (msg
->cbBuffer
< sizeof(IID
)) {
153 FIXME("Not enough bytes in buffer (%ld instead of %d)?\n",msg
->cbBuffer
,sizeof(IID
));
156 memcpy(&iid
,msg
->Buffer
,sizeof(iid
));
157 TRACE("->CreateInstance(%s)\n",debugstr_guid(&iid
));
158 hres
= IUnknown_QueryInterface(This
->pUnkServer
,&IID_IClassFactory
,(LPVOID
*)&classfac
);
160 FIXME("Ole server does not provide a IClassFactory?\n");
163 hres
= IClassFactory_CreateInstance(classfac
,NULL
,&iid
,(LPVOID
*)&ppv
);
164 IClassFactory_Release(classfac
);
167 FIXME("Failed to create an instance of %s\n",debugstr_guid(&iid
));
170 hres
= CreateStreamOnHGlobal(0,TRUE
,&pStm
);
172 FIXME("Failed to create stream on hglobal\n");
175 hres
= CoMarshalInterface(pStm
,&iid
,ppv
,0,NULL
,0);
177 FIXME("CoMarshalInterface failed, %lx!\n",hres
);
181 hres
= IStream_Stat(pStm
,&ststg
,0);
183 FIXME("Stat failed.\n");
187 msg
->cbBuffer
= ststg
.cbSize
.s
.LowPart
;
190 msg
->Buffer
= HeapReAlloc(GetProcessHeap(),0,msg
->Buffer
,ststg
.cbSize
.s
.LowPart
);
192 msg
->Buffer
= HeapAlloc(GetProcessHeap(),0,ststg
.cbSize
.s
.LowPart
);
194 seekto
.s
.LowPart
= 0;seekto
.s
.HighPart
= 0;
195 hres
= IStream_Seek(pStm
,seekto
,SEEK_SET
,&newpos
);
197 FIXME("IStream_Seek failed, %lx\n",hres
);
200 hres
= IStream_Read(pStm
,msg
->Buffer
,msg
->cbBuffer
,&res
);
202 FIXME("Stream Read failed, %lx\n",hres
);
205 IStream_Release(pStm
);
208 FIXME("(%p,%p), stub!\n",msg
,chanbuf
);
209 FIXME("iMethod is %ld\n",msg
->iMethod
);
210 FIXME("cbBuffer is %ld\n",msg
->cbBuffer
);
214 static LPRPCSTUBBUFFER WINAPI
215 CFStub_IsIIDSupported(LPRPCSTUBBUFFER iface
,REFIID riid
) {
216 FIXME("(%s), stub!\n",debugstr_guid(riid
));
221 CFStub_CountRefs(LPRPCSTUBBUFFER iface
) {
222 FIXME("(), stub!\n");
226 static HRESULT WINAPI
227 CFStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface
,void** ppv
) {
228 FIXME("(%p), stub!\n",ppv
);
232 CFStub_DebugServerRelease(LPRPCSTUBBUFFER iface
,void *pv
) {
233 FIXME("(%p), stub!\n",pv
);
236 static ICOM_VTABLE(IRpcStubBuffer
) cfstubvt
= {
237 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
238 CFStub_QueryInterface
,
244 CFStub_IsIIDSupported
,
246 CFStub_DebugServerQueryInterface
,
247 CFStub_DebugServerRelease
251 CFStub_Construct(LPRPCSTUBBUFFER
*ppv
) {
253 cfstub
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(CFStub
));
255 return E_OUTOFMEMORY
;
256 *ppv
= (LPRPCSTUBBUFFER
)cfstub
;
257 cfstub
->lpvtbl
= &cfstubvt
;
262 /* Since we create proxy buffers and classfactory in a pair, there is
263 * no need for 2 separate structs. Just put them in one, but remember
266 typedef struct _CFProxy
{
267 ICOM_VTABLE(IClassFactory
) *lpvtbl_cf
;
268 ICOM_VTABLE(IRpcProxyBuffer
) *lpvtbl_proxy
;
271 IRpcChannelBuffer
*chanbuf
;
274 static HRESULT WINAPI
IRpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface
,REFIID riid
,LPVOID
*ppv
) {
276 if (IsEqualIID(riid
,&IID_IRpcProxyBuffer
)||IsEqualIID(riid
,&IID_IUnknown
)) {
277 IRpcProxyBuffer_AddRef(iface
);
278 *ppv
= (LPVOID
)iface
;
281 FIXME("(%s), no interface.\n",debugstr_guid(riid
));
282 return E_NOINTERFACE
;
285 static ULONG WINAPI
IRpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface
) {
286 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
287 return ++(This
->ref
);
290 static ULONG WINAPI
IRpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface
) {
291 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
293 if (!--(This
->ref
)) {
294 IRpcChannelBuffer_Release(This
->chanbuf
);This
->chanbuf
= NULL
;
295 HeapFree(GetProcessHeap(),0,This
);
301 static HRESULT WINAPI
IRpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface
,IRpcChannelBuffer
* pRpcChannelBuffer
) {
302 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
304 This
->chanbuf
= pRpcChannelBuffer
;
305 IRpcChannelBuffer_AddRef(This
->chanbuf
);
308 static void WINAPI
IRpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface
) {
309 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
311 IRpcChannelBuffer_Release(This
->chanbuf
);
312 This
->chanbuf
= NULL
;
316 static HRESULT WINAPI
317 CFProxy_QueryInterface(LPCLASSFACTORY iface
,REFIID riid
, LPVOID
*ppv
) {
319 if (IsEqualIID(&IID_IClassFactory
,riid
) || IsEqualIID(&IID_IUnknown
,riid
)) {
320 *ppv
= (LPVOID
)iface
;
321 IClassFactory_AddRef(iface
);
324 if (IsEqualIID(riid
,&IID_IMarshal
)) /* just to avoid debug output */
325 return E_NOINTERFACE
;
326 FIXME("Unhandled interface: %s\n",debugstr_guid(riid
));
327 return E_NOINTERFACE
;
330 static ULONG WINAPI
CFProxy_AddRef(LPCLASSFACTORY iface
) {
331 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
336 static ULONG WINAPI
CFProxy_Release(LPCLASSFACTORY iface
) {
337 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
341 HeapFree(GetProcessHeap(),0,This
);
345 static HRESULT WINAPI
CFProxy_CreateInstance(
346 LPCLASSFACTORY iface
,
347 LPUNKNOWN pUnkOuter
,/* [in] */
348 REFIID riid
, /* [in] */
349 LPVOID
*ppv
/* [out] */
351 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
358 TRACE("(%p,%s,%p)\n",pUnkOuter
,debugstr_guid(riid
),ppv
);
360 /* Send CreateInstance to the remote classfactory.
362 * Data: Only the 'IID'.
365 msg
.cbBuffer
= sizeof(*riid
);
367 hres
= IRpcChannelBuffer_GetBuffer(This
->chanbuf
,&msg
,&IID_IClassFactory
);
369 FIXME("IRpcChannelBuffer_GetBuffer failed with %lx?\n",hres
);
372 memcpy(msg
.Buffer
,riid
,sizeof(*riid
));
373 hres
= IRpcChannelBuffer_SendReceive(This
->chanbuf
,&msg
,&srstatus
);
375 FIXME("IRpcChannelBuffer_SendReceive failed with %lx?\n",hres
);
379 if (!msg
.cbBuffer
) /* interface not found on remote */
382 /* We got back: [Marshalled Interface data] */
383 TRACE("got %ld bytes data.\n",msg
.cbBuffer
);
384 hGlobal
= GlobalAlloc(GMEM_MOVEABLE
|GMEM_NODISCARD
|GMEM_SHARE
,msg
.cbBuffer
);
385 memcpy(GlobalLock(hGlobal
),msg
.Buffer
,msg
.cbBuffer
);
386 hres
= CreateStreamOnHGlobal(hGlobal
,TRUE
,&pStream
);
388 FIXME("CreateStreamOnHGlobal failed with %lx\n",hres
);
391 hres
= CoUnmarshalInterface(
396 IStream_Release(pStream
); /* Does GlobalFree hGlobal too. */
398 FIXME("CoMarshalInterface failed, %lx\n",hres
);
404 static HRESULT WINAPI
CFProxy_LockServer(LPCLASSFACTORY iface
,BOOL fLock
) {
405 /*ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);*/
406 FIXME("(%d), stub!\n",fLock
);
407 /* basically: write BOOL, read empty */
411 static ICOM_VTABLE(IRpcProxyBuffer
) pspbvtbl
= {
412 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
413 IRpcProxyBufferImpl_QueryInterface
,
414 IRpcProxyBufferImpl_AddRef
,
415 IRpcProxyBufferImpl_Release
,
416 IRpcProxyBufferImpl_Connect
,
417 IRpcProxyBufferImpl_Disconnect
419 static ICOM_VTABLE(IClassFactory
) cfproxyvt
= {
420 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
421 CFProxy_QueryInterface
,
424 CFProxy_CreateInstance
,
429 CFProxy_Construct(LPVOID
*ppv
,LPVOID
*ppProxy
) {
432 cf
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(CFProxy
));
434 return E_OUTOFMEMORY
;
436 cf
->lpvtbl_cf
= &cfproxyvt
;
437 cf
->lpvtbl_proxy
= &pspbvtbl
;
438 cf
->ref
= 2; /* we return 2 references to the object! */
439 *ppv
= &(cf
->lpvtbl_cf
);
440 *ppProxy
= &(cf
->lpvtbl_proxy
);
445 /********************* OLE Proxy/Stub Factory ********************************/
446 static HRESULT WINAPI
447 PSFacBuf_QueryInterface(LPPSFACTORYBUFFER iface
, REFIID iid
, LPVOID
*ppv
) {
448 if (IsEqualIID(iid
,&IID_IPSFactoryBuffer
)||IsEqualIID(iid
,&IID_IUnknown
)) {
449 *ppv
= (LPVOID
)iface
;
450 /* No ref counting, static class */
453 FIXME("(%s) unknown IID?\n",debugstr_guid(iid
));
454 return E_NOINTERFACE
;
457 static ULONG WINAPI
PSFacBuf_AddRef(LPPSFACTORYBUFFER iface
) { return 2; }
458 static ULONG WINAPI
PSFacBuf_Release(LPPSFACTORYBUFFER iface
) { return 1; }
460 static HRESULT WINAPI
461 PSFacBuf_CreateProxy(
462 LPPSFACTORYBUFFER iface
, IUnknown
* pUnkOuter
, REFIID riid
,
463 IRpcProxyBuffer
**ppProxy
, LPVOID
*ppv
465 if (IsEqualIID(&IID_IClassFactory
,riid
) ||
466 IsEqualIID(&IID_IUnknown
,riid
)
468 return CFProxy_Construct(ppv
,(LPVOID
*)ppProxy
);
469 FIXME("proxying not implemented for (%s) yet!\n",debugstr_guid(riid
));
473 static HRESULT WINAPI
475 LPPSFACTORYBUFFER iface
, REFIID riid
,IUnknown
*pUnkServer
,
476 IRpcStubBuffer
** ppStub
480 TRACE("(%s,%p,%p)\n",debugstr_guid(riid
),pUnkServer
,ppStub
);
482 if (IsEqualIID(&IID_IClassFactory
,riid
) ||
483 IsEqualIID(&IID_IUnknown
,riid
)
485 hres
= CFStub_Construct(ppStub
);
487 IRpcStubBuffer_Connect((*ppStub
),pUnkServer
);
490 FIXME("stubbing not implemented for (%s) yet!\n",debugstr_guid(riid
));
494 static ICOM_VTABLE(IPSFactoryBuffer
) psfacbufvtbl
= {
495 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
496 PSFacBuf_QueryInterface
,
499 PSFacBuf_CreateProxy
,
503 /* This is the whole PSFactoryBuffer object, just the vtableptr */
504 static ICOM_VTABLE(IPSFactoryBuffer
) *lppsfac
= &psfacbufvtbl
;
506 /***********************************************************************
507 * DllGetClassObject [OLE32.@]
509 HRESULT WINAPI
OLE32_DllGetClassObject(REFCLSID rclsid
, REFIID iid
,LPVOID
*ppv
)
512 if (IsEqualIID(rclsid
,&CLSID_PSFactoryBuffer
)) {
514 /* If we create a ps factory, we might need a stub manager later
520 if (IsEqualIID(rclsid
,&CLSID_DfMarshal
)&&(
521 IsEqualIID(iid
,&IID_IClassFactory
) ||
522 IsEqualIID(iid
,&IID_IUnknown
)
525 return MARSHAL_GetStandardMarshalCF(ppv
);
526 if (IsEqualIID(rclsid
,&CLSID_StdGlobalInterfaceTable
) && (IsEqualIID(iid
,&IID_IClassFactory
) || IsEqualIID(iid
,&IID_IUnknown
)))
527 return StdGlobalInterfaceTable_GetFactory(ppv
);
529 FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid
),debugstr_guid(iid
));
530 return CLASS_E_CLASSNOTAVAILABLE
;