2 * OLE32 proxy/stub handler
4 * Copyright 2002 Marcus Meissner
5 * Copyright 2001 Ove Kåven, TransGaming Technologies
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 /* Documentation on MSDN:
24 * (Top level COM documentation)
25 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnanchor/html/componentdevelopmentank.asp
28 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1q0p.asp
31 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1lia.asp
34 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/com/htm/comext_1gfn.asp
47 #define NONAMELESSUNION
48 #define NONAMELESSSTRUCT
60 #include "compobj_private.h"
63 #include "wine/debug.h"
65 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
67 const CLSID CLSID_DfMarshal
= { 0x0000030b, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
68 const CLSID CLSID_PSFactoryBuffer
= { 0x00000320, 0, 0, {0xc0, 0, 0, 0, 0, 0, 0, 0x46} };
70 /* From: http://msdn.microsoft.com/library/en-us/com/cmi_m_4lda.asp
72 * The first time a client requests a pointer to an interface on a
73 * particular object, COM loads an IClassFactory stub in the server
74 * process and uses it to marshal the first pointer back to the
75 * client. In the client process, COM loads the generic proxy for the
76 * class factory object and calls its implementation of IMarshal to
77 * unmarshal that first pointer. COM then creates the first interface
78 * proxy and hands it a pointer to the RPC channel. Finally, COM returns
79 * the IClassFactory pointer to the client, which uses it to call
80 * IClassFactory::CreateInstance, passing it a reference to the interface.
82 * Back in the server process, COM now creates a new instance of the
83 * object, along with a stub for the requested interface. This stub marshals
84 * the interface pointer back to the client process, where another object
85 * proxy is created, this time for the object itself. Also created is a
86 * proxy for the requested interface, a pointer to which is returned to
87 * the client. With subsequent calls to other interfaces on the object,
88 * COM will load the appropriate interface stubs and proxies as needed.
90 typedef struct _CFStub
{
91 const IRpcStubBufferVtbl
*lpvtbl
;
98 CFStub_QueryInterface(LPRPCSTUBBUFFER iface
, REFIID riid
, LPVOID
*ppv
) {
99 if (IsEqualIID(&IID_IUnknown
,riid
)||IsEqualIID(&IID_IRpcStubBuffer
,riid
)) {
100 *ppv
= (LPVOID
)iface
;
101 IUnknown_AddRef(iface
);
104 FIXME("(%s), interface not supported.\n",debugstr_guid(riid
));
105 return E_NOINTERFACE
;
109 CFStub_AddRef(LPRPCSTUBBUFFER iface
) {
110 CFStub
*This
= (CFStub
*)iface
;
111 return InterlockedIncrement(&This
->ref
);
115 CFStub_Release(LPRPCSTUBBUFFER iface
) {
116 CFStub
*This
= (CFStub
*)iface
;
119 ref
= InterlockedDecrement(&This
->ref
);
121 IRpcStubBuffer_Disconnect(iface
);
122 HeapFree(GetProcessHeap(),0,This
);
127 static HRESULT WINAPI
128 CFStub_Connect(LPRPCSTUBBUFFER iface
, IUnknown
*pUnkServer
) {
129 CFStub
*This
= (CFStub
*)iface
;
131 This
->pUnkServer
= pUnkServer
;
132 IUnknown_AddRef(pUnkServer
);
137 CFStub_Disconnect(LPRPCSTUBBUFFER iface
) {
138 CFStub
*This
= (CFStub
*)iface
;
140 if (This
->pUnkServer
) {
141 IUnknown_Release(This
->pUnkServer
);
142 This
->pUnkServer
= NULL
;
146 static HRESULT WINAPI
148 LPRPCSTUBBUFFER iface
,RPCOLEMESSAGE
* msg
,IRpcChannelBuffer
* chanbuf
150 CFStub
*This
= (CFStub
*)iface
;
153 if (msg
->iMethod
== 3) { /* CreateInstance */
155 IClassFactory
*classfac
;
159 ULARGE_INTEGER newpos
;
160 LARGE_INTEGER seekto
;
163 if (msg
->cbBuffer
< sizeof(IID
)) {
164 FIXME("Not enough bytes in buffer (%ld instead of %d)?\n",msg
->cbBuffer
,sizeof(IID
));
167 memcpy(&iid
,msg
->Buffer
,sizeof(iid
));
168 TRACE("->CreateInstance(%s)\n",debugstr_guid(&iid
));
169 hres
= IUnknown_QueryInterface(This
->pUnkServer
,&IID_IClassFactory
,(LPVOID
*)&classfac
);
171 FIXME("Ole server does not provide an IClassFactory?\n");
174 hres
= IClassFactory_CreateInstance(classfac
,NULL
,&iid
,(LPVOID
*)&ppv
);
175 IClassFactory_Release(classfac
);
178 FIXME("Failed to create an instance of %s\n",debugstr_guid(&iid
));
181 hres
= CreateStreamOnHGlobal(0,TRUE
,&pStm
);
183 FIXME("Failed to create stream on hglobal\n");
186 hres
= CoMarshalInterface(pStm
,&iid
,ppv
,0,NULL
,0);
187 IUnknown_Release((IUnknown
*)ppv
);
189 FIXME("CoMarshalInterface failed, %lx!\n",hres
);
193 hres
= IStream_Stat(pStm
,&ststg
,0);
195 FIXME("Stat failed.\n");
199 msg
->cbBuffer
= ststg
.cbSize
.u
.LowPart
;
201 I_RpcGetBuffer((RPC_MESSAGE
*)msg
);
202 if (hres
) return hres
;
204 seekto
.u
.LowPart
= 0;seekto
.u
.HighPart
= 0;
205 hres
= IStream_Seek(pStm
,seekto
,SEEK_SET
,&newpos
);
207 FIXME("IStream_Seek failed, %lx\n",hres
);
210 hres
= IStream_Read(pStm
,msg
->Buffer
,msg
->cbBuffer
,&res
);
212 FIXME("Stream Read failed, %lx\n",hres
);
215 IStream_Release(pStm
);
218 FIXME("(%p,%p), stub!\n",msg
,chanbuf
);
219 FIXME("iMethod is %ld\n",msg
->iMethod
);
220 FIXME("cbBuffer is %ld\n",msg
->cbBuffer
);
224 static LPRPCSTUBBUFFER WINAPI
225 CFStub_IsIIDSupported(LPRPCSTUBBUFFER iface
,REFIID riid
) {
226 FIXME("(%s), stub!\n",debugstr_guid(riid
));
231 CFStub_CountRefs(LPRPCSTUBBUFFER iface
) {
232 FIXME("(), stub!\n");
236 static HRESULT WINAPI
237 CFStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface
,void** ppv
) {
238 FIXME("(%p), stub!\n",ppv
);
242 CFStub_DebugServerRelease(LPRPCSTUBBUFFER iface
,void *pv
) {
243 FIXME("(%p), stub!\n",pv
);
246 static const IRpcStubBufferVtbl cfstubvt
= {
247 CFStub_QueryInterface
,
253 CFStub_IsIIDSupported
,
255 CFStub_DebugServerQueryInterface
,
256 CFStub_DebugServerRelease
260 CFStub_Construct(LPRPCSTUBBUFFER
*ppv
) {
262 cfstub
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(CFStub
));
264 return E_OUTOFMEMORY
;
265 *ppv
= (LPRPCSTUBBUFFER
)cfstub
;
266 cfstub
->lpvtbl
= &cfstubvt
;
271 /* Since we create proxy buffers and classfactory in a pair, there is
272 * no need for 2 separate structs. Just put them in one, but remember
275 typedef struct _CFProxy
{
276 const IClassFactoryVtbl
*lpvtbl_cf
;
277 const IRpcProxyBufferVtbl
*lpvtbl_proxy
;
280 IRpcChannelBuffer
*chanbuf
;
281 IUnknown
*outer_unknown
;
284 static HRESULT WINAPI
IRpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface
,REFIID riid
,LPVOID
*ppv
) {
286 if (IsEqualIID(riid
,&IID_IRpcProxyBuffer
)||IsEqualIID(riid
,&IID_IUnknown
)) {
287 IRpcProxyBuffer_AddRef(iface
);
288 *ppv
= (LPVOID
)iface
;
291 FIXME("(%s), no interface.\n",debugstr_guid(riid
));
292 return E_NOINTERFACE
;
295 static ULONG WINAPI
IRpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface
) {
296 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
297 return InterlockedIncrement(&This
->ref
);
300 static ULONG WINAPI
IRpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface
) {
301 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
302 ULONG ref
= InterlockedDecrement(&This
->ref
);
305 IRpcProxyBuffer_Disconnect(iface
);
306 HeapFree(GetProcessHeap(),0,This
);
311 static HRESULT WINAPI
IRpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface
,IRpcChannelBuffer
* pRpcChannelBuffer
) {
312 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
314 This
->chanbuf
= pRpcChannelBuffer
;
315 IRpcChannelBuffer_AddRef(This
->chanbuf
);
318 static void WINAPI
IRpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface
) {
319 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
321 IRpcChannelBuffer_Release(This
->chanbuf
);
322 This
->chanbuf
= NULL
;
326 static HRESULT WINAPI
327 CFProxy_QueryInterface(LPCLASSFACTORY iface
,REFIID riid
, LPVOID
*ppv
) {
328 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
329 if (This
->outer_unknown
) return IUnknown_QueryInterface(This
->outer_unknown
, riid
, ppv
);
331 if (IsEqualIID(&IID_IClassFactory
,riid
) || IsEqualIID(&IID_IUnknown
,riid
)) {
332 *ppv
= (LPVOID
)iface
;
333 IClassFactory_AddRef(iface
);
336 if (IsEqualIID(riid
,&IID_IMarshal
)) /* just to avoid debug output */
337 return E_NOINTERFACE
;
338 FIXME("Unhandled interface: %s\n",debugstr_guid(riid
));
339 return E_NOINTERFACE
;
342 static ULONG WINAPI
CFProxy_AddRef(LPCLASSFACTORY iface
) {
343 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
344 if (This
->outer_unknown
) return IUnknown_AddRef(This
->outer_unknown
);
345 return InterlockedIncrement(&This
->ref
);
348 static ULONG WINAPI
CFProxy_Release(LPCLASSFACTORY iface
) {
350 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
351 if (This
->outer_unknown
)
352 ref
= IUnknown_Release(This
->outer_unknown
);
354 ref
= InterlockedDecrement(&This
->ref
);
357 if (This
->chanbuf
) IRpcChannelBuffer_Release(This
->chanbuf
);
358 HeapFree(GetProcessHeap(),0,This
);
363 static HRESULT WINAPI
CFProxy_CreateInstance(
364 LPCLASSFACTORY iface
,
365 LPUNKNOWN pUnkOuter
,/* [in] */
366 REFIID riid
, /* [in] */
367 LPVOID
*ppv
/* [out] */
369 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
376 TRACE("(%p,%s,%p)\n",pUnkOuter
,debugstr_guid(riid
),ppv
);
378 /* Send CreateInstance to the remote classfactory.
380 * Data: Only the 'IID'.
383 msg
.cbBuffer
= sizeof(*riid
);
385 hres
= IRpcChannelBuffer_GetBuffer(This
->chanbuf
,&msg
,&IID_IClassFactory
);
387 FIXME("IRpcChannelBuffer_GetBuffer failed with %lx?\n",hres
);
390 memcpy(msg
.Buffer
,riid
,sizeof(*riid
));
391 hres
= IRpcChannelBuffer_SendReceive(This
->chanbuf
,&msg
,&srstatus
);
393 FIXME("IRpcChannelBuffer_SendReceive failed with %lx?\n",hres
);
397 if (!msg
.cbBuffer
) /* interface not found on remote */
400 /* We got back: [Marshalled Interface data] */
401 TRACE("got %ld bytes data.\n",msg
.cbBuffer
);
402 hGlobal
= GlobalAlloc(GMEM_MOVEABLE
|GMEM_NODISCARD
|GMEM_SHARE
,msg
.cbBuffer
);
403 memcpy(GlobalLock(hGlobal
),msg
.Buffer
,msg
.cbBuffer
);
404 hres
= CreateStreamOnHGlobal(hGlobal
,TRUE
,&pStream
);
406 FIXME("CreateStreamOnHGlobal failed with %lx\n",hres
);
409 hres
= CoUnmarshalInterface(
414 IStream_Release(pStream
); /* Does GlobalFree hGlobal too. */
416 FIXME("CoMarshalInterface failed, %lx\n",hres
);
422 static HRESULT WINAPI
CFProxy_LockServer(LPCLASSFACTORY iface
,BOOL fLock
) {
423 /*ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);*/
424 FIXME("(%d), stub!\n",fLock
);
425 /* basically: write BOOL, read empty */
429 static const IRpcProxyBufferVtbl pspbvtbl
= {
430 IRpcProxyBufferImpl_QueryInterface
,
431 IRpcProxyBufferImpl_AddRef
,
432 IRpcProxyBufferImpl_Release
,
433 IRpcProxyBufferImpl_Connect
,
434 IRpcProxyBufferImpl_Disconnect
436 static const IClassFactoryVtbl cfproxyvt
= {
437 CFProxy_QueryInterface
,
440 CFProxy_CreateInstance
,
445 CFProxy_Construct(IUnknown
*pUnkOuter
, LPVOID
*ppv
,LPVOID
*ppProxy
) {
448 cf
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(CFProxy
));
450 return E_OUTOFMEMORY
;
452 cf
->lpvtbl_cf
= &cfproxyvt
;
453 cf
->lpvtbl_proxy
= &pspbvtbl
;
454 /* one reference for the proxy buffer */
456 cf
->outer_unknown
= pUnkOuter
;
457 *ppv
= &(cf
->lpvtbl_cf
);
458 *ppProxy
= &(cf
->lpvtbl_proxy
);
459 /* and one reference for the object */
460 IUnknown_AddRef((IUnknown
*)*ppv
);
465 /********************* IRemUnknown Proxy/Stub ********************************/
469 const IRpcStubBufferVtbl
*lpVtbl
;
474 static HRESULT WINAPI
RemUnkStub_QueryInterface(LPRPCSTUBBUFFER iface
,
478 RemUnkStub
*This
= (RemUnkStub
*)iface
;
479 TRACE("(%p)->QueryInterface(%s,%p)\n",This
,debugstr_guid(riid
),obj
);
480 if (IsEqualGUID(&IID_IUnknown
,riid
) ||
481 IsEqualGUID(&IID_IRpcStubBuffer
,riid
)) {
485 return E_NOINTERFACE
;
488 static ULONG WINAPI
RemUnkStub_AddRef(LPRPCSTUBBUFFER iface
)
490 RemUnkStub
*This
= (RemUnkStub
*)iface
;
491 TRACE("(%p)->AddRef()\n",This
);
492 return InterlockedIncrement(&This
->refs
);
495 static ULONG WINAPI
RemUnkStub_Release(LPRPCSTUBBUFFER iface
)
497 RemUnkStub
*This
= (RemUnkStub
*)iface
;
499 TRACE("(%p)->Release()\n",This
);
500 refs
= InterlockedDecrement(&This
->refs
);
502 HeapFree(GetProcessHeap(), 0, This
);
506 static HRESULT WINAPI
RemUnkStub_Connect(LPRPCSTUBBUFFER iface
,
507 LPUNKNOWN lpUnkServer
)
509 RemUnkStub
*This
= (RemUnkStub
*)iface
;
510 TRACE("(%p)->Connect(%p)\n",This
,lpUnkServer
);
511 This
->iface
= (IRemUnknown
*)lpUnkServer
;
512 IRemUnknown_AddRef(This
->iface
);
516 static void WINAPI
RemUnkStub_Disconnect(LPRPCSTUBBUFFER iface
)
518 RemUnkStub
*This
= (RemUnkStub
*)iface
;
519 TRACE("(%p)->Disconnect()\n",This
);
520 IUnknown_Release(This
->iface
);
524 static HRESULT WINAPI
RemUnkStub_Invoke(LPRPCSTUBBUFFER iface
,
526 LPRPCCHANNELBUFFER pChannel
)
528 RemUnkStub
*This
= (RemUnkStub
*)iface
;
529 ULONG iMethod
= pMsg
->iMethod
;
530 LPBYTE buf
= pMsg
->Buffer
;
531 HRESULT hr
= RPC_E_INVALIDMETHOD
;
533 TRACE("(%p)->Invoke(%p,%p) method %ld\n", This
, pMsg
, pChannel
, iMethod
);
536 case 3: /* RemQueryInterface */
542 REMQIRESULT
*pQIResults
= NULL
;
545 memcpy(&ipid
, buf
, sizeof(ipid
));
547 memcpy(&cRefs
, buf
, sizeof(cRefs
));
548 buf
+= sizeof(cRefs
);
549 memcpy(&cIids
, buf
, sizeof(cIids
));
550 buf
+= sizeof(cIids
);
553 hr
= IRemUnknown_RemQueryInterface(This
->iface
, &ipid
, cRefs
, cIids
, iids
, &pQIResults
);
556 pMsg
->cbBuffer
= cIids
* sizeof(REMQIRESULT
) + sizeof(HRESULT
);
558 I_RpcGetBuffer((RPC_MESSAGE
*)pMsg
);
561 *(HRESULT
*)buf
= hr
;
562 buf
+= sizeof(HRESULT
);
565 /* FIXME: pQIResults is a unique pointer so pQIResults can be NULL! */
566 memcpy(buf
, pQIResults
, cIids
* sizeof(REMQIRESULT
));
570 case 4: /* RemAddRef */
577 memcpy(&cIids
, buf
, sizeof(USHORT
));
578 buf
+= sizeof(USHORT
);
579 ir
= (REMINTERFACEREF
*)buf
;
580 pResults
= CoTaskMemAlloc(cIids
* sizeof(HRESULT
));
581 if (!pResults
) return E_OUTOFMEMORY
;
583 hr
= IRemUnknown_RemAddRef(This
->iface
, cIids
, ir
, pResults
);
586 pMsg
->cbBuffer
= cIids
* sizeof(HRESULT
);
588 I_RpcGetBuffer((RPC_MESSAGE
*)pMsg
);
592 memcpy(buf
, pResults
, cIids
* sizeof(HRESULT
));
595 CoTaskMemFree(pResults
);
599 case 5: /* RemRelease */
605 memcpy(&cIids
, buf
, sizeof(USHORT
));
606 buf
+= sizeof(USHORT
);
607 ir
= (REMINTERFACEREF
*)buf
;
609 hr
= IRemUnknown_RemRelease(This
->iface
, cIids
, ir
);
619 static LPRPCSTUBBUFFER WINAPI
RemUnkStub_IsIIDSupported(LPRPCSTUBBUFFER iface
,
622 RemUnkStub
*This
= (RemUnkStub
*)iface
;
623 TRACE("(%p)->IsIIDSupported(%s)\n", This
, debugstr_guid(riid
));
624 return IsEqualGUID(&IID_IRemUnknown
, riid
) ? iface
: NULL
;
627 static ULONG WINAPI
RemUnkStub_CountRefs(LPRPCSTUBBUFFER iface
)
629 RemUnkStub
*This
= (RemUnkStub
*)iface
;
630 FIXME("(%p)->CountRefs()\n", This
);
634 static HRESULT WINAPI
RemUnkStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface
,
637 RemUnkStub
*This
= (RemUnkStub
*)iface
;
638 FIXME("(%p)->DebugServerQueryInterface(%p)\n",This
,ppv
);
639 return E_NOINTERFACE
;
642 static void WINAPI
RemUnkStub_DebugServerRelease(LPRPCSTUBBUFFER iface
,
645 RemUnkStub
*This
= (RemUnkStub
*)iface
;
646 FIXME("(%p)->DebugServerRelease(%p)\n", This
, pv
);
649 static const IRpcStubBufferVtbl RemUnkStub_VTable
=
651 RemUnkStub_QueryInterface
,
655 RemUnkStub_Disconnect
,
657 RemUnkStub_IsIIDSupported
,
658 RemUnkStub_CountRefs
,
659 RemUnkStub_DebugServerQueryInterface
,
660 RemUnkStub_DebugServerRelease
663 static HRESULT
RemUnkStub_Construct(IRpcStubBuffer
**ppStub
)
665 RemUnkStub
*This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
666 if (!This
) return E_OUTOFMEMORY
;
667 This
->lpVtbl
= &RemUnkStub_VTable
;
670 *ppStub
= (IRpcStubBuffer
*)This
;
675 typedef struct _RemUnkProxy
{
676 const IRemUnknownVtbl
*lpvtbl_remunk
;
677 const IRpcProxyBufferVtbl
*lpvtbl_proxy
;
680 IRpcChannelBuffer
*chan
;
681 IUnknown
*outer_unknown
;
684 static HRESULT WINAPI
RemUnkProxy_QueryInterface(LPREMUNKNOWN iface
, REFIID riid
, void **ppv
)
686 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
687 if (This
->outer_unknown
)
688 return IUnknown_QueryInterface(This
->outer_unknown
, riid
, ppv
);
689 if (IsEqualIID(riid
, &IID_IUnknown
) ||
690 IsEqualIID(riid
, &IID_IRemUnknown
))
692 IRemUnknown_AddRef(iface
);
693 *ppv
= (LPVOID
)iface
;
696 return E_NOINTERFACE
;
699 static ULONG WINAPI
RemUnkProxy_AddRef(LPREMUNKNOWN iface
)
701 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
704 TRACE("(%p)->AddRef()\n",This
);
706 if (This
->outer_unknown
)
707 refs
= IUnknown_AddRef(This
->outer_unknown
);
709 refs
= InterlockedIncrement(&This
->refs
);
713 static ULONG WINAPI
RemUnkProxy_Release(LPREMUNKNOWN iface
)
715 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
718 TRACE("(%p)->Release()\n",This
);
719 if (This
->outer_unknown
)
720 refs
= IUnknown_Release(This
->outer_unknown
);
722 refs
= InterlockedDecrement(&This
->refs
);
725 if (This
->chan
) IRpcChannelBuffer_Release(This
->chan
);
726 HeapFree(GetProcessHeap(),0,This
);
731 static HRESULT WINAPI
RemUnkProxy_RemQueryInterface(LPREMUNKNOWN iface
,
736 REMQIRESULT
** ppQIResults
)
738 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
743 TRACE("(%p)->(%s,%ld,%d,%p,%p)\n",This
,
744 debugstr_guid(ripid
),cRefs
,cIids
,iids
,ppQIResults
);
747 memset(&msg
, 0, sizeof(msg
));
749 msg
.cbBuffer
= sizeof(IPID
) + sizeof(ULONG
) +
750 sizeof(USHORT
) + cIids
*sizeof(IID
);
751 hr
= IRpcChannelBuffer_GetBuffer(This
->chan
, &msg
, &IID_IRemUnknown
);
753 LPBYTE buf
= msg
.Buffer
;
754 memcpy(buf
, ripid
, sizeof(IPID
));
756 memcpy(buf
, &cRefs
, sizeof(ULONG
));
757 buf
+= sizeof(ULONG
);
758 memcpy(buf
, &cIids
, sizeof(USHORT
));
759 buf
+= sizeof(USHORT
);
760 memcpy(buf
, iids
, cIids
*sizeof(IID
));
762 hr
= IRpcChannelBuffer_SendReceive(This
->chan
, &msg
, &status
);
767 hr
= *(HRESULT
*)buf
;
768 buf
+= sizeof(HRESULT
);
772 *ppQIResults
= CoTaskMemAlloc(cIids
*sizeof(REMQIRESULT
));
773 memcpy(*ppQIResults
, buf
, cIids
*sizeof(REMQIRESULT
));
776 IRpcChannelBuffer_FreeBuffer(This
->chan
, &msg
);
782 static HRESULT WINAPI
RemUnkProxy_RemAddRef(LPREMUNKNOWN iface
,
783 USHORT cInterfaceRefs
,
784 REMINTERFACEREF
* InterfaceRefs
,
787 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
792 TRACE("(%p)->(%d,%p,%p)\n",This
,
793 cInterfaceRefs
,InterfaceRefs
,pResults
);
795 memset(&msg
, 0, sizeof(msg
));
797 msg
.cbBuffer
= sizeof(USHORT
) + cInterfaceRefs
*sizeof(REMINTERFACEREF
);
798 hr
= IRpcChannelBuffer_GetBuffer(This
->chan
, &msg
, &IID_IRemUnknown
);
800 LPBYTE buf
= msg
.Buffer
;
801 memcpy(buf
, &cInterfaceRefs
, sizeof(USHORT
));
802 buf
+= sizeof(USHORT
);
803 memcpy(buf
, InterfaceRefs
, cInterfaceRefs
*sizeof(REMINTERFACEREF
));
805 hr
= IRpcChannelBuffer_SendReceive(This
->chan
, &msg
, &status
);
809 memcpy(pResults
, buf
, cInterfaceRefs
*sizeof(HRESULT
));
812 IRpcChannelBuffer_FreeBuffer(This
->chan
, &msg
);
818 static HRESULT WINAPI
RemUnkProxy_RemRelease(LPREMUNKNOWN iface
,
819 USHORT cInterfaceRefs
,
820 REMINTERFACEREF
* InterfaceRefs
)
822 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
827 TRACE("(%p)->(%d,%p)\n",This
,
828 cInterfaceRefs
,InterfaceRefs
);
830 memset(&msg
, 0, sizeof(msg
));
832 msg
.cbBuffer
= sizeof(USHORT
) + cInterfaceRefs
*sizeof(REMINTERFACEREF
);
833 hr
= IRpcChannelBuffer_GetBuffer(This
->chan
, &msg
, &IID_IRemUnknown
);
835 LPBYTE buf
= msg
.Buffer
;
836 memcpy(buf
, &cInterfaceRefs
, sizeof(USHORT
));
837 buf
+= sizeof(USHORT
);
838 memcpy(buf
, InterfaceRefs
, cInterfaceRefs
*sizeof(REMINTERFACEREF
));
840 hr
= IRpcChannelBuffer_SendReceive(This
->chan
, &msg
, &status
);
842 IRpcChannelBuffer_FreeBuffer(This
->chan
, &msg
);
848 static const IRemUnknownVtbl RemUnkProxy_VTable
=
850 RemUnkProxy_QueryInterface
,
853 RemUnkProxy_RemQueryInterface
,
854 RemUnkProxy_RemAddRef
,
855 RemUnkProxy_RemRelease
859 static HRESULT WINAPI
RURpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface
,REFIID riid
,LPVOID
*ppv
) {
861 if (IsEqualIID(riid
,&IID_IRpcProxyBuffer
)||IsEqualIID(riid
,&IID_IUnknown
)) {
862 IRpcProxyBuffer_AddRef(iface
);
863 *ppv
= (LPVOID
)iface
;
866 FIXME("(%s), no interface.\n",debugstr_guid(riid
));
867 return E_NOINTERFACE
;
870 static ULONG WINAPI
RURpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface
) {
871 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
872 TRACE("%p, %ld\n", iface
, This
->refs
+ 1);
873 return InterlockedIncrement(&This
->refs
);
876 static ULONG WINAPI
RURpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface
) {
877 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
878 ULONG ref
= InterlockedDecrement(&This
->refs
);
879 TRACE("%p, %ld\n", iface
, ref
);
881 IRpcProxyBuffer_Disconnect(iface
);
882 HeapFree(GetProcessHeap(),0,This
);
887 static HRESULT WINAPI
RURpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface
,IRpcChannelBuffer
* pRpcChannelBuffer
) {
888 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
890 TRACE("%p, %p\n", iface
, pRpcChannelBuffer
);
891 This
->chan
= pRpcChannelBuffer
;
892 IRpcChannelBuffer_AddRef(This
->chan
);
895 static void WINAPI
RURpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface
) {
896 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
897 TRACE("%p, %p\n", iface
, This
->chan
);
899 IRpcChannelBuffer_Release(This
->chan
);
905 static const IRpcProxyBufferVtbl RURpcProxyBuffer_VTable
= {
906 RURpcProxyBufferImpl_QueryInterface
,
907 RURpcProxyBufferImpl_AddRef
,
908 RURpcProxyBufferImpl_Release
,
909 RURpcProxyBufferImpl_Connect
,
910 RURpcProxyBufferImpl_Disconnect
914 RemUnkProxy_Construct(IUnknown
*pUnkOuter
, LPVOID
*ppv
,LPVOID
*ppProxy
) {
917 This
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(*This
));
919 return E_OUTOFMEMORY
;
921 This
->lpvtbl_remunk
= &RemUnkProxy_VTable
;
922 This
->lpvtbl_proxy
= &RURpcProxyBuffer_VTable
;
923 /* only one reference for the proxy buffer */
925 This
->outer_unknown
= pUnkOuter
;
926 *ppv
= &(This
->lpvtbl_remunk
);
927 *ppProxy
= &(This
->lpvtbl_proxy
);
928 /* and one reference for the object */
929 IUnknown_AddRef((IUnknown
*)*ppv
);
934 /********************* OLE Proxy/Stub Factory ********************************/
935 static HRESULT WINAPI
936 PSFacBuf_QueryInterface(LPPSFACTORYBUFFER iface
, REFIID iid
, LPVOID
*ppv
) {
937 if (IsEqualIID(iid
,&IID_IPSFactoryBuffer
)||IsEqualIID(iid
,&IID_IUnknown
)) {
938 *ppv
= (LPVOID
)iface
;
939 /* No ref counting, static class */
942 FIXME("(%s) unknown IID?\n",debugstr_guid(iid
));
943 return E_NOINTERFACE
;
946 static ULONG WINAPI
PSFacBuf_AddRef(LPPSFACTORYBUFFER iface
) { return 2; }
947 static ULONG WINAPI
PSFacBuf_Release(LPPSFACTORYBUFFER iface
) { return 1; }
949 static HRESULT WINAPI
950 PSFacBuf_CreateProxy(
951 LPPSFACTORYBUFFER iface
, IUnknown
* pUnkOuter
, REFIID riid
,
952 IRpcProxyBuffer
**ppProxy
, LPVOID
*ppv
954 if (IsEqualIID(&IID_IClassFactory
,riid
))
955 return CFProxy_Construct(pUnkOuter
, ppv
,(LPVOID
*)ppProxy
);
956 else if (IsEqualIID(&IID_IRemUnknown
,riid
))
957 return RemUnkProxy_Construct(pUnkOuter
, ppv
,(LPVOID
*)ppProxy
);
958 FIXME("proxying not implemented for (%s) yet!\n",debugstr_guid(riid
));
962 static HRESULT WINAPI
964 LPPSFACTORYBUFFER iface
, REFIID riid
,IUnknown
*pUnkServer
,
965 IRpcStubBuffer
** ppStub
969 TRACE("(%s,%p,%p)\n",debugstr_guid(riid
),pUnkServer
,ppStub
);
971 if (IsEqualIID(&IID_IClassFactory
, riid
) ||
972 IsEqualIID(&IID_IUnknown
, riid
) /* FIXME: fixup stub manager and remove this*/) {
973 hres
= CFStub_Construct(ppStub
);
975 IRpcStubBuffer_Connect((*ppStub
),pUnkServer
);
977 } else if (IsEqualIID(&IID_IRemUnknown
,riid
)) {
978 hres
= RemUnkStub_Construct(ppStub
);
980 IRpcStubBuffer_Connect((*ppStub
),pUnkServer
);
983 FIXME("stubbing not implemented for (%s) yet!\n",debugstr_guid(riid
));
987 static const IPSFactoryBufferVtbl psfacbufvtbl
= {
988 PSFacBuf_QueryInterface
,
991 PSFacBuf_CreateProxy
,
995 /* This is the whole PSFactoryBuffer object, just the vtableptr */
996 static const IPSFactoryBufferVtbl
*lppsfac
= &psfacbufvtbl
;
998 /***********************************************************************
999 * DllGetClassObject [OLE32.@]
1001 HRESULT WINAPI
DllGetClassObject(REFCLSID rclsid
, REFIID iid
,LPVOID
*ppv
)
1004 if (IsEqualIID(rclsid
, &CLSID_PSFactoryBuffer
))
1005 return IPSFactoryBuffer_QueryInterface((IPSFactoryBuffer
*)&lppsfac
, iid
, ppv
);
1006 if (IsEqualIID(rclsid
,&CLSID_DfMarshal
)&&(
1007 IsEqualIID(iid
,&IID_IClassFactory
) ||
1008 IsEqualIID(iid
,&IID_IUnknown
)
1011 return MARSHAL_GetStandardMarshalCF(ppv
);
1012 if (IsEqualIID(rclsid
,&CLSID_StdGlobalInterfaceTable
) && (IsEqualIID(iid
,&IID_IClassFactory
) || IsEqualIID(iid
,&IID_IUnknown
)))
1013 return StdGlobalInterfaceTable_GetFactory(ppv
);
1014 if (IsEqualCLSID(rclsid
, &CLSID_FileMoniker
))
1015 return FileMonikerCF_Create(iid
, ppv
);
1016 if (IsEqualCLSID(rclsid
, &CLSID_ItemMoniker
))
1017 return ItemMonikerCF_Create(iid
, ppv
);
1019 FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid
),debugstr_guid(iid
));
1020 return CLASS_E_CLASSNOTAVAILABLE
;