HRESULT CComTypeInfoHolder::GetTI(LCID lcid, ITypeInfo** ppInfo)
{
//If this assert occurs then most likely didn't call Init
_ASSERTE(m_plibid != NULL && m_pguid != NULL);
*ppInfo = m_pInfo;
HRESULT hRes = S_OK;
if (*ppInfo == NULL)
{
_Module.m_csTypeInfoHolder.Lock();
if (m_pInfo == NULL)
{
CComPtr<ITypeLib> pTypeLib;
hRes = LoadRegTypeLib(*m_plibid, m_wMajor, m_wMinor, lcid, &pTypeLib);
if (SUCCEEDED(hRes))
hRes = pTypeLib->GetTypeInfoOfGuid(*m_pguid, &m_pInfo);
}
*ppInfo = m_pInfo;
_Module.m_csTypeInfoHolder.Unlock();
}
return hRes;
}
HRESULT get_typeinfo(enum tid_t tid, ITypeInfo **typeinfo)
{
unsigned lib = get_libid_from_tid(tid);
HRESULT hres;
if(!typelib[lib]) {
ITypeLib *tl;
hres = LoadRegTypeLib(lib_ids[lib].iid, lib_ids[lib].major, 0, LOCALE_SYSTEM_DEFAULT, &tl);
if(FAILED(hres)) {
ERR("LoadRegTypeLib failed: %08x\n", hres);
return hres;
}
if(InterlockedCompareExchangePointer((void**)&typelib[lib], tl, NULL))
ITypeLib_Release(tl);
}
if(!typeinfos[tid]) {
ITypeInfo *ti;
hres = ITypeLib_GetTypeInfoOfGuid(typelib[lib], get_riid_from_tid(tid), &ti);
if(FAILED(hres)) {
/* try harder with typelib from msxml.dll */
hres = ITypeLib_GetTypeInfoOfGuid(typelib[LibXml], get_riid_from_tid(tid), &ti);
if(FAILED(hres)) {
ERR("GetTypeInfoOfGuid failed: %08x\n", hres);
return hres;
}
}
if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL))
ITypeInfo_Release(ti);
}
*typeinfo = typeinfos[tid];
ITypeInfo_AddRef(typeinfos[tid]);
return S_OK;
}
STDMETHODIMP CJServer::GetTypeInfo(UINT itInfo, LCID lcid, ITypeInfo **ppITypeInfo)
{
HRESULT hr;
ITypeLib *pITypeLib;
ITypeInfo **ppITI=NULL;
if (0!=itInfo) return TYPE_E_ELEMENTNOTFOUND;
if (NULL==ppITypeInfo) return E_POINTER;
*ppITypeInfo=NULL;
switch (PRIMARYLANGID(lcid))
{
case LANG_NEUTRAL:
case LANG_ENGLISH:
ppITI=&m_pITINeutral;
break;
default:
return DISP_E_UNKNOWNLCID;
}
//Load a type lib if we don't have the information already.
if (NULL==*ppITI)
{
hr=LoadRegTypeLib(jlibid, atoi(jversion), 0, PRIMARYLANGID(lcid), &pITypeLib);
if (FAILED(hr)) return hr;
//Got the type lib, get type info for the interface we want
hr=pITypeLib->GetTypeInfoOfGuid(jiid, ppITI);
pITypeLib->Release();
if (FAILED(hr)) return hr;
}
// the type library is still loaded since we have an ITypeInfo from it.
(*ppITI)->AddRef();
*ppITypeInfo=*ppITI;
return NOERROR;
}
HRESULT get_typeinfo(ITypeInfo **typeinfo)
{
ITypeLib *typelib;
HRESULT hres;
if(wb_typeinfo) {
*typeinfo = wb_typeinfo;
return S_OK;
}
hres = LoadRegTypeLib(&LIBID_SHDocVw, 1, 1, LOCALE_SYSTEM_DEFAULT, &typelib);
if(FAILED(hres)) {
ERR("LoadRegTypeLib failed: %08x\n", hres);
return hres;
}
hres = ITypeLib_GetTypeInfoOfGuid(typelib, &IID_IWebBrowser2, &wb_typeinfo);
ITypeLib_Release(typelib);
*typeinfo = wb_typeinfo;
return hres;
}
int PolylineTest::writePersistFile()
{
ComPtr<IPolyline> pl;
auto hr = CoCreateInstance(CLSID_PolylineObj, NULL, CLSCTX_INPROC_SERVER, IID_IPolyline, (void**)&pl);
if (FAILED(hr)) {
return -1;
}
LPTYPEINFO pTypeInfo = NULL;
LPTYPELIB pTypelib = NULL;
IRecordInfo* pRecInfo = NULL;
hr = LoadRegTypeLib(LIBID_GraphicsLibrary, 1, 0, GetUserDefaultLCID(), &pTypelib);
_ASSERT(SUCCEEDED(hr) && pTypelib);
hr = pTypelib->GetTypeInfoOfGuid(__uuidof(PolyPoint), &pTypeInfo);
_ASSERT(SUCCEEDED(hr) && pTypeInfo);
hr = GetRecordInfoFromTypeInfo(pTypeInfo, &pRecInfo);
_ASSERT(SUCCEEDED(hr) && pRecInfo);
pTypeInfo->Release();
pTypelib->Release();
std::vector<POINT> points = { { 1, 2 }, { 100, 200 }, { 300, 400 } };
auto psa = SafeArrayCreateVectorEx(VT_RECORD, 0, points.size(), pRecInfo);
PolyPoint* pps;
SafeArrayAccessData(psa, (void**)&pps);
_ASSERT(psa);
for (size_t i = 0; i < points.size(); ++i) {
pps[i].x = points[i].x;
pps[i].y = points[i].y;
}
pl->put_Points(psa);
outputPoints(pl);
ComPtr<IPersistFile> pf;
pl->QueryInterface(IID_IPersistFile, (void**)&pf);
pf->Save(kFileName, TRUE);
pf->SaveCompleted(kFileName);
return 0;
}
HRESULT
hippoLoadRegTypeInfo(const GUID &libraryId,
unsigned short majorVersion,
unsigned short minorVersion
...)
{
HippoPtr<ITypeLib> typeLib;
va_list vap;
HRESULT hr;
va_start(vap, minorVersion);
clearArgs(vap);
va_end(vap);
hr = LoadRegTypeLib(libraryId,
majorVersion, minorVersion,
0, /* LCID */
&typeLib);
if (FAILED(hr))
goto out;
va_start(vap, minorVersion);
hr = loadTypeInfoFromTypelib(typeLib, vap);
va_end(vap);
out:
if (FAILED(hr)) {
va_start(vap, minorVersion);
freeArgs(vap);
va_end(vap);
hippoDebugLogW(L"Failed to load type info (%x)", hr);
}
return hr;
}
ITypeLib* tCOMUtil::LoadTypeLibFromCLSID(CLSID clsid,
unsigned short major_version)
{
wchar_t* wcClsid = NULL;
HRESULT hr = StringFromCLSID(clsid, &wcClsid);
if (FAILED(hr))
return NULL;
/* converte CLSID para string normal */
char* pcClsid = (char*) malloc( (wcslen(wcClsid) + 1) * sizeof(char));
wcstombs(pcClsid, wcClsid,wcslen(wcClsid)+1);
CoTaskMemFree(wcClsid);
DWORD size = 38*3; /*{F37C8063-4AD5-101B-B826-00DD01103DE1}*/
BYTE *bLibID = (BYTE *) malloc(size);
BYTE bVersion[100]; // This must hold something like "5.2"
HKEY iid_key, obj_key, typelib_key, version_key;
/* extrai do registry type library (GUID e versao) */
LONG res = 0;
bool version_info_found = true;
try
{
res = RegOpenKeyEx(HKEY_CLASSES_ROOT,"CLSID", 0, KEY_READ, &iid_key);
WINCHECK(res == ERROR_SUCCESS);
res = RegOpenKeyEx(iid_key, pcClsid, 0, KEY_READ, &obj_key);
RegCloseKey(iid_key);
free(pcClsid);
pcClsid = NULL;
WINCHECK(res == ERROR_SUCCESS);
res = RegOpenKeyEx(obj_key, "TypeLib",0, KEY_READ, &typelib_key);
if(res != ERROR_SUCCESS)
{
RegCloseKey(obj_key);
LUACOM_EXCEPTION(WINDOWS_ERROR);
}
res = RegOpenKeyEx(obj_key, "version",0, KEY_READ, &version_key);
RegCloseKey(obj_key);
if(res != ERROR_SUCCESS)
version_info_found = false;
RegQueryValueEx(typelib_key, NULL, NULL, NULL, bLibID, &size);
RegCloseKey(typelib_key);
RegQueryValueEx(version_key, NULL, NULL, NULL, bVersion, &size);
RegCloseKey(version_key);
}
catch(class tLuaCOMException& e)
{
UNUSED(e);
if(pcClsid)
free(pcClsid);
return NULL;
}
// converts libID to multibyte string
wchar_t* wcTypelib= (wchar_t*)
malloc( (strlen((char *) bLibID) + 1) * sizeof(wchar_t));
mbstowcs(wcTypelib, (char *) bLibID, strlen((char *) bLibID)+1);
// extracts version information
int version_major = 0, version_minor = 0;
int found = 0;
if(version_info_found)
{
found = sscanf(
(const char *) bVersion,
"%d.%d",
&version_major, &version_minor);
}
if(major_version > 0 &&
(
(!version_info_found) ||
(version_info_found && found == 0)
)
)
{
version_major = major_version;
version_minor = 0;
}
else if(!version_info_found)
{
// tries to load the first type library found in
// the registry
bool result = tCOMUtil::GetDefaultTypeLibVersion(
(const char*) bLibID,
&version_major,
&version_minor);
if(!result)
return NULL;
}
free(bLibID);
GUID libid = IID_NULL;
CLSIDFromString(wcTypelib, &libid);
free(wcTypelib);
ITypeLib* typelib = NULL;
hr = LoadRegTypeLib(libid, version_major, version_minor, 0, &typelib);
if(FAILED(hr))
return NULL;
return typelib;
}
BOOL AFXAPI AfxOleUnregisterTypeLib(REFGUID tlid, WORD wVerMajor,
WORD wVerMinor, LCID lcid)
{
USES_CONVERSION;
// Load type library before unregistering it.
ITypeLib* pTypeLib = NULL;
if (wVerMajor != 0)
{
if (FAILED(LoadRegTypeLib(tlid, wVerMajor, wVerMinor, lcid, &pTypeLib)))
pTypeLib = NULL;
}
// Format typelib guid as a string
OLECHAR szTypeLibID[GUID_CCH];
int cchGuid = ::StringFromGUID2(tlid, szTypeLibID, GUID_CCH);
ASSERT(cchGuid == GUID_CCH); // Did StringFromGUID2 work?
if (cchGuid != GUID_CCH)
return FALSE;
TCHAR szKeyTypeLib[_MAX_PATH];
BOOL bSurgical = FALSE;
LONG error = ERROR_SUCCESS;
wsprintf(szKeyTypeLib, _T("TYPELIB\\%s"), OLE2CT(szTypeLibID));
HKEY hKeyTypeLib;
if (RegOpenKey(HKEY_CLASSES_ROOT, szKeyTypeLib, &hKeyTypeLib) ==
ERROR_SUCCESS)
{
int iKeyVersion = 0;
HKEY hKeyVersion;
TCHAR szVersion[_MAX_PATH];
// Iterate through all installed versions of the control
while (RegEnumKey(hKeyTypeLib, iKeyVersion, szVersion, _MAX_PATH) ==
ERROR_SUCCESS)
{
hKeyVersion = NULL;
BOOL bSurgicalVersion = FALSE;
if (RegOpenKey(hKeyTypeLib, szVersion, &hKeyVersion) !=
ERROR_SUCCESS)
{
++iKeyVersion;
continue;
}
int iKeyLocale = 0;
HKEY hKeyLocale;
TCHAR szLocale[_MAX_PATH];
// Iterate through all registered locales for this version
while (RegEnumKey(hKeyVersion, iKeyLocale, szLocale, _MAX_PATH) ==
ERROR_SUCCESS)
{
// Don't remove HELPDIR or FLAGS keys.
if ((lstrcmpi(szLocale, _T("HELPDIR")) == 0) ||
(lstrcmpi(szLocale, _T("FLAGS")) == 0))
{
++iKeyLocale;
continue;
}
hKeyLocale = NULL;
if (RegOpenKey(hKeyVersion, szLocale, &hKeyLocale) !=
ERROR_SUCCESS)
{
++iKeyLocale;
continue;
}
// Check if a 16-bit key is found when unregistering 32-bit
HKEY hkey;
if (RegOpenKey(hKeyLocale, TYPELIBWIN_2, &hkey) ==
ERROR_SUCCESS)
{
RegCloseKey(hkey);
// Only remove the keys specific to the 32-bit version
// of control, leaving things intact for 16-bit version.
error = _AfxRecursiveRegDeleteKey(hKeyLocale, TYPELIBWIN);
bSurgicalVersion = TRUE;
RegCloseKey(hKeyLocale);
}
else
{
// Delete everything for this locale.
RegCloseKey(hKeyLocale);
if (_AfxRecursiveRegDeleteKey(hKeyVersion, szLocale) ==
ERROR_SUCCESS)
{
// Start over again, so we don't skip anything.
iKeyLocale = 0;
continue;
}
}
++iKeyLocale;
}
RegCloseKey(hKeyVersion);
if (bSurgicalVersion)
{
bSurgical = TRUE;
}
else
{
if (_AfxRecursiveRegDeleteKey(hKeyTypeLib, szVersion) ==
ERROR_SUCCESS)
{
// Start over again, to make sure we don't skip anything.
iKeyVersion = 0;
continue;
}
}
++iKeyVersion;
}
RegCloseKey(hKeyTypeLib);
}
if (!bSurgical)
error = _AfxRecursiveRegDeleteKey(HKEY_CLASSES_ROOT, szKeyTypeLib);
if (_AfxRegDeleteKeySucceeded(error))
{
// If type library was unregistered successfully, then also unregister
// interfaces.
if (pTypeLib != NULL)
{
ITypeLib* pDummy = NULL;
if (FAILED(LoadRegTypeLib(tlid, wVerMajor, wVerMinor, lcid, &pDummy)))
_AfxUnregisterInterfaces(pTypeLib);
else
pDummy->Release();
pTypeLib->Release();
}
}
return _AfxRegDeleteKeySucceeded(error);
}
/* The search string can be either:
* a) a file name
* b) a CLSID, major, minor e.g. "{00000200-0000-0010-8000-00AA006D2EA4},2,0"
* c) a Type Library name e.g. "Microsoft OLE DB ActiveX Data Objects 1.0 Library"
*/
PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codepage TSRMLS_DC)
{
ITypeLib *TL = NULL;
char *strtok_buf, *major, *minor;
CLSID clsid;
OLECHAR *p;
HRESULT hr;
search_string = php_strtok_r(search_string, ",", &strtok_buf);
if (search_string == NULL) {
return NULL;
}
major = php_strtok_r(NULL, ",", &strtok_buf);
minor = php_strtok_r(NULL, ",", &strtok_buf);
p = php_com_string_to_olestring(search_string, strlen(search_string), codepage TSRMLS_CC);
if (SUCCEEDED(CLSIDFromString(p, &clsid))) {
WORD major_i = 1, minor_i = 0;
/* pick up the major/minor numbers; if none specified, default to 1,0 */
if (major && minor) {
major_i = (WORD)atoi(major);
minor_i = (WORD)atoi(minor);
}
/* Load the TypeLib by GUID */
hr = LoadRegTypeLib((REFGUID)&clsid, major_i, minor_i, LANG_NEUTRAL, &TL);
/* if that failed, assumed that the GUID is actually a CLSID and
* attemp to get the library via an instance of that class */
if (FAILED(hr) && (major == NULL || minor == NULL)) {
IDispatch *disp = NULL;
ITypeInfo *info = NULL;
int idx;
if (SUCCEEDED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_SERVER, &IID_IDispatch, (LPVOID*)&disp)) &&
SUCCEEDED(hr = IDispatch_GetTypeInfo(disp, 0, LANG_NEUTRAL, &info))) {
hr = ITypeInfo_GetContainingTypeLib(info, &TL, &idx);
}
if (info) {
ITypeInfo_Release(info);
}
if (disp) {
IDispatch_Release(disp);
}
}
} else {
/* Try to load it from a file; if it fails, do a really painful search of
* the registry */
if (FAILED(LoadTypeLib(p, &TL))) {
HKEY hkey, hsubkey;
DWORD SubKeys, MaxSubKeyLength;
char *keyname;
unsigned int i, j;
DWORD VersionCount;
char version[20];
char *libname;
DWORD libnamelen;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, "TypeLib", 0, KEY_READ, &hkey) &&
ERROR_SUCCESS == RegQueryInfoKey(hkey, NULL, NULL, NULL, &SubKeys,
&MaxSubKeyLength, NULL, NULL, NULL, NULL, NULL, NULL)) {
MaxSubKeyLength++; /* make room for NUL */
keyname = emalloc(MaxSubKeyLength);
libname = emalloc(strlen(search_string) + 1);
for (i = 0; i < SubKeys && TL == NULL; i++) {
if (ERROR_SUCCESS == RegEnumKey(hkey, i, keyname, MaxSubKeyLength) &&
ERROR_SUCCESS == RegOpenKeyEx(hkey, keyname, 0, KEY_READ, &hsubkey)) {
if (ERROR_SUCCESS == RegQueryInfoKey(hsubkey, NULL, NULL, NULL, &VersionCount,
NULL, NULL, NULL, NULL, NULL, NULL, NULL)) {
for (j = 0; j < VersionCount; j++) {
if (ERROR_SUCCESS != RegEnumKey(hsubkey, j, version, sizeof(version))) {
continue;
}
/* get the default value for this key and compare */
libnamelen = strlen(search_string)+1;
if (ERROR_SUCCESS == RegQueryValue(hsubkey, version, libname, &libnamelen)) {
if (0 == stricmp(libname, search_string)) {
char *str = NULL;
int major_tmp, minor_tmp;
/* fetch the GUID and add the version numbers */
if (2 != sscanf(version, "%d.%d", &major_tmp, &minor_tmp)) {
major_tmp = 1;
minor_tmp = 0;
}
spprintf(&str, 0, "%s,%d,%d", keyname, major_tmp, minor_tmp);
/* recurse */
TL = php_com_load_typelib(str, codepage TSRMLS_CC);
efree(str);
break;
}
}
}
}
RegCloseKey(hsubkey);
}
}
RegCloseKey(hkey);
efree(keyname);
efree(libname);
}
}
}
efree(p);
return TL;
}
HRESULT CoCOMServer::LoadTypeInfo(ITypeInfo ** pptinfo, const CLSID &libid, const CLSID &iid, LCID lcid)
{
HRESULT hr;
LPTYPELIB ptlib = NULL;
LPTYPEINFO ptinfo = NULL;
*pptinfo = NULL;
// Load type library.
hr = LoadRegTypeLib(libid, 1, 0, lcid, &ptlib);
if (FAILED(hr))
{ // search for TypeLib in current dll
WCHAR buf[MAX_PATH * sizeof(WCHAR)]; // LoadTypeLibEx needs Unicode string
if (GetModuleFileNameW(g_hInstance, buf, _countof(buf)))
hr = LoadTypeLibEx(buf,REGKIND_NONE,&ptlib);
else // MemoryModule, search troug g_ListOfMemoryModules and use temp file to extract and load TypeLib file
{
HMEMORYMODULE hmodule = (HMEMORYMODULE)(g_hMemoryModule);
HMEMORYRSRC res = MemoryFindResource(hmodule,_T("TYPELIB"),MAKEINTRESOURCE(1));
if (!res)
return TYPE_E_INVALIDSTATE;
DWORD resSize = MemorySizeOfResource(hmodule,res);
// Path to temp directory + our temporary file name
DWORD tempPathLength = GetTempPathW(MAX_PATH, buf);
wcscpy(buf + tempPathLength,L"AutoHotkey.MemoryModule.temp.tlb");
// Write manifest to temportary file
// Using FILE_ATTRIBUTE_TEMPORARY will avoid writing it to disk
// It will be deleted after LoadTypeLib has been called.
HANDLE hFile = CreateFileW(buf,GENERIC_WRITE,NULL,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_TEMPORARY,NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
#if DEBUG_OUTPUT
OutputDebugStringA("CreateFile failed.\n");
#endif
return TYPE_E_CANTLOADLIBRARY; //failed to create file, continue and try loading without CreateActCtx
}
DWORD byteswritten = 0;
WriteFile(hFile,MemoryLoadResource(hmodule,res),resSize,&byteswritten,NULL);
CloseHandle(hFile);
if (byteswritten == 0)
{
#if DEBUG_OUTPUT
OutputDebugStringA("WriteFile failed.\n");
#endif
return TYPE_E_CANTLOADLIBRARY; //failed to write data, continue and try loading
}
hr = LoadTypeLibEx(buf,REGKIND_NONE,&ptlib);
// Open file and automatically delete on CloseHandle (FILE_FLAG_DELETE_ON_CLOSE)
hFile = CreateFileW(buf,GENERIC_WRITE,FILE_SHARE_DELETE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_TEMPORARY|FILE_FLAG_DELETE_ON_CLOSE,NULL);
CloseHandle(hFile);
}
if (FAILED(hr))
return hr;
}
// Get type information for interface of the object.
hr = ptlib->GetTypeInfoOfGuid(iid, &ptinfo);
if (FAILED(hr))
{
ptlib->Release();
return hr;
}
ptlib->Release();
*pptinfo = ptinfo;
return NOERROR;
}
