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

Author: akhaldi
Date: Tue Nov 22 12:25:27 2016
New Revision: 73339

URL: http://svn.reactos.org/svn/reactos?rev=73339&view=rev
Log:
[MSI] Sync with Wine Staging 1.9.23. CORE-12409

Modified:
    trunk/reactos/dll/win32/msi/action.c
    trunk/reactos/dll/win32/msi/automation.c
    trunk/reactos/dll/win32/msi/database.c
    trunk/reactos/dll/win32/msi/msi.c
    trunk/reactos/dll/win32/msi/msipriv.h
    trunk/reactos/dll/win32/msi/package.c
    trunk/reactos/dll/win32/msi/record.c
    trunk/reactos/dll/win32/msi/registry.c
    trunk/reactos/dll/win32/msi/source.c
    trunk/reactos/dll/win32/msi/table.c
    trunk/reactos/dll/win32/msi/upgrade.c
    trunk/reactos/media/doc/README.WINE

Modified: trunk/reactos/dll/win32/msi/action.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/action.c?rev…
==============================================================================
--- trunk/reactos/dll/win32/msi/action.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/action.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -129,6 +129,8 @@
    
{'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 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 @@
         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 @@
         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 @@
                 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 @@
                 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 @@
                     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_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 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 @@
 {
     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 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 @@
     return ERROR_SUCCESS;
 }
 
-static UINT msi_unpublish_product( MSIPACKAGE *package, const WCHAR *remove )
-{
-    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;
+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)
+{
     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 @@
     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 @@
     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 @@
     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 @@
     '/','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);
-
-    msi_reg_set_val_str( hkey, squished_pc, buffer );
+    snprintfW( buffer, sizeof(buffer)/sizeof(buffer[0]), msiexec_fmt, sysdir, squashed_pc
);
+
+    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);
-
-    msi_reg_set_val_str( hkey, squished_pc, buffer );
+    sprintfW( buffer, install_fmt, package->ProductCode, squashed_pc );
+
+    msi_reg_set_val_str( hkey, squashed_pc, buffer );
     RegCloseKey(hkey);
 
     return ERROR_INSTALL_SUSPEND;
@@ -5524,7 +5552,7 @@
 
     if (msi_check_unpublish(package))
     {
-        MSIREG_DeleteUserDataProductKey(package->ProductCode);
+        MSIREG_DeleteUserDataProductKey(package->ProductCode, package->Context);
         goto end;
     }
 
@@ -7391,7 +7419,8 @@
 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 @@
     { 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 @@
     { 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
},

Modified: trunk/reactos/dll/win32/msi/automation.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/automation.c…
==============================================================================
--- trunk/reactos/dll/win32/msi/automation.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/automation.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -273,7 +273,8 @@
     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 @@
     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 @@
         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 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 @@
         EXCEPINFO* pExcepInfo,
         UINT* puArgErr)
 {
-    SessionObject *session = (SessionObject*)This;
+    SessionObject *session = CONTAINING_RECORD(This, SessionObject, autoobj);
     WCHAR *szString;
     DWORD dwLen = 0;
     MSIHANDLE msiHandle;

Modified: trunk/reactos/dll/win32/msi/database.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/database.c?r…
==============================================================================
--- trunk/reactos/dll/win32/msi/database.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/database.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -549,7 +549,7 @@
 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 @@
 
     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 ', ' */

Modified: trunk/reactos/dll/win32/msi/msi.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/msi.c?rev=73…
==============================================================================
--- trunk/reactos/dll/win32/msi/msi.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/msi.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -123,10 +123,10 @@
 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 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 @@
         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 @@
     }
 
     /* 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 @@
     }
 
     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 @@
 
 done:
     RegCloseKey(compkey);
-    unsquash_guid(squished_prod, szBuffer);
+    unsquash_guid( squashed_prod, szBuffer );
     return rc;
 }
 
@@ -1085,9 +1084,7 @@
     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 @@
     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 @@
         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 @@
                                  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 @@
     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 @@
                                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))
-        return ERROR_INVALID_PARAMETER;
-
-    if (!szPatchCode || !squash_guid(szPatchCode, squished_patch))
+    if (!szProductCode || !squash_guid( szProductCode, squashed_pc ))
+        return ERROR_INVALID_PARAMETER;
+
+    if (!szPatchCode || !squash_guid( szPatchCode, squashed_patch ))
         return ERROR_INVALID_PARAMETER;
 
     if (!szProperty)
@@ -1704,7 +1694,7 @@
     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 @@
             goto done;
 
         datakey = prodpatches;
-        szProperty = squished_patch;
+        szProperty = squashed_patch;
     }
     else
     {
@@ -2115,7 +2105,7 @@
     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 @@
     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 @@
                                     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 @@
     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 @@
     *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 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 @@
 
     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 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 @@
     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 @@
     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 @@
             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 @@
     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 @@
                 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;
-
-    info = msi_reg_get_val_str( hkey, szQualifier );
+    if (MSIREG_OpenUserComponentsKey( szComponent, &hkey, FALSE )) return
ERROR_UNKNOWN_COMPONENT;
+
+    desc = reg_get_multisz( hkey, szQualifier );
     RegCloseKey(hkey);
-
-    if (!info)
-        return ERROR_INDEX_ABSENT;
-
-    MsiDecomposeDescriptorW(info, product, feature, component, &sz);
-
-    if (!szProduct)
-        state = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
-    else
-        state = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
-
-    msi_free( info );
-
-    if (state == INSTALLSTATE_MOREDATA)
-        return ERROR_MORE_DATA;
-
-    if (state != INSTALLSTATE_LOCAL)
-        return ERROR_FILE_NOT_FOUND;
-
+    if (!desc) return ERROR_INDEX_ABSENT;
+
+    /* FIXME: handle multiple descriptors */
+    ret = MsiDecomposeDescriptorW( desc, product, feature, comp, &size );
+    msi_free( desc );
+    if (ret != ERROR_SUCCESS) return ret;
+
+    if (!szProduct) szProduct = product;
+    if (!comp[0])
+    {
+        MSIINSTALLCONTEXT ctx;
+        WCHAR *components;
+        GUID guid;
+
+        /* 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;
+
+        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]) );
+    }
+
+    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 @@
                 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 @@
           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,

Modified: trunk/reactos/dll/win32/msi/msipriv.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/msipriv.h?re…
==============================================================================
--- trunk/reactos/dll/win32/msi/msipriv.h	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/msipriv.h	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -727,7 +727,7 @@
 #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_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 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 */

Modified: trunk/reactos/dll/win32/msi/package.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/package.c?re…
==============================================================================
--- trunk/reactos/dll/win32/msi/package.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/package.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -1170,7 +1170,7 @@
     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;

Modified: trunk/reactos/dll/win32/msi/record.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/record.c?rev…
==============================================================================
--- trunk/reactos/dll/win32/msi/record.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/record.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -707,7 +707,8 @@
 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 @@
             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);

Modified: trunk/reactos/dll/win32/msi/registry.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/registry.c?r…
==============================================================================
--- trunk/reactos/dll/win32/msi/registry.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/registry.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -475,24 +475,23 @@
 
 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];
