reactos/dll/win32/msi/registry.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  * Copyright 2005 Aric Stewart for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25 #define NONAMELESSUNION
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winreg.h"
  30 #include "winnls.h"
  31 #include "shlwapi.h"
  32 #include "wine/debug.h"
  33 #include "msi.h"
  34 #include "msipriv.h"
  35 #include "wincrypt.h"
  36 #include "wine/unicode.h"
  37 #include "winver.h"
  38 #include "winuser.h"
  39 #include "sddl.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  42
  43 /*
  44  * This module will be all the helper functions for registry access by the
  45  * installer bits.
  46  */
  47
  48 static const WCHAR szUserDataFeatures_fmt[] = {
  49     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  50     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  51     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  52     '%','s','\\','P','r','o','d','u','c','t','s','\\','%','s','\\','F','e','a','t','u','r','e','s',0};
  53
  54 static const WCHAR szUserDataComp_fmt[] = {
  55     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  56     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  57     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  58     '%','s','\\','C','o','m','p','o','n','e','n','t','s','\\','%','s',0};
  59
  60 static const WCHAR szUserDataComponents_fmt[] = {
  61     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  62     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  63     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  64     '%','s','\\','C','o','m','p','o','n','e','n','t','s',0};
  65
  66 static const WCHAR szUserDataProd_fmt[] = {
  67     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  68     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  69     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  70     '%','s','\\','P','r','o','d','u','c','t','s','\\','%','s',0};
  71
  72 static const WCHAR szUserDataProducts_fmt[] = {
  73     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  74     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  75     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  76     '%','s','\\','P','r','o','d','u','c','t','s',0};
  77
  78 static const WCHAR szUserDataPatch_fmt[] = {
  79     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  80     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  81     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  82     '%','s','\\','P','a','t','c','h','e','s','\\','%','s',0};
  83
  84 static const WCHAR szUserDataPatches_fmt[] = {
  85     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  86     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  87     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  88     '%','s','\\','P','a','t','c','h','e','s',0};
  89
  90 static const WCHAR szUserDataProductPatches_fmt[] = {
  91     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  92     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  93     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
  94     '%','s','\\','P','r','o','d','u','c','t','s','\\','%','s','\\','P','a','t','c','h','e','s',0};
  95
  96 static const WCHAR szInstallProperties_fmt[] = {
  97     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
  98     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  99     'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
 100     '%','s','\\','P','r','o','d','u','c','t','s','\\','%','s','\\',
 101     'I','n','s','t','a','l','l','P','r','o','p','e','r','t','i','e','s',0};
 102
 103 static const WCHAR szInstaller_LocalManaged_fmt[] = {
 104     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 105     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 106     'I','n','s','t','a','l','l','e','r','\\','M','a','n','a','g','e','d','\\','%','s','\\',
 107     'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
 108
 109 static const WCHAR szInstaller_LocalManagedProd_fmt[] = {
 110     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 111     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 112     'I','n','s','t','a','l','l','e','r','\\','M','a','n','a','g','e','d','\\','%','s','\\',
 113     'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s','\\','%','s',0};
 114
 115 static const WCHAR szInstaller_LocalManagedFeat_fmt[] = {
 116     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 117     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 118     'I','n','s','t','a','l','l','e','r','\\','M','a','n','a','g','e','d','\\','%','s','\\',
 119     'I','n','s','t','a','l','l','e','r','\\','F','e','a','t','u','r','e','s','\\','%','s',0};
 120
 121 static const WCHAR szInstaller_Products[] = {
 122     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 123     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 124     'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
 125
 126 static const WCHAR szInstaller_Patches[] = {
 127     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 128     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 129     'I','n','s','t','a','l','l','e','r','\\','P','a','t','c','h','e','s',0};
 130
 131 static const WCHAR szInstaller_Components[] = {
 132     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 133     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 134     'I','n','s','t','a','l','l','e','r','\\','C','o','m','p','o','n','e','n','t','s',0};
 135
 136 static const WCHAR szInstaller_LocalClassesProducts[] = {
 137     'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
 138     'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
 139
 140 static const WCHAR szInstaller_LocalClassesFeatures[] = {
 141     'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
 142     'I','n','s','t','a','l','l','e','r','\\','F','e','a','t','u','r','e','s',0};
 143
 144 static const WCHAR szInstaller_LocalClassesProd[] = {
 145     'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
 146     'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s','\\',0};
 147
 148 static const WCHAR szInstaller_LocalClassesFeat[] = {
 149     'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
 150     'I','n','s','t','a','l','l','e','r','\\','F','e','a','t','u','r','e','s','\\',0};
 151
 152 static const WCHAR szInstaller_ClassesUpgradeCode[] = {
 153     'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
 154     'I','n','s','t','a','l','l','e','r','\\','U','p','g','r','a','d','e','C','o','d','e','s','\\',0};
 155
 156 static const WCHAR szInstaller_ClassesUpgradeCodes[] = {
 157     'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
 158     'I','n','s','t','a','l','l','e','r','\\','U','p','g','r','a','d','e','C','o','d','e','s',0};
 159
 160 static const WCHAR szInstaller_Features[] = {
 161     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 162     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 163     'I','n','s','t','a','l','l','e','r','\\','F','e','a','t','u','r','e','s','\\',0};
 164
 165 static const WCHAR szInstaller_UpgradeCodes[] = {
 166     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 167     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 168     'I','n','s','t','a','l','l','e','r','\\','U','p','g','r','a','d','e','C','o','d','e','s','\\',0};
 169
 170 static const WCHAR szInstaller_UserUpgradeCodes[] = {
 171     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 172     'I','n','s','t','a','l','l','e','r','\\','U','p','g','r','a','d','e','C','o','d','e','s','\\',0};
 173
 174 static const WCHAR szUninstall[] = {
 175     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 176     'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 177     'U','n','i','n','s','t','a','l','l','\\',0};
 178
 179 static const WCHAR szUninstall_32node[] = {
 180     'S','o','f','t','w','a','r','e','\\','W','o','w','6','4','3','2','N','o','d','e','\\',
 181     'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
 182     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','U','n','i','n','s','t','a','l','l','\\',0};
 183
 184 static const WCHAR szUserComponents[] = {
 185     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 186     'I','n','s','t','a','l','l','e','r','\\','C','o','m','p','o','n','e','n','t','s','\\',0};
 187
 188 static const WCHAR szUserFeatures[] = {
 189     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 190     'I','n','s','t','a','l','l','e','r','\\','F','e','a','t','u','r','e','s','\\',0};
 191
 192 static const WCHAR szUserProducts[] = {
 193     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 194     'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s','\\',0};
 195
 196 static const WCHAR szUserPatches[] = {
 197     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 198     'I','n','s','t','a','l','l','e','r','\\','P','a','t','c','h','e','s','\\',0};
 199
 200 BOOL unsquash_guid(LPCWSTR in, LPWSTR out)
 201 {
 202     DWORD i,n=0;
 203
 204     if (lstrlenW(in) != 32)
 205         return FALSE;
 206
 207     out[n++]='{';
 208     for(i=0; i<8; i++)
 209         out[n++] = in[7-i];
 210     out[n++]='-';
 211     for(i=0; i<4; i++)
 212         out[n++] = in[11-i];
 213     out[n++]='-';
 214     for(i=0; i<4; i++)
 215         out[n++] = in[15-i];
 216     out[n++]='-';
 217     for(i=0; i<2; i++)
 218     {
 219         out[n++] = in[17+i*2];
 220         out[n++] = in[16+i*2];
 221     }
 222     out[n++]='-';
 223     for( ; i<8; i++)
 224     {
 225         out[n++] = in[17+i*2];
 226         out[n++] = in[16+i*2];
 227     }
 228     out[n++]='}';
 229     out[n]=0;
 230     return TRUE;
 231 }
 232
 233 BOOL squash_guid(LPCWSTR in, LPWSTR out)
 234 {
 235     DWORD i,n=1;
 236     GUID guid;
 237
 238     out[0] = 0;
 239
 240     if (FAILED(CLSIDFromString((LPCOLESTR)in, &guid)))
 241         return FALSE;
 242
 243     for(i=0; i<8; i++)
 244         out[7-i] = in[n++];
 245     n++;
 246     for(i=0; i<4; i++)
 247         out[11-i] = in[n++];
 248     n++;
 249     for(i=0; i<4; i++)
 250         out[15-i] = in[n++];
 251     n++;
 252     for(i=0; i<2; i++)
 253     {
 254         out[17+i*2] = in[n++];
 255         out[16+i*2] = in[n++];
 256     }
 257     n++;
 258     for( ; i<8; i++)
 259     {
 260         out[17+i*2] = in[n++];
 261         out[16+i*2] = in[n++];
 262     }
 263     out[32]=0;
 264     return TRUE;
 265 }
 266
 267
 268 /* tables for encoding and decoding base85 */
 269 static const unsigned char table_dec85[0x80] = {
 270 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 271 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 272 0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
 273 0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
 274 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
 275 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
 276 0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
 277 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
 278 };
 279
 280 static const char table_enc85[] =
 281 "!$%&'()*+,-.0123456789=?@ABCDEFGHIJKLMNO"
 282 "PQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwx"
 283 "yz{}~";
 284
 285 /*
 286  *  Converts a base85 encoded guid into a GUID pointer
 287  *  Base85 encoded GUIDs should be 20 characters long.
 288  *
 289  *  returns TRUE if successful, FALSE if not
 290  */
 291 BOOL decode_base85_guid( LPCWSTR str, GUID *guid )
 292 {
 293     DWORD i, val = 0, base = 1, *p;
 294
 295     if (!str)
 296         return FALSE;
 297
 298     p = (DWORD*) guid;
 299     for( i=0; i<20; i++ )
 300     {
 301         if( (i%5) == 0 )
 302         {
 303             val = 0;
 304             base = 1;
 305         }
 306         val += table_dec85[str[i]] * base;
 307         if( str[i] >= 0x80 )
 308             return FALSE;
 309         if( table_dec85[str[i]] == 0xff )
 310             return FALSE;
 311         if( (i%5) == 4 )
 312             p[i/5] = val;
 313         base *= 85;
 314     }
 315     return TRUE;
 316 }
 317
 318 /*
 319  *  Encodes a base85 guid given a GUID pointer
 320  *  Caller should provide a 21 character buffer for the encoded string.
 321  *
 322  *  returns TRUE if successful, FALSE if not
 323  */
 324 BOOL encode_base85_guid( GUID *guid, LPWSTR str )
 325 {
 326     unsigned int x, *p, i;
 327
 328     p = (unsigned int*) guid;
 329     for( i=0; i<4; i++ )
 330     {
 331         x = p[i];
 332         *str++ = table_enc85[x%85];
 333         x = x/85;
 334         *str++ = table_enc85[x%85];
 335         x = x/85;
 336         *str++ = table_enc85[x%85];
 337         x = x/85;
 338         *str++ = table_enc85[x%85];
 339         x = x/85;
 340         *str++ = table_enc85[x%85];
 341     }
 342     *str = 0;
 343
 344     return TRUE;
 345 }
 346
 347 DWORD msi_version_str_to_dword(LPCWSTR p)
 348 {
 349     DWORD major, minor = 0, build = 0, version = 0;
 350
 351     if (!p)
 352         return version;
 353
 354     major = atoiW(p);
 355
 356     p = strchrW(p, '.');
 357     if (p)
 358     {
 359         minor = atoiW(p+1);
 360         p = strchrW(p+1, '.');
 361         if (p)
 362             build = atoiW(p+1);
 363     }
 364
 365     return MAKELONG(build, MAKEWORD(minor, major));
 366 }
 367
 368 LONG msi_reg_set_val_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
 369 {
 370     DWORD len;
 371     if (!value) value = szEmpty;
 372     len = (lstrlenW(value) + 1) * sizeof (WCHAR);
 373     return RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)value, len );
 374 }
 375
 376 LONG msi_reg_set_val_multi_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
 377 {
 378     LPCWSTR p = value;
 379     while (*p) p += lstrlenW(p) + 1;
 380     return RegSetValueExW( hkey, name, 0, REG_MULTI_SZ,
 381                            (const BYTE *)value, (p + 1 - value) * sizeof(WCHAR) );
 382 }
 383
 384 LONG msi_reg_set_val_dword( HKEY hkey, LPCWSTR name, DWORD val )
 385 {
 386     return RegSetValueExW( hkey, name, 0, REG_DWORD, (LPBYTE)&val, sizeof (DWORD) );
 387 }
 388
 389 LONG msi_reg_set_subkey_val( HKEY hkey, LPCWSTR path, LPCWSTR name, LPCWSTR val )
 390 {
 391     HKEY hsubkey = 0;
 392     LONG r;
 393
 394     r = RegCreateKeyW( hkey, path, &hsubkey );
 395     if (r != ERROR_SUCCESS)
 396         return r;
 397     r = msi_reg_set_val_str( hsubkey, name, val );
 398     RegCloseKey( hsubkey );
 399     return r;
 400 }
 401
 402 LPWSTR msi_reg_get_val_str( HKEY hkey, LPCWSTR name )
 403 {
 404     DWORD len = 0;
 405     LPWSTR val;
 406     LONG r;
 407
 408     r = RegQueryValueExW(hkey, name, NULL, NULL, NULL, &len);
 409     if (r != ERROR_SUCCESS)
 410         return NULL;
 411
 412     len += sizeof (WCHAR);
 413     val = msi_alloc( len );
 414     if (!val)
 415         return NULL;
 416     val[0] = 0;
 417     RegQueryValueExW(hkey, name, NULL, NULL, (LPBYTE) val, &len);
 418     return val;
 419 }
 420
 421 BOOL msi_reg_get_val_dword( HKEY hkey, LPCWSTR name, DWORD *val)
 422 {
 423     DWORD type, len = sizeof (DWORD);
 424     LONG r = RegQueryValueExW(hkey, name, NULL, &type, (LPBYTE) val, &len);
 425     return r == ERROR_SUCCESS && type == REG_DWORD;
 426 }
 427
 428 static WCHAR *get_user_sid(void)
 429 {
 430     HANDLE token;
 431     DWORD size = 256;
 432     TOKEN_USER *user;
 433     WCHAR *ret;
 434
 435     if (!OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token )) return NULL;
 436     if (!(user = msi_alloc( size )))
 437     {
 438         CloseHandle( token );
 439         return NULL;
 440     }
 441     if (!GetTokenInformation( token, TokenUser, user, size, &size ))
 442     {
 443         msi_free( user );
 444         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER || !(user = msi_alloc( size )))
 445         {
 446             CloseHandle( token );
 447             return NULL;
 448         }
 449         GetTokenInformation( token, TokenUser, user, size, &size );
 450     }
 451     CloseHandle( token );
 452     if (!ConvertSidToStringSidW( user->User.Sid, &ret ))
 453     {
 454         msi_free( user );
 455         return NULL;
 456     }
 457     msi_free( user );
 458     return ret;
 459 }
 460
 461 UINT MSIREG_OpenUninstallKey(const WCHAR *product, enum platform platform, HKEY *key, BOOL create)
 462 {
 463     WCHAR keypath[0x200];
 464
 465     TRACE("%s\n", debugstr_w(product));
 466
 467     if (is_64bit && platform == PLATFORM_INTEL)
 468     {
 469         strcpyW(keypath, szUninstall_32node);
 470         strcatW(keypath, product);
 471     }
 472     else
 473     {
 474         strcpyW(keypath, szUninstall);
 475         strcatW(keypath, product);
 476     }
 477     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, KEY_ALL_ACCESS, NULL, key, NULL);
 478     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, KEY_ALL_ACCESS, key);
 479 }
 480
 481 UINT MSIREG_DeleteUninstallKey(const WCHAR *product, enum platform platform)
 482 {
 483     WCHAR keypath[0x200];
 484
 485     TRACE("%s\n", debugstr_w(product));
 486
 487     if (is_64bit && platform == PLATFORM_INTEL)
 488     {
 489         strcpyW(keypath, szUninstall_32node);
 490         strcatW(keypath, product);
 491     }
 492     else
 493     {
 494         strcpyW(keypath, szUninstall);
 495         strcatW(keypath, product);
 496     }
 497     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
 498 }
 499
 500 UINT MSIREG_OpenProductKey(LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
 501 {
 502     LPWSTR usersid = NULL;
 503     HKEY root = HKEY_LOCAL_MACHINE;
 504     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 505     WCHAR squished_pc[GUID_SIZE], keypath[MAX_PATH];
 506
 507     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 508     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 509
 510     if (context == MSIINSTALLCONTEXT_MACHINE)
 511     {
 512         strcpyW(keypath, szInstaller_LocalClassesProd);
 513         strcatW(keypath, squished_pc);
 514     }
 515     else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
 516     {
 517         root = HKEY_CURRENT_USER;
 518         strcpyW(keypath, szUserProducts);
 519         strcatW(keypath, squished_pc);
 520     }
 521     else
 522     {
 523         if (!szUserSid)
 524         {
 525             if (!(usersid = get_user_sid()))
 526             {
 527                 ERR("Failed to retrieve user SID\n");
 528                 return ERROR_FUNCTION_FAILED;
 529             }
 530             szUserSid = usersid;
 531         }
 532         sprintfW(keypath, szInstaller_LocalManagedProd_fmt, szUserSid, squished_pc);
 533         LocalFree(usersid);
 534     }
 535     if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
 536     return RegOpenKeyExW(root, keypath, 0, access, key);
 537 }
 538
 539 UINT MSIREG_DeleteUserProductKey(LPCWSTR szProduct)
 540 {
 541     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 542
 543     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 544     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 545
 546     strcpyW(keypath, szUserProducts);
 547     strcatW(keypath, squished_pc);
 548     return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
 549 }
 550
 551 UINT MSIREG_OpenUserPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
 552 {
 553     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 554
 555     if (!squash_guid(szPatch, squished_pc)) return ERROR_FUNCTION_FAILED;
 556     TRACE("%s squished %s\n", debugstr_w(szPatch), debugstr_w(squished_pc));
 557
 558     strcpyW(keypath, szUserPatches);
 559     strcatW(keypath, squished_pc);
 560
 561     if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
 562     return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
 563 }
 564
 565 UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
 566 {
 567     LPWSTR usersid;
 568     HKEY root = HKEY_LOCAL_MACHINE;
 569     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 570     WCHAR squished_pc[GUID_SIZE], keypath[MAX_PATH];
 571
 572     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 573     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 574
 575     if (context == MSIINSTALLCONTEXT_MACHINE)
 576     {
 577         strcpyW(keypath, szInstaller_LocalClassesFeat);
 578         strcatW(keypath, squished_pc);
 579     }
 580     else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
 581     {
 582         root = HKEY_CURRENT_USER;
 583         strcpyW(keypath, szUserFeatures);
 584         strcatW(keypath, squished_pc);
 585     }
 586     else
 587     {
 588         if (!(usersid = get_user_sid()))
 589         {
 590             ERR("Failed to retrieve user SID\n");
 591             return ERROR_FUNCTION_FAILED;
 592         }
 593         sprintfW(keypath, szInstaller_LocalManagedFeat_fmt, usersid, squished_pc);
 594         LocalFree(usersid);
 595     }
 596     if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
 597     return RegOpenKeyExW(root, keypath, 0, access, key);
 598 }
 599
 600 UINT MSIREG_DeleteUserFeaturesKey(LPCWSTR szProduct)
 601 {
 602     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 603
 604     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 605     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 606
 607     strcpyW(keypath, szUserFeatures);
 608     strcatW(keypath, squished_pc);
 609     return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
 610 }
 611
 612 static UINT MSIREG_OpenInstallerFeaturesKey(LPCWSTR szProduct, HKEY *key, BOOL create)
 613 {
 614     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 615     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 616
 617     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 618     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 619
 620     strcpyW(keypath, szInstaller_Features);
 621     strcatW(keypath, squished_pc);
 622
 623     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 624     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 625 }
 626
 627 UINT MSIREG_OpenUserDataFeaturesKey(LPCWSTR szProduct, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
 628 {
 629     LPWSTR usersid;
 630     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 631     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 632
 633     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 634     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 635
 636     if (context == MSIINSTALLCONTEXT_MACHINE)
 637     {
 638         sprintfW(keypath, szUserDataFeatures_fmt, szLocalSid, squished_pc);
 639     }
 640     else
 641     {
 642         if (!(usersid = get_user_sid()))
 643         {
 644             ERR("Failed to retrieve user SID\n");
 645             return ERROR_FUNCTION_FAILED;
 646         }
 647         sprintfW(keypath, szUserDataFeatures_fmt, usersid, squished_pc);
 648         LocalFree(usersid);
 649     }
 650     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 651     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 652 }
 653
 654 UINT MSIREG_OpenUserComponentsKey(LPCWSTR szComponent, HKEY *key, BOOL create)
 655 {
 656     WCHAR squished_cc[GUID_SIZE], keypath[0x200];
 657
 658     if (!squash_guid(szComponent, squished_cc)) return ERROR_FUNCTION_FAILED;
 659     TRACE("%s squished %s\n", debugstr_w(szComponent), debugstr_w(squished_cc));
 660
 661     strcpyW(keypath, szUserComponents);
 662     strcatW(keypath, squished_cc);
 663
 664     if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
 665     return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
 666 }
 667
 668 UINT MSIREG_OpenUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid, HKEY *key, BOOL create)
 669 {
 670     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 671     WCHAR comp[GUID_SIZE], keypath[0x200];
 672     LPWSTR usersid;
 673
 674     if (!squash_guid(szComponent, comp)) return ERROR_FUNCTION_FAILED;
 675     TRACE("%s squished %s\n", debugstr_w(szComponent), debugstr_w(comp));
 676
 677     if (!szUserSid)
 678     {
 679         if (!(usersid = get_user_sid()))
 680         {
 681             ERR("Failed to retrieve user SID\n");
 682             return ERROR_FUNCTION_FAILED;
 683         }
 684         sprintfW(keypath, szUserDataComp_fmt, usersid, comp);
 685         LocalFree(usersid);
 686     }
 687     else
 688         sprintfW(keypath, szUserDataComp_fmt, szUserSid, comp);
 689
 690     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 691     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 692 }
 693
 694 UINT MSIREG_DeleteUserDataComponentKey(LPCWSTR szComponent, LPCWSTR szUserSid)
 695 {
 696     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 697     WCHAR comp[GUID_SIZE], keypath[0x200];
 698     LPWSTR usersid;
 699     HKEY hkey;
 700     LONG r;
 701
 702     if (!squash_guid(szComponent, comp)) return ERROR_FUNCTION_FAILED;
 703     TRACE("%s squished %s\n", debugstr_w(szComponent), debugstr_w(comp));
 704
 705     if (!szUserSid)
 706     {
 707         if (!(usersid = get_user_sid()))
 708         {
 709             ERR("Failed to retrieve user SID\n");
 710             return ERROR_FUNCTION_FAILED;
 711         }
 712         sprintfW(keypath, szUserDataComponents_fmt, usersid);
 713         LocalFree(usersid);
 714     }
 715     else
 716         sprintfW(keypath, szUserDataComponents_fmt, szUserSid);
 717
 718     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
 719     r = RegDeleteTreeW(hkey, comp);
 720     RegCloseKey(hkey);
 721     return r;
 722 }
 723
 724 UINT MSIREG_OpenUserDataProductKey(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
 725 {
 726     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 727     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 728     LPWSTR usersid;
 729
 730     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 731     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 732
 733     if (dwContext == MSIINSTALLCONTEXT_MACHINE)
 734         sprintfW(keypath, szUserDataProd_fmt, szLocalSid, squished_pc);
 735     else if (szUserSid)
 736         sprintfW(keypath, szUserDataProd_fmt, szUserSid, squished_pc);
 737     else
 738     {
 739         if (!(usersid = get_user_sid()))
 740         {
 741             ERR("Failed to retrieve user SID\n");
 742             return ERROR_FUNCTION_FAILED;
 743         }
 744         sprintfW(keypath, szUserDataProd_fmt, usersid, squished_pc);
 745         LocalFree(usersid);
 746     }
 747     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 748     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 749 }
 750
 751 UINT MSIREG_OpenUserDataPatchKey(LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext, HKEY *key, BOOL create)
 752 {
 753     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 754     WCHAR squished_patch[GUID_SIZE], keypath[0x200];
 755     LPWSTR usersid;
 756
 757     if (!squash_guid(szPatch, squished_patch)) return ERROR_FUNCTION_FAILED;
 758     TRACE("%s squished %s\n", debugstr_w(szPatch), debugstr_w(squished_patch));
 759
 760     if (dwContext == MSIINSTALLCONTEXT_MACHINE)
 761         sprintfW(keypath, szUserDataPatch_fmt, szLocalSid, squished_patch);
 762     else
 763     {
 764         if (!(usersid = get_user_sid()))
 765         {
 766             ERR("Failed to retrieve user SID\n");
 767             return ERROR_FUNCTION_FAILED;
 768         }
 769         sprintfW(keypath, szUserDataPatch_fmt, usersid, squished_patch);
 770         LocalFree(usersid);
 771     }
 772     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 773     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 774 }
 775
 776 UINT MSIREG_DeleteUserDataPatchKey(LPCWSTR patch, MSIINSTALLCONTEXT context)
 777 {
 778     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 779     WCHAR squished_patch[GUID_SIZE], keypath[0x200];
 780     LPWSTR usersid;
 781     HKEY hkey;
 782     LONG r;
 783
 784     if (!squash_guid(patch, squished_patch)) return ERROR_FUNCTION_FAILED;
 785     TRACE("%s squished %s\n", debugstr_w(patch), debugstr_w(squished_patch));
 786
 787     if (context == MSIINSTALLCONTEXT_MACHINE)
 788         sprintfW(keypath, szUserDataPatches_fmt, szLocalSid);
 789     else
 790     {
 791         if (!(usersid = get_user_sid()))
 792         {
 793             ERR("Failed to retrieve user SID\n");
 794             return ERROR_FUNCTION_FAILED;
 795         }
 796         sprintfW(keypath, szUserDataPatches_fmt, usersid);
 797         LocalFree(usersid);
 798     }
 799     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
 800     r = RegDeleteTreeW(hkey, squished_patch);
 801     RegCloseKey(hkey);
 802     return r;
 803 }
 804
 805 UINT MSIREG_OpenUserDataProductPatchesKey(LPCWSTR product, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)
 806 {
 807     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 808     WCHAR squished_product[GUID_SIZE], keypath[0x200];
 809     LPWSTR usersid;
 810
 811     if (!squash_guid(product, squished_product)) return ERROR_FUNCTION_FAILED;
 812     TRACE("%s squished %s\n", debugstr_w(product), debugstr_w(squished_product));
 813
 814     if (context == MSIINSTALLCONTEXT_MACHINE)
 815         sprintfW(keypath, szUserDataProductPatches_fmt, szLocalSid, squished_product);
 816     else
 817     {
 818         if (!(usersid = get_user_sid()))
 819         {
 820             ERR("Failed to retrieve user SID\n");
 821             return ERROR_FUNCTION_FAILED;
 822         }
 823         sprintfW(keypath, szUserDataProductPatches_fmt, usersid, squished_product);
 824         LocalFree(usersid);
 825     }
 826     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 827     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 828 }
 829
 830 UINT MSIREG_OpenInstallProps(LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)
 831 {
 832     LPWSTR usersid;
 833     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 834     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 835
 836     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 837     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 838
 839     if (dwContext == MSIINSTALLCONTEXT_MACHINE)
 840         sprintfW(keypath, szInstallProperties_fmt, szLocalSid, squished_pc);
 841     else if (szUserSid)
 842         sprintfW(keypath, szInstallProperties_fmt, szUserSid, squished_pc);
 843     else
 844     {
 845         if (!(usersid = get_user_sid()))
 846         {
 847             ERR("Failed to retrieve user SID\n");
 848             return ERROR_FUNCTION_FAILED;
 849         }
 850         sprintfW(keypath, szInstallProperties_fmt, usersid, squished_pc);
 851         LocalFree(usersid);
 852     }
 853     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 854     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 855 }
 856
 857 UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct)
 858 {
 859     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 860     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 861     LPWSTR usersid;
 862     HKEY hkey;
 863     LONG r;
 864
 865     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 866     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 867
 868     if (!(usersid = get_user_sid()))
 869     {
 870         ERR("Failed to retrieve user SID\n");
 871         return ERROR_FUNCTION_FAILED;
 872     }
 873     sprintfW(keypath, szUserDataProducts_fmt, usersid);
 874     LocalFree(usersid);
 875
 876     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
 877     r = RegDeleteTreeW(hkey, squished_pc);
 878     RegCloseKey(hkey);
 879     return r;
 880 }
 881
 882 UINT MSIREG_DeleteProductKey(LPCWSTR szProduct)
 883 {
 884     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 885     WCHAR squished_pc[GUID_SIZE];
 886     HKEY hkey;
 887     LONG r;
 888
 889     if (!squash_guid(szProduct, squished_pc)) return ERROR_FUNCTION_FAILED;
 890     TRACE("%s squished %s\n", debugstr_w(szProduct), debugstr_w(squished_pc));
 891
 892     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_Products, 0, access, &hkey)) return ERROR_SUCCESS;
 893     r = RegDeleteTreeW(hkey, squished_pc);
 894     RegCloseKey(hkey);
 895     return r;
 896 }
 897
 898 UINT MSIREG_OpenPatchesKey(LPCWSTR szPatch, HKEY *key, BOOL create)
 899 {
 900     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 901     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 902
 903     if (!squash_guid(szPatch, squished_pc)) return ERROR_FUNCTION_FAILED;
 904     TRACE("%s squished %s\n", debugstr_w(szPatch), debugstr_w(squished_pc));
 905
 906     sprintfW(keypath, szInstaller_Patches, squished_pc);
 907
 908     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 909     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 910 }
 911
 912 UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
 913 {
 914     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 915     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 916
 917     if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
 918     TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
 919
 920     strcpyW(keypath, szInstaller_UpgradeCodes);
 921     strcatW(keypath, squished_pc);
 922
 923     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 924     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 925 }
 926
 927 UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
 928 {
 929     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 930
 931     if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
 932     TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
 933
 934     strcpyW(keypath, szInstaller_UserUpgradeCodes);
 935     strcatW(keypath, squished_pc);
 936
 937     if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
 938     return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
 939 }
 940
 941 UINT MSIREG_DeleteUserUpgradeCodesKey(LPCWSTR szUpgradeCode)
 942 {
 943     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 944
 945     if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
 946     TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
 947
 948     strcpyW(keypath, szInstaller_UserUpgradeCodes);
 949     strcatW(keypath, squished_pc);
 950     return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
 951 }
 952
 953 UINT MSIREG_DeleteLocalClassesProductKey(LPCWSTR szProductCode)
 954 {
 955     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 956     WCHAR squished_pc[GUID_SIZE];
 957     HKEY hkey;
 958     LONG r;
 959
 960     if (!squash_guid(szProductCode, squished_pc)) return ERROR_FUNCTION_FAILED;
 961     TRACE("%s squished %s\n", debugstr_w(szProductCode), debugstr_w(squished_pc));
 962
 963     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_LocalClassesProducts, 0, access, &hkey)) return ERROR_SUCCESS;
 964     r = RegDeleteTreeW(hkey, squished_pc);
 965     RegCloseKey(hkey);
 966     return r;
 967 }
 968
 969 UINT MSIREG_DeleteLocalClassesFeaturesKey(LPCWSTR szProductCode)
 970 {
 971     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 972     WCHAR squished_pc[GUID_SIZE];
 973     HKEY hkey;
 974     LONG r;
 975
 976     if (!squash_guid(szProductCode, squished_pc)) return ERROR_FUNCTION_FAILED;
 977     TRACE("%s squished %s\n", debugstr_w(szProductCode), debugstr_w(squished_pc));
 978
 979     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_LocalClassesFeatures, 0, access, &hkey)) return ERROR_SUCCESS;
 980     r = RegDeleteTreeW(hkey, squished_pc);
 981     RegCloseKey(hkey);
 982     return r;
 983 }
 984
 985 UINT MSIREG_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY *key, BOOL create)
 986 {
 987     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
 988     WCHAR squished_pc[GUID_SIZE], keypath[0x200];
 989
 990     if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
 991     TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
 992
 993     strcpyW(keypath, szInstaller_ClassesUpgradeCode);
 994     strcatW(keypath, squished_pc);
 995
 996     if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
 997     return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
 998 }
 999
