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