2 * Implementation of mscoree.dll
3 * Microsoft Component Object Runtime Execution Engine
5 * Copyright 2006 Paul Chitescu
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
33 #include "strongname.h"
44 #include "wine/list.h"
45 #include "mscoree_private.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL( mscoree
);
51 WINE_DECLARE_DEBUG_CHANNEL(winediag
);
53 typedef HRESULT (*fnCreateInstance
)(REFIID riid
, LPVOID
*ppObj
);
55 char *WtoA(LPCWSTR wstr
)
60 length
= WideCharToMultiByte(CP_UTF8
, 0, wstr
, -1, NULL
, 0, NULL
, NULL
);
62 result
= HeapAlloc(GetProcessHeap(), 0, length
);
65 WideCharToMultiByte(CP_UTF8
, 0, wstr
, -1, result
, length
, NULL
, NULL
);
70 static BOOL
get_install_root(LPWSTR install_dir
)
72 static const WCHAR dotnet_key
[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\','.','N','E','T','F','r','a','m','e','w','o','r','k','\\',0};
73 static const WCHAR install_root
[] = {'I','n','s','t','a','l','l','R','o','o','t',0};
78 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE
, dotnet_key
, 0, KEY_READ
, &key
))
81 len
= MAX_PATH
* sizeof(WCHAR
);
82 if (RegQueryValueExW(key
, install_root
, 0, NULL
, (LPBYTE
)install_dir
, &len
))
92 typedef struct mscorecf
94 IClassFactory IClassFactory_iface
;
97 fnCreateInstance pfnCreateInstance
;
102 static inline mscorecf
*impl_from_IClassFactory( IClassFactory
*iface
)
104 return CONTAINING_RECORD(iface
, mscorecf
, IClassFactory_iface
);
107 static HRESULT WINAPI
mscorecf_QueryInterface(IClassFactory
*iface
, REFIID riid
, LPVOID
*ppobj
)
109 TRACE("%s %p\n", debugstr_guid(riid
), ppobj
);
111 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
112 IsEqualGUID(riid
, &IID_IClassFactory
))
114 IClassFactory_AddRef( iface
);
119 ERR("interface %s not implemented\n", debugstr_guid(riid
));
120 return E_NOINTERFACE
;
123 static ULONG WINAPI
mscorecf_AddRef(IClassFactory
*iface
)
125 mscorecf
*This
= impl_from_IClassFactory(iface
);
126 ULONG ref
= InterlockedIncrement(&This
->ref
);
128 TRACE("%p ref=%u\n", This
, ref
);
133 static ULONG WINAPI
mscorecf_Release(IClassFactory
*iface
)
135 mscorecf
*This
= impl_from_IClassFactory(iface
);
136 ULONG ref
= InterlockedDecrement(&This
->ref
);
138 TRACE("%p ref=%u\n", This
, ref
);
142 HeapFree(GetProcessHeap(), 0, This
);
148 static HRESULT WINAPI
mscorecf_CreateInstance(IClassFactory
*iface
,LPUNKNOWN pOuter
,
149 REFIID riid
, LPVOID
*ppobj
)
151 mscorecf
*This
= impl_from_IClassFactory( iface
);
155 TRACE("%p %s %p\n", pOuter
, debugstr_guid(riid
), ppobj
);
160 return CLASS_E_NOAGGREGATION
;
162 hr
= This
->pfnCreateInstance( &This
->clsid
, (LPVOID
*) &punk
);
165 hr
= IUnknown_QueryInterface( punk
, riid
, ppobj
);
167 IUnknown_Release( punk
);
171 WARN("Cannot create an instance object. 0x%08x\n", hr
);
176 static HRESULT WINAPI
mscorecf_LockServer(IClassFactory
*iface
, BOOL dolock
)
178 FIXME("(%p)->(%d),stub!\n",iface
,dolock
);
182 static const struct IClassFactoryVtbl mscorecf_vtbl
=
184 mscorecf_QueryInterface
,
187 mscorecf_CreateInstance
,
191 HRESULT WINAPI
CorBindToRuntimeHost(LPCWSTR pwszVersion
, LPCWSTR pwszBuildFlavor
,
192 LPCWSTR pwszHostConfigFile
, VOID
*pReserved
,
193 DWORD startupFlags
, REFCLSID rclsid
,
194 REFIID riid
, LPVOID
*ppv
)
197 ICLRRuntimeInfo
*info
;
199 TRACE("(%s, %s, %s, %p, %d, %s, %s, %p)\n", debugstr_w(pwszVersion
),
200 debugstr_w(pwszBuildFlavor
), debugstr_w(pwszHostConfigFile
), pReserved
,
201 startupFlags
, debugstr_guid(rclsid
), debugstr_guid(riid
), ppv
);
205 ret
= get_runtime_info(NULL
, pwszVersion
, pwszHostConfigFile
, NULL
, startupFlags
, 0, TRUE
, &info
);
209 ret
= ICLRRuntimeInfo_GetInterface(info
, rclsid
, riid
, ppv
);
211 ICLRRuntimeInfo_Release(info
);
217 BOOL WINAPI
DllMain(HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
219 TRACE("(%p, %d, %p)\n", hinstDLL
, fdwReason
, lpvReserved
);
223 case DLL_PROCESS_ATTACH
:
225 DisableThreadLibraryCalls(hinstDLL
);
227 case DLL_PROCESS_DETACH
:
228 expect_no_runtimes();
229 if (lpvReserved
) break; /* process is terminating */
230 runtimehost_uninit();
236 __int32 WINAPI
_CorExeMain2(PBYTE ptrMemory
, DWORD cntMemory
, LPWSTR imageName
, LPWSTR loaderName
, LPWSTR cmdLine
)
238 TRACE("(%p, %u, %s, %s, %s)\n", ptrMemory
, cntMemory
, debugstr_w(imageName
), debugstr_w(loaderName
), debugstr_w(cmdLine
));
239 FIXME("Directly running .NET applications not supported.\n");
243 void WINAPI
CorExitProcess(int exitCode
)
245 TRACE("(%x)\n", exitCode
);
246 CLRMetaHost_ExitProcess(0, exitCode
);
249 VOID WINAPI
_CorImageUnloading(PVOID imageBase
)
251 TRACE("(%p): stub\n", imageBase
);
254 HRESULT WINAPI
_CorValidateImage(PVOID
* imageBase
, LPCWSTR imageName
)
256 TRACE("(%p, %s): stub\n", imageBase
, debugstr_w(imageName
));
260 HRESULT WINAPI
GetCORSystemDirectory(LPWSTR pbuffer
, DWORD cchBuffer
, DWORD
*dwLength
)
262 ICLRRuntimeInfo
*info
;
265 TRACE("(%p, %d, %p)!\n", pbuffer
, cchBuffer
, dwLength
);
267 if (!dwLength
|| !pbuffer
)
270 ret
= get_runtime_info(NULL
, NULL
, NULL
, NULL
, 0, RUNTIME_INFO_UPGRADE_VERSION
, TRUE
, &info
);
274 *dwLength
= cchBuffer
;
275 ret
= ICLRRuntimeInfo_GetRuntimeDirectory(info
, pbuffer
, dwLength
);
277 ICLRRuntimeInfo_Release(info
);
283 HRESULT WINAPI
GetCORVersion(LPWSTR pbuffer
, DWORD cchBuffer
, DWORD
*dwLength
)
285 ICLRRuntimeInfo
*info
;
288 TRACE("(%p, %d, %p)!\n", pbuffer
, cchBuffer
, dwLength
);
290 if (!dwLength
|| !pbuffer
)
293 ret
= get_runtime_info(NULL
, NULL
, NULL
, NULL
, 0, RUNTIME_INFO_UPGRADE_VERSION
, TRUE
, &info
);
297 *dwLength
= cchBuffer
;
298 ret
= ICLRRuntimeInfo_GetVersionString(info
, pbuffer
, dwLength
);
300 ICLRRuntimeInfo_Release(info
);
306 HRESULT WINAPI
CorIsLatestSvc(int *unk1
, int *unk2
)
308 ERR_(winediag
)("If this function is called, it is likely the result of a broken .NET installation\n");
316 HRESULT WINAPI
CorGetSvc(void *unk
)
318 ERR_(winediag
)("If this function is called, it is likely the result of a broken .NET installation\n");
323 HRESULT WINAPI
GetRequestedRuntimeInfo(LPCWSTR pExe
, LPCWSTR pwszVersion
, LPCWSTR pConfigurationFile
,
324 DWORD startupFlags
, DWORD runtimeInfoFlags
, LPWSTR pDirectory
, DWORD dwDirectory
, DWORD
*dwDirectoryLength
,
325 LPWSTR pVersion
, DWORD cchBuffer
, DWORD
*dwlength
)
328 ICLRRuntimeInfo
*info
;
331 TRACE("(%s, %s, %s, 0x%08x, 0x%08x, %p, 0x%08x, %p, %p, 0x%08x, %p)\n", debugstr_w(pExe
),
332 debugstr_w(pwszVersion
), debugstr_w(pConfigurationFile
), startupFlags
, runtimeInfoFlags
, pDirectory
,
333 dwDirectory
, dwDirectoryLength
, pVersion
, cchBuffer
, dwlength
);
335 if (!dwDirectoryLength
) dwDirectoryLength
= &length_dummy
;
337 if (!dwlength
) dwlength
= &length_dummy
;
339 ret
= get_runtime_info(pExe
, pwszVersion
, pConfigurationFile
, NULL
, startupFlags
, runtimeInfoFlags
, TRUE
, &info
);
343 *dwlength
= cchBuffer
;
344 ret
= ICLRRuntimeInfo_GetVersionString(info
, pVersion
, dwlength
);
349 pVersion
[0] = pwszVersion
[0];
351 *dwDirectoryLength
= dwDirectory
;
352 ret
= ICLRRuntimeInfo_GetRuntimeDirectory(info
, pDirectory
, dwDirectoryLength
);
355 ICLRRuntimeInfo_Release(info
);
361 HRESULT WINAPI
GetRequestedRuntimeVersion(LPWSTR pExe
, LPWSTR pVersion
, DWORD cchBuffer
, DWORD
*dwlength
)
363 TRACE("(%s, %p, %d, %p)\n", debugstr_w(pExe
), pVersion
, cchBuffer
, dwlength
);
368 return GetRequestedRuntimeInfo(pExe
, NULL
, NULL
, 0, 0, NULL
, 0, NULL
, pVersion
, cchBuffer
, dwlength
);
371 HRESULT WINAPI
GetRealProcAddress(LPCSTR procname
, void **ppv
)
373 FIXME("(%s, %p)\n", debugstr_a(procname
), ppv
);
374 return CLR_E_SHIM_RUNTIMEEXPORT
;
377 HRESULT WINAPI
GetFileVersion(LPCWSTR szFilename
, LPWSTR szBuffer
, DWORD cchBuffer
, DWORD
*dwLength
)
379 TRACE("(%s, %p, %d, %p)\n", debugstr_w(szFilename
), szBuffer
, cchBuffer
, dwLength
);
381 if (!szFilename
|| !dwLength
)
384 *dwLength
= cchBuffer
;
385 return CLRMetaHost_GetVersionFromFile(0, szFilename
, szBuffer
, dwLength
);
388 HRESULT WINAPI
LoadLibraryShim( LPCWSTR szDllName
, LPCWSTR szVersion
, LPVOID pvReserved
, HMODULE
* phModDll
)
391 WCHAR dll_filename
[MAX_PATH
];
392 WCHAR version
[MAX_PATH
];
393 static const WCHAR default_version
[] = {'v','1','.','1','.','4','3','2','2',0};
394 static const WCHAR slash
[] = {'\\',0};
397 TRACE("(%p %s, %p, %p, %p)\n", szDllName
, debugstr_w(szDllName
), szVersion
, pvReserved
, phModDll
);
399 if (!szDllName
|| !phModDll
)
402 if (!get_install_root(dll_filename
))
404 ERR("error reading registry key for installroot\n");
411 ret
= GetCORVersion(version
, MAX_PATH
, &dummy
);
415 szVersion
= default_version
;
417 lstrcatW(dll_filename
, szVersion
);
418 lstrcatW(dll_filename
, slash
);
421 lstrcatW(dll_filename
, szDllName
);
423 *phModDll
= LoadLibraryW(dll_filename
);
425 return *phModDll
? S_OK
: E_HANDLE
;
428 HRESULT WINAPI
LockClrVersion(FLockClrVersionCallback hostCallback
, FLockClrVersionCallback
*pBeginHostSetup
, FLockClrVersionCallback
*pEndHostSetup
)
430 FIXME("(%p %p %p): stub\n", hostCallback
, pBeginHostSetup
, pEndHostSetup
);
434 HRESULT WINAPI
CoInitializeCor(DWORD fFlags
)
436 FIXME("(0x%08x): stub\n", fFlags
);
440 HRESULT WINAPI
GetAssemblyMDImport(LPCWSTR szFileName
, REFIID riid
, IUnknown
**ppIUnk
)
442 FIXME("(%p %s, %s, %p): stub\n", szFileName
, debugstr_w(szFileName
), debugstr_guid(riid
), *ppIUnk
);
443 return ERROR_CALL_NOT_IMPLEMENTED
;
446 HRESULT WINAPI
GetVersionFromProcess(HANDLE hProcess
, LPWSTR pVersion
, DWORD cchBuffer
, DWORD
*dwLength
)
448 FIXME("(%p, %p, %d, %p): stub\n", hProcess
, pVersion
, cchBuffer
, dwLength
);
452 HRESULT WINAPI
LoadStringRCEx(LCID culture
, UINT resId
, LPWSTR pBuffer
, int iBufLen
, int bQuiet
, int* pBufLen
)
455 if ((iBufLen
<= 0) || !pBuffer
)
459 FIXME("(%d, %x, %p, %d, %d, %p): semi-stub\n", culture
, resId
, pBuffer
, iBufLen
, bQuiet
, pBufLen
);
465 *pBufLen
= lstrlenW(pBuffer
);
469 HRESULT WINAPI
LoadStringRC(UINT resId
, LPWSTR pBuffer
, int iBufLen
, int bQuiet
)
471 return LoadStringRCEx(-1, resId
, pBuffer
, iBufLen
, bQuiet
, NULL
);
474 HRESULT WINAPI
CorBindToRuntimeEx(LPWSTR szVersion
, LPWSTR szBuildFlavor
, DWORD nflags
, REFCLSID rslsid
,
475 REFIID riid
, LPVOID
*ppv
)
478 ICLRRuntimeInfo
*info
;
480 TRACE("%s %s %d %s %s %p\n", debugstr_w(szVersion
), debugstr_w(szBuildFlavor
), nflags
, debugstr_guid( rslsid
),
481 debugstr_guid( riid
), ppv
);
485 ret
= get_runtime_info(NULL
, szVersion
, NULL
, NULL
, nflags
, RUNTIME_INFO_UPGRADE_VERSION
, TRUE
, &info
);
489 ret
= ICLRRuntimeInfo_GetInterface(info
, rslsid
, riid
, ppv
);
491 ICLRRuntimeInfo_Release(info
);
497 HRESULT WINAPI
CorBindToCurrentRuntime(LPCWSTR filename
, REFCLSID rclsid
, REFIID riid
, LPVOID
*ppv
)
500 ICLRRuntimeInfo
*info
;
502 TRACE("(%s, %s, %s, %p)\n", debugstr_w(filename
), debugstr_guid(rclsid
), debugstr_guid(riid
), ppv
);
506 ret
= get_runtime_info(NULL
, NULL
, filename
, NULL
, 0, RUNTIME_INFO_UPGRADE_VERSION
, TRUE
, &info
);
510 ret
= ICLRRuntimeInfo_GetInterface(info
, rclsid
, riid
, ppv
);
512 ICLRRuntimeInfo_Release(info
);
518 STDAPI
ClrCreateManagedInstance(LPCWSTR pTypeName
, REFIID riid
, void **ppObject
)
521 ICLRRuntimeInfo
*info
;
526 TRACE("(%s,%s,%p)\n", debugstr_w(pTypeName
), debugstr_guid(riid
), ppObject
);
528 /* FIXME: How to determine which runtime version to use? */
529 ret
= get_runtime_info(NULL
, NULL
, NULL
, NULL
, 0, RUNTIME_INFO_UPGRADE_VERSION
, TRUE
, &info
);
533 ret
= ICLRRuntimeInfo_GetRuntimeHost(info
, &host
);
535 ICLRRuntimeInfo_Release(info
);
539 ret
= RuntimeHost_CreateManagedInstance(host
, pTypeName
, NULL
, &obj
);
542 ret
= RuntimeHost_GetIUnknownForObject(host
, obj
, &unk
);
546 ret
= IUnknown_QueryInterface(unk
, riid
, ppObject
);
547 IUnknown_Release(unk
);
553 BOOLEAN WINAPI
StrongNameSignatureVerification(LPCWSTR filename
, DWORD inFlags
, DWORD
*pOutFlags
)
555 FIXME("(%s, 0x%X, %p): stub\n", debugstr_w(filename
), inFlags
, pOutFlags
);
559 BOOLEAN WINAPI
StrongNameSignatureVerificationEx(LPCWSTR filename
, BOOLEAN forceVerification
, BOOLEAN
*pVerified
)
561 FIXME("(%s, %u, %p): stub\n", debugstr_w(filename
), forceVerification
, pVerified
);
566 HRESULT WINAPI
CreateDebuggingInterfaceFromVersion(int nDebugVersion
, LPCWSTR version
, IUnknown
**ppv
)
568 static const WCHAR v2_0
[] = {'v','2','.','0','.','5','0','7','2','7',0};
570 ICLRRuntimeInfo
*runtimeinfo
;
572 if(nDebugVersion
< 1 || nDebugVersion
> 4)
575 TRACE("(%d %s, %p): stub\n", nDebugVersion
, debugstr_w(version
), ppv
);
582 if(wcscmp(version
, v2_0
) != 0)
584 FIXME("Currently .NET Version '%s' not support.\n", debugstr_w(version
));
588 if(nDebugVersion
!= 3)
591 hr
= CLRMetaHost_GetRuntime(0, version
, &IID_ICLRRuntimeInfo
, (void**)&runtimeinfo
);
594 hr
= ICLRRuntimeInfo_GetInterface(runtimeinfo
, &CLSID_CLRDebuggingLegacy
, &IID_ICorDebug
, (void**)ppv
);
596 ICLRRuntimeInfo_Release(runtimeinfo
);
605 HRESULT WINAPI
CLRCreateInstance(REFCLSID clsid
, REFIID riid
, LPVOID
*ppInterface
)
607 TRACE("(%s,%s,%p)\n", debugstr_guid(clsid
), debugstr_guid(riid
), ppInterface
);
609 if (IsEqualGUID(clsid
, &CLSID_CLRMetaHost
))
610 return CLRMetaHost_CreateInstance(riid
, ppInterface
);
611 if (IsEqualGUID(clsid
, &CLSID_CLRMetaHostPolicy
))
612 return CLRMetaHostPolicy_CreateInstance(riid
, ppInterface
);
614 FIXME("not implemented for class %s\n", debugstr_guid(clsid
));
616 return CLASS_E_CLASSNOTAVAILABLE
;
619 HRESULT WINAPI
CreateInterface(REFCLSID clsid
, REFIID riid
, LPVOID
*ppInterface
)
621 TRACE("(%s,%s,%p)\n", debugstr_guid(clsid
), debugstr_guid(riid
), ppInterface
);
623 return CLRCreateInstance(clsid
, riid
, ppInterface
);
626 HRESULT WINAPI
DllGetClassObject(REFCLSID rclsid
, REFIID riid
, LPVOID
* ppv
)
631 TRACE("(%s, %s, %p): stub\n", debugstr_guid(rclsid
), debugstr_guid(riid
), ppv
);
636 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(mscorecf
));
638 This
->IClassFactory_iface
.lpVtbl
= &mscorecf_vtbl
;
639 This
->pfnCreateInstance
= create_monodata
;
641 This
->clsid
= *rclsid
;
643 hr
= IClassFactory_QueryInterface( &This
->IClassFactory_iface
, riid
, ppv
);
644 IClassFactory_Release(&This
->IClassFactory_iface
);
649 static void parse_msi_version_string(const char *version
, int *parts
)
651 const char *minor_start
, *build_start
;
653 parts
[0] = atoi(version
);
655 parts
[1] = parts
[2] = 0;
657 minor_start
= strchr(version
, '.');
661 parts
[1] = atoi(minor_start
);
663 build_start
= strchr(minor_start
, '.');
665 parts
[2] = atoi(build_start
+1);
669 static int compare_versions(const char *a
, const char *b
)
671 int a_parts
[3], b_parts
[3], i
;
673 parse_msi_version_string(a
, a_parts
);
674 parse_msi_version_string(b
, b_parts
);
677 if (a_parts
[i
] != b_parts
[i
])
678 return a_parts
[i
] - b_parts
[i
];
683 static BOOL
invoke_appwiz(void)
685 PROCESS_INFORMATION pi
;
692 static const WCHAR controlW
[] = {'\\','c','o','n','t','r','o','l','.','e','x','e',0};
693 static const WCHAR argsW
[] =
694 {' ','a','p','p','w','i','z','.','c','p','l',' ','i','n','s','t','a','l','l','_','m','o','n','o',0};
696 len
= GetSystemDirectoryW(app
, MAX_PATH
- ARRAY_SIZE(controlW
));
697 memcpy(app
+len
, controlW
, sizeof(controlW
));
699 args
= HeapAlloc(GetProcessHeap(), 0, (len
*sizeof(WCHAR
) + sizeof(controlW
) + sizeof(argsW
)));
703 memcpy(args
, app
, len
*sizeof(WCHAR
) + sizeof(controlW
));
704 memcpy(args
+ len
+ ARRAY_SIZE(controlW
) - 1, argsW
, sizeof(argsW
));
706 TRACE("starting %s\n", debugstr_w(args
));
708 memset(&si
, 0, sizeof(si
));
710 ret
= CreateProcessW(app
, args
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
, &si
, &pi
);
711 HeapFree(GetProcessHeap(), 0, args
);
713 CloseHandle(pi
.hThread
);
714 WaitForSingleObject(pi
.hProcess
, INFINITE
);
715 CloseHandle(pi
.hProcess
);
721 static BOOL
get_support_msi(LPCWSTR mono_path
, LPWSTR msi_path
)
723 static const WCHAR support_msi_relative
[] = {'\\','s','u','p','p','o','r','t','\\','w','i','n','e','m','o','n','o','-','s','u','p','p','o','r','t','.','m','s','i',0};
724 UINT (WINAPI
*pMsiOpenPackageW
)(LPCWSTR
,ULONG
*);
725 UINT (WINAPI
*pMsiGetProductPropertyA
)(ULONG
,LPCSTR
,LPSTR
,LPDWORD
);
726 UINT (WINAPI
*pMsiCloseHandle
)(ULONG
);
728 char versionstringbuf
[15];
734 hmsi
= GetModuleHandleA("msi");
736 lstrcpyW(msi_path
, mono_path
);
737 lstrcatW(msi_path
, support_msi_relative
);
739 pMsiOpenPackageW
= (void*)GetProcAddress(hmsi
, "MsiOpenPackageW");
741 res
= pMsiOpenPackageW(msi_path
, &msiproduct
);
743 if (res
== ERROR_SUCCESS
)
745 buffer_size
= sizeof(versionstringbuf
);
747 pMsiGetProductPropertyA
= (void*)GetProcAddress(hmsi
, "MsiGetProductPropertyA");
749 res
= pMsiGetProductPropertyA(msiproduct
, "ProductVersion", versionstringbuf
, &buffer_size
);
751 pMsiCloseHandle
= (void*)GetProcAddress(hmsi
, "MsiCloseHandle");
753 pMsiCloseHandle(msiproduct
);
756 if (res
== ERROR_SUCCESS
) {
757 TRACE("found support msi version %s at %s\n", versionstringbuf
, debugstr_w(msi_path
));
759 if (compare_versions(WINE_MONO_VERSION
, versionstringbuf
) <= 0)
768 static BOOL
install_wine_mono(void)
770 BOOL is_wow64
= FALSE
;
772 HRESULT initresult
= E_FAIL
;
773 UINT (WINAPI
*pMsiEnumRelatedProductsA
)(LPCSTR
,DWORD
,DWORD
,LPSTR
);
774 UINT (WINAPI
*pMsiGetProductInfoA
)(LPCSTR
,LPCSTR
,LPSTR
,DWORD
*);
775 UINT (WINAPI
*pMsiInstallProductW
)(LPCWSTR
,LPCWSTR
);
776 char versionstringbuf
[15];
777 char productcodebuf
[39];
781 WCHAR mono_path
[MAX_PATH
];
782 WCHAR support_msi_path
[MAX_PATH
];
784 static const char* mono_upgrade_code
= "{DE624609-C6B5-486A-9274-EF0B854F6BC5}";
786 IsWow64Process(GetCurrentProcess(), &is_wow64
);
790 TRACE("not installing mono in wow64 process\n");
794 TRACE("searching for mono runtime\n");
796 if (!get_mono_path(mono_path
, FALSE
))
798 TRACE("mono runtime not found\n");
799 return invoke_appwiz();
802 TRACE("mono runtime is at %s\n", debugstr_w(mono_path
));
804 hmsi
= LoadLibraryA("msi");
808 ERR("couldn't load msi.dll\n");
812 pMsiEnumRelatedProductsA
= (void*)GetProcAddress(hmsi
, "MsiEnumRelatedProductsA");
814 res
= pMsiEnumRelatedProductsA(mono_upgrade_code
, 0, 0, productcodebuf
);
816 if (res
== ERROR_SUCCESS
)
818 pMsiGetProductInfoA
= (void*)GetProcAddress(hmsi
, "MsiGetProductInfoA");
820 buffer_size
= sizeof(versionstringbuf
);
822 res
= pMsiGetProductInfoA(productcodebuf
, "VersionString", versionstringbuf
, &buffer_size
);
824 else if (res
!= ERROR_NO_MORE_ITEMS
)
826 ERR("MsiEnumRelatedProducts failed, err=%u\n", res
);
829 if (res
== ERROR_SUCCESS
)
831 TRACE("found installed support package %s\n", versionstringbuf
);
833 if (compare_versions(WINE_MONO_VERSION
, versionstringbuf
) <= 0)
835 TRACE("support package is at least %s, quitting\n", WINE_MONO_VERSION
);
841 initresult
= CoInitialize(NULL
);
843 ret
= get_support_msi(mono_path
, support_msi_path
);
846 /* Try looking outside c:\windows\mono */
847 ret
= (get_mono_path(mono_path
, TRUE
) &&
848 get_support_msi(mono_path
, support_msi_path
));
853 TRACE("installing support msi\n");
855 pMsiInstallProductW
= (void*)GetProcAddress(hmsi
, "MsiInstallProductW");
857 res
= pMsiInstallProductW(support_msi_path
, NULL
);
859 if (res
== ERROR_SUCCESS
)
865 ERR("MsiInstallProduct failed, err=%i\n", res
);
868 ret
= invoke_appwiz();
873 if (SUCCEEDED(initresult
))
878 HRESULT WINAPI
DllRegisterServer(void)
882 return __wine_register_resources();
885 HRESULT WINAPI
DllUnregisterServer(void)
887 return __wine_unregister_resources();
890 void WINAPI
CoEEShutDownCOM(void)
895 INT WINAPI
ND_RU1( const void *ptr
, INT offset
)
897 return *((const BYTE
*)ptr
+ offset
);
900 INT WINAPI
ND_RI2( const void *ptr
, INT offset
)
902 return *(const SHORT
*)((const BYTE
*)ptr
+ offset
);
905 INT WINAPI
ND_RI4( const void *ptr
, INT offset
)
907 return *(const INT
*)((const BYTE
*)ptr
+ offset
);
910 INT64 WINAPI
ND_RI8( const void *ptr
, INT offset
)
912 return *(const INT64
*)((const BYTE
*)ptr
+ offset
);
915 void WINAPI
ND_WU1( void *ptr
, INT offset
, BYTE val
)
917 *((BYTE
*)ptr
+ offset
) = val
;
920 void WINAPI
ND_WI2( void *ptr
, INT offset
, SHORT val
)
922 *(SHORT
*)((BYTE
*)ptr
+ offset
) = val
;
925 void WINAPI
ND_WI4( void *ptr
, INT offset
, INT val
)
927 *(INT
*)((BYTE
*)ptr
+ offset
) = val
;
930 void WINAPI
ND_WI8( void *ptr
, INT offset
, INT64 val
)
932 *(INT64
*)((BYTE
*)ptr
+ offset
) = val
;
935 void WINAPI
ND_CopyObjDst( const void *src
, void *dst
, INT offset
, INT size
)
937 memcpy( (BYTE
*)dst
+ offset
, src
, size
);
940 void WINAPI
ND_CopyObjSrc( const void *src
, INT offset
, void *dst
, INT size
)
942 memcpy( dst
, (const BYTE
*)src
+ offset
, size
);