Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-23 00:45:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

[MSI] Sync with Wine Staging 1.9.23. CORE-12409

Browse source 
svn path=/trunk/; revision=73339
This commit is contained in:
Amine Khaldi 2016-11-22 12:25:27 +00:00
parent 08824abdc1
commit 687517808b
12 changed files with 423 additions and 388 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

156
reactos/dll/win32/msi/action.c
View file

@ -129,6 +129,8 @@ static const WCHAR szUnpublishComponents[] =
{'U','n','p','u','b','l','i','s','h', 'C','o','m','p','o','n','e','n','t','s',0};
static const WCHAR szUnpublishFeatures[] =
{'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
static const WCHAR szUnpublishProduct[] =
{'U','n','p','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
static const WCHAR szUnregisterComPlus[] =
{'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
static const WCHAR szUnregisterTypeLibraries[] =
@ -3490,14 +3492,14 @@ static WCHAR *build_full_keypath( MSIPACKAGE *package, MSICOMPONENT *comp )
static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
{
WCHAR squished_pc[GUID_SIZE], squished_cc[GUID_SIZE];
WCHAR squashed_pc[SQUASHED_GUID_SIZE], squashed_cc[SQUASHED_GUID_SIZE];
UINT rc;
MSICOMPONENT *comp;
HKEY hkey;
TRACE("\n");
squash_guid(package->ProductCode,squished_pc);
squash_guid( package->ProductCode, squashed_pc );
msi_set_sourcedir_props(package, FALSE);
LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
@ -3509,7 +3511,7 @@ static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
if (!comp->ComponentId)
continue;
squash_guid( comp->ComponentId, squished_cc );
squash_guid( comp->ComponentId, squashed_cc );
msi_free( comp->FullKeypath );
comp->FullKeypath = build_full_keypath( package, comp );
@ -3519,7 +3521,7 @@ static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
else action = comp->ActionRequest;
TRACE("Component %s (%s) Keypath=%s RefCount=%u Clients=%u Action=%u\n",
debugstr_w(comp->Component), debugstr_w(squished_cc),
debugstr_w(comp->Component), debugstr_w(squashed_cc),
debugstr_w(comp->FullKeypath), comp->RefCount, comp->num_clients, action);
if (action == INSTALLSTATE_LOCAL || action == INSTALLSTATE_SOURCE)
@ -3542,7 +3544,7 @@ static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
msi_reg_set_val_str(hkey, szPermKey, comp->FullKeypath);
}
if (action == INSTALLSTATE_LOCAL)
msi_reg_set_val_str(hkey, squished_pc, comp->FullKeypath);
msi_reg_set_val_str( hkey, squashed_pc, comp->FullKeypath );
else
{
MSIFILE *file;
@ -3579,7 +3581,7 @@ static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
lstrcpyW(ptr2, ptr);
msi_free(sourcepath);
msi_reg_set_val_str(hkey, squished_pc, source);
msi_reg_set_val_str( hkey, squashed_pc, source );
}
RegCloseKey(hkey);
}
@ -3608,7 +3610,7 @@ static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
WARN( "failed to open component key %u\n", rc );
continue;
}
res = RegDeleteValueW( hkey, squished_pc );
res = RegDeleteValueW( hkey, squashed_pc );
RegCloseKey(hkey);
if (res) WARN( "failed to delete component value %d\n", res );
}
@ -4206,15 +4208,6 @@ static UINT msi_publish_sourcelist(MSIPACKAGE *package, HKEY hkey)
static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
{
MSIHANDLE hdb, suminfo;
WCHAR guids[MAX_PATH];
WCHAR packcode[SQUISH_GUID_SIZE];
LPWSTR buffer;
LPWSTR ptr;
DWORD langid;
DWORD size;
UINT r;
static const WCHAR szARPProductIcon[] =
{'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
static const WCHAR szAssignment[] =
@ -4224,6 +4217,10 @@ static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
static const WCHAR szClients[] =
{'C','l','i','e','n','t','s',0};
static const WCHAR szColon[] = {':',0};
MSIHANDLE hdb, suminfo;
WCHAR *buffer, *ptr, guids[MAX_PATH], packcode[SQUASHED_GUID_SIZE];
DWORD langid, size;
UINT r;
buffer = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTNAMEW, buffer);
@ -4286,8 +4283,7 @@ static UINT msi_publish_upgrade_code(MSIPACKAGE *package)
{
UINT r;
HKEY hkey;
LPWSTR upgrade;
WCHAR squashed_pc[SQUISH_GUID_SIZE];
WCHAR *upgrade, squashed_pc[SQUASHED_GUID_SIZE];
upgrade = msi_dup_property(package->db, szUpgradeCode);
if (!upgrade)
@ -5186,9 +5182,8 @@ static UINT msi_publish_install_properties(MSIPACKAGE *package, HKEY hkey)
static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
{
WCHAR squashed_pc[SQUISH_GUID_SIZE];
WCHAR *upgrade_code, squashed_pc[SQUASHED_GUID_SIZE];
MSIRECORD *uirow;
LPWSTR upgrade_code;
HKEY hkey, props, upgrade_key;
UINT rc;
@ -5281,31 +5276,50 @@ static UINT msi_unpublish_icons( MSIPACKAGE *package )
return ERROR_SUCCESS;
}
static UINT msi_unpublish_product( MSIPACKAGE *package, const WCHAR *remove )
static void remove_product_upgrade_code( MSIPACKAGE *package )
{
WCHAR *code, product[SQUASHED_GUID_SIZE];
HKEY hkey;
LONG res;
DWORD count;
squash_guid( package->ProductCode, product );
if (!(code = msi_dup_property( package->db, szUpgradeCode )))
{
WARN( "upgrade code not found\n" );
return;
}
if (!MSIREG_OpenUpgradeCodesKey( code, &hkey, FALSE ))
{
RegDeleteValueW( hkey, product );
res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL, NULL );
RegCloseKey( hkey );
if (!res && !count) MSIREG_DeleteUpgradeCodesKey( code );
}
if (!MSIREG_OpenUserUpgradeCodesKey( code, &hkey, FALSE ))
{
RegDeleteValueW( hkey, product );
res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL, NULL );
RegCloseKey( hkey );
if (!res && !count) MSIREG_DeleteUserUpgradeCodesKey( code );
}
if (!MSIREG_OpenClassesUpgradeCodesKey( code, &hkey, FALSE ))
{
RegDeleteValueW( hkey, product );
res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL, NULL );
RegCloseKey( hkey );
if (!res && !count) MSIREG_DeleteClassesUpgradeCodesKey( code );
}
msi_free( code );
}
static UINT ACTION_UnpublishProduct(MSIPACKAGE *package)
{
static const WCHAR szUpgradeCode[] = {'U','p','g','r','a','d','e','C','o','d','e',0};
WCHAR *upgrade, **features;
BOOL full_uninstall = TRUE;
MSIFEATURE *feature;
MSIPATCHINFO *patch;
UINT i;
LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
{
if (feature->Action == INSTALLSTATE_LOCAL) full_uninstall = FALSE;
}
features = msi_split_string( remove, ',' );
for (i = 0; features && features[i]; i++)
{
if (!strcmpW( features[i], szAll )) full_uninstall = TRUE;
}
msi_free(features);
if (!full_uninstall)
return ERROR_SUCCESS;
MSIREG_DeleteProductKey(package->ProductCode);
MSIREG_DeleteUserDataProductKey(package->ProductCode);
MSIREG_DeleteUserDataProductKey(package->ProductCode, package->Context);
MSIREG_DeleteUninstallKey(package->ProductCode, package->platform);
MSIREG_DeleteLocalClassesProductKey(package->ProductCode);
@ -5313,13 +5327,7 @@ static UINT msi_unpublish_product( MSIPACKAGE *package, const WCHAR *remove )
MSIREG_DeleteUserProductKey(package->ProductCode);
MSIREG_DeleteUserFeaturesKey(package->ProductCode);
upgrade = msi_dup_property(package->db, szUpgradeCode);
if (upgrade)
{
MSIREG_DeleteUserUpgradeCodesKey(upgrade);
MSIREG_DeleteClassesUpgradeCodesKey(upgrade);
msi_free(upgrade);
}
remove_product_upgrade_code( package );
LIST_FOR_EACH_ENTRY(patch, &package->patches, MSIPATCHINFO, entry)
{
@ -5338,10 +5346,32 @@ static UINT msi_unpublish_product( MSIPACKAGE *package, const WCHAR *remove )
return ERROR_SUCCESS;
}
static BOOL is_full_uninstall( MSIPACKAGE *package )
{
WCHAR **features, *remove = msi_dup_property( package->db, szRemove );
MSIFEATURE *feature;
BOOL ret = TRUE;
UINT i;
LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
{
if (feature->Action == INSTALLSTATE_LOCAL) ret = FALSE;
}
features = msi_split_string( remove, ',' );
for (i = 0; features && features[i]; i++)
{
if (!strcmpW( features[i], szAll )) ret = TRUE;
}
msi_free(features);
msi_free(remove);
return ret;
}
static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
{
UINT rc;
WCHAR *remove;
/* first do the same as an InstallExecute */
rc = execute_script(package, SCRIPT_INSTALL);
@ -5353,9 +5383,9 @@ static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
if (rc != ERROR_SUCCESS)
return rc;
remove = msi_dup_property(package->db, szRemove);
rc = msi_unpublish_product(package, remove);
msi_free(remove);
if (is_full_uninstall(package))
rc = ACTION_UnpublishProduct(package);
return rc;
}
@ -5383,26 +5413,24 @@ UINT ACTION_ForceReboot(MSIPACKAGE *package)
'/','I',' ','\"','%','s','\"',' ',
'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
WCHAR buffer[256], sysdir[MAX_PATH];
WCHAR buffer[256], sysdir[MAX_PATH], squashed_pc[SQUASHED_GUID_SIZE];
HKEY hkey;
WCHAR squished_pc[100];
squash_guid(package->ProductCode,squished_pc);
squash_guid( package->ProductCode, squashed_pc );
GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
squished_pc);
snprintfW( buffer, sizeof(buffer)/sizeof(buffer[0]), msiexec_fmt, sysdir, squashed_pc );
msi_reg_set_val_str( hkey, squished_pc, buffer );
msi_reg_set_val_str( hkey, squashed_pc, buffer );
RegCloseKey(hkey);
TRACE("Reboot command %s\n",debugstr_w(buffer));
RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
sprintfW( buffer, install_fmt, package->ProductCode, squashed_pc );
msi_reg_set_val_str( hkey, squished_pc, buffer );
msi_reg_set_val_str( hkey, squashed_pc, buffer );
RegCloseKey(hkey);
return ERROR_INSTALL_SUSPEND;
@ -5524,7 +5552,7 @@ static UINT ACTION_RegisterUser(MSIPACKAGE *package)
if (msi_check_unpublish(package))
{
MSIREG_DeleteUserDataProductKey(package->ProductCode);
MSIREG_DeleteUserDataProductKey(package->ProductCode, package->Context);
goto end;
}
@ -7391,7 +7419,8 @@ static UINT ACTION_SetODBCFolders( MSIPACKAGE *package )
static UINT ITERATE_RemoveExistingProducts( MSIRECORD *rec, LPVOID param )
{
static const WCHAR fmtW[] =
{'m','s','i','e','x','e','c',' ','/','i',' ','%','s',' ','R','E','M','O','V','E','=','%','s',0};
{'m','s','i','e','x','e','c',' ','/','q','n',' ','/','i',' ','%','s',' ',
'R','E','M','O','V','E','=','%','s',0};
MSIPACKAGE *package = param;
const WCHAR *property = MSI_RecordGetString( rec, 7 );
int attrs = MSI_RecordGetInteger( rec, 5 );
@ -7672,7 +7701,7 @@ StandardActions[] =
{ szProcessComponents, ACTION_ProcessComponents, szProcessComponents },
{ szPublishComponents, ACTION_PublishComponents, szUnpublishComponents },
{ szPublishFeatures, ACTION_PublishFeatures, szUnpublishFeatures },
{ szPublishProduct, ACTION_PublishProduct, NULL },
{ szPublishProduct, ACTION_PublishProduct, szUnpublishProduct },
{ szRegisterClassInfo, ACTION_RegisterClassInfo, szUnregisterClassInfo },
{ szRegisterComPlus, ACTION_RegisterComPlus, szUnregisterComPlus },
{ szRegisterExtensionInfo, ACTION_RegisterExtensionInfo, szUnregisterExtensionInfo },
@ -7701,6 +7730,7 @@ StandardActions[] =
{ szStopServices, ACTION_StopServices, szStartServices },
{ szUnpublishComponents, ACTION_UnpublishComponents, szPublishComponents },
{ szUnpublishFeatures, ACTION_UnpublishFeatures, szPublishFeatures },
{ szUnpublishProduct, ACTION_UnpublishProduct, NULL }, /* for rollback only */
{ szUnregisterClassInfo, ACTION_UnregisterClassInfo, szRegisterClassInfo },
{ szUnregisterComPlus, ACTION_UnregisterComPlus, szRegisterComPlus },
{ szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo, szRegisterExtensionInfo },

13
reactos/dll/win32/msi/automation.c
View file

@ -273,7 +273,8 @@ static HRESULT WINAPI AutomationObject_GetIDsOfNames(
ITypeInfo *ti;
HRESULT hr;
TRACE("(%p/%p)->(%p,%p,%d,%d,%p)\n", iface, This, riid, rgszNames, cNames, lcid, rgDispId);
TRACE("(%p/%p)->(%s, %p, %d, %d, %p)\n", iface, This,
debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
if (!IsEqualGUID(riid, &IID_NULL)) return E_INVALIDARG;
@ -316,7 +317,9 @@ static HRESULT WINAPI AutomationObject_Invoke(
BSTR bstrName = NULL;
ITypeInfo *ti;
TRACE("(%p/%p)->(%d,%p,%d,%d,%p,%p,%p,%p)\n", iface, This, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
TRACE("(%p/%p)->(%d, %s, %d, %d, %p, %p, %p, %p)\n", iface, This,
dispIdMember, debugstr_guid(riid), lcid, wFlags,
pDispParams, pVarResult, pExcepInfo, puArgErr);
if (!IsEqualIID(riid, &IID_NULL))
{
@ -1012,7 +1015,7 @@ static HRESULT list_invoke(
EXCEPINFO* pExcepInfo,
UINT* puArgErr)
{
ListObject *list = (ListObject*)This;
ListObject *list = CONTAINING_RECORD(This, ListObject, autoobj);
IUnknown *pUnk = NULL;
HRESULT hr;
@ -1060,7 +1063,7 @@ static HRESULT list_invoke(
static void list_free(AutomationObject *This)
{
ListObject *list = (ListObject*)This;
ListObject *list = CONTAINING_RECORD(This, ListObject, autoobj);
int i;
for (i = 0; i < list->count; i++)
@ -1348,7 +1351,7 @@ static HRESULT session_invoke(
EXCEPINFO* pExcepInfo,
UINT* puArgErr)
{
SessionObject *session = (SessionObject*)This;
SessionObject *session = CONTAINING_RECORD(This, SessionObject, autoobj);
WCHAR *szString;
DWORD dwLen = 0;
MSIHANDLE msiHandle;

6
reactos/dll/win32/msi/database.c
View file

@ -549,7 +549,7 @@ static LPWSTR msi_build_createsql_columns(LPWSTR *columns_data, LPWSTR *types, D
static LPWSTR msi_build_createsql_postlude(LPWSTR *primary_keys, DWORD num_keys)
{
LPWSTR postlude, keys, ptr;
DWORD size, key_size, i;
DWORD size, i;
static const WCHAR key_fmt[] = {'`','%','s','`',',',' ',0};
static const WCHAR postlude_fmt[] = {'P','R','I','M','A','R','Y',' ','K','E','Y',' ','%','s',')',0};
@ -563,9 +563,7 @@ static LPWSTR msi_build_createsql_postlude(LPWSTR *primary_keys, DWORD num_keys)
for (i = 0, ptr = keys; i < num_keys; i++)
{
key_size = lstrlenW(key_fmt) + lstrlenW(primary_keys[i]) -2;
sprintfW(ptr, key_fmt, primary_keys[i]);
ptr += key_size;
ptr += sprintfW(ptr, key_fmt, primary_keys[i]);
}
/* remove final ', ' */

173
reactos/dll/win32/msi/msi.c
View file

@ -123,10 +123,10 @@ done:
UINT WINAPI MsiOpenProductW(LPCWSTR szProduct, MSIHANDLE *phProduct)
{
MSIPACKAGE *package = NULL;
WCHAR squished_pc[GUID_SIZE];
WCHAR squashed_pc[SQUASHED_GUID_SIZE];
UINT r;
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (!phProduct)
@ -987,16 +987,15 @@ UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
{
UINT rc, index;
HKEY compkey, prodkey;
WCHAR squished_comp[GUID_SIZE];
WCHAR squished_prod[GUID_SIZE];
DWORD sz = GUID_SIZE;
WCHAR squashed_comp[SQUASHED_GUID_SIZE], squashed_prod[SQUASHED_GUID_SIZE];
DWORD sz = sizeof(squashed_prod)/sizeof(squashed_prod[0]);
TRACE("%s %p\n", debugstr_w(szComponent), szBuffer);
if (!szComponent || !*szComponent)
return ERROR_INVALID_PARAMETER;
if (!squash_guid(szComponent, squished_comp))
if (!squash_guid( szComponent, squashed_comp ))
return ERROR_INVALID_PARAMETER;
if (MSIREG_OpenUserDataComponentKey(szComponent, NULL, &compkey, FALSE) != ERROR_SUCCESS &&
@ -1005,7 +1004,7 @@ UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
return ERROR_UNKNOWN_COMPONENT;
}
rc = RegEnumValueW(compkey, 0, squished_prod, &sz, NULL, NULL, NULL, NULL);
rc = RegEnumValueW( compkey, 0, squashed_prod, &sz, NULL, NULL, NULL, NULL );
if (rc != ERROR_SUCCESS)
{
RegCloseKey(compkey);
@ -1013,7 +1012,7 @@ UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
}
/* check simple case, only one product */
rc = RegEnumValueW(compkey, 1, squished_prod, &sz, NULL, NULL, NULL, NULL);
rc = RegEnumValueW( compkey, 1, squashed_prod, &sz, NULL, NULL, NULL, NULL );
if (rc == ERROR_NO_MORE_ITEMS)
{
rc = ERROR_SUCCESS;
@ -1021,12 +1020,12 @@ UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
}
index = 0;
while ((rc = RegEnumValueW(compkey, index, squished_prod, &sz,
NULL, NULL, NULL, NULL)) != ERROR_NO_MORE_ITEMS)
while ((rc = RegEnumValueW( compkey, index, squashed_prod, &sz, NULL, NULL, NULL, NULL )) !=
ERROR_NO_MORE_ITEMS)
{
index++;
sz = GUID_SIZE;
unsquash_guid(squished_prod, szBuffer);
unsquash_guid( squashed_prod, szBuffer );
if (MSIREG_OpenProductKey(szBuffer, NULL,
MSIINSTALLCONTEXT_USERMANAGED,
@ -1048,7 +1047,7 @@ UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
done:
RegCloseKey(compkey);
unsquash_guid(squished_prod, szBuffer);
unsquash_guid( squashed_prod, szBuffer );
return rc;
}
@ -1085,9 +1084,7 @@ static UINT MSI_GetProductInfo(LPCWSTR szProduct, LPCWSTR szAttribute,
MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_USERUNMANAGED;
UINT r = ERROR_UNKNOWN_PROPERTY;
HKEY prodkey, userdata, source;
LPWSTR val = NULL;
WCHAR squished_pc[GUID_SIZE];
WCHAR packagecode[GUID_SIZE];
WCHAR *val = NULL, squashed_pc[SQUASHED_GUID_SIZE], packagecode[SQUASHED_GUID_SIZE];
BOOL badconfig = FALSE;
LONG res;
DWORD type = REG_NONE;
@ -1098,7 +1095,7 @@ static UINT MSI_GetProductInfo(LPCWSTR szProduct, LPCWSTR szAttribute,
if ((szValue->str.w && !pcchValueBuf) || !szProduct || !szAttribute)
return ERROR_INVALID_PARAMETER;
if (!squash_guid(szProduct, squished_pc))
if (!squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if ((r = MSIREG_OpenProductKey(szProduct, NULL,
@ -1197,7 +1194,7 @@ static UINT MSI_GetProductInfo(LPCWSTR szProduct, LPCWSTR szAttribute,
if (val != empty && type != REG_DWORD &&
!strcmpW( szAttribute, INSTALLPROPERTY_PACKAGECODEW ))
{
if (lstrlenW(val) != SQUISH_GUID_SIZE - 1)
if (lstrlenW( val ) != SQUASHED_GUID_SIZE - 1)
badconfig = TRUE;
else
{
@ -1387,15 +1384,6 @@ UINT WINAPI MsiGetProductInfoExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
MSIINSTALLCONTEXT dwContext, LPCWSTR szProperty,
LPWSTR szValue, LPDWORD pcchValue)
{
WCHAR squished_pc[GUID_SIZE];
LPWSTR val = NULL;
LPCWSTR package = NULL;
HKEY props = NULL, prod;
HKEY classes = NULL, managed;
HKEY hkey = NULL;
DWORD type;
UINT r = ERROR_UNKNOWN_PRODUCT;
static const WCHAR five[] = {'5',0};
static const WCHAR displayname[] = {
'D','i','s','p','l','a','y','N','a','m','e',0};
@ -1404,12 +1392,17 @@ UINT WINAPI MsiGetProductInfoExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
static const WCHAR managed_local_package[] = {
'M','a','n','a','g','e','d','L','o','c','a','l',
'P','a','c','k','a','g','e',0};
WCHAR *val = NULL, squashed_pc[SQUASHED_GUID_SIZE];
LPCWSTR package = NULL;
HKEY props = NULL, prod, classes = NULL, managed, hkey = NULL;
DWORD type;
UINT r = ERROR_UNKNOWN_PRODUCT;
TRACE("(%s, %s, %d, %s, %p, %p)\n", debugstr_w(szProductCode),
debugstr_w(szUserSid), dwContext, debugstr_w(szProperty),
szValue, pcchValue);
if (!szProductCode || !squash_guid(szProductCode, squished_pc))
if (!szProductCode || !squash_guid( szProductCode, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (szValue && !pcchValue)
@ -1649,28 +1642,25 @@ UINT WINAPI MsiGetPatchInfoExW(LPCWSTR szPatchCode, LPCWSTR szProductCode,
LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
LPCWSTR szProperty, LPWSTR lpValue, DWORD *pcchValue)
{
WCHAR squished_pc[GUID_SIZE];
WCHAR squished_patch[GUID_SIZE];
static const WCHAR szManagedPackage[] =
{'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0};
WCHAR *val = NULL, squashed_pc[SQUASHED_GUID_SIZE], squashed_patch[SQUASHED_GUID_SIZE];
HKEY udprod = 0, prod = 0, props = 0;
HKEY patch = 0, patches = 0;
HKEY udpatch = 0, datakey = 0;
HKEY prodpatches = 0;
LPWSTR val = NULL;
UINT r = ERROR_UNKNOWN_PRODUCT;
DWORD len;
LONG res;
static const WCHAR szManagedPackage[] = {'M','a','n','a','g','e','d',
'L','o','c','a','l','P','a','c','k','a','g','e',0};
TRACE("(%s, %s, %s, %d, %s, %p, %p)\n", debugstr_w(szPatchCode),
debugstr_w(szProductCode), debugstr_w(szUserSid), dwContext,
debugstr_w(szProperty), lpValue, pcchValue);
if (!szProductCode || !squash_guid(szProductCode, squished_pc))
if (!szProductCode || !squash_guid( szProductCode, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (!szPatchCode || !squash_guid(szPatchCode, squished_patch))
if (!szPatchCode || !squash_guid( szPatchCode, squashed_patch ))
return ERROR_INVALID_PARAMETER;
if (!szProperty)
@ -1704,7 +1694,7 @@ UINT WINAPI MsiGetPatchInfoExW(LPCWSTR szPatchCode, LPCWSTR szProductCode,
if (res != ERROR_SUCCESS)
goto done;
res = RegOpenKeyExW(patches, squished_patch, 0, KEY_WOW64_64KEY|KEY_READ, &patch);
res = RegOpenKeyExW( patches, squashed_patch, 0, KEY_WOW64_64KEY|KEY_READ, &patch );
if (res != ERROR_SUCCESS)
goto done;
@ -1719,7 +1709,7 @@ UINT WINAPI MsiGetPatchInfoExW(LPCWSTR szPatchCode, LPCWSTR szProductCode,
goto done;
datakey = prodpatches;
szProperty = squished_patch;
szProperty = squashed_patch;
}
else
{
@ -2115,7 +2105,7 @@ static BOOL msi_comp_find_package(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
return (res == ERROR_SUCCESS);
}
static UINT msi_comp_find_prodcode(LPWSTR squished_pc,
static UINT msi_comp_find_prodcode(WCHAR *squashed_pc,
MSIINSTALLCONTEXT context,
LPCWSTR comp, LPWSTR val, DWORD *sz)
{
@ -2131,7 +2121,7 @@ static UINT msi_comp_find_prodcode(LPWSTR squished_pc,
if (r != ERROR_SUCCESS)
return r;
res = RegQueryValueExW(hkey, squished_pc, NULL, NULL, (BYTE *)val, sz);
res = RegQueryValueExW( hkey, squashed_pc, NULL, NULL, (BYTE *)val, sz );
if (res != ERROR_SUCCESS)
return res;
@ -2143,7 +2133,7 @@ UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
LPCWSTR szComponent, INSTALLSTATE *pdwState)
{
WCHAR squished_pc[GUID_SIZE];
WCHAR squashed_pc[SQUASHED_GUID_SIZE];
BOOL found;
DWORD sz;
@ -2156,7 +2146,7 @@ UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
if (!szProductCode || !*szProductCode || lstrlenW(szProductCode) != GUID_SIZE - 1)
return ERROR_INVALID_PARAMETER;
if (!squash_guid(szProductCode, squished_pc))
if (!squash_guid( szProductCode, squashed_pc ))
return ERROR_INVALID_PARAMETER;
found = msi_comp_find_prod_key(szProductCode, dwContext);
@ -2175,7 +2165,7 @@ UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
*pdwState = INSTALLSTATE_UNKNOWN;
sz = 0;
if (msi_comp_find_prodcode(squished_pc, dwContext, szComponent, NULL, &sz))
if (msi_comp_find_prodcode( squashed_pc, dwContext, szComponent, NULL, &sz ))
return ERROR_UNKNOWN_COMPONENT;
if (sz == 0)
@ -2186,7 +2176,7 @@ UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
UINT r;
if (!(val = msi_alloc( sz ))) return ERROR_OUTOFMEMORY;
if ((r = msi_comp_find_prodcode(squished_pc, dwContext, szComponent, val, &sz)))
if ((r = msi_comp_find_prodcode( squashed_pc, dwContext, szComponent, val, &sz )))
{
msi_free(val);
return r;
@ -2519,7 +2509,7 @@ HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR path, DWORD flags, PCCERT
TRACE("%s %08x %p %p %p\n", debugstr_a(path), flags, cert, hash, hashlen);
if (path && !(pathW = strdupAtoW( path ))) return ERROR_OUTOFMEMORY;
if (path && !(pathW = strdupAtoW( path ))) return E_OUTOFMEMORY;
r = MsiGetFileSignatureInformationW( pathW, flags, cert, hash, hashlen );
msi_free( pathW );
return r;
@ -2769,10 +2759,8 @@ static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
{
static const WCHAR wininstaller[] =
{'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
WCHAR squished_pc[GUID_SIZE];
WCHAR squished_comp[GUID_SIZE];
WCHAR *path = NULL, squashed_pc[SQUASHED_GUID_SIZE], squashed_comp[SQUASHED_GUID_SIZE];
HKEY hkey;
LPWSTR path = NULL;
INSTALLSTATE state;
DWORD version;
@ -2782,8 +2770,7 @@ static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
if (lpPathBuf->str.w && !pcchBuf)
return INSTALLSTATE_INVALIDARG;
if (!squash_guid(szProduct, squished_pc) ||
!squash_guid(szComponent, squished_comp))
if (!squash_guid( szProduct, squashed_pc ) || !squash_guid( szComponent, squashed_comp ))
return INSTALLSTATE_INVALIDARG;
state = INSTALLSTATE_UNKNOWN;
@ -2791,7 +2778,7 @@ static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
{
path = msi_reg_get_val_str(hkey, squished_pc);
path = msi_reg_get_val_str( hkey, squashed_pc );
RegCloseKey(hkey);
state = INSTALLSTATE_ABSENT;
@ -2821,7 +2808,7 @@ static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
{
msi_free(path);
path = msi_reg_get_val_str(hkey, squished_pc);
path = msi_reg_get_val_str( hkey, squashed_pc );
RegCloseKey(hkey);
state = INSTALLSTATE_ABSENT;
@ -3339,6 +3326,26 @@ INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
}
WCHAR *reg_get_multisz( HKEY hkey, const WCHAR *name )
{
WCHAR *ret;
DWORD len, type;
if (RegQueryValueExW( hkey, name, NULL, &type, NULL, &len ) || type != REG_MULTI_SZ) return NULL;
if ((ret = msi_alloc( len ))) RegQueryValueExW( hkey, name, NULL, NULL, (BYTE *)ret, &len );
return ret;
}
WCHAR *reg_get_sz( HKEY hkey, const WCHAR *name )
{
WCHAR *ret;
DWORD len, type;
if (RegQueryValueExW( hkey, name, NULL, &type, NULL, &len ) || type != REG_SZ) return NULL;
if ((ret = msi_alloc( len ))) RegQueryValueExW( hkey, name, NULL, NULL, (BYTE *)ret, &len );
return ret;
}
#define BASE85_SIZE 20
/***********************************************************************
* MSI_ProvideQualifiedComponentEx [internal]
*/
@ -3347,39 +3354,54 @@ static UINT MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
LPDWORD pcchPathBuf)
{
WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
feature[MAX_FEATURE_CHARS+1];
LPWSTR info;
WCHAR product[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
WCHAR *desc;
HKEY hkey;
DWORD sz;
UINT rc;
DWORD size;
UINT ret;
INSTALLSTATE state;
rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
if (rc != ERROR_SUCCESS)
return ERROR_INDEX_ABSENT;
if (MSIREG_OpenUserComponentsKey( szComponent, &hkey, FALSE )) return ERROR_UNKNOWN_COMPONENT;
info = msi_reg_get_val_str( hkey, szQualifier );
desc = reg_get_multisz( hkey, szQualifier );
RegCloseKey(hkey);
if (!desc) return ERROR_INDEX_ABSENT;
if (!info)
return ERROR_INDEX_ABSENT;
/* FIXME: handle multiple descriptors */
ret = MsiDecomposeDescriptorW( desc, product, feature, comp, &size );
msi_free( desc );
if (ret != ERROR_SUCCESS) return ret;
MsiDecomposeDescriptorW(info, product, feature, component, &sz);
if (!szProduct) szProduct = product;
if (!comp[0])
{
MSIINSTALLCONTEXT ctx;
WCHAR *components;
GUID guid;
if (!szProduct)
state = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
else
state = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
/* use the first component of the feature if the descriptor component is empty */
if ((ret = msi_locate_product( szProduct, &ctx ))) return ret;
if ((ret = MSIREG_OpenUserDataFeaturesKey( szProduct, NULL, ctx, &hkey, FALSE )))
{
return ERROR_FILE_NOT_FOUND;
}
components = reg_get_sz( hkey, feature );
RegCloseKey( hkey );
if (!components) return ERROR_FILE_NOT_FOUND;
msi_free( info );
if (strlenW( components ) < BASE85_SIZE || !decode_base85_guid( components, &guid ))
{
msi_free( components );
return ERROR_FILE_NOT_FOUND;
}
msi_free( components );
StringFromGUID2( &guid, comp, sizeof(comp)/sizeof(comp[0]) );
}
if (state == INSTALLSTATE_MOREDATA)
return ERROR_MORE_DATA;
if (state != INSTALLSTATE_LOCAL)
return ERROR_FILE_NOT_FOUND;
state = MSI_GetComponentPath( szProduct, comp, lpPathBuf, pcchPathBuf );
if (state == INSTALLSTATE_MOREDATA) return ERROR_MORE_DATA;
if (state != INSTALLSTATE_LOCAL) return ERROR_FILE_NOT_FOUND;
return ERROR_SUCCESS;
}
@ -3476,8 +3498,7 @@ static USERINFOSTATE MSI_GetUserInfo(LPCWSTR szProduct,
awstring *lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
awstring *lpSerialBuf, LPDWORD pcchSerialBuf)
{
WCHAR squished_pc[SQUISH_GUID_SIZE];
LPWSTR user, org, serial;
WCHAR *user, *org, *serial, squashed_pc[SQUASHED_GUID_SIZE];
USERINFOSTATE state;
HKEY hkey, props;
LPCWSTR orgptr;
@ -3487,7 +3508,7 @@ static USERINFOSTATE MSI_GetUserInfo(LPCWSTR szProduct,
pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
pcchSerialBuf);
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return USERINFOSTATE_INVALIDARG;
if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,

6
reactos/dll/win32/msi/msipriv.h
View file

@ -727,7 +727,7 @@ typedef struct tagMSISCRIPT
#define MSI_BUILDNUMBER 6001
#define GUID_SIZE 39
#define SQUISH_GUID_SIZE 33
#define SQUASHED_GUID_SIZE 33
#define MSIHANDLE_MAGIC 0x4d434923
@ -929,10 +929,11 @@ extern UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szProduct, HKEY* key, BOOL cr
extern UINT MSIREG_DeleteProductKey(LPCWSTR szProduct) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUserProductKey(LPCWSTR szProduct) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUserDataPatchKey(LPCWSTR patch, MSIINSTALLCONTEXT context) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUserDataProductKey(LPCWSTR, MSIINSTALLCONTEXT) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUserFeaturesKey(LPCWSTR szProduct) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUserUpgradeCodesKey(LPCWSTR szUpgradeCode) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteUpgradeCodesKey(const WCHAR *) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteClassesUpgradeCodesKey(LPCWSTR szUpgradeCode) DECLSPEC_HIDDEN;
extern UINT MSIREG_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create) DECLSPEC_HIDDEN;
extern UINT MSIREG_DeleteLocalClassesProductKey(LPCWSTR szProductCode) DECLSPEC_HIDDEN;
@ -969,7 +970,6 @@ extern INT msi_suminfo_get_int32( MSISUMMARYINFO *si, UINT uiProperty ) DECLSPEC
extern LPWSTR msi_get_suminfo_product( IStorage *stg ) DECLSPEC_HIDDEN;
extern UINT msi_add_suminfo( MSIDATABASE *db, LPWSTR **records, int num_records, int num_columns ) DECLSPEC_HIDDEN;
extern UINT msi_export_suminfo( MSIDATABASE *db, HANDLE handle ) DECLSPEC_HIDDEN;
extern enum platform parse_platform( const WCHAR *str ) DECLSPEC_HIDDEN;
extern UINT msi_load_suminfo_properties( MSIPACKAGE *package ) DECLSPEC_HIDDEN;
/* undocumented functions */

2
reactos/dll/win32/msi/package.c
View file

@ -1170,7 +1170,7 @@ UINT msi_create_empty_local_file( LPWSTR path, LPCWSTR suffix )
return ERROR_SUCCESS;
}
enum platform parse_platform( const WCHAR *str )
static enum platform parse_platform( const WCHAR *str )
{
if (!str[0] || !strcmpW( str, szIntel )) return PLATFORM_INTEL;
else if (!strcmpW( str, szIntel64 )) return PLATFORM_INTEL64;

13
reactos/dll/win32/msi/record.c
View file

@ -707,7 +707,8 @@ UINT MSI_RecordSetStream(MSIRECORD *rec, UINT iField, IStream *stream)
UINT MSI_RecordSetStreamFromFileW(MSIRECORD *rec, UINT iField, LPCWSTR szFilename)
{
IStream *stm = NULL;
HRESULT r;
HRESULT hr;
UINT ret;
if( (iField == 0) || (iField > rec->count) )
return ERROR_INVALID_PARAMETER;
@ -726,16 +727,16 @@ UINT MSI_RecordSetStreamFromFileW(MSIRECORD *rec, UINT iField, LPCWSTR szFilenam
return ERROR_INVALID_FIELD;
ofs.QuadPart = 0;
r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
if( FAILED( r ) )
hr = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
if (FAILED( hr ))
return ERROR_FUNCTION_FAILED;
}
else
{
/* read the file into a stream and save the stream in the record */
r = RECORD_StreamFromFile(szFilename, &stm);
if( r != ERROR_SUCCESS )
return r;
ret = RECORD_StreamFromFile(szFilename, &stm);
if (ret != ERROR_SUCCESS)
return ret;
/* if all's good, store it in the record */
MSI_RecordSetStream(rec, iField, stm);

328
reactos/dll/win32/msi/registry.c
View file

@ -475,24 +475,23 @@ UINT MSIREG_DeleteUninstallKey(const WCHAR *product, enum platform platform)
UINT MSIREG_OpenProductKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
{
LPWSTR usersid = NULL;
HKEY root = HKEY_LOCAL_MACHINE;
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[MAX_PATH];
WCHAR *usersid = NULL, squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH];
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
if (context == MSIINSTALLCONTEXT_MACHINE)
{
strcpyW(keypath, szInstaller_LocalClassesProd);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
}
else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
{
root = HKEY_CURRENT_USER;
strcpyW(keypath, szUserProducts);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
}
else
{
@ -505,7 +504,7 @@ UINT MSIREG_OpenProductKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTE
}
szUserSid = usersid;
}
sprintfW(keypath, szInstaller_LocalManagedProd_fmt, szUserSid, squished_pc);
sprintfW( keypath, szInstaller_LocalManagedProd_fmt, szUserSid, squashed_pc );
LocalFree(usersid);
}
if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
@ -514,25 +513,25 @@ UINT MSIREG_OpenProductKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTE
UINT MSIREG_DeleteUserProductKey(LPCWSTR szProduct)
{
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
strcpyW(keypath, szUserProducts);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}
UINT MSIREG_OpenUserPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
{
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szPatch, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szPatch), debugstr_w(squished_pc));
if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
strcpyW(keypath, szUserPatches);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
@ -543,21 +542,21 @@ UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONT
{
HKEY root = HKEY_LOCAL_MACHINE;
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[MAX_PATH], *usersid = NULL;
WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH], *usersid = NULL;
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
if (context == MSIINSTALLCONTEXT_MACHINE)
{
strcpyW(keypath, szInstaller_LocalClassesFeat);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
}
else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
{
root = HKEY_CURRENT_USER;
strcpyW(keypath, szUserFeatures);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
}
else
{
@ -570,7 +569,7 @@ UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONT
}
szUserSid = usersid;
}
sprintfW(keypath, szInstaller_LocalManagedFeat_fmt, szUserSid, squished_pc);
sprintfW( keypath, szInstaller_LocalManagedFeat_fmt, szUserSid, squashed_pc );
LocalFree(usersid);
}
if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
@ -579,26 +578,26 @@ UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONT
UINT MSIREG_DeleteUserFeaturesKey(LPCWSTR szProduct)
{
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
strcpyW(keypath, szUserFeatures);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}
static UINT MSIREG_OpenInstallerFeaturesKey(LPCWSTR szProduct, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
strcpyW(keypath, szInstaller_Features);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_pc );
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
@ -608,14 +607,14 @@ UINT MSIREG_OpenUserDataFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINS
HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200], *usersid = NULL;
WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200], *usersid = NULL;
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
if (context == MSIINSTALLCONTEXT_MACHINE)
{
sprintfW(keypath, szUserDataFeatures_fmt, szLocalSid, squished_pc);
sprintfW( keypath, szUserDataFeatures_fmt, szLocalSid, squashed_pc );
}
else
{
@ -628,7 +627,7 @@ UINT MSIREG_OpenUserDataFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINS
}
szUserSid = usersid;
}
sprintfW(keypath, szUserDataFeatures_fmt, szUserSid, squished_pc);
sprintfW( keypath, szUserDataFeatures_fmt, szUserSid, squashed_pc );
LocalFree(usersid);
}
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
@ -637,32 +636,31 @@ UINT MSIREG_OpenUserDataFeaturesKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINS
UINT MSIREG_OpenUserComponentsKey(LPCWSTR szComponent, HKEY *key, BOOL create)
{
WCHAR squished_cc[GUID_SIZE], keypath[0x200];
WCHAR squashed_cc[SQUASHED_GUID_SIZE], keypath[0x200];
UINT ret;
if (!squash_guid(szComponent, squished_cc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szComponent), debugstr_w(squished_cc));
if (!squash_guid( szComponent, squashed_cc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_cc));
strcpyW(keypath, szUserComponents);
strcatW(keypath, squished_cc);
strcatW( keypath, squashed_cc );
if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
ret = RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
if (ret != ERROR_FILE_NOT_FOUND) return ret;
strcpyW(keypath, szInstaller_Components);
strcatW(keypath, squished_cc);
strcatW( keypath, squashed_cc );
return RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
}
UINT MSIREG_OpenUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR comp[GUID_SIZE], keypath[0x200];
LPWSTR usersid;
WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szComponent, comp)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szComponent), debugstr_w(comp));
if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
if (!szUserSid)
{
@ -671,11 +669,11 @@ UINT MSIREG_OpenUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid, HKE
ERR("Failed to retrieve user SID\n");
return ERROR_FUNCTION_FAILED;
}
sprintfW(keypath, szUserDataComp_fmt, usersid, comp);
sprintfW( keypath, szUserDataComp_fmt, usersid, squashed_comp );
LocalFree(usersid);
}
else
sprintfW(keypath, szUserDataComp_fmt, szUserSid, comp);
sprintfW( keypath, szUserDataComp_fmt, szUserSid, squashed_comp );
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
@ -684,13 +682,12 @@ UINT MSIREG_OpenUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid, HKE
UINT MSIREG_DeleteUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR comp[GUID_SIZE], keypath[0x200];
LPWSTR usersid;
WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
HKEY hkey;
LONG r;
if (!squash_guid(szComponent, comp)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szComponent), debugstr_w(comp));
if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
if (!szUserSid)
{
@ -706,7 +703,7 @@ UINT MSIREG_DeleteUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid)
sprintfW(keypath, szUserDataComponents_fmt, szUserSid);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
r = RegDeleteTreeW(hkey, comp);
r = RegDeleteTreeW( hkey, squashed_comp );
RegCloseKey(hkey);
return r;
}
@ -714,16 +711,15 @@ UINT MSIREG_DeleteUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid)
UINT MSIREG_OpenUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
LPWSTR usersid;
WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
if (dwContext == MSIINSTALLCONTEXT_MACHINE)
sprintfW(keypath, szUserDataProd_fmt, szLocalSid, squished_pc);
sprintfW( keypath, szUserDataProd_fmt, szLocalSid, squashed_pc );
else if (szUserSid)
sprintfW(keypath, szUserDataProd_fmt, szUserSid, squished_pc);
sprintfW( keypath, szUserDataProd_fmt, szUserSid, squashed_pc );
else
{
if (!(usersid = get_user_sid()))
@ -731,7 +727,7 @@ UINT MSIREG_OpenUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContex
ERR("Failed to retrieve user SID\n");
return ERROR_FUNCTION_FAILED;
}
sprintfW(keypath, szUserDataProd_fmt, usersid, squished_pc);
sprintfW( keypath, szUserDataProd_fmt, usersid, squashed_pc );
LocalFree(usersid);
}
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
@ -741,14 +737,13 @@ UINT MSIREG_OpenUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContex
UINT MSIREG_OpenUserDataPatchKey(LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_patch[GUID_SIZE], keypath[0x200];
LPWSTR usersid;
WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szPatch, squished_patch)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szPatch), debugstr_w(squished_patch));
if (!squash_guid( szPatch, squashed_patch )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_patch));
if (dwContext == MSIINSTALLCONTEXT_MACHINE)
sprintfW(keypath, szUserDataPatch_fmt, szLocalSid, squished_patch);
sprintfW( keypath, szUserDataPatch_fmt, szLocalSid, squashed_patch );
else
{
if (!(usersid = get_user_sid()))
@ -756,7 +751,7 @@ UINT MSIREG_OpenUserDataPatchKey(LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext, H
ERR("Failed to retrieve user SID\n");
return ERROR_FUNCTION_FAILED;
}
sprintfW(keypath, szUserDataPatch_fmt, usersid, squished_patch);
sprintfW( keypath, szUserDataPatch_fmt, usersid, squashed_patch );
LocalFree(usersid);
}
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
@ -766,13 +761,12 @@ UINT MSIREG_OpenUserDataPatchKey(LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext, H
UINT MSIREG_DeleteUserDataPatchKey(LPCWSTR patch, MSIINSTALLCONTEXT context)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_patch[GUID_SIZE], keypath[0x200];
LPWSTR usersid;
WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
HKEY hkey;
LONG r;
if (!squash_guid(patch, squished_patch)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(patch), debugstr_w(squished_patch));
if (!squash_guid( patch, squashed_patch )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(patch), debugstr_w(squashed_patch));
if (context == MSIINSTALLCONTEXT_MACHINE)
sprintfW(keypath, szUserDataPatches_fmt, szLocalSid);
@ -787,7 +781,7 @@ UINT MSIREG_DeleteUserDataPatchKey(LPCWSTR patch, MSIINSTALLCONTEXT context)
LocalFree(usersid);
}
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
r = RegDeleteTreeW(hkey, squished_patch);
r = RegDeleteTreeW( hkey, squashed_patch );
RegCloseKey(hkey);
return r;
}
@ -795,14 +789,13 @@ UINT MSIREG_DeleteUserDataPatchKey(LPCWSTR patch, MSIINSTALLCONTEXT context)
UINT MSIREG_OpenUserDataProductPatchesKey(LPCWSTR product, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_product[GUID_SIZE], keypath[0x200];
LPWSTR usersid;
WCHAR *usersid, squashed_product[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(product, squished_product)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(product), debugstr_w(squished_product));
if (!squash_guid( product, squashed_product )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(product), debugstr_w(squashed_product));
if (context == MSIINSTALLCONTEXT_MACHINE)
sprintfW(keypath, szUserDataProductPatches_fmt, szLocalSid, squished_product);
sprintfW( keypath, szUserDataProductPatches_fmt, szLocalSid, squashed_product );
else
{
if (!(usersid = get_user_sid()))
@ -810,7 +803,7 @@ UINT MSIREG_OpenUserDataProductPatchesKey(LPCWSTR product, MSIINSTALLCONTEXT con
ERR("Failed to retrieve user SID\n");
return ERROR_FUNCTION_FAILED;
}
sprintfW(keypath, szUserDataProductPatches_fmt, usersid, squished_product);
sprintfW( keypath, szUserDataProductPatches_fmt, usersid, squashed_product );
LocalFree(usersid);
}
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
@ -819,17 +812,16 @@ UINT MSIREG_OpenUserDataProductPatchesKey(LPCWSTR product, MSIINSTALLCONTEXT con
UINT MSIREG_OpenInstallProps(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
{
LPWSTR usersid;
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
if (dwContext == MSIINSTALLCONTEXT_MACHINE)
sprintfW(keypath, szInstallProperties_fmt, szLocalSid, squished_pc);
sprintfW( keypath, szInstallProperties_fmt, szLocalSid, squashed_pc );
else if (szUserSid)
sprintfW(keypath, szInstallProperties_fmt, szUserSid, squished_pc);
sprintfW( keypath, szInstallProperties_fmt, szUserSid, squashed_pc );
else
{
if (!(usersid = get_user_sid()))
@ -837,34 +829,38 @@ UINT MSIREG_OpenInstallProps(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPC
ERR("Failed to retrieve user SID\n");
return ERROR_FUNCTION_FAILED;
}
sprintfW(keypath, szInstallProperties_fmt, usersid, squished_pc);
sprintfW( keypath, szInstallProperties_fmt, usersid, squashed_pc );
LocalFree(usersid);
}
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}
UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct)
UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT context)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
LPWSTR usersid;
WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
HKEY hkey;
LONG r;
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
if (!(usersid = get_user_sid()))
if (context == MSIINSTALLCONTEXT_MACHINE)
sprintfW(keypath, szUserDataProducts_fmt, szLocalSid);
else
{
ERR("Failed to retrieve user SID\n");
return ERROR_FUNCTION_FAILED;
if (!(usersid = get_user_sid()))
{
ERR("Failed to retrieve user SID\n");
return ERROR_FUNCTION_FAILED;
}
sprintfW(keypath, szUserDataProducts_fmt, usersid);
LocalFree(usersid);
}
sprintfW(keypath, szUserDataProducts_fmt, usersid);
LocalFree(usersid);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
r = RegDeleteTreeW(hkey, squished_pc);
r = RegDeleteTreeW( hkey, squashed_pc );
RegCloseKey(hkey);
return r;
}
@ -872,15 +868,15 @@ UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct)
UINT MSIREG_DeleteProductKey(LPCWSTR szProduct)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE];
WCHAR squashed_pc[SQUASHED_GUID_SIZE];
HKEY hkey;
LONG r;
if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_Products, 0, access, &hkey)) return ERROR_SUCCESS;
r = RegDeleteTreeW(hkey, squished_pc);
r = RegDeleteTreeW( hkey, squashed_pc );
RegCloseKey(hkey);
return r;
}
@ -888,12 +884,12 @@ UINT MSIREG_DeleteProductKey(LPCWSTR szProduct)
UINT MSIREG_OpenPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szPatch, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szPatch), debugstr_w(squished_pc));
if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
sprintfW(keypath, szInstaller_Patches, squished_pc);
sprintfW( keypath, szInstaller_Patches, squashed_pc );
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
@ -902,13 +898,13 @@ UINT MSIREG_OpenPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
strcpyW(keypath, szInstaller_UpgradeCodes);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_uc );
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
@ -916,42 +912,54 @@ UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
{
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
strcpyW(keypath, szInstaller_UserUpgradeCodes);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_uc );
if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
}
UINT MSIREG_DeleteUpgradeCodesKey( const WCHAR *code )
{
WCHAR squashed_code[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid( code, squashed_code )) return ERROR_FUNCTION_FAILED;
TRACE( "%s squashed %s\n", debugstr_w(code), debugstr_w(squashed_code) );
strcpyW( keypath, szInstaller_UpgradeCodes );
strcatW( keypath, squashed_code );
return RegDeleteTreeW( HKEY_LOCAL_MACHINE, keypath );
}
UINT MSIREG_DeleteUserUpgradeCodesKey(LPCWSTR szUpgradeCode)
{
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
strcpyW(keypath, szInstaller_UserUpgradeCodes);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_uc );
return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}
UINT MSIREG_DeleteLocalClassesProductKey(LPCWSTR szProductCode)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE];
WCHAR squashed_pc[SQUASHED_GUID_SIZE];
HKEY hkey;
LONG r;
if (!squash_guid(szProductCode, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProductCode), debugstr_w(squished_pc));
if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_LocalClassesProducts, 0, access, &hkey)) return ERROR_SUCCESS;
r = RegDeleteTreeW(hkey, squished_pc);
r = RegDeleteTreeW( hkey, squashed_pc );
RegCloseKey(hkey);
return r;
}
@ -959,15 +967,15 @@ UINT MSIREG_DeleteLocalClassesProductKey(LPCWSTR szProductCode)
UINT MSIREG_DeleteLocalClassesFeaturesKey(LPCWSTR szProductCode)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE];
WCHAR squashed_pc[SQUASHED_GUID_SIZE];
HKEY hkey;
LONG r;
if (!squash_guid(szProductCode, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szProductCode), debugstr_w(squished_pc));
if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_LocalClassesFeatures, 0, access, &hkey)) return ERROR_SUCCESS;
r = RegDeleteTreeW(hkey, squished_pc);
r = RegDeleteTreeW( hkey, squashed_pc );
RegCloseKey(hkey);
return r;
}
@ -975,13 +983,13 @@ UINT MSIREG_DeleteLocalClassesFeaturesKey(LPCWSTR szProductCode)
UINT MSIREG_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE], keypath[0x200];
WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
strcpyW(keypath, szInstaller_ClassesUpgradeCode);
strcatW(keypath, squished_pc);
strcatW( keypath, squashed_uc );
if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
@ -990,15 +998,15 @@ UINT MSIREG_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL cr
UINT MSIREG_DeleteClassesUpgradeCodesKey(LPCWSTR szUpgradeCode)
{
REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
WCHAR squished_pc[GUID_SIZE];
WCHAR squashed_uc[SQUASHED_GUID_SIZE];
HKEY hkey;
LONG r;
if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_ClassesUpgradeCodes, 0, access, &hkey)) return ERROR_SUCCESS;
r = RegDeleteTreeW(hkey, squished_pc);
r = RegDeleteTreeW( hkey, squashed_uc );
RegCloseKey(hkey);
return r;
}
@ -1008,7 +1016,8 @@ UINT MSIREG_DeleteClassesUpgradeCodesKey(LPCWSTR szUpgradeCode)
*
* Decomposes an MSI descriptor into product, feature and component parts.
* An MSI descriptor is a string of the form:
* [base 85 guid] [feature code] '>' [base 85 guid]
* [base 85 guid] [feature code] '>' [base 85 guid] or
* [base 85 guid] [feature code] '<'
*
* PARAMS
* szDescriptor [I] the descriptor to decompose
@ -1025,21 +1034,21 @@ UINT MSIREG_DeleteClassesUpgradeCodesKey(LPCWSTR szUpgradeCode)
UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
LPWSTR szFeature, LPWSTR szComponent, LPDWORD pUsed )
{
UINT r, len;
LPWSTR p;
UINT len;
const WCHAR *p;
GUID product, component;
TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
szFeature, szComponent, pUsed);
r = decode_base85_guid( szDescriptor, &product );
if( !r )
if (!decode_base85_guid( szDescriptor, &product ))
return ERROR_INVALID_PARAMETER;
TRACE("product %s\n", debugstr_guid( &product ));
p = strchrW(&szDescriptor[20],'>');
if( !p )
if (!(p = strchrW( &szDescriptor[20], '>' )))
p = strchrW( &szDescriptor[20], '<' );
if (!p)
return ERROR_INVALID_PARAMETER;
len = (p - &szDescriptor[20]);
@ -1048,22 +1057,30 @@ UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
r = decode_base85_guid( p+1, &component );
if( !r )
return ERROR_INVALID_PARAMETER;
TRACE("component %s\n", debugstr_guid( &component ));
if (*p == '>')
{
if (!decode_base85_guid( p+1, &component ))
return ERROR_INVALID_PARAMETER;
TRACE( "component %s\n", debugstr_guid(&component) );
}
if (szProduct)
StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
if (szComponent)
StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
{
if (*p == '>')
StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
else
szComponent[0] = 0;
}
if (szFeature)
{
memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
szFeature[len] = 0;
}
len = ( &p[21] - szDescriptor );
len = p - szDescriptor + 1;
if (*p == '>') len += 20;
TRACE("length = %d\n", len);
if (pUsed) *pUsed = len;
@ -1251,7 +1268,7 @@ static UINT fetch_machine_component( DWORD ctx, DWORD index, DWORD *idx, WCHAR g
'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
'S','-','1','-','5','-','1','8','\\','C','o','m','p','o','n','e','n','t','s',0};
UINT r = ERROR_SUCCESS;
WCHAR component[GUID_SIZE];
WCHAR component[SQUASHED_GUID_SIZE];
DWORD i = 0, len_component;
REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
HKEY key_components;
@ -1300,7 +1317,7 @@ static UINT fetch_user_component( const WCHAR *usersid, DWORD ctx, DWORD index,
'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a',0};
static const WCHAR componentsW[] = {'\\','C','o','m','p','o','n','e','n','t','s',0};
UINT r = ERROR_SUCCESS;
WCHAR path[MAX_PATH], component[GUID_SIZE], user[128];
WCHAR path[MAX_PATH], component[SQUASHED_GUID_SIZE], user[128];
DWORD i = 0, j = 0, len_component, len_user;
REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
HKEY key_users, key_components;
@ -1461,7 +1478,7 @@ UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
{
HKEY hkeyComp = 0;
DWORD r, sz;
WCHAR szValName[SQUISH_GUID_SIZE];
WCHAR szValName[SQUASHED_GUID_SIZE];
TRACE("%s %d %p\n", debugstr_w(szComponent), index, szProduct);
@ -1473,7 +1490,7 @@ UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
return ERROR_UNKNOWN_COMPONENT;
/* see if there are any products at all */
sz = SQUISH_GUID_SIZE;
sz = SQUASHED_GUID_SIZE;
r = RegEnumValueW(hkeyComp, 0, szValName, &sz, NULL, NULL, NULL, NULL);
if (r != ERROR_SUCCESS)
{
@ -1485,7 +1502,7 @@ UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
return ERROR_UNKNOWN_COMPONENT;
}
sz = SQUISH_GUID_SIZE;
sz = SQUASHED_GUID_SIZE;
r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
if( r == ERROR_SUCCESS )
{
@ -1670,8 +1687,8 @@ UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
{
UINT r;
HKEY hkey;
DWORD dwSize = SQUISH_GUID_SIZE;
WCHAR szKeyName[SQUISH_GUID_SIZE];
WCHAR szKeyName[SQUASHED_GUID_SIZE];
DWORD dwSize = sizeof(szKeyName)/sizeof(szKeyName[0]);
TRACE("%s %u %u %p\n", debugstr_w(szUpgradeCode), dwReserved,
iProductIndex, lpProductBuf);
@ -2082,7 +2099,7 @@ UINT WINAPI MsiEnumPatchesExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
LPWSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
LPWSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
{
WCHAR squished_pc[GUID_SIZE];
WCHAR squashed_pc[SQUASHED_GUID_SIZE];
DWORD idx = 0;
UINT r;
@ -2093,7 +2110,7 @@ UINT WINAPI MsiEnumPatchesExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
szTargetUserSid, pcchTargetUserSid);
if (!szProductCode || !squash_guid(szProductCode, squished_pc))
if (!szProductCode || !squash_guid( szProductCode, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (szUserSid && !strcmpW( szUserSid, szLocalSid ))
@ -2189,8 +2206,7 @@ done:
UINT WINAPI MsiEnumPatchesW(LPCWSTR szProduct, DWORD iPatchIndex,
LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
{
WCHAR squished_pc[GUID_SIZE];
LPWSTR transforms = NULL;
WCHAR *transforms = NULL, squashed_pc[SQUASHED_GUID_SIZE];
HKEY prod;
DWORD idx = 0;
UINT r;
@ -2198,7 +2214,7 @@ UINT WINAPI MsiEnumPatchesW(LPCWSTR szProduct, DWORD iPatchIndex,
TRACE("(%s %d %p %p %p)\n", debugstr_w(szProduct), iPatchIndex,
lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (!lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
@ -2279,7 +2295,7 @@ static UINT fetch_machine_product( const WCHAR *match, DWORD index, DWORD *idx,
{'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
UINT r;
WCHAR product[GUID_SIZE];
WCHAR product[SQUASHED_GUID_SIZE];
DWORD i = 0, len;
REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
HKEY key;
@ -2340,7 +2356,7 @@ static UINT fetch_user_product( const WCHAR *match, const WCHAR *usersid, DWORD
'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
UINT r;
const WCHAR *subkey;
WCHAR path[MAX_PATH], product[GUID_SIZE], user[128];
WCHAR path[MAX_PATH], product[SQUASHED_GUID_SIZE], user[128];
DWORD i = 0, j = 0, len_product, len_user;
REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
HKEY key_users, key_products;

90
reactos/dll/win32/msi/source.c
View file

@ -191,27 +191,20 @@ UINT WINAPI MsiSourceListEnumMediaDisksW(LPCWSTR szProductCodeOrPatchCode,
LPWSTR szVolumeLabel, LPDWORD pcchVolumeLabel,
LPWSTR szDiskPrompt, LPDWORD pcchDiskPrompt)
{
WCHAR squished_pc[GUID_SIZE];
WCHAR convert[11];
LPWSTR value = NULL;
LPWSTR data = NULL;
LPWSTR ptr, ptr2;
static const WCHAR fmt[] = {'#','%','d',0};
WCHAR squashed_pc[SQUASHED_GUID_SIZE], convert[11];
WCHAR *value = NULL, *data = NULL, *ptr, *ptr2;
HKEY source, media;
DWORD valuesz, datasz = 0;
DWORD type;
DWORD numvals, size;
DWORD valuesz, datasz = 0, type, numvals, size;
LONG res;
UINT r;
static DWORD index = 0;
static const WCHAR fmt[] = {'#','%','d',0};
TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p)\n", debugstr_w(szProductCodeOrPatchCode),
debugstr_w(szUserSid), dwContext, dwOptions, dwIndex, szVolumeLabel,
pcchVolumeLabel, szDiskPrompt, pcchDiskPrompt);
if (!szProductCodeOrPatchCode ||
!squash_guid(szProductCodeOrPatchCode, squished_pc))
if (!szProductCodeOrPatchCode || !squash_guid( szProductCodeOrPatchCode, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
@ -229,8 +222,7 @@ UINT WINAPI MsiSourceListEnumMediaDisksW(LPCWSTR szProductCodeOrPatchCode,
if (dwIndex != index)
return ERROR_INVALID_PARAMETER;
r = OpenSourceKey(szProductCodeOrPatchCode, &source,
dwOptions, dwContext, FALSE);
r = OpenSourceKey(szProductCodeOrPatchCode, &source, dwOptions, dwContext, FALSE);
if (r != ERROR_SUCCESS)
return r;
@ -403,23 +395,20 @@ UINT WINAPI MsiSourceListEnumSourcesW(LPCWSTR szProductCodeOrPatch, LPCWSTR szUs
DWORD dwOptions, DWORD dwIndex,
LPWSTR szSource, LPDWORD pcchSource)
{
WCHAR squished_pc[GUID_SIZE];
WCHAR name[32];
HKEY source = NULL;
HKEY subkey = NULL;
static const WCHAR format[] = {'%','d',0};
WCHAR squashed_pc[SQUASHED_GUID_SIZE], name[32];
HKEY source = NULL, subkey = NULL;
LONG res;
UINT r = ERROR_INVALID_PARAMETER;
static DWORD index = 0;
static const WCHAR format[] = {'%','d',0};
TRACE("(%s, %s, %d, %d, %d, %p, %p)\n", debugstr_w(szProductCodeOrPatch),
debugstr_w(szUserSid), dwContext, dwOptions, dwIndex, szSource, pcchSource);
if (dwIndex == 0)
index = 0;
if (!szProductCodeOrPatch || !squash_guid(szProductCodeOrPatch, squished_pc))
if (!szProductCodeOrPatch || !squash_guid( szProductCodeOrPatch, squashed_pc ))
goto done;
if (szSource && !pcchSource)
@ -437,8 +426,7 @@ UINT WINAPI MsiSourceListEnumSourcesW(LPCWSTR szProductCodeOrPatch, LPCWSTR szUs
if (dwIndex != index)
goto done;
r = OpenSourceKey(szProductCodeOrPatch, &source,
dwOptions, dwContext, FALSE);
r = OpenSourceKey( szProductCodeOrPatch, &source, dwOptions, dwContext, FALSE );
if (r != ERROR_SUCCESS)
goto done;
@ -534,18 +522,15 @@ UINT WINAPI MsiSourceListGetInfoW( LPCWSTR szProduct, LPCWSTR szUserSid,
LPCWSTR szProperty, LPWSTR szValue,
LPDWORD pcchValue)
{
WCHAR squished_pc[GUID_SIZE];
static const WCHAR mediapack[] = {'M','e','d','i','a','P','a','c','k','a','g','e',0};
WCHAR *source, *ptr, squashed_pc[SQUASHED_GUID_SIZE];
HKEY sourcekey, media;
LPWSTR source, ptr;
DWORD size;
UINT rc;
static const WCHAR mediapack[] = {
'M','e','d','i','a','P','a','c','k','a','g','e',0};
TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szProperty));
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (szValue && !pcchValue)
@ -761,19 +746,16 @@ UINT WINAPI MsiSourceListSetInfoW( LPCWSTR szProduct, LPCWSTR szUserSid,
MSIINSTALLCONTEXT dwContext, DWORD dwOptions,
LPCWSTR szProperty, LPCWSTR szValue)
{
WCHAR squished_pc[GUID_SIZE];
static const WCHAR media_package[] = {'M','e','d','i','a','P','a','c','k','a','g','e',0};
WCHAR squashed_pc[SQUASHED_GUID_SIZE];
HKEY sourcekey, media;
LPCWSTR property;
UINT rc;
static const WCHAR media_package[] = {
'M','e','d','i','a','P','a','c','k','a','g','e',0
};
TRACE("%s %s %x %x %s %s\n", debugstr_w(szProduct), debugstr_w(szUserSid),
dwContext, dwOptions, debugstr_w(szProperty), debugstr_w(szValue));
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (!szProperty)
@ -845,12 +827,9 @@ UINT WINAPI MsiSourceListSetInfoW( LPCWSTR szProduct, LPCWSTR szUserSid,
UINT WINAPI MsiSourceListAddSourceW( LPCWSTR szProduct, LPCWSTR szUserName,
DWORD dwReserved, LPCWSTR szSource)
{
WCHAR squished_pc[GUID_SIZE];
WCHAR *sidstr = NULL, squashed_pc[SQUASHED_GUID_SIZE];
INT ret;
LPWSTR sidstr = NULL;
DWORD sidsize = 0;
DWORD domsize = 0;
DWORD context;
DWORD sidsize = 0, domsize = 0, context;
HKEY hkey = 0;
UINT r;
@ -862,7 +841,7 @@ UINT WINAPI MsiSourceListAddSourceW( LPCWSTR szProduct, LPCWSTR szUserName,
if (dwReserved != 0)
return ERROR_INVALID_PARAMETER;
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (!szUserName || !*szUserName)
@ -1056,24 +1035,19 @@ UINT WINAPI MsiSourceListAddSourceExW( LPCWSTR szProduct, LPCWSTR szUserSid,
MSIINSTALLCONTEXT dwContext, DWORD dwOptions, LPCWSTR szSource,
DWORD dwIndex)
{
HKEY sourcekey;
HKEY typekey;
static const WCHAR fmt[] = {'%','i',0};
HKEY sourcekey, typekey;
UINT rc;
struct list sourcelist;
media_info *info;
WCHAR squished_pc[GUID_SIZE];
WCHAR name[10];
LPWSTR source;
WCHAR *source, squashed_pc[SQUASHED_GUID_SIZE], name[10];
LPCWSTR postfix;
DWORD size, count;
DWORD index;
static const WCHAR fmt[] = {'%','i',0};
DWORD size, count, index;
TRACE("%s %s %x %x %s %i\n", debugstr_w(szProduct), debugstr_w(szUserSid),
dwContext, dwOptions, debugstr_w(szSource), dwIndex);
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (!szSource || !*szSource)
@ -1215,21 +1189,17 @@ UINT WINAPI MsiSourceListAddMediaDiskW(LPCWSTR szProduct, LPCWSTR szUserSid,
MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId,
LPCWSTR szVolumeLabel, LPCWSTR szDiskPrompt)
{
HKEY sourcekey;
HKEY mediakey;
UINT rc;
WCHAR szIndex[10];
WCHAR squished_pc[GUID_SIZE];
LPWSTR buffer;
DWORD size;
static const WCHAR fmt[] = {'%','i',0};
HKEY sourcekey, mediakey;
UINT rc;
WCHAR *buffer, squashed_pc[SQUASHED_GUID_SIZE], szIndex[10];
DWORD size;
TRACE("%s %s %x %x %i %s %s\n", debugstr_w(szProduct),
debugstr_w(szUserSid), dwContext, dwOptions, dwDiskId,
debugstr_w(szVolumeLabel), debugstr_w(szDiskPrompt));
if (!szProduct || !squash_guid(szProduct, squished_pc))
if (!szProduct || !squash_guid( szProduct, squashed_pc ))
return ERROR_INVALID_PARAMETER;
if (dwOptions != MSICODE_PRODUCT && dwOptions != MSICODE_PATCH)

16
reactos/dll/win32/msi/table.c
View file

@ -2721,7 +2721,7 @@ UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
IEnumSTATSTG *stgenum = NULL;
TRANSFORMDATA *transform;
TRANSFORMDATA *tables = NULL, *columns = NULL;
HRESULT r;
HRESULT hr;
STATSTG stat;
string_table *strings;
UINT ret = ERROR_FUNCTION_FAILED;
@ -2734,8 +2734,8 @@ UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
if( !strings )
goto end;
r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
if( FAILED( r ) )
hr = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
if (FAILED( hr ))
goto end;
list_init(&transforms);
@ -2746,8 +2746,8 @@ UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
WCHAR name[0x40];
ULONG count = 0;
r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
if ( FAILED( r ) || !count )
hr = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
if (FAILED( hr ) || !count)
break;
decode_streamname( stat.pwcsName, name );
@ -2777,12 +2777,10 @@ UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
TRACE("transform contains stream %s\n", debugstr_w(name));
/* load the table */
r = TABLE_CreateView( db, transform->name, (MSIVIEW**) &tv );
if( r != ERROR_SUCCESS )
if (TABLE_CreateView( db, transform->name, (MSIVIEW**) &tv ) != ERROR_SUCCESS)
continue;
r = tv->view.ops->execute( &tv->view, NULL );
if( r != ERROR_SUCCESS )
if (tv->view.ops->execute( &tv->view, NULL ) != ERROR_SUCCESS)
{
tv->view.ops->delete( &tv->view );
continue;

6
reactos/dll/win32/msi/upgrade.c
View file

@ -92,10 +92,8 @@ static void append_productcode(MSIPACKAGE* package, LPCWSTR action_property,
static UINT ITERATE_FindRelatedProducts(MSIRECORD *rec, LPVOID param)
{
MSIPACKAGE *package = param;
WCHAR product[GUID_SIZE];
DWORD index = 0;
DWORD attributes = 0;
DWORD sz = GUID_SIZE;
WCHAR product[SQUASHED_GUID_SIZE];
DWORD index = 0, attributes = 0, sz = sizeof(product)/sizeof(product[0]);
LPCWSTR upgrade_code;
HKEY hkey = 0;
UINT rc = ERROR_SUCCESS;

2
reactos/media/doc/README.WINE
View file

@ -112,7 +112,7 @@ reactos/dll/win32/msg711.acm # Synced to WineStaging-1.9.11
reactos/dll/win32/msgsm32.acm # Synced to WineStaging-1.9.11
reactos/dll/win32/mshtml # Synced to WineStaging-1.7.55
reactos/dll/win32/mshtml.tlb # Synced to WineStaging-1.7.55
reactos/dll/win32/msi # Synced to WineStaging-1.9.16
reactos/dll/win32/msi # Synced to WineStaging-1.9.23
reactos/dll/win32/msimg32 # Synced to WineStaging-1.9.11
reactos/dll/win32/msimtf # Synced to WineStaging-1.9.23
reactos/dll/win32/msisip # Synced to WineStaging-1.9.11