projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[OLEAUT32] Sync with Wine Staging 4.0. CORE-15682
[reactos.git] / dll / win32 / 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 "config.h"
22
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <limits.h>
27
28 #define COBJMACROS
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winerror.h"
35
36 #include "ole2.h"
37 #include "olectl.h"
38 #include "oleauto.h"
39 #include "initguid.h"
40 #include "typelib.h"
41 #include "oleaut32_oaidl.h"
42
43 #include "wine/debug.h"
44 #include "wine/unicode.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(ole);
47 WINE_DECLARE_DEBUG_CHANNEL(heap);
48
49 /******************************************************************************
50 * BSTR {OLEAUT32}
51 *
52 * NOTES
53 * BSTR is a simple typedef for a wide-character string used as the principle
54 * string type in ole automation. When encapsulated in a Variant type they are
55 * automatically copied and destroyed as the variant is processed.
56 *
57 * The low level BSTR API allows manipulation of these strings and is used by
58 * higher level API calls to manage the strings transparently to the caller.
59 *
60 * Internally the BSTR type is allocated with space for a DWORD byte count before
61 * the string data begins. This is undocumented and non-system code should not
62 * access the count directly. Use SysStringLen() or SysStringByteLen()
63 * instead. Note that the byte count does not include the terminating NUL.
64 *
65 * To create a new BSTR, use SysAllocString(), SysAllocStringLen() or
66 * SysAllocStringByteLen(). To change the size of an existing BSTR, use SysReAllocString()
67 * or SysReAllocStringLen(). Finally to destroy a string use SysFreeString().
68 *
69 * BSTR's are cached by Ole Automation by default. To override this behaviour
70 * either set the environment variable 'OANOCACHE', or call SetOaNoCache().
71 *
72 * SEE ALSO
73 * 'Inside OLE, second edition' by Kraig Brockshmidt.
74 */
75
76 static BOOL bstr_cache_enabled;
77
78 static CRITICAL_SECTION cs_bstr_cache;
79 static CRITICAL_SECTION_DEBUG cs_bstr_cache_dbg =
80 {
81 0, 0, &cs_bstr_cache,
82 { &cs_bstr_cache_dbg.ProcessLocksList, &cs_bstr_cache_dbg.ProcessLocksList },
83 0, 0, { (DWORD_PTR)(__FILE__ ": bstr_cache") }
84 };
85 static CRITICAL_SECTION cs_bstr_cache = { &cs_bstr_cache_dbg, -1, 0, 0, 0, 0 };
86
87 typedef struct {
88 #ifdef _WIN64
89 DWORD pad;
90 #endif
91 DWORD size;
92 union {
93 char ptr[1];
94 WCHAR str[1];
95 DWORD dwptr[1];
96 } u;
97 } bstr_t;
98
99 #define BUCKET_SIZE 16
100 #define BUCKET_BUFFER_SIZE 6
101
102 typedef struct {
103 unsigned short head;
104 unsigned short cnt;
105 bstr_t *buf[BUCKET_BUFFER_SIZE];
106 } bstr_cache_entry_t;
107
108 #define ARENA_INUSE_FILLER 0x55
109 #define ARENA_TAIL_FILLER 0xab
110 #define ARENA_FREE_FILLER 0xfeeefeee
111
112 static bstr_cache_entry_t bstr_cache[0x10000/BUCKET_SIZE];
113
114 static inline size_t bstr_alloc_size(size_t size)
115 {
116 return (FIELD_OFFSET(bstr_t, u.ptr[size]) + sizeof(WCHAR) + BUCKET_SIZE-1) & ~(BUCKET_SIZE-1);
117 }
118
119 static inline bstr_t *bstr_from_str(BSTR str)
120 {
121 return CONTAINING_RECORD((void *)str, bstr_t, u.str);
122 }
123
124 static inline bstr_cache_entry_t *get_cache_entry_from_idx(unsigned cache_idx)
125 {
126 return bstr_cache_enabled && cache_idx < ARRAY_SIZE(bstr_cache) ? bstr_cache + cache_idx : NULL;
127 }
128
129 static inline bstr_cache_entry_t *get_cache_entry(size_t size)
130 {
131 unsigned cache_idx = FIELD_OFFSET(bstr_t, u.ptr[size+sizeof(WCHAR)-1])/BUCKET_SIZE;
132 return get_cache_entry_from_idx(cache_idx);
133 }
134
135 static inline bstr_cache_entry_t *get_cache_entry_from_alloc_size(SIZE_T alloc_size)
136 {
137 unsigned cache_idx;
138 if (alloc_size < BUCKET_SIZE) return NULL;
139 cache_idx = (alloc_size - BUCKET_SIZE) / BUCKET_SIZE;
140 return get_cache_entry_from_idx(cache_idx);
141 }
142
143 static bstr_t *alloc_bstr(size_t size)
144 {
145 bstr_cache_entry_t *cache_entry = get_cache_entry(size);
146 bstr_t *ret;
147
148 if(cache_entry) {
149 EnterCriticalSection(&cs_bstr_cache);
150
151 if(!cache_entry->cnt) {
152 cache_entry = get_cache_entry(size+BUCKET_SIZE);
153 if(cache_entry && !cache_entry->cnt)
154 cache_entry = NULL;
155 }
156
157 if(cache_entry) {
158 ret = cache_entry->buf[cache_entry->head++];
159 cache_entry->head %= BUCKET_BUFFER_SIZE;
160 cache_entry->cnt--;
161 }
162
163 LeaveCriticalSection(&cs_bstr_cache);
164
165 if(cache_entry) {
166 if(WARN_ON(heap)) {
167 size_t fill_size = (FIELD_OFFSET(bstr_t, u.ptr[size])+2*sizeof(WCHAR)-1) & ~(sizeof(WCHAR)-1);
168 memset(ret, ARENA_INUSE_FILLER, fill_size);
169 memset((char *)ret+fill_size, ARENA_TAIL_FILLER, bstr_alloc_size(size)-fill_size);
170 }
171 ret->size = size;
172 return ret;
173 }
174 }
175
176 ret = CoTaskMemAlloc(bstr_alloc_size(size));
177 if(ret)
178 ret->size = size;
179 return ret;
180 }
181
182 /******************************************************************************
183 * SysStringLen [OLEAUT32.7]
184 *
185 * Get the allocated length of a BSTR in wide characters.
186 *
187 * PARAMS
188 * str [I] BSTR to find the length of
189 *
190 * RETURNS
191 * The allocated length of str, or 0 if str is NULL.
192 *
193 * NOTES
194 * See BSTR.
195 * The returned length may be different from the length of the string as
196 * calculated by lstrlenW(), since it returns the length that was used to
197 * allocate the string by SysAllocStringLen().
198 */
199 UINT WINAPI SysStringLen(BSTR str)
200 {
201 return str ? bstr_from_str(str)->size/sizeof(WCHAR) : 0;
202 }
203
204 /******************************************************************************
205 * SysStringByteLen [OLEAUT32.149]
206 *
207 * Get the allocated length of a BSTR in bytes.
208 *
209 * PARAMS
210 * str [I] BSTR to find the length of
211 *
212 * RETURNS
213 * The allocated length of str, or 0 if str is NULL.
214 *
215 * NOTES
216 * See SysStringLen(), BSTR().
217 */
218 UINT WINAPI SysStringByteLen(BSTR str)
219 {
220 return str ? bstr_from_str(str)->size : 0;
221 }
222
223 /******************************************************************************
224 * SysAllocString [OLEAUT32.2]
225 *
226 * Create a BSTR from an OLESTR.
227 *
228 * PARAMS
229 * str [I] Source to create BSTR from
230 *
231 * RETURNS
232 * Success: A BSTR allocated with SysAllocStringLen().
233 * Failure: NULL, if oleStr is NULL.
234 *
235 * NOTES
236 * See BSTR.
237 * MSDN (October 2001) incorrectly states that NULL is returned if oleStr has
238 * a length of 0. Native Win32 and this implementation both return a valid
239 * empty BSTR in this case.
240 */
241 BSTR WINAPI SysAllocString(LPCOLESTR str)
242 {
243 if (!str) return 0;
244
245 /* Delegate this to the SysAllocStringLen32 method. */
246 return SysAllocStringLen(str, lstrlenW(str));
247 }
248
249 static inline IMalloc *get_malloc(void)
250 {
251 static IMalloc *malloc;
252
253 if (!malloc)
254 CoGetMalloc(1, &malloc);
255
256 return malloc;
257 }
258
259 /******************************************************************************
260 * SysFreeString [OLEAUT32.6]
261 *
262 * Free a BSTR.
263 *
264 * PARAMS
265 * str [I] BSTR to free.
266 *
267 * RETURNS
268 * Nothing.
269 *
270 * NOTES
271 * See BSTR.
272 * str may be NULL, in which case this function does nothing.
273 */
274 void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
275 {
276 bstr_cache_entry_t *cache_entry;
277 bstr_t *bstr;
278 IMalloc *malloc = get_malloc();
279 SIZE_T alloc_size;
280
281 if(!str)
282 return;
283
284 bstr = bstr_from_str(str);
285
286 alloc_size = IMalloc_GetSize(malloc, bstr);
287 if (alloc_size == ~0UL)
288 return;
289
290 cache_entry = get_cache_entry_from_alloc_size(alloc_size);
291 if(cache_entry) {
292 unsigned i;
293
294 EnterCriticalSection(&cs_bstr_cache);
295
296 /* According to tests, freeing a string that's already in cache doesn't corrupt anything.
297 * For that to work we need to search the cache. */
298 for(i=0; i < cache_entry->cnt; i++) {
299 if(cache_entry->buf[(cache_entry->head+i) % BUCKET_BUFFER_SIZE] == bstr) {
300 WARN_(heap)("String already is in cache!\n");
301 LeaveCriticalSection(&cs_bstr_cache);
302 return;
303 }
304 }
305
306 if(cache_entry->cnt < ARRAY_SIZE(cache_entry->buf)) {
307 cache_entry->buf[(cache_entry->head+cache_entry->cnt) % BUCKET_BUFFER_SIZE] = bstr;
308 cache_entry->cnt++;
309
310 if(WARN_ON(heap)) {
311 unsigned n = (alloc_size-FIELD_OFFSET(bstr_t, u.ptr))/sizeof(DWORD);
312 for(i=0; i<n; i++)
313 bstr->u.dwptr[i] = ARENA_FREE_FILLER;
314 }
315
316 LeaveCriticalSection(&cs_bstr_cache);
317 return;
318 }
319
320 LeaveCriticalSection(&cs_bstr_cache);
321 }
322
323 CoTaskMemFree(bstr);
324 }
325
326 /******************************************************************************
327 * SysAllocStringLen [OLEAUT32.4]
328 *
329 * Create a BSTR from an OLESTR of a given wide character length.
330 *
331 * PARAMS
332 * str [I] Source to create BSTR from
333 * len [I] Length of oleStr in wide characters
334 *
335 * RETURNS
336 * Success: A newly allocated BSTR from SysAllocStringByteLen()
337 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
338 *
339 * NOTES
340 * See BSTR(), SysAllocStringByteLen().
341 */
342 BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
343 {
344 bstr_t *bstr;
345 DWORD size;
346
347 /* Detect integer overflow. */
348 if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
349 return NULL;
350
351 TRACE("%s\n", debugstr_wn(str, len));
352
353 size = len*sizeof(WCHAR);
354 bstr = alloc_bstr(size);
355 if(!bstr)
356 return NULL;
357
358 if(str) {
359 memcpy(bstr->u.str, str, size);
360 bstr->u.str[len] = 0;
361 }else {
362 memset(bstr->u.str, 0, size+sizeof(WCHAR));
363 }
364
365 return bstr->u.str;
366 }
367
368 /******************************************************************************
369 * SysReAllocStringLen [OLEAUT32.5]
370 *
371 * Change the length of a previously created BSTR.
372 *
373 * PARAMS
374 * old [O] BSTR to change the length of
375 * str [I] New source for pbstr
376 * len [I] Length of oleStr in wide characters
377 *
378 * RETURNS
379 * Success: 1. The size of pbstr is updated.
380 * Failure: 0, if len >= 0x80000000 or memory allocation fails.
381 *
382 * NOTES
383 * See BSTR(), SysAllocStringByteLen().
384 * *old may be changed by this function.
385 */
386 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* str, unsigned int len)
387 {
388 /* Detect integer overflow. */
389 if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
390 return FALSE;
391
392 if (*old!=NULL) {
393 DWORD newbytelen = len*sizeof(WCHAR);
394 bstr_t *old_bstr = bstr_from_str(*old);
395 bstr_t *bstr = CoTaskMemRealloc(old_bstr, bstr_alloc_size(newbytelen));
396
397 if (!bstr) return FALSE;
398
399 *old = bstr->u.str;
400 bstr->size = newbytelen;
401 /* The old string data is still there when str is NULL */
402 if (str && old_bstr->u.str != str) memmove(bstr->u.str, str, newbytelen);
403 bstr->u.str[len] = 0;
404 } else {
405 *old = SysAllocStringLen(str, len);
406 }
407
408 return TRUE;
409 }
410
411 /******************************************************************************
412 * SysAllocStringByteLen [OLEAUT32.150]
413 *
414 * Create a BSTR from an OLESTR of a given byte length.
415 *
416 * PARAMS
417 * str [I] Source to create BSTR from
418 * len [I] Length of oleStr in bytes
419 *
420 * RETURNS
421 * Success: A newly allocated BSTR
422 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
423 *
424 * NOTES
425 * -If len is 0 or oleStr is NULL the resulting string is empty ("").
426 * -This function always NUL terminates the resulting BSTR.
427 * -oleStr may be either an LPCSTR or LPCOLESTR, since it is copied
428 * without checking for a terminating NUL.
429 * See BSTR.
430 */
431 BSTR WINAPI DECLSPEC_HOTPATCH SysAllocStringByteLen(LPCSTR str, UINT len)
432 {
433 bstr_t *bstr;
434
435 /* Detect integer overflow. */
436 if (len >= (UINT_MAX-sizeof(WCHAR)-sizeof(DWORD)))
437 return NULL;
438
439 bstr = alloc_bstr(len);
440 if(!bstr)
441 return NULL;
442
443 if(str) {
444 memcpy(bstr->u.ptr, str, len);
445 bstr->u.ptr[len] = 0;
446 }else {
447 memset(bstr->u.ptr, 0, len+1);
448 }
449 bstr->u.str[(len+sizeof(WCHAR)-1)/sizeof(WCHAR)] = 0;
450
451 return bstr->u.str;
452 }
453
454 /******************************************************************************
455 * SysReAllocString [OLEAUT32.3]
456 *
457 * Change the length of a previously created BSTR.
458 *
459 * PARAMS
460 * old [I/O] BSTR to change the length of
461 * str [I] New source for pbstr
462 *
463 * RETURNS
464 * Success: 1
465 * Failure: 0.
466 *
467 * NOTES
468 * See BSTR(), SysAllocStringStringLen().
469 */
470 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR str)
471 {
472 /*
473 * Sanity check
474 */
475 if (old==NULL)
476 return 0;
477
478 /*
479 * Make sure we free the old string.
480 */
481 SysFreeString(*old);
482
483 /*
484 * Allocate the new string
485 */
486 *old = SysAllocString(str);
487
488 return 1;
489 }
490
491 /******************************************************************************
492 * SetOaNoCache (OLEAUT32.327)
493 *
494 * Instruct Ole Automation not to cache BSTR allocations.
495 *
496 * PARAMS
497 * None.
498 *
499 * RETURNS
500 * Nothing.
501 *
502 * NOTES
503 * SetOaNoCache does not release cached strings, so it leaks by design.
504 */
505 void WINAPI SetOaNoCache(void)
506 {
507 TRACE("\n");
508 bstr_cache_enabled = FALSE;
509 }
510
511 static const WCHAR _delimiter[] = {'!',0}; /* default delimiter apparently */
512 static const WCHAR *pdelimiter = &_delimiter[0];
513
514 /***********************************************************************
515 * RegisterActiveObject (OLEAUT32.33)
516 *
517 * Registers an object in the global item table.
518 *
519 * PARAMS
520 * punk [I] Object to register.
521 * rcid [I] CLSID of the object.
522 * dwFlags [I] Flags.
523 * pdwRegister [O] Address to store cookie of object registration in.
524 *
525 * RETURNS
526 * Success: S_OK.
527 * Failure: HRESULT code.
528 */
529 HRESULT WINAPI DECLSPEC_HOTPATCH RegisterActiveObject(
530 LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
531 ) {
532 WCHAR guidbuf[80];
533 HRESULT ret;
534 LPRUNNINGOBJECTTABLE runobtable;
535 LPMONIKER moniker;
536 DWORD rot_flags = ROTFLAGS_REGISTRATIONKEEPSALIVE; /* default registration is strong */
537
538 StringFromGUID2(rcid,guidbuf,39);
539 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
540 if (FAILED(ret))
541 return ret;
542 ret = GetRunningObjectTable(0,&runobtable);
543 if (FAILED(ret)) {
544 IMoniker_Release(moniker);
545 return ret;
546 }
547 if(dwFlags == ACTIVEOBJECT_WEAK)
548 rot_flags = 0;
549 ret = IRunningObjectTable_Register(runobtable,rot_flags,punk,moniker,pdwRegister);
550 IRunningObjectTable_Release(runobtable);
551 IMoniker_Release(moniker);
552 return ret;
553 }
554
555 /***********************************************************************
556 * RevokeActiveObject (OLEAUT32.34)
557 *
558 * Revokes an object from the global item table.
559 *
560 * PARAMS
561 * xregister [I] Registration cookie.
562 * reserved [I] Reserved. Set to NULL.
563 *
564 * RETURNS
565 * Success: S_OK.
566 * Failure: HRESULT code.
567 */
568 HRESULT WINAPI DECLSPEC_HOTPATCH RevokeActiveObject(DWORD xregister,LPVOID reserved)
569 {
570 LPRUNNINGOBJECTTABLE runobtable;
571 HRESULT ret;
572
573 ret = GetRunningObjectTable(0,&runobtable);
574 if (FAILED(ret)) return ret;
575 ret = IRunningObjectTable_Revoke(runobtable,xregister);
576 if (SUCCEEDED(ret)) ret = S_OK;
577 IRunningObjectTable_Release(runobtable);
578 return ret;
579 }
580
581 /***********************************************************************
582 * GetActiveObject (OLEAUT32.35)
583 *
584 * Gets an object from the global item table.
585 *
586 * PARAMS
587 * rcid [I] CLSID of the object.
588 * preserved [I] Reserved. Set to NULL.
589 * ppunk [O] Address to store object into.
590 *
591 * RETURNS
592 * Success: S_OK.
593 * Failure: HRESULT code.
594 */
595 HRESULT WINAPI DECLSPEC_HOTPATCH GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
596 {
597 WCHAR guidbuf[80];
598 HRESULT ret;
599 LPRUNNINGOBJECTTABLE runobtable;
600 LPMONIKER moniker;
601
602 StringFromGUID2(rcid,guidbuf,39);
603 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
604 if (FAILED(ret))
605 return ret;
606 ret = GetRunningObjectTable(0,&runobtable);
607 if (FAILED(ret)) {
608 IMoniker_Release(moniker);
609 return ret;
610 }
611 ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
612 IRunningObjectTable_Release(runobtable);
613 IMoniker_Release(moniker);
614 return ret;
615 }
616
617
618 /***********************************************************************
619 * OaBuildVersion [OLEAUT32.170]
620 *
621 * Get the Ole Automation build version.
622 *
623 * PARAMS
624 * None
625 *
626 * RETURNS
627 * The build version.
628 *
629 * NOTES
630 * Known oleaut32.dll versions:
631 *| OLE Ver. Comments Date Build Ver.
632 *| -------- ------------------------- ---- ---------
633 *| OLE 2.1 NT 1993-95 10 3023
634 *| OLE 2.1 10 3027
635 *| Win32s Ver 1.1e 20 4049
636 *| OLE 2.20 W95/NT 1993-96 20 4112
637 *| OLE 2.20 W95/NT 1993-96 20 4118
638 *| OLE 2.20 W95/NT 1993-96 20 4122
639 *| OLE 2.30 W95/NT 1993-98 30 4265
640 *| OLE 2.40 NT?? 1993-98 40 4267
641 *| OLE 2.40 W98 SE orig. file 1993-98 40 4275
642 *| OLE 2.40 W2K orig. file 1993-XX 40 4514
643 *
644 * Currently the versions returned are 2.20 for Win3.1, 2.30 for Win95 & NT 3.51,
645 * and 2.40 for all later versions. The build number is maximum, i.e. 0xffff.
646 */
647 ULONG WINAPI OaBuildVersion(void)
648 {
649 switch(GetVersion() & 0x8000ffff) /* mask off build number */
650 {
651 case 0x80000a03: /* WIN31 */
652 return MAKELONG(0xffff, 20);
653 case 0x00003303: /* NT351 */
654 return MAKELONG(0xffff, 30);
655 case 0x80000004: /* WIN95; I'd like to use the "standard" w95 minor
656 version here (30), but as we still use w95
657 as default winver (which is good IMHO), I better
658 play safe and use the latest value for w95 for now.
659 Change this as soon as default winver gets changed
660 to something more recent */
661 case 0x80000a04: /* WIN98 */
662 case 0x00000004: /* NT40 */
663 case 0x00000005: /* W2K */
664 return MAKELONG(0xffff, 40);
665 case 0x00000105: /* WinXP */
666 case 0x00000006: /* Vista */
667 case 0x00000106: /* Win7 */
668 return MAKELONG(0xffff, 50);
669 default:
670 FIXME("Version value not known yet. Please investigate it !\n");
671 return MAKELONG(0xffff, 40); /* for now return the same value as for w2k */
672 }
673 }
674
675 /******************************************************************************
676 * OleTranslateColor [OLEAUT32.421]
677 *
678 * Convert an OLE_COLOR to a COLORREF.
679 *
680 * PARAMS
681 * clr [I] Color to convert
682 * hpal [I] Handle to a palette for the conversion
683 * pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
684 *
685 * RETURNS
686 * Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
687 * Failure: E_INVALIDARG, if any argument is invalid.
688 *
689 * FIXME
690 * Document the conversion rules.
691 */
692 HRESULT WINAPI OleTranslateColor(
693 OLE_COLOR clr,
694 HPALETTE hpal,
695 COLORREF* pColorRef)
696 {
697 COLORREF colorref;
698 BYTE b = HIBYTE(HIWORD(clr));
699
700 TRACE("(%08x, %p, %p)\n", clr, hpal, pColorRef);
701
702 /*
703 * In case pColorRef is NULL, provide our own to simplify the code.
704 */
705 if (pColorRef == NULL)
706 pColorRef = &colorref;
707
708 switch (b)
709 {
710 case 0x00:
711 {
712 if (hpal != 0)
713 *pColorRef = PALETTERGB(GetRValue(clr),
714 GetGValue(clr),
715 GetBValue(clr));
716 else
717 *pColorRef = clr;
718
719 break;
720 }
721
722 case 0x01:
723 {
724 if (hpal != 0)
725 {
726 PALETTEENTRY pe;
727 /*
728 * Validate the palette index.
729 */
730 if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
731 return E_INVALIDARG;
732 }
733
734 *pColorRef = clr;
735
736 break;
737 }
738
739 case 0x02:
740 *pColorRef = clr;
741 break;
742
743 case 0x80:
744 {
745 int index = LOBYTE(LOWORD(clr));
746
747 /*
748 * Validate GetSysColor index.
749 */
750 if ((index < COLOR_SCROLLBAR) || (index > COLOR_MENUBAR))
751 return E_INVALIDARG;
752
753 *pColorRef = GetSysColor(index);
754
755 break;
756 }
757
758 default:
759 return E_INVALIDARG;
760 }
761
762 return S_OK;
763 }
764
765 extern HRESULT WINAPI OLEAUTPS_DllGetClassObject(REFCLSID, REFIID, LPVOID *) DECLSPEC_HIDDEN;
766 extern BOOL WINAPI OLEAUTPS_DllMain(HINSTANCE, DWORD, LPVOID) DECLSPEC_HIDDEN;
767 extern HRESULT WINAPI OLEAUTPS_DllRegisterServer(void) DECLSPEC_HIDDEN;
768 extern HRESULT WINAPI OLEAUTPS_DllUnregisterServer(void) DECLSPEC_HIDDEN;
769
770 extern HRESULT WINAPI CreateProxyFromTypeInfo(ITypeInfo *typeinfo,
771 IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **obj);
772 extern HRESULT WINAPI CreateStubFromTypeInfo(ITypeInfo *typeinfo, REFIID iid,
773 IUnknown *server, IRpcStubBuffer **stub);
774
775 struct ifacepsredirect_data
776 {
777 ULONG size;
778 DWORD mask;
779 GUID iid;
780 ULONG nummethods;
781 GUID tlbid;
782 GUID base;
783 ULONG name_len;
784 ULONG name_offset;
785 };
786
787 struct tlibredirect_data
788 {
789 ULONG size;
790 DWORD res;
791 ULONG name_len;
792 ULONG name_offset;
793 LANGID langid;
794 WORD flags;
795 ULONG help_len;
796 ULONG help_offset;
797 WORD major_version;
798 WORD minor_version;
799 };
800
801 static BOOL actctx_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
802 {
803 struct ifacepsredirect_data *iface;
804 struct tlibredirect_data *tlib;
805 ACTCTX_SECTION_KEYED_DATA data;
806 WCHAR *ptrW;
807
808 data.cbSize = sizeof(data);
809 if (!FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION,
810 iid, &data))
811 return FALSE;
812
813 iface = (struct ifacepsredirect_data *)data.lpData;
814 if (!FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION,
815 &iface->tlbid, &data))
816 return FALSE;
817
818 tlib = (struct tlibredirect_data *)data.lpData;
819 ptrW = (WCHAR *)((BYTE *)data.lpSectionBase + tlib->name_offset);
820
821 if (tlib->name_len/sizeof(WCHAR) >= len)
822 {
823 ERR("need larger module buffer, %u\n", tlib->name_len);
824 return FALSE;
825 }
826
827 memcpy(module, ptrW, tlib->name_len);
828 module[tlib->name_len/sizeof(WCHAR)] = 0;
829 return TRUE;
830 }
831
832 static HRESULT reg_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
833 {
834 REGSAM opposite = (sizeof(void*) == 8) ? KEY_WOW64_32KEY : KEY_WOW64_64KEY;
835 char tlguid[200], typelibkey[300], interfacekey[300], ver[100], tlfn[260];
836 DWORD tlguidlen, verlen, type;
837 LONG tlfnlen, err;
838 BOOL is_wow64;
839 HKEY ikey;
840
841 sprintf( interfacekey, "Interface\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\Typelib",
842 iid->Data1, iid->Data2, iid->Data3,
843 iid->Data4[0], iid->Data4[1], iid->Data4[2], iid->Data4[3],
844 iid->Data4[4], iid->Data4[5], iid->Data4[6], iid->Data4[7]
845 );
846
847 err = RegOpenKeyExA(HKEY_CLASSES_ROOT,interfacekey,0,KEY_READ,&ikey);
848 if (err && (opposite == KEY_WOW64_32KEY || (IsWow64Process(GetCurrentProcess(), &is_wow64)
849 && is_wow64)))
850 err = RegOpenKeyExA(HKEY_CLASSES_ROOT,interfacekey,0,KEY_READ|opposite,&ikey);
851
852 if (err)
853 {
854 ERR("No %s key found.\n", interfacekey);
855 return E_FAIL;
856 }
857
858 tlguidlen = sizeof(tlguid);
859 if (RegQueryValueExA(ikey, NULL, NULL, &type, (BYTE *)tlguid, &tlguidlen))
860 {
861 ERR("Getting typelib guid failed.\n");
862 RegCloseKey(ikey);
863 return E_FAIL;
864 }
865
866 verlen = sizeof(ver);
867 if (RegQueryValueExA(ikey, "Version", NULL, &type, (BYTE *)ver, &verlen))
868 {
869 ERR("Could not get version value?\n");
870 RegCloseKey(ikey);
871 return E_FAIL;
872 }
873
874 RegCloseKey(ikey);
875
876 sprintf(typelibkey, "Typelib\\%s\\%s\\0\\win%u", tlguid, ver, sizeof(void *) == 8 ? 64 : 32);
877 tlfnlen = sizeof(tlfn);
878 if (RegQueryValueA(HKEY_CLASSES_ROOT, typelibkey, tlfn, &tlfnlen))
879 {
880 #ifdef _WIN64
881 sprintf(typelibkey, "Typelib\\%s\\%s\\0\\win32", tlguid, ver);
882 tlfnlen = sizeof(tlfn);
883 if (RegQueryValueA(HKEY_CLASSES_ROOT, typelibkey, tlfn, &tlfnlen))
884 {
885 #endif
886 ERR("Could not get typelib fn?\n");
887 return E_FAIL;
888 #ifdef _WIN64
889 }
890 #endif
891 }
892 MultiByteToWideChar(CP_ACP, 0, tlfn, -1, module, len);
893 return S_OK;
894 }
895
896 static HRESULT get_typeinfo_for_iid(REFIID iid, ITypeInfo **typeinfo)
897 {
898 WCHAR module[MAX_PATH];
899 ITypeLib *typelib;
900 HRESULT hr;
901
902 *typeinfo = NULL;
903
904 module[0] = 0;
905 if (!actctx_get_typelib_module(iid, module, ARRAY_SIZE(module)))
906 {
907 hr = reg_get_typelib_module(iid, module, ARRAY_SIZE(module));
908 if (FAILED(hr))
909 return hr;
910 }
911
912 hr = LoadTypeLib(module, &typelib);
913 if (hr != S_OK) {
914 ERR("Failed to load typelib for %s, but it should be there.\n", debugstr_guid(iid));
915 return hr;
916 }
917
918 hr = ITypeLib_GetTypeInfoOfGuid(typelib, iid, typeinfo);
919 ITypeLib_Release(typelib);
920 if (hr != S_OK)
921 ERR("typelib does not contain info for %s\n", debugstr_guid(iid));
922
923 return hr;
924 }
925
926 static HRESULT WINAPI typelib_ps_QueryInterface(IPSFactoryBuffer *iface, REFIID iid, void **out)
927 {
928 if (IsEqualIID(iid, &IID_IPSFactoryBuffer) || IsEqualIID(iid, &IID_IUnknown))
929 {
930 *out = iface;
931 return S_OK;
932 }
933
934 FIXME("No interface for %s.\n", debugstr_guid(iid));
935 *out = NULL;
936 return E_NOINTERFACE;
937 }
938
939 static ULONG WINAPI typelib_ps_AddRef(IPSFactoryBuffer *iface)
940 {
941 return 2;
942 }
943
944 static ULONG WINAPI typelib_ps_Release(IPSFactoryBuffer *iface)
945 {
946 return 1;
947 }
948
949 static HRESULT WINAPI typelib_ps_CreateProxy(IPSFactoryBuffer *iface,
950 IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **out)
951 {
952 ITypeInfo *typeinfo;
953 HRESULT hr;
954
955 hr = get_typeinfo_for_iid(iid, &typeinfo);
956 if (FAILED(hr)) return hr;
957
958 hr = CreateProxyFromTypeInfo(typeinfo, outer, iid, proxy, out);
959 if (FAILED(hr))
960 ERR("Failed to create proxy, hr %#x.\n", hr);
961
962 ITypeInfo_Release(typeinfo);
963 return hr;
964 }
965
966 static HRESULT WINAPI typelib_ps_CreateStub(IPSFactoryBuffer *iface, REFIID iid,
967 IUnknown *server, IRpcStubBuffer **stub)
968 {
969 ITypeInfo *typeinfo;
970 HRESULT hr;
971
972 hr = get_typeinfo_for_iid(iid, &typeinfo);
973 if (FAILED(hr)) return hr;
974
975 hr = CreateStubFromTypeInfo(typeinfo, iid, server, stub);
976 if (FAILED(hr))
977 ERR("Failed to create stub, hr %#x.\n", hr);
978
979 ITypeInfo_Release(typeinfo);
980 return hr;
981 }
982
983 static const IPSFactoryBufferVtbl typelib_ps_vtbl =
984 {
985 typelib_ps_QueryInterface,
986 typelib_ps_AddRef,
987 typelib_ps_Release,
988 typelib_ps_CreateProxy,
989 typelib_ps_CreateStub,
990 };
991
992 static IPSFactoryBuffer typelib_ps = { &typelib_ps_vtbl };
993
994 extern void _get_STDFONT_CF(LPVOID *);
995 extern void _get_STDPIC_CF(LPVOID *);
996
997 static HRESULT WINAPI PSDispatchFacBuf_QueryInterface(IPSFactoryBuffer *iface, REFIID riid, void **ppv)
998 {
999 if (IsEqualIID(riid, &IID_IUnknown) ||
1000 IsEqualIID(riid, &IID_IPSFactoryBuffer))
1001 {
1002 IPSFactoryBuffer_AddRef(iface);
1003 *ppv = iface;
1004 return S_OK;
1005 }
1006 return E_NOINTERFACE;
1007 }
1008
1009 static ULONG WINAPI PSDispatchFacBuf_AddRef(IPSFactoryBuffer *iface)
1010 {
1011 return 2;
1012 }
1013
1014 static ULONG WINAPI PSDispatchFacBuf_Release(IPSFactoryBuffer *iface)
1015 {
1016 return 1;
1017 }
1018
1019 static HRESULT WINAPI PSDispatchFacBuf_CreateProxy(IPSFactoryBuffer *iface,
1020 IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **obj)
1021 {
1022 IPSFactoryBuffer *factory;
1023 HRESULT hr;
1024
1025 if (IsEqualIID(iid, &IID_IDispatch))
1026 {
1027 hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory);
1028 if (FAILED(hr)) return hr;
1029
1030 hr = IPSFactoryBuffer_CreateProxy(factory, outer, iid, proxy, obj);
1031 IPSFactoryBuffer_Release(factory);
1032 return hr;
1033 }
1034 else
1035 return IPSFactoryBuffer_CreateProxy(&typelib_ps, outer, iid, proxy, obj);
1036 }
1037
1038 static HRESULT WINAPI PSDispatchFacBuf_CreateStub(IPSFactoryBuffer *iface,
1039 REFIID iid, IUnknown *server, IRpcStubBuffer **stub)
1040 {
1041 IPSFactoryBuffer *factory;
1042 HRESULT hr;
1043
1044 if (IsEqualIID(iid, &IID_IDispatch))
1045 {
1046 hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory);
1047 if (FAILED(hr)) return hr;
1048
1049 hr = IPSFactoryBuffer_CreateStub(factory, iid, server, stub);
1050 IPSFactoryBuffer_Release(factory);
1051 return hr;
1052 }
1053 else
1054 return IPSFactoryBuffer_CreateStub(&typelib_ps, iid, server, stub);
1055 }
1056
1057 static const IPSFactoryBufferVtbl PSDispatchFacBuf_Vtbl =
1058 {
1059 PSDispatchFacBuf_QueryInterface,
1060 PSDispatchFacBuf_AddRef,
1061 PSDispatchFacBuf_Release,
1062 PSDispatchFacBuf_CreateProxy,
1063 PSDispatchFacBuf_CreateStub
1064 };
1065
1066 /* This is the whole PSFactoryBuffer object, just the vtableptr */
1067 static const IPSFactoryBufferVtbl *pPSDispatchFacBuf = &PSDispatchFacBuf_Vtbl;
1068
1069 /***********************************************************************
1070 * DllGetClassObject (OLEAUT32.@)
1071 */
1072 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
1073 {
1074 *ppv = NULL;
1075 if (IsEqualGUID(rclsid,&CLSID_StdFont)) {
1076 if (IsEqualGUID(iid,&IID_IClassFactory)) {
1077 _get_STDFONT_CF(ppv);
1078 IClassFactory_AddRef((IClassFactory*)*ppv);
1079 return S_OK;
1080 }
1081 }
1082 if (IsEqualGUID(rclsid,&CLSID_StdPicture)) {
1083 if (IsEqualGUID(iid,&IID_IClassFactory)) {
1084 _get_STDPIC_CF(ppv);
1085 IClassFactory_AddRef((IClassFactory*)*ppv);
1086 return S_OK;
1087 }
1088 }
1089 if (IsEqualCLSID(rclsid, &CLSID_PSDispatch) && IsEqualIID(iid, &IID_IPSFactoryBuffer)) {
1090 *ppv = &pPSDispatchFacBuf;
1091 IPSFactoryBuffer_AddRef((IPSFactoryBuffer *)*ppv);
1092 return S_OK;
1093 }
1094
1095 if (IsEqualGUID(rclsid, &CLSID_PSOAInterface))
1096 return IPSFactoryBuffer_QueryInterface(&typelib_ps, iid, ppv);
1097
1098 if (IsEqualCLSID(rclsid, &CLSID_PSTypeComp) ||
1099 IsEqualCLSID(rclsid, &CLSID_PSTypeInfo) ||
1100 IsEqualCLSID(rclsid, &CLSID_PSTypeLib) ||
1101 IsEqualCLSID(rclsid, &CLSID_PSDispatch) ||
1102 IsEqualCLSID(rclsid, &CLSID_PSEnumVariant))
1103 return OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, iid, ppv);
1104
1105 return OLEAUTPS_DllGetClassObject(rclsid, iid, ppv);
1106 }
1107
1108 /***********************************************************************
1109 * DllCanUnloadNow (OLEAUT32.@)
1110 *
1111 * Determine if this dll can be unloaded from the callers address space.
1112 *
1113 * PARAMS
1114 * None.
1115 *
1116 * RETURNS
1117 * Always returns S_FALSE. This dll cannot be unloaded.
1118 */
1119 HRESULT WINAPI DllCanUnloadNow(void)
1120 {
1121 return S_FALSE;
1122 }
1123
1124 /*****************************************************************************
1125 * DllMain [OLEAUT32.@]
1126 */
1127 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
1128 {
1129 static const WCHAR oanocacheW[] = {'o','a','n','o','c','a','c','h','e',0};
1130
1131 if(fdwReason == DLL_PROCESS_ATTACH)
1132 bstr_cache_enabled = !GetEnvironmentVariableW(oanocacheW, NULL, 0);
1133
1134 return OLEAUTPS_DllMain( hInstDll, fdwReason, lpvReserved );
1135 }
1136
1137 /***********************************************************************
1138 * DllRegisterServer (OLEAUT32.@)
1139 */
1140 HRESULT WINAPI DllRegisterServer(void)
1141 {
1142 return OLEAUTPS_DllRegisterServer();
1143 }
1144
1145 /***********************************************************************
1146 * DllUnregisterServer (OLEAUT32.@)
1147 */
1148 HRESULT WINAPI DllUnregisterServer(void)
1149 {
1150 return OLEAUTPS_DllUnregisterServer();
1151 }
1152
1153 /***********************************************************************
1154 * OleIconToCursor (OLEAUT32.415)
1155 */
1156 HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hIcon)
1157 {
1158 FIXME("(%p,%p), partially implemented.\n",hinstExe,hIcon);
1159 /* FIXME: make an extended conversation from HICON to HCURSOR */
1160 return CopyCursor(hIcon);
1161 }
1162
1163 /***********************************************************************
1164 * GetAltMonthNames (OLEAUT32.@)
1165 */
1166 HRESULT WINAPI GetAltMonthNames(LCID lcid, LPOLESTR **str)
1167 {
1168 static const WCHAR ar_month1W[] = {0x645,0x62d,0x631,0x645,0};
1169 static const WCHAR ar_month2W[] = {0x635,0x641,0x631,0};
1170 static const WCHAR ar_month3W[] = {0x631,0x628,0x64a,0x639,' ',0x627,0x644,0x627,0x648,0x644,0};
1171 static const WCHAR ar_month4W[] = {0x631,0x628,0x64a,0x639,' ',0x627,0x644,0x62b,0x627,0x646,0x64a,0};
1172 static const WCHAR ar_month5W[] = {0x62c,0x645,0x627,0x62f,0x649,' ',0x627,0x644,0x627,0x648,0x644,0x649,0};
1173 static const WCHAR ar_month6W[] = {0x62c,0x645,0x627,0x62f,0x649,' ',0x627,0x644,0x62b,0x627,0x646,0x64a,0x629,0};
1174 static const WCHAR ar_month7W[] = {0x631,0x62c,0x628,0};
1175 static const WCHAR ar_month8W[] = {0x634,0x639,0x628,0x627,0x646,0};
1176 static const WCHAR ar_month9W[] = {0x631,0x645,0x636,0x627,0x646,0};
1177 static const WCHAR ar_month10W[] = {0x634,0x648,0x627,0x643,0};
1178 static const WCHAR ar_month11W[] = {0x630,0x648,' ',0x627,0x644,0x642,0x639,0x62f,0x629,0};
1179 static const WCHAR ar_month12W[] = {0x630,0x648,' ',0x627,0x644,0x62d,0x62c,0x629,0};
1180
1181 static const WCHAR *arabic_hijri[] =
1182 {
1183 ar_month1W,
1184 ar_month2W,
1185 ar_month3W,
1186 ar_month4W,
1187 ar_month5W,
1188 ar_month6W,
1189 ar_month7W,
1190 ar_month8W,
1191 ar_month9W,
1192 ar_month10W,
1193 ar_month11W,
1194 ar_month12W,
1195 NULL
1196 };
1197
1198 static const WCHAR pl_month1W[] = {'s','t','y','c','z','n','i','a',0};
1199 static const WCHAR pl_month2W[] = {'l','u','t','e','g','o',0};
1200 static const WCHAR pl_month3W[] = {'m','a','r','c','a',0};
1201 static const WCHAR pl_month4W[] = {'k','w','i','e','t','n','i','a',0};
1202 static const WCHAR pl_month5W[] = {'m','a','j','a',0};
1203 static const WCHAR pl_month6W[] = {'c','z','e','r','w','c','a',0};
1204 static const WCHAR pl_month7W[] = {'l','i','p','c','a',0};
1205 static const WCHAR pl_month8W[] = {'s','i','e','r','p','n','i','a',0};
1206 static const WCHAR pl_month9W[] = {'w','r','z','e',0x15b,'n','i','a',0};
1207 static const WCHAR pl_month10W[] = {'p','a',0x17a,'d','z','i','e','r','n','i','k','a',0};
1208 static const WCHAR pl_month11W[] = {'l','i','s','t','o','p','a','d','a',0};
1209 static const WCHAR pl_month12W[] = {'g','r','u','d','n','i','a',0};
1210
1211 static const WCHAR *polish_genitive_names[] =
1212 {
1213 pl_month1W,
1214 pl_month2W,
1215 pl_month3W,
1216 pl_month4W,
1217 pl_month5W,
1218 pl_month6W,
1219 pl_month7W,
1220 pl_month8W,
1221 pl_month9W,
1222 pl_month10W,
1223 pl_month11W,
1224 pl_month12W,
1225 NULL
1226 };
1227
1228 static const WCHAR ru_month1W[] = {0x44f,0x43d,0x432,0x430,0x440,0x44f,0};
1229 static const WCHAR ru_month2W[] = {0x444,0x435,0x432,0x440,0x430,0x43b,0x44f,0};
1230 static const WCHAR ru_month3W[] = {0x43c,0x430,0x440,0x442,0x430,0};
1231 static const WCHAR ru_month4W[] = {0x430,0x43f,0x440,0x435,0x43b,0x44f,0};
1232 static const WCHAR ru_month5W[] = {0x43c,0x430,0x44f,0};
1233 static const WCHAR ru_month6W[] = {0x438,0x44e,0x43d,0x44f,0};
1234 static const WCHAR ru_month7W[] = {0x438,0x44e,0x43b,0x44f,0};
1235 static const WCHAR ru_month8W[] = {0x430,0x432,0x433,0x443,0x441,0x442,0x430,0};
1236 static const WCHAR ru_month9W[] = {0x441,0x435,0x43d,0x442,0x44f,0x431,0x440,0x44f,0};
1237 static const WCHAR ru_month10W[] = {0x43e,0x43a,0x442,0x44f,0x431,0x440,0x44f,0};
1238 static const WCHAR ru_month11W[] = {0x43d,0x43e,0x44f,0x431,0x440,0x44f,0};
1239 static const WCHAR ru_month12W[] = {0x434,0x435,0x43a,0x430,0x431,0x440,0x44f,0};
1240
1241 static const WCHAR *russian_genitive_names[] =
1242 {
1243 ru_month1W,
1244 ru_month2W,
1245 ru_month3W,
1246 ru_month4W,
1247 ru_month5W,
1248 ru_month6W,
1249 ru_month7W,
1250 ru_month8W,
1251 ru_month9W,
1252 ru_month10W,
1253 ru_month11W,
1254 ru_month12W,
1255 NULL
1256 };
1257
1258 TRACE("%#x, %p\n", lcid, str);
1259
1260 if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_ARABIC)
1261 *str = (LPOLESTR *)arabic_hijri;
1262 else if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_POLISH)
1263 *str = (LPOLESTR *)polish_genitive_names;
1264 else if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_RUSSIAN)
1265 *str = (LPOLESTR *)russian_genitive_names;
1266 else
1267 *str = NULL;
1268
1269 return S_OK;
1270 }
A free Windows-compatible Operating System