-
-    if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
+    WCHAR *usersid = NULL, squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH];
+
+    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 @@
             }
             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_DeleteUserProductKey(LPCWSTR szProduct)
 {
-    WCHAR squished_pc[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));
+    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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];
-
-    if (!squash_guid(szPatch, squished_pc)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szPatch), debugstr_w(squished_pc));
+    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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 @@
 {
     HKEY root = HKEY_LOCAL_MACHINE;
     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
-    WCHAR squished_pc[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));
+    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH], *usersid = NULL;
+
+    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 @@
             }
             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_DeleteUserFeaturesKey(LPCWSTR szProduct)
 {
-    WCHAR squished_pc[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));
+    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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];
-
-    if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
+    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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 @@
                                     HKEY *key, BOOL create)
 {
     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
-    WCHAR squished_pc[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));
+    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200], *usersid = NULL;
+
+    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 @@
             }
             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_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;
-
-    if (!squash_guid(szComponent, comp)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szComponent), debugstr_w(comp));
+    WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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 @@
             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_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 @@
         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_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;
-
-    if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
+    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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 @@
             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_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;
-
-    if (!squash_guid(szPatch, squished_patch)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szPatch),
debugstr_w(squished_patch));
+    WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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 @@
             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_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 @@
         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_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;
-
-    if (!squash_guid(product, squished_product)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(product),
debugstr_w(squished_product));
+    WCHAR *usersid, squashed_product[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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 @@
             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_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];
