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