jscript: Added Date.setYear stub implementation.
[wine] / dlls / oleaut32 / oleaut.c
1 /*
2  *      OLEAUT32
3  *
4  * Copyright 1999, 2000 Marcus Meissner
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22 #include <string.h>
23 #include <limits.h>
24
25 #define COBJMACROS
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "winerror.h"
32
33 #include "ole2.h"
34 #include "olectl.h"
35 #include "oleauto.h"
36 #include "typelib.h"
37
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(ole);
41
42 static BOOL BSTR_bCache = TRUE; /* Cache allocations to minimise alloc calls? */
43
44 /******************************************************************************
45  * BSTR  {OLEAUT32}
46  *
47  * NOTES
48  *  BSTR is a simple typedef for a wide-character string used as the principle
49  *  string type in ole automation. When encapsulated in a Variant type they are
50  *  automatically copied and destroyed as the variant is processed.
51  *
52  *  The low level BSTR Api allows manipulation of these strings and is used by
53  *  higher level Api calls to manage the strings transparently to the caller.
54  *
55  *  Internally the BSTR type is allocated with space for a DWORD byte count before
56  *  the string data begins. This is undocumented and non-system code should not
57  *  access the count directly. Use SysStringLen() or SysStringByteLen()
58  *  instead. Note that the byte count does not include the terminating NUL.
59  *
60  *  To create a new BSTR, use SysAllocString(), SysAllocStringLen() or
61  *  SysAllocStringByteLen(). To change the size of an existing BSTR, use SysReAllocString()
62  *  or SysReAllocStringLen(). Finally to destroy a string use SysFreeString().
63  *
64  *  BSTR's are cached by Ole Automation by default. To override this behaviour
65  *  either set the environment variable 'OANOCACHE', or call SetOaNoCache().
66  *
67  * SEE ALSO
68  *  'Inside OLE, second edition' by Kraig Brockshmidt.
69  */
70
71 /******************************************************************************
72  *             SysStringLen  [OLEAUT32.7]
73  *
74  * Get the allocated length of a BSTR in wide characters.
75  *
76  * PARAMS
77  *  str [I] BSTR to find the length of
78  *
79  * RETURNS
80  *  The allocated length of str, or 0 if str is NULL.
81  *
82  * NOTES
83  *  See BSTR.
84  *  The returned length may be different from the length of the string as
85  *  calculated by lstrlenW(), since it returns the length that was used to
86  *  allocate the string by SysAllocStringLen().
87  */
88 UINT WINAPI SysStringLen(BSTR str)
89 {
90     DWORD* bufferPointer;
91
92      if (!str) return 0;
93     /*
94      * The length of the string (in bytes) is contained in a DWORD placed
95      * just before the BSTR pointer
96      */
97     bufferPointer = (DWORD*)str;
98
99     bufferPointer--;
100
101     return (int)(*bufferPointer/sizeof(WCHAR));
102 }
103
104 /******************************************************************************
105  *             SysStringByteLen  [OLEAUT32.149]
106  *
107  * Get the allocated length of a BSTR in bytes.
108  *
109  * PARAMS
110  *  str [I] BSTR to find the length of
111  *
112  * RETURNS
113  *  The allocated length of str, or 0 if str is NULL.
114  *
115  * NOTES
116  *  See SysStringLen(), BSTR().
117  */
118 UINT WINAPI SysStringByteLen(BSTR str)
119 {
120     DWORD* bufferPointer;
121
122      if (!str) return 0;
123     /*
124      * The length of the string (in bytes) is contained in a DWORD placed
125      * just before the BSTR pointer
126      */
127     bufferPointer = (DWORD*)str;
128
129     bufferPointer--;
130
131     return (int)(*bufferPointer);
132 }
133
134 /******************************************************************************
135  *              SysAllocString  [OLEAUT32.2]
136  *
137  * Create a BSTR from an OLESTR.
138  *
139  * PARAMS
140  *  str [I] Source to create BSTR from
141  *
142  * RETURNS
143  *  Success: A BSTR allocated with SysAllocStringLen().
144  *  Failure: NULL, if oleStr is NULL.
145  *
146  * NOTES
147  *  See BSTR.
148  *  MSDN (October 2001) incorrectly states that NULL is returned if oleStr has
149  *  a length of 0. Native Win32 and this implementation both return a valid
150  *  empty BSTR in this case.
151  */
152 BSTR WINAPI SysAllocString(LPCOLESTR str)
153 {
154     if (!str) return 0;
155
156     /* Delegate this to the SysAllocStringLen32 method. */
157     return SysAllocStringLen(str, lstrlenW(str));
158 }
159
160 /******************************************************************************
161  *              SysFreeString   [OLEAUT32.6]
162  *
163  * Free a BSTR.
164  *
165  * PARAMS
166  *  str [I] BSTR to free.
167  *
168  * RETURNS
169  *  Nothing.
170  *
171  * NOTES
172  *  See BSTR.
173  *  str may be NULL, in which case this function does nothing.
174  */
175 void WINAPI SysFreeString(BSTR str)
176 {
177     DWORD* bufferPointer;
178
179     /* NULL is a valid parameter */
180     if(!str) return;
181
182     /*
183      * We have to be careful when we free a BSTR pointer, it points to
184      * the beginning of the string but it skips the byte count contained
185      * before the string.
186      */
187     bufferPointer = (DWORD*)str;
188
189     bufferPointer--;
190
191     /*
192      * Free the memory from its "real" origin.
193      */
194     HeapFree(GetProcessHeap(), 0, bufferPointer);
195 }
196
197 /******************************************************************************
198  *             SysAllocStringLen     [OLEAUT32.4]
199  *
200  * Create a BSTR from an OLESTR of a given wide character length.
201  *
202  * PARAMS
203  *  str [I] Source to create BSTR from
204  *  len [I] Length of oleStr in wide characters
205  *
206  * RETURNS
207  *  Success: A newly allocated BSTR from SysAllocStringByteLen()
208  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
209  *
210  * NOTES
211  *  See BSTR(), SysAllocStringByteLen().
212  */
213 BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
214 {
215     DWORD  bufferSize;
216     DWORD* newBuffer;
217     WCHAR* stringBuffer;
218
219     /* Detect integer overflow. */
220     if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
221         return NULL;
222     /*
223      * Find the length of the buffer passed-in, in bytes.
224      */
225     bufferSize = len * sizeof (WCHAR);
226
227     /*
228      * Allocate a new buffer to hold the string.
229      * don't forget to keep an empty spot at the beginning of the
230      * buffer for the character count and an extra character at the
231      * end for the NULL.
232      */
233     newBuffer = HeapAlloc(GetProcessHeap(), 0,
234                           bufferSize + sizeof(WCHAR) + sizeof(DWORD));
235
236     /*
237      * If the memory allocation failed, return a null pointer.
238      */
239     if (!newBuffer)
240       return NULL;
241
242     /*
243      * Copy the length of the string in the placeholder.
244      */
245     *newBuffer = bufferSize;
246
247     /*
248      * Skip the byte count.
249      */
250     newBuffer++;
251
252     /*
253      * Copy the information in the buffer.
254      * Since it is valid to pass a NULL pointer here, we'll initialize the
255      * buffer to nul if it is the case.
256      */
257     if (str != 0)
258       memcpy(newBuffer, str, bufferSize);
259     else
260       memset(newBuffer, 0, bufferSize);
261
262     /*
263      * Make sure that there is a nul character at the end of the
264      * string.
265      */
266     stringBuffer = (WCHAR*)newBuffer;
267     stringBuffer[len] = '\0';
268
269     return stringBuffer;
270 }
271
272 /******************************************************************************
273  *             SysReAllocStringLen   [OLEAUT32.5]
274  *
275  * Change the length of a previously created BSTR.
276  *
277  * PARAMS
278  *  old [O] BSTR to change the length of
279  *  str [I] New source for pbstr
280  *  len [I] Length of oleStr in wide characters
281  *
282  * RETURNS
283  *  Success: 1. The size of pbstr is updated.
284  *  Failure: 0, if len >= 0x80000000 or memory allocation fails.
285  *
286  * NOTES
287  *  See BSTR(), SysAllocStringByteLen().
288  *  *old may be changed by this function.
289  */
290 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* str, unsigned int len)
291 {
292     /* Detect integer overflow. */
293     if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
294         return 0;
295
296     if (*old!=NULL) {
297       BSTR old_copy = *old;
298       DWORD newbytelen = len*sizeof(WCHAR);
299       DWORD *ptr = HeapReAlloc(GetProcessHeap(),0,((DWORD*)*old)-1,newbytelen+sizeof(WCHAR)+sizeof(DWORD));
300       *old = (BSTR)(ptr+1);
301       *ptr = newbytelen;
302       /* Subtle hidden feature: The old string data is still there
303        * when 'in' is NULL!
304        * Some Microsoft program needs it.
305        */
306       if (str && old_copy!=str) memmove(*old, str, newbytelen);
307       (*old)[len] = 0;
308     } else {
309       /*
310        * Allocate the new string
311        */
312       *old = SysAllocStringLen(str, len);
313     }
314
315     return 1;
316 }
317
318 /******************************************************************************
319  *             SysAllocStringByteLen     [OLEAUT32.150]
320  *
321  * Create a BSTR from an OLESTR of a given byte length.
322  *
323  * PARAMS
324  *  str [I] Source to create BSTR from
325  *  len [I] Length of oleStr in bytes
326  *
327  * RETURNS
328  *  Success: A newly allocated BSTR
329  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
330  *
331  * NOTES
332  *  -If len is 0 or oleStr is NULL the resulting string is empty ("").
333  *  -This function always NUL terminates the resulting BSTR.
334  *  -oleStr may be either an LPCSTR or LPCOLESTR, since it is copied
335  *  without checking for a terminating NUL.
336  *  See BSTR.
337  */
338 BSTR WINAPI SysAllocStringByteLen(LPCSTR str, UINT len)
339 {
340     DWORD* newBuffer;
341     char* stringBuffer;
342
343     /* Detect integer overflow. */
344     if (len >= (UINT_MAX-sizeof(WCHAR)-sizeof(DWORD)))
345         return NULL;
346
347     /*
348      * Allocate a new buffer to hold the string.
349      * don't forget to keep an empty spot at the beginning of the
350      * buffer for the character count and an extra character at the
351      * end for the NULL.
352      */
353     newBuffer = HeapAlloc(GetProcessHeap(), 0,
354                           len + sizeof(WCHAR) + sizeof(DWORD));
355
356     /*
357      * If the memory allocation failed, return a null pointer.
358      */
359     if (newBuffer==0)
360       return 0;
361
362     /*
363      * Copy the length of the string in the placeholder.
364      */
365     *newBuffer = len;
366
367     /*
368      * Skip the byte count.
369      */
370     newBuffer++;
371
372     /*
373      * Copy the information in the buffer.
374      * Since it is valid to pass a NULL pointer here, we'll initialize the
375      * buffer to nul if it is the case.
376      */
377     if (str != 0)
378       memcpy(newBuffer, str, len);
379
380     /*
381      * Make sure that there is a nul character at the end of the
382      * string.
383      */
384     stringBuffer = (char *)newBuffer;
385     stringBuffer[len] = 0;
386     stringBuffer[len+1] = 0;
387
388     return (LPWSTR)stringBuffer;
389 }
390
391 /******************************************************************************
392  *              SysReAllocString        [OLEAUT32.3]
393  *
394  * Change the length of a previously created BSTR.
395  *
396  * PARAMS
397  *  old [I/O] BSTR to change the length of
398  *  str [I]   New source for pbstr
399  *
400  * RETURNS
401  *  Success: 1
402  *  Failure: 0.
403  *
404  * NOTES
405  *  See BSTR(), SysAllocStringStringLen().
406  */
407 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR str)
408 {
409     /*
410      * Sanity check
411      */
412     if (old==NULL)
413       return 0;
414
415     /*
416      * Make sure we free the old string.
417      */
418     SysFreeString(*old);
419
420     /*
421      * Allocate the new string
422      */
423     *old = SysAllocString(str);
424
425      return 1;
426 }
427
428 /******************************************************************************
429  *              SetOaNoCache (OLEAUT32.327)
430  *
431  * Instruct Ole Automation not to cache BSTR allocations.
432  *
433  * PARAMS
434  *  None.
435  *
436  * RETURNS
437  *  Nothing.
438  *
439  * NOTES
440  *  See BSTR.
441  */
442 void WINAPI SetOaNoCache(void)
443 {
444   BSTR_bCache = FALSE;
445 }
446
447 static const WCHAR      _delimiter[2] = {'!',0}; /* default delimiter apparently */
448 static const WCHAR      *pdelimiter = &_delimiter[0];
449
450 /***********************************************************************
451  *              RegisterActiveObject (OLEAUT32.33)
452  *
453  * Registers an object in the global item table.
454  *
455  * PARAMS
456  *  punk        [I] Object to register.
457  *  rcid        [I] CLSID of the object.
458  *  dwFlags     [I] Flags.
459  *  pdwRegister [O] Address to store cookie of object registration in.
460  *
461  * RETURNS
462  *  Success: S_OK.
463  *  Failure: HRESULT code.
464  */
465 HRESULT WINAPI RegisterActiveObject(
466         LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
467 ) {
468         WCHAR                   guidbuf[80];
469         HRESULT                 ret;
470         LPRUNNINGOBJECTTABLE    runobtable;
471         LPMONIKER               moniker;
472
473         StringFromGUID2(rcid,guidbuf,39);
474         ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
475         if (FAILED(ret))
476                 return ret;
477         ret = GetRunningObjectTable(0,&runobtable);
478         if (FAILED(ret)) {
479                 IMoniker_Release(moniker);
480                 return ret;
481         }
482         ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
483         IRunningObjectTable_Release(runobtable);
484         IMoniker_Release(moniker);
485         return ret;
486 }
487
488 /***********************************************************************
489  *              RevokeActiveObject (OLEAUT32.34)
490  *
491  * Revokes an object from the global item table.
492  *
493  * PARAMS
494  *  xregister [I] Registration cookie.
495  *  reserved  [I] Reserved. Set to NULL.
496  *
497  * RETURNS
498  *  Success: S_OK.
499  *  Failure: HRESULT code.
500  */
501 HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
502 {
503         LPRUNNINGOBJECTTABLE    runobtable;
504         HRESULT                 ret;
505
506         ret = GetRunningObjectTable(0,&runobtable);
507         if (FAILED(ret)) return ret;
508         ret = IRunningObjectTable_Revoke(runobtable,xregister);
509         if (SUCCEEDED(ret)) ret = S_OK;
510         IRunningObjectTable_Release(runobtable);
511         return ret;
512 }
513
514 /***********************************************************************
515  *              GetActiveObject (OLEAUT32.35)
516  *
517  * Gets an object from the global item table.
518  *
519  * PARAMS
520  *  rcid        [I] CLSID of the object.
521  *  preserved   [I] Reserved. Set to NULL.
522  *  ppunk       [O] Address to store object into.
523  *
524  * RETURNS
525  *  Success: S_OK.
526  *  Failure: HRESULT code.
527  */
528 HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
529 {
530         WCHAR                   guidbuf[80];
531         HRESULT                 ret;
532         LPRUNNINGOBJECTTABLE    runobtable;
533         LPMONIKER               moniker;
534
535         StringFromGUID2(rcid,guidbuf,39);
536         ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
537         if (FAILED(ret))
538                 return ret;
539         ret = GetRunningObjectTable(0,&runobtable);
540         if (FAILED(ret)) {
541                 IMoniker_Release(moniker);
542                 return ret;
543         }
544         ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
545         IRunningObjectTable_Release(runobtable);
546         IMoniker_Release(moniker);
547         return ret;
548 }
549
550
551 /***********************************************************************
552  *           OaBuildVersion           [OLEAUT32.170]
553  *
554  * Get the Ole Automation build version.
555  *
556  * PARAMS
557  *  None
558  *
559  * RETURNS
560  *  The build version.
561  *
562  * NOTES
563  *  Known oleaut32.dll versions:
564  *| OLE Ver.  Comments                   Date     Build Ver.
565  *| --------  -------------------------  ----     ---------
566  *| OLE 2.1   NT                         1993-95  10 3023
567  *| OLE 2.1                                       10 3027
568  *| Win32s    Ver 1.1e                            20 4049
569  *| OLE 2.20  W95/NT                     1993-96  20 4112
570  *| OLE 2.20  W95/NT                     1993-96  20 4118
571  *| OLE 2.20  W95/NT                     1993-96  20 4122
572  *| OLE 2.30  W95/NT                     1993-98  30 4265
573  *| OLE 2.40  NT??                       1993-98  40 4267
574  *| OLE 2.40  W98 SE orig. file          1993-98  40 4275
575  *| OLE 2.40  W2K orig. file             1993-XX  40 4514
576  *
577  * Currently the versions returned are 2.20 for Win3.1, 2.30 for Win95 & NT 3.51,
578  * and 2.40 for all later versions. The build number is maximum, i.e. 0xffff.
579  */
580 ULONG WINAPI OaBuildVersion(void)
581 {
582     switch(GetVersion() & 0x8000ffff)  /* mask off build number */
583     {
584     case 0x80000a03:  /* WIN31 */
585                 return MAKELONG(0xffff, 20);
586     case 0x00003303:  /* NT351 */
587                 return MAKELONG(0xffff, 30);
588     case 0x80000004:  /* WIN95; I'd like to use the "standard" w95 minor
589                          version here (30), but as we still use w95
590                          as default winver (which is good IMHO), I better
591                          play safe and use the latest value for w95 for now.
592                          Change this as soon as default winver gets changed
593                          to something more recent */
594     case 0x80000a04:  /* WIN98 */
595     case 0x00000004:  /* NT40 */
596     case 0x00000005:  /* W2K */
597     case 0x00000105:  /* WinXP */
598                 return MAKELONG(0xffff, 40);
599     default:
600                 FIXME("Version value not known yet. Please investigate it !\n");
601                 return MAKELONG(0xffff, 40);  /* for now return the same value as for w2k */
602     }
603 }
604
605 /******************************************************************************
606  *              OleTranslateColor       [OLEAUT32.421]
607  *
608  * Convert an OLE_COLOR to a COLORREF.
609  *
610  * PARAMS
611  *  clr       [I] Color to convert
612  *  hpal      [I] Handle to a palette for the conversion
613  *  pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
614  *
615  * RETURNS
616  *  Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
617  *  Failure: E_INVALIDARG, if any argument is invalid.
618  *
619  * FIXME
620  *  Document the conversion rules.
621  */
622 HRESULT WINAPI OleTranslateColor(
623   OLE_COLOR clr,
624   HPALETTE  hpal,
625   COLORREF* pColorRef)
626 {
627   COLORREF colorref;
628   BYTE b = HIBYTE(HIWORD(clr));
629
630   TRACE("(%08x, %p, %p)\n", clr, hpal, pColorRef);
631
632   /*
633    * In case pColorRef is NULL, provide our own to simplify the code.
634    */
635   if (pColorRef == NULL)
636     pColorRef = &colorref;
637
638   switch (b)
639   {
640     case 0x00:
641     {
642       if (hpal != 0)
643         *pColorRef =  PALETTERGB(GetRValue(clr),
644                                  GetGValue(clr),
645                                  GetBValue(clr));
646       else
647         *pColorRef = clr;
648
649       break;
650     }
651
652     case 0x01:
653     {
654       if (hpal != 0)
655       {
656         PALETTEENTRY pe;
657         /*
658          * Validate the palette index.
659          */
660         if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
661           return E_INVALIDARG;
662       }
663
664       *pColorRef = clr;
665
666       break;
667     }
668
669     case 0x02:
670       *pColorRef = clr;
671       break;
672
673     case 0x80:
674     {
675       int index = LOBYTE(LOWORD(clr));
676
677       /*
678        * Validate GetSysColor index.
679        */
680       if ((index < COLOR_SCROLLBAR) || (index > COLOR_MENUBAR))
681         return E_INVALIDARG;
682
683       *pColorRef =  GetSysColor(index);
684
685       break;
686     }
687
688     default:
689       return E_INVALIDARG;
690   }
691
692   return S_OK;
693 }
694
695 extern HRESULT WINAPI OLEAUTPS_DllGetClassObject(REFCLSID, REFIID, LPVOID *) DECLSPEC_HIDDEN;
696 extern BOOL WINAPI OLEAUTPS_DllMain(HINSTANCE, DWORD, LPVOID) DECLSPEC_HIDDEN;
697 extern GUID const CLSID_PSFactoryBuffer DECLSPEC_HIDDEN;
698
699 extern void _get_STDFONT_CF(LPVOID *);
700 extern void _get_STDPIC_CF(LPVOID *);
701
702 static HRESULT WINAPI PSDispatchFacBuf_QueryInterface(IPSFactoryBuffer *iface, REFIID riid, void **ppv)
703 {
704     if (IsEqualIID(riid, &IID_IUnknown) ||
705         IsEqualIID(riid, &IID_IPSFactoryBuffer))
706     {
707         IUnknown_AddRef(iface);
708         *ppv = iface;
709         return S_OK;
710     }
711     return E_NOINTERFACE;
712 }
713
714 static ULONG WINAPI PSDispatchFacBuf_AddRef(IPSFactoryBuffer *iface)
715 {
716     return 2;
717 }
718
719 static ULONG WINAPI PSDispatchFacBuf_Release(IPSFactoryBuffer *iface)
720 {
721     return 1;
722 }
723
724 static HRESULT WINAPI PSDispatchFacBuf_CreateProxy(IPSFactoryBuffer *iface, IUnknown *pUnkOuter, REFIID riid, IRpcProxyBuffer **ppProxy, void **ppv)
725 {
726     IPSFactoryBuffer *pPSFB;
727     HRESULT hr;
728
729     if (IsEqualIID(riid, &IID_IDispatch))
730         hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&pPSFB);
731     else
732         hr = TMARSHAL_DllGetClassObject(&CLSID_PSOAInterface, &IID_IPSFactoryBuffer, (void **)&pPSFB);
733
734     if (FAILED(hr)) return hr;
735
736     hr = IPSFactoryBuffer_CreateProxy(pPSFB, pUnkOuter, riid, ppProxy, ppv);
737
738     IPSFactoryBuffer_Release(pPSFB);
739     return hr;
740 }
741
742 static HRESULT WINAPI PSDispatchFacBuf_CreateStub(IPSFactoryBuffer *iface, REFIID riid, IUnknown *pUnkOuter, IRpcStubBuffer **ppStub)
743 {
744     IPSFactoryBuffer *pPSFB;
745     HRESULT hr;
746
747     if (IsEqualIID(riid, &IID_IDispatch))
748         hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&pPSFB);
749     else
750         hr = TMARSHAL_DllGetClassObject(&CLSID_PSOAInterface, &IID_IPSFactoryBuffer, (void **)&pPSFB);
751
752     if (FAILED(hr)) return hr;
753
754     hr = IPSFactoryBuffer_CreateStub(pPSFB, riid, pUnkOuter, ppStub);
755
756     IPSFactoryBuffer_Release(pPSFB);
757     return hr;
758 }
759
760 static const IPSFactoryBufferVtbl PSDispatchFacBuf_Vtbl =
761 {
762     PSDispatchFacBuf_QueryInterface,
763     PSDispatchFacBuf_AddRef,
764     PSDispatchFacBuf_Release,
765     PSDispatchFacBuf_CreateProxy,
766     PSDispatchFacBuf_CreateStub
767 };
768
769 /* This is the whole PSFactoryBuffer object, just the vtableptr */
770 static const IPSFactoryBufferVtbl *pPSDispatchFacBuf = &PSDispatchFacBuf_Vtbl;
771
772 /***********************************************************************
773  *              DllGetClassObject (OLEAUT32.@)
774  */
775 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
776 {
777     *ppv = NULL;
778     if (IsEqualGUID(rclsid,&CLSID_StdFont)) {
779         if (IsEqualGUID(iid,&IID_IClassFactory)) {
780             _get_STDFONT_CF(ppv);
781             IClassFactory_AddRef((IClassFactory*)*ppv);
782             return S_OK;
783         }
784     }
785     if (IsEqualGUID(rclsid,&CLSID_StdPicture)) {
786         if (IsEqualGUID(iid,&IID_IClassFactory)) {
787             _get_STDPIC_CF(ppv);
788             IClassFactory_AddRef((IClassFactory*)*ppv);
789             return S_OK;
790         }
791     }
792     if (IsEqualCLSID(rclsid, &CLSID_PSDispatch) && IsEqualIID(iid, &IID_IPSFactoryBuffer)) {
793         *ppv = &pPSDispatchFacBuf;
794         IPSFactoryBuffer_AddRef((IPSFactoryBuffer *)*ppv);
795         return S_OK;
796     }
797     if (IsEqualGUID(rclsid,&CLSID_PSOAInterface)) {
798         if (S_OK==TMARSHAL_DllGetClassObject(rclsid,iid,ppv))
799             return S_OK;
800         /*FALLTHROUGH*/
801     }
802     if (IsEqualCLSID(rclsid, &CLSID_PSTypeInfo) ||
803         IsEqualCLSID(rclsid, &CLSID_PSTypeLib) ||
804         IsEqualCLSID(rclsid, &CLSID_PSDispatch) ||
805         IsEqualCLSID(rclsid, &CLSID_PSEnumVariant))
806         return OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, iid, ppv);
807
808     return OLEAUTPS_DllGetClassObject(rclsid, iid, ppv);
809 }
810
811 /***********************************************************************
812  *              DllCanUnloadNow (OLEAUT32.@)
813  *
814  * Determine if this dll can be unloaded from the callers address space.
815  *
816  * PARAMS
817  *  None.
818  *
819  * RETURNS
820  *  Always returns S_FALSE. This dll cannot be unloaded.
821  */
822 HRESULT WINAPI DllCanUnloadNow(void)
823 {
824     return S_FALSE;
825 }
826
827 /*****************************************************************************
828  *              DllMain         [OLEAUT32.@]
829  */
830 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
831 {
832     return OLEAUTPS_DllMain( hInstDll, fdwReason, lpvReserved );
833 }
834
835 /***********************************************************************
836  *              OleIconToCursor (OLEAUT32.415)
837  */
838 HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hIcon)
839 {
840     FIXME("(%p,%p), partially implemented.\n",hinstExe,hIcon);
841     /* FIXME: make a extended conversation from HICON to HCURSOR */
842     return CopyCursor(hIcon);
843 }