-
-    if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
+    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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 @@
             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 (!(usersid = get_user_sid()))
-    {
-        ERR("Failed to retrieve user SID\n");
-        return ERROR_FUNCTION_FAILED;
-    }
-    sprintfW(keypath, szUserDataProducts_fmt, usersid);
-    LocalFree(usersid);
+    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, szUserDataProducts_fmt, szLocalSid);
+    else
+    {
+        if (!(usersid = get_user_sid()))
+        {
+            ERR("Failed to retrieve user SID\n");
+            return ERROR_FUNCTION_FAILED;
+        }
+        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_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_OpenPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
 {
     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
-    WCHAR squished_pc[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));
-
-    sprintfW(keypath, szInstaller_Patches, squished_pc);
+    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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, 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_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
 {
     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
-    WCHAR squished_pc[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));
+    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
 {
-    WCHAR squished_pc[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));
+    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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];
-
-    if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
-    TRACE("%s squished %s\n", debugstr_w(szUpgradeCode),
debugstr_w(squished_pc));
+    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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_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_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
 {
     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
-    WCHAR squished_pc[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));
+    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
+
+    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_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 @@
  *
  * 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 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 @@
 
     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 @@
         
'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 @@
         
'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 @@
 {
     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 @@
         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 @@
         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 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 @@
         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 @@
           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 @@
 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 @@
     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 @@
        
{'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 @@
         
'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;

Modified: trunk/reactos/dll/win32/msi/source.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/source.c?rev…
==============================================================================
--- trunk/reactos/dll/win32/msi/source.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/source.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -191,27 +191,20 @@
                                          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 @@
     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 @@
                                       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 @@
     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 @@
                                    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 @@
                                    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 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 @@
     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 @@
         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 @@
         MSIINSTALLCONTEXT dwContext, DWORD dwOptions, DWORD dwDiskId, 
         LPCWSTR szVolumeLabel, LPCWSTR szDiskPrompt)
 {
-    HKEY sourcekey;
-    HKEY mediakey;
+    static const WCHAR fmt[] = {'%','i',0};
+    HKEY sourcekey, mediakey;
     UINT rc;
-    WCHAR szIndex[10];
-    WCHAR squished_pc[GUID_SIZE];
-    LPWSTR buffer;
+    WCHAR *buffer, squashed_pc[SQUASHED_GUID_SIZE], szIndex[10];
     DWORD size;
-
-    static const WCHAR fmt[] = {'%','i',0};
 
     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)

Modified: trunk/reactos/dll/win32/msi/table.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/table.c?rev=…
==============================================================================
--- trunk/reactos/dll/win32/msi/table.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/table.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -2721,7 +2721,7 @@
     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 @@
     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 @@
         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 @@
         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;

Modified: trunk/reactos/dll/win32/msi/upgrade.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msi/upgrade.c?re…
==============================================================================
--- trunk/reactos/dll/win32/msi/upgrade.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/msi/upgrade.c	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -92,10 +92,8 @@
 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;

Modified: trunk/reactos/media/doc/README.WINE
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/media/doc/README.WINE?rev=…
==============================================================================
--- trunk/reactos/media/doc/README.WINE	[iso-8859-1] (original)
+++ trunk/reactos/media/doc/README.WINE	[iso-8859-1] Tue Nov 22 12:25:27 2016
@@ -112,7 +112,7 @@
 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