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