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
38 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(ole);
42 /* The OLE Automation ProxyStub Interface Class (aka Typelib Marshaler) */
43 extern const GUID CLSID_PSOAInterface;
45 /* IDispatch marshaler */
46 extern const GUID CLSID_PSDispatch;
48 static BOOL BSTR_bCache = TRUE; /* Cache allocations to minimise alloc calls? */
50 HMODULE OLEAUT32_hModule = NULL;
52 /******************************************************************************
56 * BSTR is a simple typedef for a wide-character string used as the principle
57 * string type in ole automation. When encapsulated in a Variant type they are
58 * automatically copied and destroyed as the variant is processed.
60 * The low level BSTR Api allows manipulation of these strings and is used by
61 * higher level Api calls to manage the strings transparently to the caller.
63 * Internally the BSTR type is allocated with space for a DWORD byte count before
64 * the string data begins. This is undocumented and non-system code should not
65 * access the count directly. Use SysStringLen() or SysStringByteLen()
66 * instead. Note that the byte count does not include the terminating NUL.
68 * To create a new BSTR, use SysAllocString(), SysAllocStringLen() or
69 * SysAllocStringByteLen(). To change the size of an existing BSTR, use SysReAllocString()
70 * or SysReAllocStringLen(). Finally to destroy a string use SysFreeString().
72 * BSTR's are cached by Ole Automation by default. To override this behaviour
73 * either set the environment variable 'OANOCACHE', or call SetOaNoCache().
76 * 'Inside OLE, second edition' by Kraig Brockshmidt.
79 /******************************************************************************
80 * SysStringLen [OLEAUT32.7]
82 * Get the allocated length of a BSTR in wide characters.
85 * str [I] BSTR to find the length of
88 * The allocated length of str, or 0 if str is NULL.
92 * The returned length may be different from the length of the string as
93 * calculated by lstrlenW(), since it returns the length that was used to
94 * allocate the string by SysAllocStringLen().
96 UINT WINAPI SysStringLen(BSTR str)
102 * The length of the string (in bytes) is contained in a DWORD placed
103 * just before the BSTR pointer
105 bufferPointer = (DWORD*)str;
109 return (int)(*bufferPointer/sizeof(WCHAR));
112 /******************************************************************************
113 * SysStringByteLen [OLEAUT32.149]
115 * Get the allocated length of a BSTR in bytes.
118 * str [I] BSTR to find the length of
121 * The allocated length of str, or 0 if str is NULL.
124 * See SysStringLen(), BSTR().
126 UINT WINAPI SysStringByteLen(BSTR str)
128 DWORD* bufferPointer;
132 * The length of the string (in bytes) is contained in a DWORD placed
133 * just before the BSTR pointer
135 bufferPointer = (DWORD*)str;
139 return (int)(*bufferPointer);
142 /******************************************************************************
143 * SysAllocString [OLEAUT32.2]
145 * Create a BSTR from an OLESTR.
148 * str [I] Source to create BSTR from
151 * Success: A BSTR allocated with SysAllocStringLen().
152 * Failure: NULL, if oleStr is NULL.
156 * MSDN (October 2001) incorrectly states that NULL is returned if oleStr has
157 * a length of 0. Native Win32 and this implementation both return a valid
158 * empty BSTR in this case.
160 BSTR WINAPI SysAllocString(LPCOLESTR str)
164 /* Delegate this to the SysAllocStringLen32 method. */
165 return SysAllocStringLen(str, lstrlenW(str));
168 /******************************************************************************
169 * SysFreeString [OLEAUT32.6]
174 * str [I] BSTR to free.
181 * str may be NULL, in which case this function does nothing.
183 void WINAPI SysFreeString(BSTR str)
185 DWORD* bufferPointer;
187 /* NULL is a valid parameter */
191 * We have to be careful when we free a BSTR pointer, it points to
192 * the beginning of the string but it skips the byte count contained
195 bufferPointer = (DWORD*)str;
200 * Free the memory from its "real" origin.
202 HeapFree(GetProcessHeap(), 0, bufferPointer);
205 /******************************************************************************
206 * SysAllocStringLen [OLEAUT32.4]
208 * Create a BSTR from an OLESTR of a given wide character length.
211 * str [I] Source to create BSTR from
212 * len [I] Length of oleStr in wide characters
215 * Success: A newly allocated BSTR from SysAllocStringByteLen()
216 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
219 * See BSTR(), SysAllocStringByteLen().
221 BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
228 * Find the length of the buffer passed-in in bytes.
230 bufferSize = len * sizeof (WCHAR);
233 * Allocate a new buffer to hold the string.
234 * don't forget to keep an empty spot at the beginning of the
235 * buffer for the character count and an extra character at the
238 newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
240 bufferSize + sizeof(WCHAR) + sizeof(DWORD));
243 * If the memory allocation failed, return a null pointer.
249 * Copy the length of the string in the placeholder.
251 *newBuffer = bufferSize;
254 * Skip the byte count.
259 * Copy the information in the buffer.
260 * Since it is valid to pass a NULL pointer here, we'll initialize the
261 * buffer to nul if it is the case.
264 memcpy(newBuffer, str, bufferSize);
266 memset(newBuffer, 0, bufferSize);
269 * Make sure that there is a nul character at the end of the
272 stringBuffer = (WCHAR*)newBuffer;
273 stringBuffer[len] = L'\0';
275 return (LPWSTR)stringBuffer;
278 /******************************************************************************
279 * SysReAllocStringLen [OLEAUT32.5]
281 * Change the length of a previously created BSTR.
284 * old [O] BSTR to change the length of
285 * str [I] New source for pbstr
286 * len [I] Length of oleStr in wide characters
289 * Success: 1. The size of pbstr is updated.
290 * Failure: 0, if len >= 0x80000000 or memory allocation fails.
293 * See BSTR(), SysAllocStringByteLen().
294 * *pbstr may be changed by this function.
296 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* str, unsigned int len)
299 DWORD newbytelen = len*sizeof(WCHAR);
300 DWORD *ptr = HeapReAlloc(GetProcessHeap(),0,((DWORD*)*old)-1,newbytelen+sizeof(WCHAR)+sizeof(DWORD));
301 *old = (BSTR)(ptr+1);
304 memcpy(*old, str, newbytelen);
307 /* Subtle hidden feature: The old string data is still there
309 * Some Microsoft program needs it.
314 * Allocate the new string
316 *old = SysAllocStringLen(str, len);
322 /******************************************************************************
323 * SysAllocStringByteLen [OLEAUT32.150]
325 * Create a BSTR from an OLESTR of a given byte length.
328 * str [I] Source to create BSTR from
329 * len [I] Length of oleStr in bytes
332 * Success: A newly allocated BSTR
333 * Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
336 * -If len is 0 or oleStr is NULL the resulting string is empty ("").
337 * -This function always NUL terminates the resulting BSTR.
338 * -oleStr may be either an LPCSTR or LPCOLESTR, since it is copied
339 * without checking for a terminating NUL.
342 BSTR WINAPI SysAllocStringByteLen(LPCSTR str, UINT len)
348 * Allocate a new buffer to hold the string.
349 * don't forget to keep an empty spot at the beginning of the
350 * buffer for the character count and an extra character at the
353 newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
355 len + sizeof(WCHAR) + sizeof(DWORD));
358 * If the memory allocation failed, return a null pointer.
364 * Copy the length of the string in the placeholder.
369 * Skip the byte count.
374 * Copy the information in the buffer.
375 * Since it is valid to pass a NULL pointer here, we'll initialize the
376 * buffer to nul if it is the case.
379 memcpy(newBuffer, str, len);
382 * Make sure that there is a nul character at the end of the
385 stringBuffer = (char *)newBuffer;
386 stringBuffer[len] = 0;
387 stringBuffer[len+1] = 0;
389 return (LPWSTR)stringBuffer;
392 /******************************************************************************
393 * SysReAllocString [OLEAUT32.3]
395 * Change the length of a previously created BSTR.
398 * old [I/O] BSTR to change the length of
399 * str [I] New source for pbstr
406 * See BSTR(), SysAllocStringStringLen().
408 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR str)
417 * Make sure we free the old string.
423 * Allocate the new string
425 *old = SysAllocString(str);
430 /******************************************************************************
431 * SetOaNoCache (OLEAUT32.327)
433 * Instruct Ole Automation not to cache BSTR allocations.
444 void WINAPI SetOaNoCache(void)
449 static WCHAR _delimiter[2] = {'!',0}; /* default delimiter apparently */
450 static WCHAR *pdelimiter = &_delimiter[0];
452 /***********************************************************************
453 * RegisterActiveObject (OLEAUT32.33)
455 HRESULT WINAPI RegisterActiveObject(
456 LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
460 LPRUNNINGOBJECTTABLE runobtable;
463 StringFromGUID2(rcid,guidbuf,39);
464 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
467 ret = GetRunningObjectTable(0,&runobtable);
469 IMoniker_Release(moniker);
472 ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
473 IRunningObjectTable_Release(runobtable);
474 IMoniker_Release(moniker);
478 /***********************************************************************
479 * RevokeActiveObject (OLEAUT32.34)
481 HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
483 LPRUNNINGOBJECTTABLE runobtable;
486 ret = GetRunningObjectTable(0,&runobtable);
487 if (FAILED(ret)) return ret;
488 ret = IRunningObjectTable_Revoke(runobtable,xregister);
489 if (SUCCEEDED(ret)) ret = S_OK;
490 IRunningObjectTable_Release(runobtable);
494 /***********************************************************************
495 * GetActiveObject (OLEAUT32.35)
497 HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
501 LPRUNNINGOBJECTTABLE runobtable;
504 StringFromGUID2(rcid,guidbuf,39);
505 ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
508 ret = GetRunningObjectTable(0,&runobtable);
510 IMoniker_Release(moniker);
513 ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
514 IRunningObjectTable_Release(runobtable);
515 IMoniker_Release(moniker);
520 /***********************************************************************
521 * OaBuildVersion [OLEAUT32.170]
523 * Get the Ole Automation build version.
532 * Known oleaut32.dll versions:
533 *| OLE Ver. Comments Date Build Ver.
534 *| -------- ------------------------- ---- ---------
535 *| OLE 2.1 NT 1993-95 10 3023
537 *| Win32s Ver 1.1e 20 4049
538 *| OLE 2.20 W95/NT 1993-96 20 4112
539 *| OLE 2.20 W95/NT 1993-96 20 4118
540 *| OLE 2.20 W95/NT 1993-96 20 4122
541 *| OLE 2.30 W95/NT 1993-98 30 4265
542 *| OLE 2.40 NT?? 1993-98 40 4267
543 *| OLE 2.40 W98 SE orig. file 1993-98 40 4275
544 *| OLE 2.40 W2K orig. file 1993-XX 40 4514
546 * Currently the versions returned are 2.20 for Win3.1, 2.30 for Win95 & NT 3.51,
547 * and 2.40 for all later versions. The build number is maximum, i.e. 0xffff.
549 ULONG WINAPI OaBuildVersion()
551 switch(GetVersion() & 0x8000ffff) /* mask off build number */
553 case 0x80000a03: /* WIN31 */
554 return MAKELONG(0xffff, 20);
555 case 0x00003303: /* NT351 */
556 return MAKELONG(0xffff, 30);
557 case 0x80000004: /* WIN95; I'd like to use the "standard" w95 minor
558 version here (30), but as we still use w95
559 as default winver (which is good IMHO), I better
560 play safe and use the latest value for w95 for now.
561 Change this as soon as default winver gets changed
562 to something more recent */
563 case 0x80000a04: /* WIN98 */
564 case 0x00000004: /* NT40 */
565 case 0x00000005: /* W2K */
566 return MAKELONG(0xffff, 40);
568 ERR("Version value not known yet. Please investigate it !\n");
573 /******************************************************************************
574 * GetRecordInfoFromGuids [OLEAUT32.322]
578 * Failure: E_INVALIDARG, if any argument is invalid.
583 HRESULT WINAPI GetRecordInfoFromGuids(
584 REFGUID rGuidTypeLib,
588 REFGUID rGuidTypeInfo,
589 IRecordInfo** ppRecInfo)
591 FIXME("(%p,%ld,%ld,%ld,%p,%p),stub!\n",rGuidTypeLib, uVerMajor, uVerMinor, lcid, rGuidTypeInfo, ppRecInfo);
595 /******************************************************************************
596 * OleTranslateColor [OLEAUT32.421]
598 * Convert an OLE_COLOR to a COLORREF.
601 * clr [I] Color to convert
602 * hpal [I] Handle to a palette for the conversion
603 * pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
606 * Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
607 * Failure: E_INVALIDARG, if any argument is invalid.
610 * Document the conversion rules.
612 HRESULT WINAPI OleTranslateColor(
618 BYTE b = HIBYTE(HIWORD(clr));
620 TRACE("(%08lx, %p, %p):stub\n", clr, hpal, pColorRef);
623 * In case pColorRef is NULL, provide our own to simplify the code.
625 if (pColorRef == NULL)
626 pColorRef = &colorref;
633 *pColorRef = PALETTERGB(GetRValue(clr),
648 * Validate the palette index.
650 if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
665 int index = LOBYTE(LOWORD(clr));
668 * Validate GetSysColor index.
670 if ((index < COLOR_SCROLLBAR) || (index > COLOR_MENUBAR))
673 *pColorRef = GetSysColor(index);
685 extern HRESULT OLEAUTPS_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv);
687 extern void _get_STDFONT_CF(LPVOID);
688 extern void _get_STDPIC_CF(LPVOID);
690 /***********************************************************************
691 * DllGetClassObject (OLEAUT32.1)
693 HRESULT WINAPI OLEAUT32_DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
696 if (IsEqualGUID(rclsid,&CLSID_StdFont)) {
697 if (IsEqualGUID(iid,&IID_IClassFactory)) {
698 _get_STDFONT_CF(ppv);
699 IClassFactory_AddRef((IClassFactory*)*ppv);
703 if (IsEqualGUID(rclsid,&CLSID_StdPicture)) {
704 if (IsEqualGUID(iid,&IID_IClassFactory)) {
706 IClassFactory_AddRef((IClassFactory*)*ppv);
710 if (IsEqualGUID(rclsid,&CLSID_PSDispatch)) {
711 return OLEAUTPS_DllGetClassObject(rclsid,iid,ppv);
713 if (IsEqualGUID(rclsid,&CLSID_PSOAInterface)) {
714 if (S_OK==TypeLibFac_DllGetClassObject(rclsid,iid,ppv))
718 FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid));
719 return CLASS_E_CLASSNOTAVAILABLE;
722 /***********************************************************************
723 * DllCanUnloadNow (OLEAUT32.410)
725 * Determine if this dll can be unloaded from the callers address space.
731 * Always returns S_FALSE. This dll cannot be unloaded.
733 HRESULT WINAPI OLEAUT32_DllCanUnloadNow(void)
738 /*****************************************************************************
739 * DllMain [OLEAUT32.@]
741 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
743 TRACE("(%p,%lu,%p)\n", hInstDll, fdwReason, lpvReserved);
746 case DLL_PROCESS_ATTACH:
747 DisableThreadLibraryCalls(hInstDll);
748 OLEAUT32_hModule = (HMODULE)hInstDll;
750 case DLL_PROCESS_DETACH: