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