4 * Copyright 1999, 2000 Marcus Meissner
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
36 #include "wine/debug.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
40 /* The OLE Automation ProxyStub Interface Class (aka Typelib Marshaler) */
41 extern const GUID CLSID_PSOAInterface;
43 /* IDispatch marshaler */
44 extern const GUID CLSID_PSDispatch;
46 static BOOL BSTR_bCache = TRUE; /* Cache allocations to minimise alloc calls? */
48 HMODULE OLEAUT32_hModule = NULL;
50 /******************************************************************************
54 * BSTR is a simple typedef for a wide-character string used as the principle
55 * string type in ole automation. When encapsulated in a Variant type they are
56 * automatically copied and destroyed as the variant is processed.
58 * The low level BSTR Api allows manipulation of these strings and is used by
59 * higher level Api calls to manage the strings transparently to the caller.
61 * Internally the BSTR type is allocated with space for a DWORD byte count before
62 * the string data begins. This is undocumented and non-system code should not
63 * access the count directly. Use SysStringLen() or SysStringByteLen()
64 * instead. Note that the byte count does not include the terminating NUL.
66 * To create a new BSTR, use SysAllocString(), SysAllocStringLen() or
67 * SysAllocStringByteLen(). To change the size of an existing BSTR, use SysReAllocString()
68 * or SysReAllocStringLen(). Finally to destroy a string use SysFreeString().
70 * BSTR's are cached by Ole Automation by default. To override this behaviour
71 * either set the environment variable 'OANOCACHE', or call SetOaNoCache().
74 * 'Inside OLE, second edition' by Kraig Brockshmidt.
77 /******************************************************************************
78 * SysStringLen [OLEAUT32.7]
80 * Get the allocated length of a BSTR in wide characters.
83 * str [I] BSTR to find the length of
86 * The allocated length of str, or 0 if str is NULL.
90 * The returned length may be different from the length of the string as
91 * calculated by lstrlenW(), since it returns the length that was used to
92 * allocate the string by SysAllocStringLen().
94 int WINAPI SysStringLen(BSTR str)
100 * The length of the string (in bytes) is contained in a DWORD placed
101 * just before the BSTR pointer
103 bufferPointer = (DWORD*)str;
107 return (int)(*bufferPointer/sizeof(WCHAR));
110 /******************************************************************************
111 * SysStringByteLen [OLEAUT32.149]
113 * Get the allocated length of a BSTR in bytes.
116 * str [I] BSTR to find the length of
119 * The allocated length of str, or 0 if str is NULL.
122 * See SysStringLen(), BSTR().
124 int WINAPI SysStringByteLen(BSTR str)
126 DWORD* bufferPointer;
130 * The length of the string (in bytes) is contained in a DWORD placed
131 * just before the BSTR pointer
133 bufferPointer = (DWORD*)str;
137 return (int)(*bufferPointer);
140 /******************************************************************************
141 * SysAllocString [OLEAUT32.2]
143 * Create a BSTR from an OLESTR.
146 * str [I] Source to create BSTR from
149 * Success: A BSTR allocated with SysAllocStringLen().
150 * Failure: NULL, if oleStr is NULL.
154 * MSDN (October 2001) incorrectly states that NULL is returned if oleStr has
155 * a length of 0. Native Win32 and this implementation both return a valid
156 * empty BSTR in this case.
158 BSTR WINAPI SysAllocString(LPCOLESTR str)
162 /* Delegate this to the SysAllocStringLen32 method. */
163 return SysAllocStringLen(str, lstrlenW(str));
166 /******************************************************************************
167 * SysFreeString [OLEAUT32.6]
172 * str [I] BSTR to free.
179 * str may be NULL, in which case this function does nothing.
181 void WINAPI SysFreeString(BSTR str)
183 DWORD* bufferPointer;
185 /* NULL is a valid parameter */
189 * We have to be careful when we free a BSTR pointer, it points to
190 * the beginning of the string but it skips the byte count contained
193 bufferPointer = (DWORD*)str;
198 * Free the memory from its "real" origin.
200 HeapFree(GetProcessHeap(), 0, bufferPointer);
203 /******************************************************************************
204 * SysAllocStringLen [OLEAUT32.4]
206 * Create a BSTR from an OLESTR of a given wide character length.
209 * str [I] Source to create BSTR from
210 * len [I] Length of oleStr in wide characters
213 * Success: A newly allocated BSTR from SysAllocStringByteLen()
214 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
217 * See BSTR(), SysAllocStringByteLen().
219 BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
226 * Find the length of the buffer passed-in in bytes.
228 bufferSize = len * sizeof (WCHAR);
231 * Allocate a new buffer to hold the string.
232 * dont't forget to keep an empty spot at the beginning of the
233 * buffer for the character count and an extra character at the
236 newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
238 bufferSize + sizeof(WCHAR) + sizeof(DWORD));
241 * If the memory allocation failed, return a null pointer.
247 * Copy the length of the string in the placeholder.
249 *newBuffer = bufferSize;
252 * Skip the byte count.
257 * Copy the information in the buffer.
258 * Since it is valid to pass a NULL pointer here, we'll initialize the
259 * buffer to nul if it is the case.
262 memcpy(newBuffer, str, bufferSize);
264 memset(newBuffer, 0, bufferSize);
267 * Make sure that there is a nul character at the end of the
270 stringBuffer = (WCHAR*)newBuffer;
271 stringBuffer[len] = L'\0';
273 return (LPWSTR)stringBuffer;
276 /******************************************************************************
277 * SysReAllocStringLen [OLEAUT32.5]
279 * Change the length of a previously created BSTR.
282 * old [O] BSTR to change the length of
283 * str [I] New source for pbstr
284 * len [I] Length of oleStr in wide characters
287 * Success: 1. The size of pbstr is updated.
288 * Failure: 0, if len >= 0x80000000 or memory allocation fails.
291 * See BSTR(), SysAllocStringByteLen().
292 * *pbstr may be changed by this function.
294 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* str, unsigned int len)
303 DWORD newbytelen = len*sizeof(WCHAR);
304 DWORD *ptr = HeapReAlloc(GetProcessHeap(),0,((DWORD*)*old)-1,newbytelen+sizeof(WCHAR)+sizeof(DWORD));
305 *old = (BSTR)(ptr+1);
308 memcpy(*old, str, newbytelen);
311 /* Subtle hidden feature: The old string data is still there
313 * Some Microsoft program needs it.
318 * Allocate the new string
320 *old = SysAllocStringLen(str, len);
326 /******************************************************************************
327 * SysAllocStringByteLen [OLEAUT32.150]
329 * Create a BSTR from an OLESTR of a given byte length.
332 * str [I] Source to create BSTR from
333 * len [I] Length of oleStr in bytes
336 * Success: A newly allocated BSTR
337 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
340 * -If len is 0 or oleStr is NULL the resulting string is empty ("").
341 * -This function always NUL terminates the resulting BSTR.
342 * -oleStr may be either an LPCSTR or LPCOLESTR, since it is copied
343 * without checking for a terminating NUL.
346 BSTR WINAPI SysAllocStringByteLen(LPCSTR str, UINT len)
352 * Allocate a new buffer to hold the string.
353 * dont't forget to keep an empty spot at the beginning of the
354 * buffer for the character count and an extra character at the
357 newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
359 len + sizeof(WCHAR) + sizeof(DWORD));
362 * If the memory allocation failed, return a null pointer.
368 * Copy the length of the string in the placeholder.
373 * Skip the byte count.
378 * Copy the information in the buffer.
379 * Since it is valid to pass a NULL pointer here, we'll initialize the
380 * buffer to nul if it is the case.
383 memcpy(newBuffer, str, len);
386 * Make sure that there is a nul character at the end of the
389 stringBuffer = (char *)newBuffer;
390 stringBuffer[len] = 0;
391 stringBuffer[len+1] = 0;
393 return (LPWSTR)stringBuffer;
396 /******************************************************************************
397 * SysReAllocString [OLEAUT32.3]
399 * Change the length of a previously created BSTR.
402 * old [I/O] BSTR to change the length of
403 * str [I] New source for pbstr
410 * See BSTR(), SysAllocStringStringLen().
412 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR str)
421 * Make sure we free the old string.
427 * Allocate the new string
429 *old = SysAllocString(str);
434 /******************************************************************************
435 * SetOaNoCache (OLEAUT32.327)
437 * Instruct Ole Automation not to cache BSTR allocations.
448 void WINAPI SetOaNoCache(void)
453 static WCHAR _delimiter[2] = {'!',0}; /* default delimiter apparently */
454 static WCHAR *pdelimiter = &_delimiter[0];
456 /***********************************************************************
457 * RegisterActiveObject (OLEAUT32.33)
459 HRESULT WINAPI RegisterActiveObject(
460 LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
464 LPRUNNINGOBJECTTABLE runobtable;
467 StringFromGUID2(rcid,guidbuf,39);
468 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
471 ret = GetRunningObjectTable(0,&runobtable);
473 IMoniker_Release(moniker);
476 ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
477 IRunningObjectTable_Release(runobtable);
478 IMoniker_Release(moniker);
482 /***********************************************************************
483 * RevokeActiveObject (OLEAUT32.34)
485 HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
487 LPRUNNINGOBJECTTABLE runobtable;
490 ret = GetRunningObjectTable(0,&runobtable);
491 if (FAILED(ret)) return ret;
492 ret = IRunningObjectTable_Revoke(runobtable,xregister);
493 if (SUCCEEDED(ret)) ret = S_OK;
494 IRunningObjectTable_Release(runobtable);
498 /***********************************************************************
499 * GetActiveObject (OLEAUT32.35)
501 HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
505 LPRUNNINGOBJECTTABLE runobtable;
508 StringFromGUID2(rcid,guidbuf,39);
509 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
512 ret = GetRunningObjectTable(0,&runobtable);
514 IMoniker_Release(moniker);
517 ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
518 IRunningObjectTable_Release(runobtable);
519 IMoniker_Release(moniker);
524 /***********************************************************************
525 * OaBuildVersion [OLEAUT32.170]
527 * Get the Ole Automation build version.
536 * Known oleaut32.dll versions:
537 *| OLE Ver. Comments Date Build Ver.
538 *| -------- ------------------------- ---- ---------
539 *| OLE 2.1 NT 1993-95 10 3023
541 *| Win32s Ver 1.1e 20 4049
542 *| OLE 2.20 W95/NT 1993-96 20 4112
543 *| OLE 2.20 W95/NT 1993-96 20 4118
544 *| OLE 2.20 W95/NT 1993-96 20 4122
545 *| OLE 2.30 W95/NT 1993-98 30 4265
546 *| OLE 2.40 NT?? 1993-98 40 4267
547 *| OLE 2.40 W98 SE orig. file 1993-98 40 4275
548 *| OLE 2.40 W2K orig. file 1993-XX 40 4514
550 * Currently the versions returned are 2.20 for Win3.1, 2.30 for Win95 & NT 3.51,
551 * and 2.40 for all later versions. The build number is maximum, i.e. 0xffff.
553 ULONG WINAPI OaBuildVersion()
555 switch(GetVersion() & 0x8000ffff) /* mask off build number */
557 case 0x80000a03: /* WIN31 */
558 return MAKELONG(0xffff, 20);
559 case 0x00003303: /* NT351 */
560 return MAKELONG(0xffff, 30);
561 case 0x80000004: /* WIN95; I'd like to use the "standard" w95 minor
562 version here (30), but as we still use w95
563 as default winver (which is good IMHO), I better
564 play safe and use the latest value for w95 for now.
565 Change this as soon as default winver gets changed
566 to something more recent */
567 case 0x80000a04: /* WIN98 */
568 case 0x00000004: /* NT40 */
569 case 0x00000005: /* W2K */
570 return MAKELONG(0xffff, 40);
572 ERR("Version value not known yet. Please investigate it !\n");
577 /******************************************************************************
578 * OleTranslateColor [OLEAUT32.421]
580 * Convert an OLE_COLOR to a COLORREF.
583 * clr [I] Color to convert
584 * hpal [I] Handle to a palette for the conversion
585 * pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
588 * Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
589 * Failure: E_INVALIDARG, if any argument is invalid.
592 * Document the conversion rules.
594 HRESULT WINAPI OleTranslateColor(
600 BYTE b = HIBYTE(HIWORD(clr));
602 TRACE("(%08lx, %p, %p):stub\n", clr, hpal, pColorRef);
605 * In case pColorRef is NULL, provide our own to simplify the code.
607 if (pColorRef == NULL)
608 pColorRef = &colorref;
615 *pColorRef = PALETTERGB(GetRValue(clr),
630 * Validate the palette index.
632 if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
647 int index = LOBYTE(LOWORD(clr));
650 * Validate GetSysColor index.
652 if ((index < COLOR_SCROLLBAR) || (index > COLOR_GRADIENTINACTIVECAPTION))
655 *pColorRef = GetSysColor(index);
667 extern HRESULT OLEAUTPS_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv);
669 extern void _get_STDFONT_CF(LPVOID);
670 extern void _get_STDPIC_CF(LPVOID);
672 /***********************************************************************
673 * DllGetClassObject (OLEAUT32.1)
675 HRESULT WINAPI OLEAUT32_DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
678 if (IsEqualGUID(rclsid,&CLSID_StdFont)) {
679 if (IsEqualGUID(iid,&IID_IClassFactory)) {
680 _get_STDFONT_CF(ppv);
681 IClassFactory_AddRef((IClassFactory*)*ppv);
685 if (IsEqualGUID(rclsid,&CLSID_StdPicture)) {
686 if (IsEqualGUID(iid,&IID_IClassFactory)) {
688 IClassFactory_AddRef((IClassFactory*)*ppv);
692 if (IsEqualGUID(rclsid,&CLSID_PSDispatch)) {
693 return OLEAUTPS_DllGetClassObject(rclsid,iid,ppv);
695 if (IsEqualGUID(rclsid,&CLSID_PSOAInterface)) {
696 if (S_OK==TypeLibFac_DllGetClassObject(rclsid,iid,ppv))
700 FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid));
701 return CLASS_E_CLASSNOTAVAILABLE;
704 /***********************************************************************
705 * DllCanUnloadNow (OLEAUT32.410)
707 * Determine if this dll can be unloaded from the callers address space.
713 * Always returns S_FALSE. This dll cannot be unloaded.
715 HRESULT WINAPI OLEAUT32_DllCanUnloadNow()
720 /*****************************************************************************
721 * DllMain [OLEAUT32.@]
723 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
725 TRACE("(%p,%lu,%p)\n", hInstDll, fdwReason, lpvReserved);
728 case DLL_PROCESS_ATTACH:
729 DisableThreadLibraryCalls(hInstDll);
730 OLEAUT32_hModule = (HMODULE)hInstDll;
732 case DLL_PROCESS_DETACH: