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 }
896
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.