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