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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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
46 #define NONAMELESSUNION
47 #define NONAMELESSSTRUCT
59 #include "compobj_private.h"
62 #include "wine/debug.h"
64 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
66 static ULONG WINAPI
RURpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface
);
68 /* From: http://msdn.microsoft.com/library/en-us/com/cmi_m_4lda.asp
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.
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.
88 typedef struct _CFStub
{
89 const IRpcStubBufferVtbl
*lpvtbl
;
96 CFStub_QueryInterface(LPRPCSTUBBUFFER iface
, REFIID riid
, LPVOID
*ppv
) {
97 if (IsEqualIID(&IID_IUnknown
,riid
)||IsEqualIID(&IID_IRpcStubBuffer
,riid
)) {
99 IUnknown_AddRef(iface
);
102 FIXME("(%s), interface not supported.\n",debugstr_guid(riid
));
103 return E_NOINTERFACE
;
107 CFStub_AddRef(LPRPCSTUBBUFFER iface
) {
108 CFStub
*This
= (CFStub
*)iface
;
109 return InterlockedIncrement(&This
->ref
);
113 CFStub_Release(LPRPCSTUBBUFFER iface
) {
114 CFStub
*This
= (CFStub
*)iface
;
117 ref
= InterlockedDecrement(&This
->ref
);
119 IRpcStubBuffer_Disconnect(iface
);
120 HeapFree(GetProcessHeap(),0,This
);
125 static HRESULT WINAPI
126 CFStub_Connect(LPRPCSTUBBUFFER iface
, IUnknown
*pUnkServer
) {
127 CFStub
*This
= (CFStub
*)iface
;
129 This
->pUnkServer
= pUnkServer
;
130 IUnknown_AddRef(pUnkServer
);
135 CFStub_Disconnect(LPRPCSTUBBUFFER iface
) {
136 CFStub
*This
= (CFStub
*)iface
;
138 if (This
->pUnkServer
) {
139 IUnknown_Release(This
->pUnkServer
);
140 This
->pUnkServer
= NULL
;
144 static HRESULT WINAPI
146 LPRPCSTUBBUFFER iface
,RPCOLEMESSAGE
* msg
,IRpcChannelBuffer
* chanbuf
148 CFStub
*This
= (CFStub
*)iface
;
151 if (msg
->iMethod
== 3) { /* CreateInstance */
153 IClassFactory
*classfac
;
157 ULARGE_INTEGER newpos
;
158 LARGE_INTEGER seekto
;
161 if (msg
->cbBuffer
< sizeof(IID
)) {
162 FIXME("Not enough bytes in buffer (%d)?\n",msg
->cbBuffer
);
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
);
169 FIXME("Ole server does not provide an IClassFactory?\n");
172 hres
= IClassFactory_CreateInstance(classfac
,NULL
,&iid
,(LPVOID
*)&ppv
);
173 IClassFactory_Release(classfac
);
176 FIXME("Failed to create an instance of %s\n",debugstr_guid(&iid
));
179 hres
= CreateStreamOnHGlobal(0,TRUE
,&pStm
);
181 FIXME("Failed to create stream on hglobal\n");
184 hres
= CoMarshalInterface(pStm
,&iid
,ppv
,0,NULL
,0);
185 IUnknown_Release((IUnknown
*)ppv
);
187 FIXME("CoMarshalInterface failed, %x!\n",hres
);
190 hres
= IStream_Stat(pStm
,&ststg
,0);
192 FIXME("Stat failed.\n");
196 msg
->cbBuffer
= ststg
.cbSize
.u
.LowPart
;
199 IRpcChannelBuffer_GetBuffer(chanbuf
, msg
, &IID_IClassFactory
);
200 if (hres
) return hres
;
202 seekto
.u
.LowPart
= 0;seekto
.u
.HighPart
= 0;
203 hres
= IStream_Seek(pStm
,seekto
,SEEK_SET
,&newpos
);
205 FIXME("IStream_Seek failed, %x\n",hres
);
208 hres
= IStream_Read(pStm
,msg
->Buffer
,msg
->cbBuffer
,&res
);
210 FIXME("Stream Read failed, %x\n",hres
);
213 IStream_Release(pStm
);
216 FIXME("(%p,%p), stub!\n",msg
,chanbuf
);
217 FIXME("iMethod is %d\n",msg
->iMethod
);
218 FIXME("cbBuffer is %d\n",msg
->cbBuffer
);
222 static LPRPCSTUBBUFFER WINAPI
223 CFStub_IsIIDSupported(LPRPCSTUBBUFFER iface
,REFIID riid
) {
224 FIXME("(%s), stub!\n",debugstr_guid(riid
));
229 CFStub_CountRefs(LPRPCSTUBBUFFER iface
) {
230 FIXME("(), stub!\n");
234 static HRESULT WINAPI
235 CFStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface
,void** ppv
) {
236 FIXME("(%p), stub!\n",ppv
);
240 CFStub_DebugServerRelease(LPRPCSTUBBUFFER iface
,void *pv
) {
241 FIXME("(%p), stub!\n",pv
);
244 static const IRpcStubBufferVtbl cfstubvt
= {
245 CFStub_QueryInterface
,
251 CFStub_IsIIDSupported
,
253 CFStub_DebugServerQueryInterface
,
254 CFStub_DebugServerRelease
258 CFStub_Construct(LPRPCSTUBBUFFER
*ppv
) {
260 cfstub
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(CFStub
));
262 return E_OUTOFMEMORY
;
263 *ppv
= (LPRPCSTUBBUFFER
)cfstub
;
264 cfstub
->lpvtbl
= &cfstubvt
;
269 /* Since we create proxy buffers and classfactory in a pair, there is
270 * no need for 2 separate structs. Just put them in one, but remember
273 typedef struct _CFProxy
{
274 const IClassFactoryVtbl
*lpvtbl_cf
;
275 const IRpcProxyBufferVtbl
*lpvtbl_proxy
;
278 IRpcChannelBuffer
*chanbuf
;
279 IUnknown
*outer_unknown
;
282 static HRESULT WINAPI
IRpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface
,REFIID riid
,LPVOID
*ppv
) {
284 if (IsEqualIID(riid
,&IID_IRpcProxyBuffer
)||IsEqualIID(riid
,&IID_IUnknown
)) {
285 IRpcProxyBuffer_AddRef(iface
);
286 *ppv
= (LPVOID
)iface
;
289 FIXME("(%s), no interface.\n",debugstr_guid(riid
));
290 return E_NOINTERFACE
;
293 static ULONG WINAPI
IRpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface
) {
294 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
295 return InterlockedIncrement(&This
->ref
);
298 static ULONG WINAPI
IRpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface
) {
299 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
300 ULONG ref
= InterlockedDecrement(&This
->ref
);
303 IRpcProxyBuffer_Disconnect(iface
);
304 HeapFree(GetProcessHeap(),0,This
);
309 static HRESULT WINAPI
IRpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface
,IRpcChannelBuffer
* pRpcChannelBuffer
) {
310 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
312 This
->chanbuf
= pRpcChannelBuffer
;
313 IRpcChannelBuffer_AddRef(This
->chanbuf
);
316 static void WINAPI
IRpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface
) {
317 ICOM_THIS_MULTI(CFProxy
,lpvtbl_proxy
,iface
);
319 IRpcChannelBuffer_Release(This
->chanbuf
);
320 This
->chanbuf
= NULL
;
324 static HRESULT WINAPI
325 CFProxy_QueryInterface(LPCLASSFACTORY iface
,REFIID riid
, LPVOID
*ppv
) {
326 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
327 if (This
->outer_unknown
) return IUnknown_QueryInterface(This
->outer_unknown
, riid
, ppv
);
329 if (IsEqualIID(&IID_IClassFactory
,riid
) || IsEqualIID(&IID_IUnknown
,riid
)) {
330 *ppv
= (LPVOID
)iface
;
331 IClassFactory_AddRef(iface
);
334 if (IsEqualIID(riid
,&IID_IMarshal
)) /* just to avoid debug output */
335 return E_NOINTERFACE
;
336 FIXME("Unhandled interface: %s\n",debugstr_guid(riid
));
337 return E_NOINTERFACE
;
340 static ULONG WINAPI
CFProxy_AddRef(LPCLASSFACTORY iface
) {
341 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
342 if (This
->outer_unknown
) return IUnknown_AddRef(This
->outer_unknown
);
343 return InterlockedIncrement(&This
->ref
);
346 static ULONG WINAPI
CFProxy_Release(LPCLASSFACTORY iface
) {
347 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
348 if (This
->outer_unknown
)
349 return IUnknown_Release(This
->outer_unknown
);
351 return IRpcProxyBufferImpl_Release((IRpcProxyBuffer
*)&This
->lpvtbl_proxy
);
354 static HRESULT WINAPI
CFProxy_CreateInstance(
355 LPCLASSFACTORY iface
,
356 LPUNKNOWN pUnkOuter
,/* [in] */
357 REFIID riid
, /* [in] */
358 LPVOID
*ppv
/* [out] */
360 ICOM_THIS_MULTI(CFProxy
,lpvtbl_cf
,iface
);
367 TRACE("(%p,%s,%p)\n",pUnkOuter
,debugstr_guid(riid
),ppv
);
369 /* Send CreateInstance to the remote classfactory.
371 * Data: Only the 'IID'.
374 msg
.cbBuffer
= sizeof(*riid
);
376 hres
= IRpcChannelBuffer_GetBuffer(This
->chanbuf
,&msg
,&IID_IClassFactory
);
378 FIXME("IRpcChannelBuffer_GetBuffer failed with %x?\n",hres
);
381 memcpy(msg
.Buffer
,riid
,sizeof(*riid
));
382 hres
= IRpcChannelBuffer_SendReceive(This
->chanbuf
,&msg
,&srstatus
);
384 FIXME("IRpcChannelBuffer_SendReceive failed with %x?\n",hres
);
385 IRpcChannelBuffer_FreeBuffer(This
->chanbuf
,&msg
);
389 if (!msg
.cbBuffer
) { /* interface not found on remote */
390 IRpcChannelBuffer_FreeBuffer(This
->chanbuf
,&msg
);
394 /* We got back: [Marshalled Interface data] */
395 TRACE("got %d bytes data.\n",msg
.cbBuffer
);
396 hGlobal
= GlobalAlloc(GMEM_MOVEABLE
|GMEM_NODISCARD
|GMEM_SHARE
,msg
.cbBuffer
);
397 memcpy(GlobalLock(hGlobal
),msg
.Buffer
,msg
.cbBuffer
);
398 hres
= CreateStreamOnHGlobal(hGlobal
,TRUE
,&pStream
);
400 FIXME("CreateStreamOnHGlobal failed with %x\n",hres
);
401 IRpcChannelBuffer_FreeBuffer(This
->chanbuf
,&msg
);
404 hres
= CoUnmarshalInterface(
409 IStream_Release(pStream
); /* Does GlobalFree hGlobal too. */
411 IRpcChannelBuffer_FreeBuffer(This
->chanbuf
,&msg
);
414 FIXME("CoMarshalInterface failed, %x\n",hres
);
420 static HRESULT WINAPI
CFProxy_LockServer(LPCLASSFACTORY iface
,BOOL fLock
) {
421 /*ICOM_THIS_MULTI(CFProxy,lpvtbl_cf,iface);*/
422 FIXME("(%d), stub!\n",fLock
);
423 /* basically: write BOOL, read empty */
427 static const IRpcProxyBufferVtbl pspbvtbl
= {
428 IRpcProxyBufferImpl_QueryInterface
,
429 IRpcProxyBufferImpl_AddRef
,
430 IRpcProxyBufferImpl_Release
,
431 IRpcProxyBufferImpl_Connect
,
432 IRpcProxyBufferImpl_Disconnect
434 static const IClassFactoryVtbl cfproxyvt
= {
435 CFProxy_QueryInterface
,
438 CFProxy_CreateInstance
,
443 CFProxy_Construct(IUnknown
*pUnkOuter
, LPVOID
*ppv
,LPVOID
*ppProxy
) {
446 cf
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(CFProxy
));
448 return E_OUTOFMEMORY
;
450 cf
->lpvtbl_cf
= &cfproxyvt
;
451 cf
->lpvtbl_proxy
= &pspbvtbl
;
452 /* one reference for the proxy buffer */
454 cf
->outer_unknown
= pUnkOuter
;
455 *ppv
= &(cf
->lpvtbl_cf
);
456 *ppProxy
= &(cf
->lpvtbl_proxy
);
457 /* and one reference for the object */
458 IUnknown_AddRef((IUnknown
*)*ppv
);
463 /********************* IRemUnknown Proxy/Stub ********************************/
467 const IRpcStubBufferVtbl
*lpVtbl
;
472 static HRESULT WINAPI
RemUnkStub_QueryInterface(LPRPCSTUBBUFFER iface
,
476 RemUnkStub
*This
= (RemUnkStub
*)iface
;
477 TRACE("(%p)->QueryInterface(%s,%p)\n",This
,debugstr_guid(riid
),obj
);
478 if (IsEqualGUID(&IID_IUnknown
,riid
) ||
479 IsEqualGUID(&IID_IRpcStubBuffer
,riid
)) {
483 return E_NOINTERFACE
;
486 static ULONG WINAPI
RemUnkStub_AddRef(LPRPCSTUBBUFFER iface
)
488 RemUnkStub
*This
= (RemUnkStub
*)iface
;
489 TRACE("(%p)->AddRef()\n",This
);
490 return InterlockedIncrement(&This
->refs
);
493 static ULONG WINAPI
RemUnkStub_Release(LPRPCSTUBBUFFER iface
)
495 RemUnkStub
*This
= (RemUnkStub
*)iface
;
497 TRACE("(%p)->Release()\n",This
);
498 refs
= InterlockedDecrement(&This
->refs
);
500 HeapFree(GetProcessHeap(), 0, This
);
504 static HRESULT WINAPI
RemUnkStub_Connect(LPRPCSTUBBUFFER iface
,
505 LPUNKNOWN lpUnkServer
)
507 RemUnkStub
*This
= (RemUnkStub
*)iface
;
508 TRACE("(%p)->Connect(%p)\n",This
,lpUnkServer
);
509 This
->iface
= (IRemUnknown
*)lpUnkServer
;
510 IRemUnknown_AddRef(This
->iface
);
514 static void WINAPI
RemUnkStub_Disconnect(LPRPCSTUBBUFFER iface
)
516 RemUnkStub
*This
= (RemUnkStub
*)iface
;
517 TRACE("(%p)->Disconnect()\n",This
);
518 IUnknown_Release(This
->iface
);
522 static HRESULT WINAPI
RemUnkStub_Invoke(LPRPCSTUBBUFFER iface
,
524 LPRPCCHANNELBUFFER pChannel
)
526 RemUnkStub
*This
= (RemUnkStub
*)iface
;
527 ULONG iMethod
= pMsg
->iMethod
;
528 LPBYTE buf
= pMsg
->Buffer
;
529 HRESULT hr
= RPC_E_INVALIDMETHOD
;
531 TRACE("(%p)->Invoke(%p,%p) method %d\n", This
, pMsg
, pChannel
, iMethod
);
534 case 3: /* RemQueryInterface */
540 REMQIRESULT
*pQIResults
= NULL
;
543 memcpy(&ipid
, buf
, sizeof(ipid
));
545 memcpy(&cRefs
, buf
, sizeof(cRefs
));
546 buf
+= sizeof(cRefs
);
547 memcpy(&cIids
, buf
, sizeof(cIids
));
548 buf
+= sizeof(cIids
);
551 hr
= IRemUnknown_RemQueryInterface(This
->iface
, &ipid
, cRefs
, cIids
, iids
, &pQIResults
);
554 pMsg
->cbBuffer
= cIids
* sizeof(REMQIRESULT
) + sizeof(HRESULT
);
556 IRpcChannelBuffer_GetBuffer(pChannel
, pMsg
, &IID_IRemUnknown
);
559 *(HRESULT
*)buf
= hr
;
560 buf
+= sizeof(HRESULT
);
563 /* FIXME: pQIResults is a unique pointer so pQIResults can be NULL! */
564 memcpy(buf
, pQIResults
, cIids
* sizeof(REMQIRESULT
));
568 case 4: /* RemAddRef */
575 memcpy(&cIids
, buf
, sizeof(USHORT
));
576 buf
+= sizeof(USHORT
);
577 ir
= (REMINTERFACEREF
*)buf
;
578 pResults
= CoTaskMemAlloc(cIids
* sizeof(HRESULT
));
579 if (!pResults
) return E_OUTOFMEMORY
;
581 hr
= IRemUnknown_RemAddRef(This
->iface
, cIids
, ir
, pResults
);
584 pMsg
->cbBuffer
= cIids
* sizeof(HRESULT
);
586 IRpcChannelBuffer_GetBuffer(pChannel
, pMsg
, &IID_IRemUnknown
);
590 memcpy(buf
, pResults
, cIids
* sizeof(HRESULT
));
593 CoTaskMemFree(pResults
);
597 case 5: /* RemRelease */
603 memcpy(&cIids
, buf
, sizeof(USHORT
));
604 buf
+= sizeof(USHORT
);
605 ir
= (REMINTERFACEREF
*)buf
;
607 hr
= IRemUnknown_RemRelease(This
->iface
, cIids
, ir
);
611 IRpcChannelBuffer_GetBuffer(pChannel
, pMsg
, &IID_IRemUnknown
);
618 static LPRPCSTUBBUFFER WINAPI
RemUnkStub_IsIIDSupported(LPRPCSTUBBUFFER iface
,
621 RemUnkStub
*This
= (RemUnkStub
*)iface
;
622 TRACE("(%p)->IsIIDSupported(%s)\n", This
, debugstr_guid(riid
));
623 return IsEqualGUID(&IID_IRemUnknown
, riid
) ? iface
: NULL
;
626 static ULONG WINAPI
RemUnkStub_CountRefs(LPRPCSTUBBUFFER iface
)
628 RemUnkStub
*This
= (RemUnkStub
*)iface
;
629 FIXME("(%p)->CountRefs()\n", This
);
633 static HRESULT WINAPI
RemUnkStub_DebugServerQueryInterface(LPRPCSTUBBUFFER iface
,
636 RemUnkStub
*This
= (RemUnkStub
*)iface
;
637 FIXME("(%p)->DebugServerQueryInterface(%p)\n",This
,ppv
);
638 return E_NOINTERFACE
;
641 static void WINAPI
RemUnkStub_DebugServerRelease(LPRPCSTUBBUFFER iface
,
644 RemUnkStub
*This
= (RemUnkStub
*)iface
;
645 FIXME("(%p)->DebugServerRelease(%p)\n", This
, pv
);
648 static const IRpcStubBufferVtbl RemUnkStub_VTable
=
650 RemUnkStub_QueryInterface
,
654 RemUnkStub_Disconnect
,
656 RemUnkStub_IsIIDSupported
,
657 RemUnkStub_CountRefs
,
658 RemUnkStub_DebugServerQueryInterface
,
659 RemUnkStub_DebugServerRelease
662 static HRESULT
RemUnkStub_Construct(IRpcStubBuffer
**ppStub
)
664 RemUnkStub
*This
= HeapAlloc(GetProcessHeap(), 0, sizeof(*This
));
665 if (!This
) return E_OUTOFMEMORY
;
666 This
->lpVtbl
= &RemUnkStub_VTable
;
669 *ppStub
= (IRpcStubBuffer
*)This
;
674 typedef struct _RemUnkProxy
{
675 const IRemUnknownVtbl
*lpvtbl_remunk
;
676 const IRpcProxyBufferVtbl
*lpvtbl_proxy
;
679 IRpcChannelBuffer
*chan
;
680 IUnknown
*outer_unknown
;
683 static HRESULT WINAPI
RemUnkProxy_QueryInterface(LPREMUNKNOWN iface
, REFIID riid
, void **ppv
)
685 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
686 if (This
->outer_unknown
)
687 return IUnknown_QueryInterface(This
->outer_unknown
, riid
, ppv
);
688 if (IsEqualIID(riid
, &IID_IUnknown
) ||
689 IsEqualIID(riid
, &IID_IRemUnknown
))
691 IRemUnknown_AddRef(iface
);
692 *ppv
= (LPVOID
)iface
;
695 return E_NOINTERFACE
;
698 static ULONG WINAPI
RemUnkProxy_AddRef(LPREMUNKNOWN iface
)
700 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
703 TRACE("(%p)->AddRef()\n",This
);
705 if (This
->outer_unknown
)
706 refs
= IUnknown_AddRef(This
->outer_unknown
);
708 refs
= InterlockedIncrement(&This
->refs
);
712 static ULONG WINAPI
RemUnkProxy_Release(LPREMUNKNOWN iface
)
714 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
716 TRACE("(%p)->Release()\n",This
);
717 if (This
->outer_unknown
)
718 return IUnknown_Release(This
->outer_unknown
);
720 return IRpcProxyBufferImpl_Release((IRpcProxyBuffer
*)&This
->lpvtbl_proxy
);
723 static HRESULT WINAPI
RemUnkProxy_RemQueryInterface(LPREMUNKNOWN iface
,
728 REMQIRESULT
** ppQIResults
)
730 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
735 TRACE("(%p)->(%s,%d,%d,%p,%p)\n",This
,
736 debugstr_guid(ripid
),cRefs
,cIids
,iids
,ppQIResults
);
739 memset(&msg
, 0, sizeof(msg
));
741 msg
.cbBuffer
= sizeof(IPID
) + sizeof(ULONG
) +
742 sizeof(USHORT
) + cIids
*sizeof(IID
);
743 hr
= IRpcChannelBuffer_GetBuffer(This
->chan
, &msg
, &IID_IRemUnknown
);
745 LPBYTE buf
= msg
.Buffer
;
746 memcpy(buf
, ripid
, sizeof(IPID
));
748 memcpy(buf
, &cRefs
, sizeof(ULONG
));
749 buf
+= sizeof(ULONG
);
750 memcpy(buf
, &cIids
, sizeof(USHORT
));
751 buf
+= sizeof(USHORT
);
752 memcpy(buf
, iids
, cIids
*sizeof(IID
));
754 hr
= IRpcChannelBuffer_SendReceive(This
->chan
, &msg
, &status
);
759 hr
= *(HRESULT
*)buf
;
760 buf
+= sizeof(HRESULT
);
764 *ppQIResults
= CoTaskMemAlloc(cIids
*sizeof(REMQIRESULT
));
765 memcpy(*ppQIResults
, buf
, cIids
*sizeof(REMQIRESULT
));
768 IRpcChannelBuffer_FreeBuffer(This
->chan
, &msg
);
774 static HRESULT WINAPI
RemUnkProxy_RemAddRef(LPREMUNKNOWN iface
,
775 USHORT cInterfaceRefs
,
776 REMINTERFACEREF
* InterfaceRefs
,
779 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
784 TRACE("(%p)->(%d,%p,%p)\n",This
,
785 cInterfaceRefs
,InterfaceRefs
,pResults
);
787 memset(&msg
, 0, sizeof(msg
));
789 msg
.cbBuffer
= sizeof(USHORT
) + cInterfaceRefs
*sizeof(REMINTERFACEREF
);
790 hr
= IRpcChannelBuffer_GetBuffer(This
->chan
, &msg
, &IID_IRemUnknown
);
792 LPBYTE buf
= msg
.Buffer
;
793 memcpy(buf
, &cInterfaceRefs
, sizeof(USHORT
));
794 buf
+= sizeof(USHORT
);
795 memcpy(buf
, InterfaceRefs
, cInterfaceRefs
*sizeof(REMINTERFACEREF
));
797 hr
= IRpcChannelBuffer_SendReceive(This
->chan
, &msg
, &status
);
801 memcpy(pResults
, buf
, cInterfaceRefs
*sizeof(HRESULT
));
804 IRpcChannelBuffer_FreeBuffer(This
->chan
, &msg
);
810 static HRESULT WINAPI
RemUnkProxy_RemRelease(LPREMUNKNOWN iface
,
811 USHORT cInterfaceRefs
,
812 REMINTERFACEREF
* InterfaceRefs
)
814 RemUnkProxy
*This
= (RemUnkProxy
*)iface
;
819 TRACE("(%p)->(%d,%p)\n",This
,
820 cInterfaceRefs
,InterfaceRefs
);
822 memset(&msg
, 0, sizeof(msg
));
824 msg
.cbBuffer
= sizeof(USHORT
) + cInterfaceRefs
*sizeof(REMINTERFACEREF
);
825 hr
= IRpcChannelBuffer_GetBuffer(This
->chan
, &msg
, &IID_IRemUnknown
);
827 LPBYTE buf
= msg
.Buffer
;
828 memcpy(buf
, &cInterfaceRefs
, sizeof(USHORT
));
829 buf
+= sizeof(USHORT
);
830 memcpy(buf
, InterfaceRefs
, cInterfaceRefs
*sizeof(REMINTERFACEREF
));
832 hr
= IRpcChannelBuffer_SendReceive(This
->chan
, &msg
, &status
);
834 IRpcChannelBuffer_FreeBuffer(This
->chan
, &msg
);
840 static const IRemUnknownVtbl RemUnkProxy_VTable
=
842 RemUnkProxy_QueryInterface
,
845 RemUnkProxy_RemQueryInterface
,
846 RemUnkProxy_RemAddRef
,
847 RemUnkProxy_RemRelease
851 static HRESULT WINAPI
RURpcProxyBufferImpl_QueryInterface(LPRPCPROXYBUFFER iface
,REFIID riid
,LPVOID
*ppv
) {
853 if (IsEqualIID(riid
,&IID_IRpcProxyBuffer
)||IsEqualIID(riid
,&IID_IUnknown
)) {
854 IRpcProxyBuffer_AddRef(iface
);
855 *ppv
= (LPVOID
)iface
;
858 FIXME("(%s), no interface.\n",debugstr_guid(riid
));
859 return E_NOINTERFACE
;
862 static ULONG WINAPI
RURpcProxyBufferImpl_AddRef(LPRPCPROXYBUFFER iface
) {
863 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
864 TRACE("%p, %d\n", iface
, This
->refs
+ 1);
865 return InterlockedIncrement(&This
->refs
);
868 static ULONG WINAPI
RURpcProxyBufferImpl_Release(LPRPCPROXYBUFFER iface
) {
869 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
870 ULONG ref
= InterlockedDecrement(&This
->refs
);
871 TRACE("%p, %d\n", iface
, ref
);
873 IRpcProxyBuffer_Disconnect(iface
);
874 HeapFree(GetProcessHeap(),0,This
);
879 static HRESULT WINAPI
RURpcProxyBufferImpl_Connect(LPRPCPROXYBUFFER iface
,IRpcChannelBuffer
* pRpcChannelBuffer
) {
880 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
882 TRACE("%p, %p\n", iface
, pRpcChannelBuffer
);
883 This
->chan
= pRpcChannelBuffer
;
884 IRpcChannelBuffer_AddRef(This
->chan
);
887 static void WINAPI
RURpcProxyBufferImpl_Disconnect(LPRPCPROXYBUFFER iface
) {
888 ICOM_THIS_MULTI(RemUnkProxy
,lpvtbl_proxy
,iface
);
889 TRACE("%p, %p\n", iface
, This
->chan
);
891 IRpcChannelBuffer_Release(This
->chan
);
897 static const IRpcProxyBufferVtbl RURpcProxyBuffer_VTable
= {
898 RURpcProxyBufferImpl_QueryInterface
,
899 RURpcProxyBufferImpl_AddRef
,
900 RURpcProxyBufferImpl_Release
,
901 RURpcProxyBufferImpl_Connect
,
902 RURpcProxyBufferImpl_Disconnect
906 RemUnkProxy_Construct(IUnknown
*pUnkOuter
, LPVOID
*ppv
,LPVOID
*ppProxy
) {
909 This
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(*This
));
911 return E_OUTOFMEMORY
;
913 This
->lpvtbl_remunk
= &RemUnkProxy_VTable
;
914 This
->lpvtbl_proxy
= &RURpcProxyBuffer_VTable
;
915 /* only one reference for the proxy buffer */
917 This
->outer_unknown
= pUnkOuter
;
918 *ppv
= &(This
->lpvtbl_remunk
);
919 *ppProxy
= &(This
->lpvtbl_proxy
);
920 /* and one reference for the object */
921 IUnknown_AddRef((IUnknown
*)*ppv
);
926 /********************* OLE Proxy/Stub Factory ********************************/
927 static HRESULT WINAPI
928 PSFacBuf_QueryInterface(LPPSFACTORYBUFFER iface
, REFIID iid
, LPVOID
*ppv
) {
929 if (IsEqualIID(iid
,&IID_IPSFactoryBuffer
)||IsEqualIID(iid
,&IID_IUnknown
)) {
930 *ppv
= (LPVOID
)iface
;
931 /* No ref counting, static class */
934 FIXME("(%s) unknown IID?\n",debugstr_guid(iid
));
935 return E_NOINTERFACE
;
938 static ULONG WINAPI
PSFacBuf_AddRef(LPPSFACTORYBUFFER iface
) { return 2; }
939 static ULONG WINAPI
PSFacBuf_Release(LPPSFACTORYBUFFER iface
) { return 1; }
941 static HRESULT WINAPI
942 PSFacBuf_CreateProxy(
943 LPPSFACTORYBUFFER iface
, IUnknown
* pUnkOuter
, REFIID riid
,
944 IRpcProxyBuffer
**ppProxy
, LPVOID
*ppv
946 if (IsEqualIID(&IID_IClassFactory
,riid
))
947 return CFProxy_Construct(pUnkOuter
, ppv
,(LPVOID
*)ppProxy
);
948 else if (IsEqualIID(&IID_IRemUnknown
,riid
))
949 return RemUnkProxy_Construct(pUnkOuter
, ppv
,(LPVOID
*)ppProxy
);
950 FIXME("proxying not implemented for (%s) yet!\n",debugstr_guid(riid
));
954 static HRESULT WINAPI
956 LPPSFACTORYBUFFER iface
, REFIID riid
,IUnknown
*pUnkServer
,
957 IRpcStubBuffer
** ppStub
961 TRACE("(%s,%p,%p)\n",debugstr_guid(riid
),pUnkServer
,ppStub
);
963 if (IsEqualIID(&IID_IClassFactory
, riid
) ||
964 IsEqualIID(&IID_IUnknown
, riid
) /* FIXME: fixup stub manager and remove this*/) {
965 hres
= CFStub_Construct(ppStub
);
967 IRpcStubBuffer_Connect((*ppStub
),pUnkServer
);
969 } else if (IsEqualIID(&IID_IRemUnknown
,riid
)) {
970 hres
= RemUnkStub_Construct(ppStub
);
972 IRpcStubBuffer_Connect((*ppStub
),pUnkServer
);
975 FIXME("stubbing not implemented for (%s) yet!\n",debugstr_guid(riid
));
979 static const IPSFactoryBufferVtbl psfacbufvtbl
= {
980 PSFacBuf_QueryInterface
,
983 PSFacBuf_CreateProxy
,
987 /* This is the whole PSFactoryBuffer object, just the vtableptr */
988 static const IPSFactoryBufferVtbl
*lppsfac
= &psfacbufvtbl
;
990 /***********************************************************************
991 * DllGetClassObject [OLE32.@]
993 HRESULT WINAPI
DllGetClassObject(REFCLSID rclsid
, REFIID iid
,LPVOID
*ppv
)
996 if (IsEqualIID(rclsid
, &CLSID_PSFactoryBuffer
))
997 return IPSFactoryBuffer_QueryInterface((IPSFactoryBuffer
*)&lppsfac
, iid
, ppv
);
998 if (IsEqualIID(rclsid
,&CLSID_DfMarshal
)&&(
999 IsEqualIID(iid
,&IID_IClassFactory
) ||
1000 IsEqualIID(iid
,&IID_IUnknown
)
1003 return MARSHAL_GetStandardMarshalCF(ppv
);
1004 if (IsEqualIID(rclsid
,&CLSID_StdGlobalInterfaceTable
) && (IsEqualIID(iid
,&IID_IClassFactory
) || IsEqualIID(iid
,&IID_IUnknown
)))
1005 return StdGlobalInterfaceTable_GetFactory(ppv
);
1006 if (IsEqualCLSID(rclsid
, &CLSID_FileMoniker
))
1007 return FileMonikerCF_Create(iid
, ppv
);
1008 if (IsEqualCLSID(rclsid
, &CLSID_ItemMoniker
))
1009 return ItemMonikerCF_Create(iid
, ppv
);
1010 if (IsEqualCLSID(rclsid
, &CLSID_AntiMoniker
))
1011 return AntiMonikerCF_Create(iid
, ppv
);
1012 if (IsEqualCLSID(rclsid
, &CLSID_CompositeMoniker
))
1013 return CompositeMonikerCF_Create(iid
, ppv
);
1014 if (IsEqualCLSID(rclsid
, &CLSID_ClassMoniker
))
1015 return ClassMonikerCF_Create(iid
, ppv
);
1017 FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid
),debugstr_guid(iid
));
1018 return CLASS_E_CLASSNOTAVAILABLE
;