1000 UINT MSIREG_DeleteClassesUpgradeCodesKey(LPCWSTR szUpgradeCode)
1001 {
1002     REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
1003     WCHAR squished_pc[GUID_SIZE];
1004     HKEY hkey;
1005     LONG r;
1006
1007     if (!squash_guid(szUpgradeCode, squished_pc)) return ERROR_FUNCTION_FAILED;
1008     TRACE("%s squished %s\n", debugstr_w(szUpgradeCode), debugstr_w(squished_pc));
1009
1010     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szInstaller_ClassesUpgradeCodes, 0, access, &hkey)) return ERROR_SUCCESS;
1011     r = RegDeleteTreeW(hkey, squished_pc);
1012     RegCloseKey(hkey);
1013     return r;
1014 }
1015
1016 /*************************************************************************
1017  *  MsiDecomposeDescriptorW   [MSI.@]
1018  *
1019  * Decomposes an MSI descriptor into product, feature and component parts.
1020  * An MSI descriptor is a string of the form:
1021  *   [base 85 guid] [feature code] '>' [base 85 guid]
1022  *
1023  * PARAMS
1024  *   szDescriptor  [I]  the descriptor to decompose
1025  *   szProduct     [O]  buffer of MAX_FEATURE_CHARS+1 for the product guid
1026  *   szFeature     [O]  buffer of MAX_FEATURE_CHARS+1 for the feature code
1027  *   szComponent   [O]  buffer of MAX_FEATURE_CHARS+1 for the component guid
1028  *   pUsed         [O]  the length of the descriptor
1029  *
1030  * RETURNS
1031  *   ERROR_SUCCESS             if everything worked correctly
1032  *   ERROR_INVALID_PARAMETER   if the descriptor was invalid
1033  *
1034  */
1035 UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
1036                 LPWSTR szFeature, LPWSTR szComponent, LPDWORD pUsed )
1037 {
1038     UINT r, len;
1039     LPWSTR p;
1040     GUID product, component;
1041
1042     TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
1043           szFeature, szComponent, pUsed);
1044
1045     r = decode_base85_guid( szDescriptor, &product );
1046     if( !r )
1047         return ERROR_INVALID_PARAMETER;
1048
1049     TRACE("product %s\n", debugstr_guid( &product ));
1050
1051     p = strchrW(&szDescriptor[20],'>');
1052     if( !p )
1053         return ERROR_INVALID_PARAMETER;
1054
1055     len = (p - &szDescriptor[20]);
1056     if( len > MAX_FEATURE_CHARS )
1057         return ERROR_INVALID_PARAMETER;
1058
1059     TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
1060
1061     r = decode_base85_guid( p+1, &component );
1062     if( !r )
1063         return ERROR_INVALID_PARAMETER;
1064
1065     TRACE("component %s\n", debugstr_guid( &component ));
1066
1067     if (szProduct)
1068         StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
1069     if (szComponent)
1070         StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
1071     if (szFeature)
1072     {
1073         memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
1074         szFeature[len] = 0;
1075     }
1076     len = ( &p[21] - szDescriptor );
1077
1078     TRACE("length = %d\n", len);
1079     if (pUsed) *pUsed = len;
1080
1081     return ERROR_SUCCESS;
1082 }
1083
1084 UINT WINAPI MsiDecomposeDescriptorA( LPCSTR szDescriptor, LPSTR szProduct,
1085                 LPSTR szFeature, LPSTR szComponent, LPDWORD pUsed )
1086 {
1087     WCHAR product[MAX_FEATURE_CHARS+1];
1088     WCHAR feature[MAX_FEATURE_CHARS+1];
1089     WCHAR component[MAX_FEATURE_CHARS+1];
1090     LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
1091     UINT r;
1092
1093     TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
1094           szFeature, szComponent, pUsed);
1095
1096     str = strdupAtoW( szDescriptor );
1097     if( szDescriptor && !str )
1098         return ERROR_OUTOFMEMORY;
1099
1100     if (szProduct)
1101         p = product;
1102     if (szFeature)
1103         f = feature;
1104     if (szComponent)
1105         c = component;
1106
1107     r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
1108
1109     if (r == ERROR_SUCCESS)
1110     {
1111         WideCharToMultiByte( CP_ACP, 0, p, -1,
1112                              szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
1113         WideCharToMultiByte( CP_ACP, 0, f, -1,
1114                              szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
1115         WideCharToMultiByte( CP_ACP, 0, c, -1,
1116                              szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
1117     }
1118
1119     msi_free( str );
1120
1121     return r;
1122 }
1123
1124 UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
1125 {
1126     DWORD r;
1127     WCHAR szwGuid[GUID_SIZE];
1128
1129     TRACE("%d %p\n", index, lpguid);
1130
1131     if (NULL == lpguid)
1132         return ERROR_INVALID_PARAMETER;
1133     r = MsiEnumProductsW(index, szwGuid);
1134     if( r == ERROR_SUCCESS )
1135         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1136
1137     return r;
1138 }
1139
1140 UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
1141 {
1142     TRACE("%d %p\n", index, lpguid);
1143
1144     if (NULL == lpguid)
1145         return ERROR_INVALID_PARAMETER;
1146
1147     return MsiEnumProductsExW( NULL, szAllSid, MSIINSTALLCONTEXT_ALL, index, lpguid,
1148                                NULL, NULL, NULL );
1149 }
1150
1151 UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index,
1152       LPSTR szFeature, LPSTR szParent)
1153 {
1154     DWORD r;
1155     WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
1156     LPWSTR szwProduct = NULL;
1157
1158     TRACE("%s %d %p %p\n", debugstr_a(szProduct), index, szFeature, szParent);
1159
1160     if( szProduct )
1161     {
1162         szwProduct = strdupAtoW( szProduct );
1163         if( !szwProduct )
1164             return ERROR_OUTOFMEMORY;
1165     }
1166
1167     r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
1168     if( r == ERROR_SUCCESS )
1169     {
1170         WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
1171                             szFeature, GUID_SIZE, NULL, NULL);
1172         WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
1173                             szParent, GUID_SIZE, NULL, NULL);
1174     }
1175
1176     msi_free( szwProduct);
1177
1178     return r;
1179 }
1180
1181 UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index,
1182       LPWSTR szFeature, LPWSTR szParent)
1183 {
1184     HKEY hkeyProduct = 0;
1185     DWORD r, sz;
1186
1187     TRACE("%s %d %p %p\n", debugstr_w(szProduct), index, szFeature, szParent);
1188
1189     if( !szProduct )
1190         return ERROR_INVALID_PARAMETER;
1191
1192     r = MSIREG_OpenInstallerFeaturesKey(szProduct,&hkeyProduct,FALSE);
1193     if( r != ERROR_SUCCESS )
1194         return ERROR_NO_MORE_ITEMS;
1195
1196     sz = GUID_SIZE;
1197     r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
1198     RegCloseKey(hkeyProduct);
1199
1200     return r;
1201 }
1202
1203 UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
1204 {
1205     DWORD r;
1206     WCHAR szwGuid[GUID_SIZE];
1207
1208     TRACE("%u, %p\n", index, lpguid);
1209
1210     if (!lpguid) return ERROR_INVALID_PARAMETER;
1211
1212     r = MsiEnumComponentsW(index, szwGuid);
1213     if( r == ERROR_SUCCESS )
1214         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1215
1216     return r;
1217 }
1218
1219 UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
1220 {
1221     TRACE("%u, %p\n", index, lpguid);
1222
1223     if (!lpguid) return ERROR_INVALID_PARAMETER;
1224
1225     return MsiEnumComponentsExW( szAllSid, MSIINSTALLCONTEXT_ALL, index, lpguid, NULL, NULL, NULL );
1226 }
1227
1228 UINT WINAPI MsiEnumComponentsExA( LPCSTR user_sid, DWORD ctx, DWORD index, CHAR guid[39],
1229                                   MSIINSTALLCONTEXT *installed_ctx, LPSTR sid, LPDWORD sid_len )
1230 {
1231     UINT r;
1232     WCHAR *user_sidW = NULL, *sidW = NULL, guidW[GUID_SIZE];
1233
1234     TRACE("%s, %u, %u, %p, %p, %p, %p\n", debugstr_a(user_sid), ctx, index, guid, installed_ctx,
1235           sid, sid_len);
1236
1237     if (sid && !sid_len) return ERROR_INVALID_PARAMETER;
1238     if (user_sid && !(user_sidW = strdupAtoW( user_sid ))) return ERROR_OUTOFMEMORY;
1239     if (sid && !(sidW = msi_alloc( *sid_len * sizeof(WCHAR) )))
1240     {
1241         msi_free( user_sidW );
1242         return ERROR_OUTOFMEMORY;
1243     }
1244     r = MsiEnumComponentsExW( user_sidW, ctx, index, guidW, installed_ctx, sidW, sid_len );
1245     if (r == ERROR_SUCCESS)
1246     {
1247         if (guid) WideCharToMultiByte( CP_ACP, 0, guidW, GUID_SIZE, guid, GUID_SIZE, NULL, NULL );
1248         if (sid) WideCharToMultiByte( CP_ACP, 0, sidW, *sid_len + 1, sid, *sid_len + 1, NULL, NULL );
1249     }
1250     msi_free( user_sidW );
1251     msi_free( sidW );
1252     return r;
1253 }
1254
1255 static UINT fetch_machine_component( DWORD ctx, DWORD index, DWORD *idx, WCHAR guid[39],
1256                                      MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
1257 {
1258     static const WCHAR componentsW[] =
1259         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1260          'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1261          'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a','\\',
1262          'S','-','1','-','5','-','1','8','\\','C','o','m','p','o','n','e','n','t','s',0};
1263     UINT r = ERROR_SUCCESS;
1264     WCHAR component[GUID_SIZE];
1265     DWORD i = 0, len_component;
1266     REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
1267     HKEY key_components;
1268
1269     if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, componentsW, 0, access, &key_components ))
1270         return ERROR_NO_MORE_ITEMS;
1271
1272     len_component = sizeof(component)/sizeof(component[0]);
1273     while (!RegEnumKeyExW( key_components, i, component, &len_component, NULL, NULL, NULL, NULL ))
1274     {
1275         if (*idx == index) goto found;
1276         (*idx)++;
1277         len_component = sizeof(component)/sizeof(component[0]);
1278         i++;
1279     }
1280     RegCloseKey( key_components );
1281     return ERROR_NO_MORE_ITEMS;
1282
1283 found:
1284     if (sid_len)
1285     {
1286         if (*sid_len < 1)
1287         {
1288             *sid_len = 1;
1289             r = ERROR_MORE_DATA;
1290         }
1291         else if (sid)
1292         {
1293             *sid_len = 0;
1294             sid[0] = 0;
1295         }
1296     }
1297     if (guid) unsquash_guid( component, guid );
1298     if (installed_ctx) *installed_ctx = MSIINSTALLCONTEXT_MACHINE;
1299     RegCloseKey( key_components );
1300     return r;
1301 }
1302
1303 static UINT fetch_user_component( const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx,
1304                                   WCHAR guid[39], MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid,
1305                                   LPDWORD sid_len )
1306 {
1307     static const WCHAR userdataW[] =
1308         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1309          'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1310          'I','n','s','t','a','l','l','e','r','\\','U','s','e','r','D','a','t','a',0};
1311     static const WCHAR componentsW[] = {'\\','C','o','m','p','o','n','e','n','t','s',0};
1312     UINT r = ERROR_SUCCESS;
1313     WCHAR path[MAX_PATH], component[GUID_SIZE], user[128];
1314     DWORD i = 0, j = 0, len_component, len_user;
1315     REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
1316     HKEY key_users, key_components;
1317
1318     if (ctx == MSIINSTALLCONTEXT_USERMANAGED) /* FIXME: were to find these? */
1319         return ERROR_NO_MORE_ITEMS;
1320
1321     if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, userdataW, 0, access, &key_users ))
1322         return ERROR_NO_MORE_ITEMS;
1323
1324     len_user = sizeof(user)/sizeof(user[0]);
1325     while (!RegEnumKeyExW( key_users, i, user, &len_user, NULL, NULL, NULL, NULL ))
1326     {
1327         if ((strcmpW( usersid, szAllSid ) && strcmpW( usersid, user )) ||
1328             !strcmpW( szLocalSid, user ))
1329         {
1330             i++;
1331             len_user = sizeof(user)/sizeof(user[0]);
1332             continue;
1333         }
1334         strcpyW( path, user );
1335         strcatW( path, componentsW );
1336         if (RegOpenKeyExW( key_users, path, 0, access, &key_components ))
1337         {
1338             i++;
1339             len_user = sizeof(user)/sizeof(user[0]);
1340             continue;
1341         }
1342         len_component = sizeof(component)/sizeof(component[0]);
1343         while (!RegEnumKeyExW( key_components, j, component, &len_component, NULL, NULL, NULL, NULL ))
1344         {
1345             if (*idx == index) goto found;
1346             (*idx)++;
1347             len_component = sizeof(component)/sizeof(component[0]);
1348             j++;
1349         }
1350         RegCloseKey( key_components );
1351         len_user = sizeof(user)/sizeof(user[0]);
1352         i++;
1353     }
1354     RegCloseKey( key_users );
1355     return ERROR_NO_MORE_ITEMS;
1356
1357 found:
1358     if (sid_len)
1359     {
1360         if (*sid_len < len_user + 1)
1361         {
1362             *sid_len = len_user + 1;
1363             r = ERROR_MORE_DATA;
1364         }
1365         else if (sid)
1366         {
1367             *sid_len = len_user;
1368             strcpyW( sid, user );
1369         }
1370     }
1371     if (guid) unsquash_guid( component, guid );
1372     if (installed_ctx) *installed_ctx = ctx;
1373     RegCloseKey( key_components );
1374     RegCloseKey( key_users );
1375     return r;
1376 }
1377
1378 static UINT enum_components( const WCHAR *usersid, DWORD ctx, DWORD index, DWORD *idx, WCHAR guid[39],
1379                              MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
1380 {
1381     UINT r = ERROR_NO_MORE_ITEMS;
1382     WCHAR *user = NULL;
1383
1384     if (!usersid)
1385     {
1386         usersid = user = get_user_sid();
1387         if (!user) return ERROR_FUNCTION_FAILED;
1388     }
1389     if (ctx & MSIINSTALLCONTEXT_USERMANAGED)
1390     {
1391         r = fetch_user_component( usersid, MSIINSTALLCONTEXT_USERMANAGED, index, idx, guid,
1392                                   installed_ctx, sid, sid_len );
1393         if (r != ERROR_NO_MORE_ITEMS) goto done;
1394     }
1395     if (ctx & MSIINSTALLCONTEXT_USERUNMANAGED)
1396     {
1397         r = fetch_user_component( usersid, MSIINSTALLCONTEXT_USERUNMANAGED, index, idx, guid,
1398                                   installed_ctx, sid, sid_len );
1399         if (r != ERROR_NO_MORE_ITEMS) goto done;
1400     }
1401     if (ctx & MSIINSTALLCONTEXT_MACHINE)
1402     {
1403         r = fetch_machine_component( MSIINSTALLCONTEXT_MACHINE, index, idx, guid, installed_ctx,
1404                                      sid, sid_len );
1405         if (r != ERROR_NO_MORE_ITEMS) goto done;
1406     }
1407
1408 done:
1409     LocalFree( user );
1410     return r;
1411 }
1412
1413 UINT WINAPI MsiEnumComponentsExW( LPCWSTR user_sid, DWORD ctx, DWORD index, WCHAR guid[39],
1414                                   MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
1415 {
1416     UINT r;
1417     DWORD idx = 0;
1418     static DWORD last_index;
1419
1420     TRACE("%s, %u, %u, %p, %p, %p, %p\n", debugstr_w(user_sid), ctx, index, guid, installed_ctx,
1421           sid, sid_len);
1422
1423     if ((sid && !sid_len) || !ctx || (user_sid && ctx == MSIINSTALLCONTEXT_MACHINE))
1424         return ERROR_INVALID_PARAMETER;
1425
1426     if (index && index - last_index != 1)
1427         return ERROR_INVALID_PARAMETER;
1428
1429     if (!index) last_index = 0;
1430
1431     r = enum_components( user_sid, ctx, index, &idx, guid, installed_ctx, sid, sid_len );
1432     if (r == ERROR_SUCCESS)
1433         last_index = index;
1434     else
1435         last_index = 0;
1436
1437     return r;
1438 }
1439
1440 UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
1441 {
1442     DWORD r;
1443     WCHAR szwProduct[GUID_SIZE];
1444     LPWSTR szwComponent = NULL;
1445
1446     TRACE("%s %d %p\n", debugstr_a(szComponent), index, szProduct);
1447
1448     if ( !szProduct )
1449         return ERROR_INVALID_PARAMETER;
1450
1451     if( szComponent )
1452     {
1453         szwComponent = strdupAtoW( szComponent );
1454         if( !szwComponent )
1455             return ERROR_OUTOFMEMORY;
1456     }
1457
1458     r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
1459     if( r == ERROR_SUCCESS )
1460     {
1461         WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
1462                             szProduct, GUID_SIZE, NULL, NULL);
1463     }
1464
1465     msi_free( szwComponent);
1466
1467     return r;
1468 }
1469
1470 UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
1471 {
1472     HKEY hkeyComp = 0;
1473     DWORD r, sz;
1474     WCHAR szValName[SQUISH_GUID_SIZE];
1475
1476     TRACE("%s %d %p\n", debugstr_w(szComponent), index, szProduct);
1477
1478     if (!szComponent || !*szComponent || !szProduct)
1479         return ERROR_INVALID_PARAMETER;
1480
1481     if (MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkeyComp, FALSE) != ERROR_SUCCESS &&
1482         MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkeyComp, FALSE) != ERROR_SUCCESS)
1483         return ERROR_UNKNOWN_COMPONENT;
1484
1485     /* see if there are any products at all */
1486     sz = SQUISH_GUID_SIZE;
1487     r = RegEnumValueW(hkeyComp, 0, szValName, &sz, NULL, NULL, NULL, NULL);
1488     if (r != ERROR_SUCCESS)
1489     {
1490         RegCloseKey(hkeyComp);
1491
1492         if (index != 0)
1493             return ERROR_INVALID_PARAMETER;
1494
1495         return ERROR_UNKNOWN_COMPONENT;
1496     }
1497
1498     sz = SQUISH_GUID_SIZE;
1499     r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
1500     if( r == ERROR_SUCCESS )
1501     {
1502         unsquash_guid(szValName, szProduct);
1503         TRACE("-> %s\n", debugstr_w(szProduct));
1504     }
1505     RegCloseKey(hkeyComp);
1506     return r;
1507 }
1508
1509 static UINT MSI_EnumComponentQualifiers( LPCWSTR szComponent, DWORD iIndex,
1510                 awstring *lpQualBuf, LPDWORD pcchQual,
1511                 awstring *lpAppBuf, LPDWORD pcchAppBuf )
1512 {
1513     DWORD name_sz, val_sz, name_max, val_max, type, ofs;
1514     LPWSTR name = NULL, val = NULL;
1515     UINT r, r2;
1516     HKEY key;
1517
1518     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1519           lpQualBuf, pcchQual, lpAppBuf, pcchAppBuf);
1520
1521     if (!szComponent)
1522         return ERROR_INVALID_PARAMETER;
1523
1524     r = MSIREG_OpenUserComponentsKey( szComponent, &key, FALSE );
1525     if (r != ERROR_SUCCESS)
1526         return ERROR_UNKNOWN_COMPONENT;
1527
1528     /* figure out how big the name is we want to return */
1529     name_max = 0x10;
1530     r = ERROR_OUTOFMEMORY;
1531     name = msi_alloc( name_max * sizeof(WCHAR) );
1532     if (!name)
1533         goto end;
1534
1535     val_max = 0x10;
1536     r = ERROR_OUTOFMEMORY;
1537     val = msi_alloc( val_max );
1538     if (!val)
1539         goto end;
1540
1541     /* loop until we allocate enough memory */
1542     while (1)
1543     {
1544         name_sz = name_max;
1545         val_sz = val_max;
1546         r = RegEnumValueW( key, iIndex, name, &name_sz,
1547                            NULL, &type, (LPBYTE)val, &val_sz );
1548         if (r == ERROR_SUCCESS)
1549             break;
1550         if (r != ERROR_MORE_DATA)
1551             goto end;
1552
1553         if (type != REG_MULTI_SZ)
1554         {
1555             ERR("component data has wrong type (%d)\n", type);
1556             goto end;
1557         }
1558
1559         r = ERROR_OUTOFMEMORY;
1560         if ((name_sz+1) >= name_max)
1561         {
1562             name_max *= 2;
1563             msi_free( name );
1564             name = msi_alloc( name_max * sizeof (WCHAR) );
1565             if (!name)
1566                 goto end;
1567             continue;
1568         }
1569         if (val_sz > val_max)
1570         {
1571             val_max = val_sz + sizeof (WCHAR);
1572             msi_free( val );
1573             val = msi_alloc( val_max * sizeof (WCHAR) );
1574             if (!val)
1575                 goto end;
1576             continue;
1577         }
1578         ERR("should be enough data, but isn't %d %d\n", name_sz, val_sz );
1579         goto end;
1580     }
1581
1582     ofs = 0;
1583     r = MsiDecomposeDescriptorW( val, NULL, NULL, NULL, &ofs );
1584     if (r != ERROR_SUCCESS)
1585         goto end;
1586
1587     TRACE("Providing %s and %s\n", debugstr_w(name), debugstr_w(val+ofs));
1588
1589     r = msi_strcpy_to_awstring( name, lpQualBuf, pcchQual );
1590     r2 = msi_strcpy_to_awstring( val+ofs, lpAppBuf, pcchAppBuf );
1591
1592     if (r2 != ERROR_SUCCESS)
1593         r = r2;
1594
1595 end:
1596     msi_free(val);
1597     msi_free(name);
1598     RegCloseKey(key);
1599
1600     return r;
1601 }
1602
1603 /*************************************************************************
1604  *  MsiEnumComponentQualifiersA [MSI.@]
1605  */
1606 UINT WINAPI MsiEnumComponentQualifiersA( LPCSTR szComponent, DWORD iIndex,
1607                 LPSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1608                 LPSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1609 {
1610     awstring qual, appdata;
1611     LPWSTR comp;
1612     UINT r;
1613
1614     TRACE("%s %08x %p %p %p %p\n", debugstr_a(szComponent), iIndex,
1615           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1616           pcchApplicationDataBuf);
1617
1618     comp = strdupAtoW( szComponent );
1619     if (szComponent && !comp)
1620         return ERROR_OUTOFMEMORY;
1621
1622     qual.unicode = FALSE;
1623     qual.str.a = lpQualifierBuf;
1624
1625     appdata.unicode = FALSE;
1626     appdata.str.a = lpApplicationDataBuf;
1627
1628     r = MSI_EnumComponentQualifiers( comp, iIndex,
1629               &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1630     msi_free( comp );
1631     return r;
1632 }
1633
1634 /*************************************************************************
1635  *  MsiEnumComponentQualifiersW [MSI.@]
1636  */
1637 UINT WINAPI MsiEnumComponentQualifiersW( LPCWSTR szComponent, DWORD iIndex,
1638                 LPWSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1639                 LPWSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1640 {
1641     awstring qual, appdata;
1642
1643     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1644           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1645           pcchApplicationDataBuf);
1646
1647     qual.unicode = TRUE;
1648     qual.str.w = lpQualifierBuf;
1649
1650     appdata.unicode = TRUE;
1651     appdata.str.w = lpApplicationDataBuf;
1652
1653     return MSI_EnumComponentQualifiers( szComponent, iIndex,
1654                  &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1655 }
1656
1657 /*************************************************************************
1658  *  MsiEnumRelatedProductsW   [MSI.@]
1659  *
1660  */
1661 UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
1662                                     DWORD iProductIndex, LPWSTR lpProductBuf)
1663 {
1664     UINT r;
1665     HKEY hkey;
1666     DWORD dwSize = SQUISH_GUID_SIZE;
1667     WCHAR szKeyName[SQUISH_GUID_SIZE];
1668
1669     TRACE("%s %u %u %p\n", debugstr_w(szUpgradeCode), dwReserved,
1670           iProductIndex, lpProductBuf);
1671
1672     if (NULL == szUpgradeCode)
1673         return ERROR_INVALID_PARAMETER;
1674     if (NULL == lpProductBuf)
1675         return ERROR_INVALID_PARAMETER;
1676
1677     r = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
1678     if (r != ERROR_SUCCESS)
1679         return ERROR_NO_MORE_ITEMS;
1680
1681     r = RegEnumValueW(hkey, iProductIndex, szKeyName, &dwSize, NULL, NULL, NULL, NULL);
1682     if( r == ERROR_SUCCESS )
1683         unsquash_guid(szKeyName, lpProductBuf);
1684     RegCloseKey(hkey);
1685
1686     return r;
1687 }
1688
1689 /*************************************************************************
1690  *  MsiEnumRelatedProductsA   [MSI.@]
1691  *
1692  */
1693 UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
1694                                     DWORD iProductIndex, LPSTR lpProductBuf)
1695 {
1696     LPWSTR szwUpgradeCode = NULL;
1697     WCHAR productW[GUID_SIZE];
1698     UINT r;
1699
1700     TRACE("%s %u %u %p\n", debugstr_a(szUpgradeCode), dwReserved,
1701           iProductIndex, lpProductBuf);
1702
1703     if (szUpgradeCode)
1704     {
1705         szwUpgradeCode = strdupAtoW( szUpgradeCode );
1706         if( !szwUpgradeCode )
1707             return ERROR_OUTOFMEMORY;
1708     }
1709
1710     r = MsiEnumRelatedProductsW( szwUpgradeCode, dwReserved,
1711                                  iProductIndex, productW );
1712     if (r == ERROR_SUCCESS)
1713     {
1714         WideCharToMultiByte( CP_ACP, 0, productW, GUID_SIZE,
1715                              lpProductBuf, GUID_SIZE, NULL, NULL );
1716     }
1717     msi_free( szwUpgradeCode);
1718     return r;
1719 }
1720
1721 /***********************************************************************
1722  * MsiEnumPatchesExA            [MSI.@]
1723  */
1724 UINT WINAPI MsiEnumPatchesExA(LPCSTR szProductCode, LPCSTR szUserSid,
1725         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPSTR szPatchCode,
1726         LPSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
1727         LPSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
1728 {
1729     LPWSTR prodcode = NULL;
1730     LPWSTR usersid = NULL;
1731     LPWSTR targsid = NULL;
1732     WCHAR patch[GUID_SIZE];
1733     WCHAR targprod[GUID_SIZE];
1734     DWORD len;
1735     UINT r;
1736
1737     TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
1738           debugstr_a(szProductCode), debugstr_a(szUserSid), dwContext, dwFilter,
1739           dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
1740           szTargetUserSid, pcchTargetUserSid);
1741
1742     if (szTargetUserSid && !pcchTargetUserSid)
1743         return ERROR_INVALID_PARAMETER;
1744
1745     if (szProductCode) prodcode = strdupAtoW(szProductCode);
1746     if (szUserSid) usersid = strdupAtoW(szUserSid);
1747
1748     r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1749                           patch, targprod, pdwTargetProductContext,
1750                           NULL, &len);
1751     if (r != ERROR_SUCCESS)
1752         goto done;
1753
1754     WideCharToMultiByte(CP_ACP, 0, patch, -1, szPatchCode,
1755                         GUID_SIZE, NULL, NULL);
1756     WideCharToMultiByte(CP_ACP, 0, targprod, -1, szTargetProductCode,
1757                         GUID_SIZE, NULL, NULL);
1758
1759     if (!szTargetUserSid)
1760     {
1761         if (pcchTargetUserSid)
1762             *pcchTargetUserSid = len;
1763
1764         goto done;
1765     }
1766
1767     targsid = msi_alloc(++len * sizeof(WCHAR));
1768     if (!targsid)
1769     {
1770         r = ERROR_OUTOFMEMORY;
1771         goto done;
1772     }
1773
1774     r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1775                           patch, targprod, pdwTargetProductContext,
1776                           targsid, &len);
1777     if (r != ERROR_SUCCESS || !szTargetUserSid)
1778         goto done;
1779
1780     WideCharToMultiByte(CP_ACP, 0, targsid, -1, szTargetUserSid,
1781                         *pcchTargetUserSid, NULL, NULL);
1782
1783     len = lstrlenW(targsid);
1784     if (*pcchTargetUserSid < len + 1)
1785     {
1786         r = ERROR_MORE_DATA;
1787         *pcchTargetUserSid = len * sizeof(WCHAR);
1788     }
1789     else
1790         *pcchTargetUserSid = len;
1791
1792 done:
1793     msi_free(prodcode);
1794     msi_free(usersid);
1795     msi_free(targsid);
1796
1797     return r;
1798 }
1799
1800 static UINT msi_get_patch_state(LPCWSTR prodcode, LPCWSTR usersid,
1801                                 MSIINSTALLCONTEXT context,
1802                                 LPWSTR patch, MSIPATCHSTATE *state)
1803 {
1804     DWORD type, val, size;
1805     HKEY prod, hkey = 0;
1806     HKEY udpatch = 0;
1807     LONG res;
1808     UINT r = ERROR_NO_MORE_ITEMS;
1809
1810     *state = MSIPATCHSTATE_INVALID;
1811
1812     r = MSIREG_OpenUserDataProductKey(prodcode, context,
1813                                       usersid, &prod, FALSE);
1814     if (r != ERROR_SUCCESS)
1815         return ERROR_NO_MORE_ITEMS;
1816
1817     res = RegOpenKeyExW(prod, szPatches, 0, KEY_READ, &hkey);
1818     if (res != ERROR_SUCCESS)
1819         goto done;
1820
1821     res = RegOpenKeyExW(hkey, patch, 0, KEY_READ, &udpatch);
1822     if (res != ERROR_SUCCESS)
1823         goto done;
1824
1825     size = sizeof(DWORD);
1826     res = RegGetValueW(udpatch, NULL, szState, RRF_RT_DWORD, &type, &val, &size);
1827     if (res != ERROR_SUCCESS ||
1828         val < MSIPATCHSTATE_APPLIED || val > MSIPATCHSTATE_REGISTERED)
1829     {
1830         r = ERROR_BAD_CONFIGURATION;
1831         goto done;
1832     }
1833
1834     *state = val;
1835     r = ERROR_SUCCESS;
1836
1837 done:
1838     RegCloseKey(udpatch);
1839     RegCloseKey(hkey);
1840     RegCloseKey(prod);
1841
1842     return r;
1843 }
1844
1845 static UINT msi_check_product_patches(LPCWSTR prodcode, LPCWSTR usersid,
1846         MSIINSTALLCONTEXT context, DWORD filter, DWORD index, DWORD *idx,
1847         LPWSTR patch, LPWSTR targetprod, MSIINSTALLCONTEXT *targetctx,
1848         LPWSTR targetsid, DWORD *sidsize, LPWSTR *transforms)
1849 {
1850     MSIPATCHSTATE state = MSIPATCHSTATE_INVALID;
1851     LPWSTR ptr, patches = NULL;
1852     HKEY prod, patchkey = 0;
1853     HKEY localprod = 0, localpatch = 0;
1854     DWORD type, size;
1855     LONG res;
1856     UINT temp, r = ERROR_NO_MORE_ITEMS;
1857
1858     if (MSIREG_OpenProductKey(prodcode, usersid, context,
1859                               &prod, FALSE) != ERROR_SUCCESS)
1860         return ERROR_NO_MORE_ITEMS;
1861
1862     size = 0;
1863     res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type, NULL,
1864                        &size);
1865     if (res != ERROR_SUCCESS)
1866         goto done;
1867
1868     if (type != REG_MULTI_SZ)
1869     {
1870         r = ERROR_BAD_CONFIGURATION;
1871         goto done;
1872     }
1873
1874     patches = msi_alloc(size);
1875     if (!patches)
1876     {
1877         r = ERROR_OUTOFMEMORY;
1878         goto done;
1879     }
1880
1881     res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type,
1882                        patches, &size);
1883     if (res != ERROR_SUCCESS)
1884         goto done;
1885
1886     for (ptr = patches; *ptr && r == ERROR_NO_MORE_ITEMS; ptr += lstrlenW(ptr) + 1)
1887     {
1888         if (!unsquash_guid(ptr, patch))
1889         {
1890             r = ERROR_BAD_CONFIGURATION;
1891             goto done;
1892         }
1893
1894         size = 0;
1895         res = RegGetValueW(prod, szPatches, ptr, RRF_RT_REG_SZ,
1896                            &type, NULL, &size);
1897         if (res != ERROR_SUCCESS)
1898             continue;
1899
1900         if (transforms)
1901         {
1902             *transforms = msi_alloc(size);
1903             if (!*transforms)
1904             {
1905                 r = ERROR_OUTOFMEMORY;
1906                 goto done;
1907             }
1908
1909             res = RegGetValueW(prod, szPatches, ptr, RRF_RT_REG_SZ,
1910                                &type, *transforms, &size);
1911             if (res != ERROR_SUCCESS)
1912                 continue;
1913         }
1914
1915         if (context == MSIINSTALLCONTEXT_USERMANAGED)
1916         {
1917             if (!(filter & MSIPATCHSTATE_APPLIED))
1918             {
1919                 temp = msi_get_patch_state(prodcode, usersid, context,
1920                                            ptr, &state);
1921                 if (temp == ERROR_BAD_CONFIGURATION)
1922                 {
1923                     r = ERROR_BAD_CONFIGURATION;
1924                     goto done;
1925                 }
1926
1927                 if (temp != ERROR_SUCCESS || !(filter & state))
1928                     continue;
1929             }
1930         }
1931         else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
1932         {
1933             if (!(filter & MSIPATCHSTATE_APPLIED))
1934             {
1935                 temp = msi_get_patch_state(prodcode, usersid, context,
1936                                            ptr, &state);
1937                 if (temp == ERROR_BAD_CONFIGURATION)
1938                 {
1939                     r = ERROR_BAD_CONFIGURATION;
1940                     goto done;
1941                 }
1942
1943                 if (temp != ERROR_SUCCESS || !(filter & state))
1944                     continue;
1945             }
1946             else
1947             {
1948                 temp = MSIREG_OpenUserDataPatchKey(patch, context,
1949                                                    &patchkey, FALSE);
1950                 RegCloseKey(patchkey);
1951                 if (temp != ERROR_SUCCESS)
1952                     continue;
1953             }
1954         }
1955         else if (context == MSIINSTALLCONTEXT_MACHINE)
1956         {
1957             usersid = szEmpty;
1958
1959             if (MSIREG_OpenUserDataProductKey(prodcode, context, NULL, &localprod, FALSE) == ERROR_SUCCESS &&
1960                 RegOpenKeyExW(localprod, szPatches, 0, KEY_READ, &localpatch) == ERROR_SUCCESS &&
1961                 RegOpenKeyExW(localpatch, ptr, 0, KEY_READ, &patchkey) == ERROR_SUCCESS)
1962             {
1963                 res = RegGetValueW(patchkey, NULL, szState, RRF_RT_REG_DWORD,
1964                                    &type, &state, &size);
1965
1966                 if (!(filter & state))
1967                     res = ERROR_NO_MORE_ITEMS;
1968
1969                 RegCloseKey(patchkey);
1970             }
1971
1972             RegCloseKey(localpatch);
1973             RegCloseKey(localprod);
1974
1975             if (res != ERROR_SUCCESS)
1976                 continue;
1977         }
1978
1979         if (*idx < index)
1980         {
1981             (*idx)++;
1982             continue;
1983         }
1984
1985         r = ERROR_SUCCESS;
1986         if (targetprod)
1987             lstrcpyW(targetprod, prodcode);
1988
1989         if (targetctx)
1990             *targetctx = context;
1991
1992         if (targetsid)
1993         {
1994             lstrcpynW(targetsid, usersid, *sidsize);
1995             if (lstrlenW(usersid) >= *sidsize)
1996                 r = ERROR_MORE_DATA;
1997         }
1998
1999         if (sidsize)
2000         {
2001             *sidsize = lstrlenW(usersid);
2002             if (!targetsid)
2003                 *sidsize *= sizeof(WCHAR);
2004         }
2005     }
2006
2007 done:
2008     RegCloseKey(prod);
2009     msi_free(patches);
2010
2011     return r;
2012 }
2013
2014 static UINT msi_enum_patches(LPCWSTR szProductCode, LPCWSTR szUserSid,
2015         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, DWORD *idx,
2016         LPWSTR szPatchCode, LPWSTR szTargetProductCode,
2017         MSIINSTALLCONTEXT *pdwTargetProductContext, LPWSTR szTargetUserSid,
2018         LPDWORD pcchTargetUserSid, LPWSTR *szTransforms)
2019 {
2020     LPWSTR usersid = NULL;
2021     UINT r = ERROR_INVALID_PARAMETER;
2022
2023     if (!szUserSid)
2024     {
2025         szUserSid = usersid = get_user_sid();
2026         if (!usersid) return ERROR_FUNCTION_FAILED;
2027     }
2028
2029     if (dwContext & MSIINSTALLCONTEXT_USERMANAGED)
2030     {
2031         r = msi_check_product_patches(szProductCode, szUserSid,
2032                                       MSIINSTALLCONTEXT_USERMANAGED, dwFilter,
2033                                       dwIndex, idx, szPatchCode,
2034                                       szTargetProductCode,
2035                                       pdwTargetProductContext, szTargetUserSid,
2036                                       pcchTargetUserSid, szTransforms);
2037         if (r != ERROR_NO_MORE_ITEMS)
2038             goto done;
2039     }
2040
2041     if (dwContext & MSIINSTALLCONTEXT_USERUNMANAGED)
2042     {
2043         r = msi_check_product_patches(szProductCode, szUserSid,
2044                                       MSIINSTALLCONTEXT_USERUNMANAGED, dwFilter,
2045                                       dwIndex, idx, szPatchCode,
2046                                       szTargetProductCode,
2047                                       pdwTargetProductContext, szTargetUserSid,
2048                                       pcchTargetUserSid, szTransforms);
2049         if (r != ERROR_NO_MORE_ITEMS)
2050             goto done;
2051     }
2052
2053     if (dwContext & MSIINSTALLCONTEXT_MACHINE)
2054     {
2055         r = msi_check_product_patches(szProductCode, szUserSid,
2056                                       MSIINSTALLCONTEXT_MACHINE, dwFilter,
2057                                       dwIndex, idx, szPatchCode,
2058                                       szTargetProductCode,
2059                                       pdwTargetProductContext, szTargetUserSid,
2060                                       pcchTargetUserSid, szTransforms);
2061         if (r != ERROR_NO_MORE_ITEMS)
2062             goto done;
2063     }
2064
2065 done:
2066     LocalFree(usersid);
2067     return r;
2068 }
2069
2070 /***********************************************************************
2071  * MsiEnumPatchesExW            [MSI.@]
2072  */
2073 UINT WINAPI MsiEnumPatchesExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
2074         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPWSTR szPatchCode,
2075         LPWSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
2076         LPWSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
2077 {
2078     WCHAR squished_pc[GUID_SIZE];
2079     DWORD idx = 0;
2080     UINT r;
2081
2082     static DWORD last_index;
2083
2084     TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
2085           debugstr_w(szProductCode), debugstr_w(szUserSid), dwContext, dwFilter,
2086           dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
2087           szTargetUserSid, pcchTargetUserSid);
2088
2089     if (!szProductCode || !squash_guid(szProductCode, squished_pc))
2090         return ERROR_INVALID_PARAMETER;
2091
2092     if (szUserSid && !strcmpW( szUserSid, szLocalSid ))
2093         return ERROR_INVALID_PARAMETER;
2094
2095     if (dwContext & MSIINSTALLCONTEXT_MACHINE && szUserSid)
2096         return ERROR_INVALID_PARAMETER;
2097
2098     if (dwContext <= MSIINSTALLCONTEXT_NONE ||
2099         dwContext > MSIINSTALLCONTEXT_ALL)
2100         return ERROR_INVALID_PARAMETER;
2101
2102     if (dwFilter <= MSIPATCHSTATE_INVALID || dwFilter > MSIPATCHSTATE_ALL)
2103         return ERROR_INVALID_PARAMETER;
2104
2105     if (dwIndex && dwIndex - last_index != 1)
2106         return ERROR_INVALID_PARAMETER;
2107
2108     if (dwIndex == 0)
2109         last_index = 0;
2110
2111     r = msi_enum_patches(szProductCode, szUserSid, dwContext, dwFilter,
2112                          dwIndex, &idx, szPatchCode, szTargetProductCode,
2113                          pdwTargetProductContext, szTargetUserSid,
2114                          pcchTargetUserSid, NULL);
2115
2116     if (r == ERROR_SUCCESS)
2117         last_index = dwIndex;
2118     else
2119         last_index = 0;
2120
2121     return r;
2122 }
2123
2124 /***********************************************************************
2125  * MsiEnumPatchesA            [MSI.@]
2126  */
2127 UINT WINAPI MsiEnumPatchesA(LPCSTR szProduct, DWORD iPatchIndex,
2128         LPSTR lpPatchBuf, LPSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
2129 {
2130     LPWSTR product, transforms;
2131     WCHAR patch[GUID_SIZE];
2132     DWORD len;
2133     UINT r;
2134
2135     TRACE("(%s %d %p %p %p)\n", debugstr_a(szProduct), iPatchIndex,
2136           lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
2137
2138     if (!szProduct || !lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
2139         return ERROR_INVALID_PARAMETER;
2140
2141     product = strdupAtoW(szProduct);
2142     if (!product)
2143         return ERROR_OUTOFMEMORY;
2144
2145     len = *pcchTransformsBuf;
2146     transforms = msi_alloc( len * sizeof(WCHAR) );
2147     if (!transforms)
2148     {
2149         r = ERROR_OUTOFMEMORY;
2150         goto done;
2151     }
2152
2153     r = MsiEnumPatchesW(product, iPatchIndex, patch, transforms, &len);
2154     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2155         goto done;
2156
2157     WideCharToMultiByte(CP_ACP, 0, patch, -1, lpPatchBuf,
2158                         GUID_SIZE, NULL, NULL);
2159
2160     if (!WideCharToMultiByte(CP_ACP, 0, transforms, -1, lpTransformsBuf,
2161                              *pcchTransformsBuf, NULL, NULL))
2162         r = ERROR_MORE_DATA;
2163
2164     if (r == ERROR_MORE_DATA)
2165     {
2166         lpTransformsBuf[*pcchTransformsBuf - 1] = '\0';
2167         *pcchTransformsBuf = len * 2;
2168     }
2169     else
2170         *pcchTransformsBuf = strlen( lpTransformsBuf );
2171
2172 done:
2173     msi_free(transforms);
2174     msi_free(product);
2175
2176     return r;
2177 }
2178
2179 /***********************************************************************
2180  * MsiEnumPatchesW            [MSI.@]
2181  */
2182 UINT WINAPI MsiEnumPatchesW(LPCWSTR szProduct, DWORD iPatchIndex,
2183         LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
2184 {
2185     WCHAR squished_pc[GUID_SIZE];
2186     LPWSTR transforms = NULL;
2187     HKEY prod;
2188     DWORD idx = 0;
2189     UINT r;
2190
2191     TRACE("(%s %d %p %p %p)\n", debugstr_w(szProduct), iPatchIndex,
2192           lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
2193
2194     if (!szProduct || !squash_guid(szProduct, squished_pc))
2195         return ERROR_INVALID_PARAMETER;
2196
2197     if (!lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
2198         return ERROR_INVALID_PARAMETER;
2199
2200     if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
2201                               &prod, FALSE) != ERROR_SUCCESS &&
2202         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2203                               &prod, FALSE) != ERROR_SUCCESS &&
2204         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2205                               &prod, FALSE) != ERROR_SUCCESS)
2206         return ERROR_UNKNOWN_PRODUCT;
2207
2208     RegCloseKey(prod);
2209
2210     r = msi_enum_patches(szProduct, NULL, MSIINSTALLCONTEXT_ALL,
2211                          MSIPATCHSTATE_ALL, iPatchIndex, &idx, lpPatchBuf,
2212                          NULL, NULL, NULL, NULL, &transforms);
2213     if (r != ERROR_SUCCESS)
2214         goto done;
2215
2216     lstrcpynW(lpTransformsBuf, transforms, *pcchTransformsBuf);
2217     if (*pcchTransformsBuf <= lstrlenW(transforms))
2218     {
2219         r = ERROR_MORE_DATA;
2220         *pcchTransformsBuf = lstrlenW(transforms);
2221     }
2222     else
2223         *pcchTransformsBuf = lstrlenW(transforms);
2224
2225 done:
2226     msi_free(transforms);
2227     return r;
2228 }
2229
2230 UINT WINAPI MsiEnumProductsExA( LPCSTR product, LPCSTR usersid, DWORD ctx, DWORD index,
2231                                 CHAR installed_product[GUID_SIZE],
2232                                 MSIINSTALLCONTEXT *installed_ctx, LPSTR sid, LPDWORD sid_len )
2233 {
2234     UINT r;
2235     WCHAR installed_productW[GUID_SIZE], *productW = NULL, *usersidW = NULL, *sidW = NULL;
2236
2237     TRACE("%s, %s, %u, %u, %p, %p, %p, %p\n", debugstr_a(product), debugstr_a(usersid),
2238           ctx, index, installed_product, installed_ctx, sid, sid_len);
2239
2240     if (sid && !sid_len) return ERROR_INVALID_PARAMETER;
2241     if (product && !(productW = strdupAtoW( product ))) return ERROR_OUTOFMEMORY;
2242     if (usersid && !(usersidW = strdupAtoW( usersid )))
2243     {
2244         msi_free( productW );
2245         return ERROR_OUTOFMEMORY;
2246     }
2247     if (sid && !(sidW = msi_alloc( *sid_len * sizeof(WCHAR) )))
2248     {
2249         msi_free( usersidW );
2250         msi_free( productW );
2251         return ERROR_OUTOFMEMORY;
2252     }
2253     r = MsiEnumProductsExW( productW, usersidW, ctx, index, installed_productW,
2254                             installed_ctx, sidW, sid_len );
2255     if (r == ERROR_SUCCESS)
2256     {
2257         if (installed_product) WideCharToMultiByte( CP_ACP, 0, installed_productW, GUID_SIZE,
2258                                                     installed_product, GUID_SIZE, NULL, NULL );
2259         if (sid) WideCharToMultiByte( CP_ACP, 0, sidW, *sid_len + 1, sid, *sid_len + 1, NULL, NULL );
2260     }
2261     msi_free( productW );
2262     msi_free( usersidW );
2263     msi_free( sidW );
2264     return r;
2265 }
2266
2267 static UINT fetch_machine_product( const WCHAR *match, DWORD index, DWORD *idx,
2268                                    WCHAR installed_product[GUID_SIZE],
2269                                    MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len )
2270 {
2271     static const WCHAR productsW[] =
2272         {'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s','\\',
2273          'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
2274     UINT r;
2275     WCHAR product[GUID_SIZE];
2276     DWORD i = 0, len;
2277     REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
2278     HKEY key;
2279
2280     if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, productsW, 0, access, &key ))
2281         return ERROR_NO_MORE_ITEMS;
2282
2283     len = sizeof(product)/sizeof(product[0]);
2284     while (!RegEnumKeyExW( key, i, product, &len, NULL, NULL, NULL, NULL ))
2285     {
2286         if (match && strcmpW( match, product ))
2287         {
2288             i++;
2289             len = sizeof(product)/sizeof(product[0]);
2290             continue;
2291         }
2292         if (*idx == index) goto found;
2293         (*idx)++;
2294         len = sizeof(product)/sizeof(product[0]);
2295         i++;
2296     }
2297     RegCloseKey( key );
2298     return ERROR_NO_MORE_ITEMS;
2299
2300 found:
2301     if (sid_len && *sid_len < 1)
2302     {
2303         *sid_len = 1;
2304         r = ERROR_MORE_DATA;
2305     }
2306     else
2307     {
2308         if (installed_product) unsquash_guid( product, installed_product );
2309         if (installed_ctx) *installed_ctx = MSIINSTALLCONTEXT_MACHINE;
2310         if (sid)
2311         {
2312             sid[0] = 0;
2313             *sid_len = 0;
2314         }
2315         r = ERROR_SUCCESS;
2316     }
2317     RegCloseKey( key );
2318     return r;
2319 }
2320
2321 static UINT fetch_user_product( const WCHAR *match, const WCHAR *usersid, DWORD ctx, DWORD index,
2322                                 DWORD *idx, WCHAR installed_product[GUID_SIZE],
2323                                 MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len )
2324 {
2325     static const WCHAR managedW[] =
2326         {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
2327          'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s',
2328          'i','o','n','\\','I','n','s','t','a','l','l','e','r','\\','M','a','n','a','g','e','d',0};
2329     static const WCHAR managed_productsW[] =
2330         {'\\','I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
2331     static const WCHAR unmanaged_productsW[] =
2332         {'\\','S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
2333          'I','n','s','t','a','l','l','e','r','\\','P','r','o','d','u','c','t','s',0};
2334     UINT r;
2335     const WCHAR *subkey;
2336     WCHAR path[MAX_PATH], product[GUID_SIZE], user[128];
2337     DWORD i = 0, j = 0, len_product, len_user;
2338     REGSAM access = KEY_ENUMERATE_SUB_KEYS | KEY_WOW64_64KEY;
2339     HKEY key_users, key_products;
2340
2341     if (ctx == MSIINSTALLCONTEXT_USERMANAGED)
2342     {
2343         subkey = managed_productsW;
2344         if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, managedW, 0, access, &key_users ))
2345             return ERROR_NO_MORE_ITEMS;
2346     }
2347     else if (ctx == MSIINSTALLCONTEXT_USERUNMANAGED)
2348     {
2349         subkey = unmanaged_productsW;
2350         if (RegOpenKeyExW( HKEY_USERS, NULL, 0, access, &key_users ))
2351             return ERROR_NO_MORE_ITEMS;
2352     }
2353     else return ERROR_INVALID_PARAMETER;
2354
2355     len_user = sizeof(user)/sizeof(user[0]);
2356     while (!RegEnumKeyExW( key_users, i, user, &len_user, NULL, NULL, NULL, NULL ))
2357     {
2358         if (strcmpW( usersid, user ) && strcmpW( usersid, szAllSid ))
2359         {
2360             i++;
2361             len_user = sizeof(user)/sizeof(user[0]);
2362             continue;
2363         }
2364         strcpyW( path, user );
2365         strcatW( path, subkey );
2366         if (RegOpenKeyExW( key_users, path, 0, access, &key_products ))
2367         {
2368             i++;
2369             len_user = sizeof(user)/sizeof(user[0]);
2370             continue;
2371         }
2372         len_product = sizeof(product)/sizeof(product[0]);
2373         while (!RegEnumKeyExW( key_products, j, product, &len_product, NULL, NULL, NULL, NULL ))
2374         {
2375             if (match && strcmpW( match, product ))
2376             {
2377                 j++;
2378                 len_product = sizeof(product)/sizeof(product[0]);
2379                 continue;
2380             }
2381             if (*idx == index) goto found;
2382             (*idx)++;
2383             len_product = sizeof(product)/sizeof(product[0]);
2384             j++;
2385         }
2386         RegCloseKey( key_products );
2387         len_user = sizeof(user)/sizeof(user[0]);
2388         i++;
2389     }
2390     RegCloseKey( key_users );
2391     return ERROR_NO_MORE_ITEMS;
2392
2393 found:
2394     if (sid_len && *sid_len <= len_user)
2395     {
2396         *sid_len = len_user;
2397         r = ERROR_MORE_DATA;
2398     }
2399     else
2400     {
2401         if (installed_product) unsquash_guid( product, installed_product );
2402         if (installed_ctx) *installed_ctx = ctx;
2403         if (sid)
2404         {
2405             strcpyW( sid, user );
2406             *sid_len = len_user;
2407         }
2408         r = ERROR_SUCCESS;
2409     }
2410     RegCloseKey( key_products );
2411     RegCloseKey( key_users );
2412     return r;
2413 }
2414
2415 static UINT enum_products( const WCHAR *product, const WCHAR *usersid, DWORD ctx, DWORD index,
2416                            DWORD *idx, WCHAR installed_product[GUID_SIZE],
2417                            MSIINSTALLCONTEXT *installed_ctx, WCHAR *sid, DWORD *sid_len )
2418 {
2419     UINT r = ERROR_NO_MORE_ITEMS;
2420     WCHAR *user = NULL;
2421
2422     if (!usersid)
2423     {
2424         usersid = user = get_user_sid();
2425         if (!user) return ERROR_FUNCTION_FAILED;
2426     }
2427     if (ctx & MSIINSTALLCONTEXT_MACHINE)
2428     {
2429         r = fetch_machine_product( product, index, idx, installed_product, installed_ctx,
2430                                    sid, sid_len );
2431         if (r != ERROR_NO_MORE_ITEMS) goto done;
2432     }
2433     if (ctx & MSIINSTALLCONTEXT_USERUNMANAGED)
2434     {
2435         r = fetch_user_product( product, usersid, MSIINSTALLCONTEXT_USERUNMANAGED, index,
2436                                 idx, installed_product, installed_ctx, sid, sid_len );
2437         if (r != ERROR_NO_MORE_ITEMS) goto done;
2438     }
2439     if (ctx & MSIINSTALLCONTEXT_USERMANAGED)
2440     {
2441         r = fetch_user_product( product, usersid, MSIINSTALLCONTEXT_USERMANAGED, index,
2442                                 idx, installed_product, installed_ctx, sid, sid_len );
2443         if (r != ERROR_NO_MORE_ITEMS) goto done;
2444     }
2445
2446 done:
2447     LocalFree( user );
2448     return r;
2449 }
2450
2451 UINT WINAPI MsiEnumProductsExW( LPCWSTR product, LPCWSTR usersid, DWORD ctx, DWORD index,
2452                                 WCHAR installed_product[GUID_SIZE],
2453                                 MSIINSTALLCONTEXT *installed_ctx, LPWSTR sid, LPDWORD sid_len )
2454 {
2455     UINT r;
2456     DWORD idx = 0;
2457     static DWORD last_index;
2458
2459     TRACE("%s, %s, %u, %u, %p, %p, %p, %p\n", debugstr_w(product), debugstr_w(usersid),
2460           ctx, index, installed_product, installed_ctx, sid, sid_len);
2461
2462     if ((sid && !sid_len) || !ctx || (usersid && ctx == MSIINSTALLCONTEXT_MACHINE))
2463         return ERROR_INVALID_PARAMETER;
2464
2465     if (index && index - last_index != 1)
2466         return ERROR_INVALID_PARAMETER;
2467
2468     if (!index) last_index = 0;
2469
2470     r = enum_products( product, usersid, ctx, index, &idx, installed_product, installed_ctx,
2471                        sid, sid_len );
2472     if (r == ERROR_SUCCESS)
2473         last_index = index;
2474     else
2475         last_index = 0;
2476
2477     return r;
2478 }