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, LPCWSTR szUserSid,
 803                                    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 (!szUserSid)
 816     {
 817         rc = get_user_sid(&usersid);
 818         if (rc != ERROR_SUCCESS || !usersid)
 819         {
 820             ERR("Failed to retrieve user SID: %d\n", rc);
 821             return rc;
 822         }
 823
 824         sprintfW(keypath, szUserDataProd_fmt, usersid, squished_pc);
 825         LocalFree(usersid);
 826     }
 827     else
 828         sprintfW(keypath, szUserDataProd_fmt, szUserSid, squished_pc);
 829
 830     if (create)
 831         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 832     else
 833         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 834
 835     return rc;
 836 }
 837
 838 UINT MSIREG_OpenUserDataPatchKey(LPWSTR patch, HKEY *key, BOOL create)
 839 {
 840     UINT rc;
 841     WCHAR keypath[0x200];
 842     LPWSTR usersid;
 843
 844     TRACE("\n");
 845
 846     rc = get_user_sid(&usersid);
 847     if (rc != ERROR_SUCCESS || !usersid)
 848     {
 849         ERR("Failed to retrieve user SID: %d\n", rc);
 850         return rc;
 851     }
 852
 853     sprintfW(keypath, szUserDataPatch_fmt, usersid, patch);
 854
 855     if (create)
 856         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 857     else
 858         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 859
 860     LocalFree(usersid);
 861     return rc;
 862 }
 863
 864 UINT MSIREG_OpenInstallProps(LPCWSTR szProduct, LPCWSTR szUserSID,
 865                              HKEY *key, BOOL create)
 866 {
 867     UINT rc;
 868     WCHAR squished_pc[GUID_SIZE];
 869     WCHAR keypath[0x200];
 870
 871     TRACE("%s\n", debugstr_w(szProduct));
 872     if (!squash_guid(szProduct, squished_pc))
 873         return ERROR_FUNCTION_FAILED;
 874     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 875
 876     sprintfW(keypath, szInstallProperties_fmt, szUserSID, squished_pc);
 877
 878     if (create)
 879         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 880     else
 881         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 882
 883     return rc;
 884 }
 885
 886 UINT MSIREG_OpenCurrentUserInstallProps(LPCWSTR szProduct, HKEY *key,
 887                                                BOOL create)
 888 {
 889     UINT rc;
 890     LPWSTR usersid;
 891
 892     rc = get_user_sid(&usersid);
 893     if (rc != ERROR_SUCCESS || !usersid)
 894     {
 895         ERR("Failed to retrieve user SID: %d\n", rc);
 896         return rc;
 897     }
 898
 899     rc = MSIREG_OpenInstallProps(szProduct, usersid, key, create);
 900
 901     LocalFree(usersid);
 902     return rc;
 903 }
 904
 905 UINT MSIREG_DeleteUserDataProductKey(LPCWSTR szProduct)
 906 {
 907     UINT rc;
 908     WCHAR squished_pc[GUID_SIZE];
 909     WCHAR keypath[0x200];
 910     LPWSTR usersid;
 911
 912     TRACE("%s\n", debugstr_w(szProduct));
 913     if (!squash_guid(szProduct, squished_pc))
 914         return ERROR_FUNCTION_FAILED;
 915     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 916
 917     rc = get_user_sid(&usersid);
 918     if (rc != ERROR_SUCCESS || !usersid)
 919     {
 920         ERR("Failed to retrieve user SID: %d\n", rc);
 921         return rc;
 922     }
 923
 924     sprintfW(keypath, szUserDataProd_fmt, usersid, squished_pc);
 925
 926     LocalFree(usersid);
 927     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
 928 }
 929
 930 UINT MSIREG_DeleteProductKey(LPCWSTR szProduct)
 931 {
 932     WCHAR squished_pc[GUID_SIZE];
 933     WCHAR keypath[0x200];
 934
 935     TRACE("%s\n", debugstr_w(szProduct));
 936     if (!squash_guid(szProduct, squished_pc))
 937         return ERROR_FUNCTION_FAILED;
 938     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 939
 940     sprintfW(keypath, szInstaller_Products_fmt, squished_pc);
 941
 942     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
 943 }
 944
 945 UINT MSIREG_OpenPatchesKey(LPCWSTR szPatch, HKEY* key, BOOL create)
 946 {
 947     UINT rc;
 948     WCHAR squished_pc[GUID_SIZE];
 949     WCHAR keypath[0x200];
 950
 951     TRACE("%s\n",debugstr_w(szPatch));
 952     if (!squash_guid(szPatch,squished_pc))
 953         return ERROR_FUNCTION_FAILED;
 954     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 955
 956     sprintfW(keypath,szInstaller_Patches_fmt,squished_pc);
 957
 958     if (create)
 959         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 960     else
 961         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 962
 963     return rc;
 964 }
 965
 966 UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, 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(szUpgradeCode));
 973     if (!squash_guid(szUpgradeCode,squished_pc))
 974         return ERROR_FUNCTION_FAILED;
 975     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 976
 977     sprintfW(keypath,szInstaller_UpgradeCodes_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_OpenUserUpgradeCodesKey(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_UserUpgradeCodes_fmt,squished_pc);
 999
1000     if (create)
1001         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
1002     else
1003         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
1004
1005     return rc;
1006 }
1007
1008 UINT MSIREG_DeleteUserUpgradeCodesKey(LPCWSTR szUpgradeCode)
1009 {
1010     WCHAR squished_pc[GUID_SIZE];
1011     WCHAR keypath[0x200];
1012
1013     TRACE("%s\n",debugstr_w(szUpgradeCode));
1014     if (!squash_guid(szUpgradeCode,squished_pc))
1015         return ERROR_FUNCTION_FAILED;
1016     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1017
1018     sprintfW(keypath,szInstaller_UserUpgradeCodes_fmt,squished_pc);
1019
1020     return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
1021 }
1022
1023 UINT MSIREG_DeleteLocalClassesProductKey(LPCWSTR szProductCode)
1024 {
1025     WCHAR squished_pc[GUID_SIZE];
1026     WCHAR keypath[0x200];
1027
1028     TRACE("%s\n", debugstr_w(szProductCode));
1029
1030     if (!squash_guid(szProductCode, squished_pc))
1031         return ERROR_FUNCTION_FAILED;
1032
1033     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1034
1035     sprintfW(keypath, szInstaller_LocalClassesProd_fmt, squished_pc);
1036
1037     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
1038 }
1039
1040 UINT MSIREG_DeleteLocalClassesFeaturesKey(LPCWSTR szProductCode)
1041 {
1042     WCHAR squished_pc[GUID_SIZE];
1043     WCHAR keypath[0x200];
1044
1045     TRACE("%s\n", debugstr_w(szProductCode));
1046
1047     if (!squash_guid(szProductCode, squished_pc))
1048         return ERROR_FUNCTION_FAILED;
1049
1050     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1051
1052     sprintfW(keypath, szInstaller_LocalClassesFeat_fmt, squished_pc);
1053
1054     return RegDeleteTreeW(HKEY_LOCAL_MACHINE, keypath);
1055 }
1056
1057 UINT MSIREG_OpenClassesUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
1058 {
1059     WCHAR squished_pc[GUID_SIZE];
1060     WCHAR keypath[0x200];
1061
1062     TRACE("%s\n", debugstr_w(szUpgradeCode));
1063     if (!squash_guid(szUpgradeCode, squished_pc))
1064         return ERROR_FUNCTION_FAILED;
1065     TRACE("squished (%s)\n", debugstr_w(squished_pc));
1066
1067     sprintfW(keypath, szInstaller_ClassesUpgrade_fmt, squished_pc);
1068
1069     if (create)
1070         return RegCreateKeyW(HKEY_CLASSES_ROOT, keypath, key);
1071
1072     return RegOpenKeyW(HKEY_CLASSES_ROOT, keypath, key);
1073 }
1074
1075 /*************************************************************************
1076  *  MsiDecomposeDescriptorW   [MSI.@]
1077  *
1078  * Decomposes an MSI descriptor into product, feature and component parts.
1079  * An MSI descriptor is a string of the form:
1080  *   [base 85 guid] [feature code] '>' [base 85 guid]
1081  *
1082  * PARAMS
1083  *   szDescriptor  [I]  the descriptor to decompose
1084  *   szProduct     [O]  buffer of MAX_FEATURE_CHARS+1 for the product guid
1085  *   szFeature     [O]  buffer of MAX_FEATURE_CHARS+1 for the feature code
1086  *   szComponent   [O]  buffer of MAX_FEATURE_CHARS+1 for the component guid
1087  *   pUsed         [O]  the length of the descriptor
1088  *
1089  * RETURNS
1090  *   ERROR_SUCCESS             if everything worked correctly
1091  *   ERROR_INVALID_PARAMETER   if the descriptor was invalid
1092  *
1093  */
1094 UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
1095                 LPWSTR szFeature, LPWSTR szComponent, LPDWORD pUsed )
1096 {
1097     UINT r, len;
1098     LPWSTR p;
1099     GUID product, component;
1100
1101     TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
1102           szFeature, szComponent, pUsed);
1103
1104     r = decode_base85_guid( szDescriptor, &product );
1105     if( !r )
1106         return ERROR_INVALID_PARAMETER;
1107
1108     TRACE("product %s\n", debugstr_guid( &product ));
1109
1110     p = strchrW(&szDescriptor[20],'>');
1111     if( !p )
1112         return ERROR_INVALID_PARAMETER;
1113
1114     len = (p - &szDescriptor[20]);
1115     if( len > MAX_FEATURE_CHARS )
1116         return ERROR_INVALID_PARAMETER;
1117
1118     TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
1119
1120     r = decode_base85_guid( p+1, &component );
1121     if( !r )
1122         return ERROR_INVALID_PARAMETER;
1123
1124     TRACE("component %s\n", debugstr_guid( &component ));
1125
1126     if (szProduct)
1127         StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
1128     if (szComponent)
1129         StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
1130     if (szFeature)
1131     {
1132         memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
1133         szFeature[len] = 0;
1134     }
1135     len = ( &p[21] - szDescriptor );
1136
1137     TRACE("length = %d\n", len);
1138     *pUsed = len;
1139
1140     return ERROR_SUCCESS;
1141 }
1142
1143 UINT WINAPI MsiDecomposeDescriptorA( LPCSTR szDescriptor, LPSTR szProduct,
1144                 LPSTR szFeature, LPSTR szComponent, LPDWORD pUsed )
1145 {
1146     WCHAR product[MAX_FEATURE_CHARS+1];
1147     WCHAR feature[MAX_FEATURE_CHARS+1];
1148     WCHAR component[MAX_FEATURE_CHARS+1];
1149     LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
1150     UINT r;
1151
1152     TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
1153           szFeature, szComponent, pUsed);
1154
1155     str = strdupAtoW( szDescriptor );
1156     if( szDescriptor && !str )
1157         return ERROR_OUTOFMEMORY;
1158
1159     if (szProduct)
1160         p = product;
1161     if (szFeature)
1162         f = feature;
1163     if (szComponent)
1164         c = component;
1165
1166     r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
1167
1168     if (r == ERROR_SUCCESS)
1169     {
1170         WideCharToMultiByte( CP_ACP, 0, p, -1,
1171                              szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
1172         WideCharToMultiByte( CP_ACP, 0, f, -1,
1173                              szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
1174         WideCharToMultiByte( CP_ACP, 0, c, -1,
1175                              szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
1176     }
1177
1178     msi_free( str );
1179
1180     return r;
1181 }
1182
1183 UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
1184 {
1185     DWORD r;
1186     WCHAR szwGuid[GUID_SIZE];
1187
1188     TRACE("%d %p\n", index, lpguid);
1189
1190     if (NULL == lpguid)
1191         return ERROR_INVALID_PARAMETER;
1192     r = MsiEnumProductsW(index, szwGuid);
1193     if( r == ERROR_SUCCESS )
1194         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1195
1196     return r;
1197 }
1198
1199 UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
1200 {
1201     HKEY hkeyProducts = 0;
1202     DWORD r;
1203     WCHAR szKeyName[SQUISH_GUID_SIZE];
1204
1205     TRACE("%d %p\n", index, lpguid);
1206
1207     if (NULL == lpguid)
1208         return ERROR_INVALID_PARAMETER;
1209
1210     r = RegCreateKeyW(HKEY_LOCAL_MACHINE, szInstaller_Products, &hkeyProducts);
1211     if( r != ERROR_SUCCESS )
1212         return ERROR_NO_MORE_ITEMS;
1213
1214     r = RegEnumKeyW(hkeyProducts, index, szKeyName, SQUISH_GUID_SIZE);
1215     if( r == ERROR_SUCCESS )
1216         unsquash_guid(szKeyName, lpguid);
1217     RegCloseKey(hkeyProducts);
1218
1219     return r;
1220 }
1221
1222 UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index,
1223       LPSTR szFeature, LPSTR szParent)
1224 {
1225     DWORD r;
1226     WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
1227     LPWSTR szwProduct = NULL;
1228
1229     TRACE("%s %d %p %p\n", debugstr_a(szProduct), index, szFeature, szParent);
1230
1231     if( szProduct )
1232     {
1233         szwProduct = strdupAtoW( szProduct );
1234         if( !szwProduct )
1235             return ERROR_OUTOFMEMORY;
1236     }
1237
1238     r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
1239     if( r == ERROR_SUCCESS )
1240     {
1241         WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
1242                             szFeature, GUID_SIZE, NULL, NULL);
1243         WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
1244                             szParent, GUID_SIZE, NULL, NULL);
1245     }
1246
1247     msi_free( szwProduct);
1248
1249     return r;
1250 }
1251
1252 UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index,
1253       LPWSTR szFeature, LPWSTR szParent)
1254 {
1255     HKEY hkeyProduct = 0;
1256     DWORD r, sz;
1257
1258     TRACE("%s %d %p %p\n", debugstr_w(szProduct), index, szFeature, szParent);
1259
1260     if( !szProduct )
1261         return ERROR_INVALID_PARAMETER;
1262
1263     r = MSIREG_OpenInstallerFeaturesKey(szProduct,&hkeyProduct,FALSE);
1264     if( r != ERROR_SUCCESS )
1265         return ERROR_NO_MORE_ITEMS;
1266
1267     sz = GUID_SIZE;
1268     r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
1269     RegCloseKey(hkeyProduct);
1270
1271     return r;
1272 }
1273
1274 UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
1275 {
1276     DWORD r;
1277     WCHAR szwGuid[GUID_SIZE];
1278
1279     TRACE("%d %p\n", index, lpguid);
1280
1281     r = MsiEnumComponentsW(index, szwGuid);
1282     if( r == ERROR_SUCCESS )
1283         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
1284
1285     return r;
1286 }
1287
1288 UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
1289 {
1290     HKEY hkeyComponents = 0;
1291     DWORD r;
1292     WCHAR szKeyName[SQUISH_GUID_SIZE];
1293
1294     TRACE("%d %p\n", index, lpguid);
1295
1296     r = RegCreateKeyW(HKEY_LOCAL_MACHINE, szInstaller_Components, &hkeyComponents);
1297     if( r != ERROR_SUCCESS )
1298         return ERROR_NO_MORE_ITEMS;
1299
1300     r = RegEnumKeyW(hkeyComponents, index, szKeyName, SQUISH_GUID_SIZE);
1301     if( r == ERROR_SUCCESS )
1302         unsquash_guid(szKeyName, lpguid);
1303     RegCloseKey(hkeyComponents);
1304
1305     return r;
1306 }
1307
1308 UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
1309 {
1310     DWORD r;
1311     WCHAR szwProduct[GUID_SIZE];
1312     LPWSTR szwComponent = NULL;
1313
1314     TRACE("%s %d %p\n", debugstr_a(szComponent), index, szProduct);
1315
1316     if ( !szProduct )
1317         return ERROR_INVALID_PARAMETER;
1318
1319     if( szComponent )
1320     {
1321         szwComponent = strdupAtoW( szComponent );
1322         if( !szwComponent )
1323             return ERROR_OUTOFMEMORY;
1324     }
1325
1326     r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
1327     if( r == ERROR_SUCCESS )
1328     {
1329         WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
1330                             szProduct, GUID_SIZE, NULL, NULL);
1331     }
1332
1333     msi_free( szwComponent);
1334
1335     return r;
1336 }
1337
1338 UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
1339 {
1340     HKEY hkeyComp = 0;
1341     DWORD r, sz;
1342     WCHAR szValName[SQUISH_GUID_SIZE];
1343
1344     TRACE("%s %d %p\n", debugstr_w(szComponent), index, szProduct);
1345
1346     if (!szComponent || !*szComponent || !szProduct)
1347         return ERROR_INVALID_PARAMETER;
1348
1349     if (MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkeyComp, FALSE) != ERROR_SUCCESS &&
1350         MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkeyComp, FALSE) != ERROR_SUCCESS)
1351         return ERROR_UNKNOWN_COMPONENT;
1352
1353     /* see if there are any products at all */
1354     sz = SQUISH_GUID_SIZE;
1355     r = RegEnumValueW(hkeyComp, 0, szValName, &sz, NULL, NULL, NULL, NULL);
1356     if (r != ERROR_SUCCESS)
1357     {
1358         RegCloseKey(hkeyComp);
1359
1360         if (index != 0)
1361             return ERROR_INVALID_PARAMETER;
1362
1363         return ERROR_UNKNOWN_COMPONENT;
1364     }
1365
1366     sz = SQUISH_GUID_SIZE;
1367     r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
1368     if( r == ERROR_SUCCESS )
1369         unsquash_guid(szValName, szProduct);
1370
1371     RegCloseKey(hkeyComp);
1372
1373     return r;
1374 }
1375
1376 static UINT MSI_EnumComponentQualifiers( LPCWSTR szComponent, DWORD iIndex,
1377                 awstring *lpQualBuf, LPDWORD pcchQual,
1378                 awstring *lpAppBuf, LPDWORD pcchAppBuf )
1379 {
1380     DWORD name_sz, val_sz, name_max, val_max, type, ofs;
1381     LPWSTR name = NULL, val = NULL;
1382     UINT r, r2;
1383     HKEY key;
1384
1385     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1386           lpQualBuf, pcchQual, lpAppBuf, pcchAppBuf);
1387
1388     if (!szComponent)
1389         return ERROR_INVALID_PARAMETER;
1390
1391     r = MSIREG_OpenUserComponentsKey( szComponent, &key, FALSE );
1392     if (r != ERROR_SUCCESS)
1393         return ERROR_UNKNOWN_COMPONENT;
1394
1395     /* figure out how big the name is we want to return */
1396     name_max = 0x10;
1397     r = ERROR_OUTOFMEMORY;
1398     name = msi_alloc( name_max * sizeof(WCHAR) );
1399     if (!name)
1400         goto end;
1401
1402     val_max = 0x10;
1403     r = ERROR_OUTOFMEMORY;
1404     val = msi_alloc( val_max );
1405     if (!val)
1406         goto end;
1407
1408     /* loop until we allocate enough memory */
1409     while (1)
1410     {
1411         name_sz = name_max;
1412         val_sz = val_max;
1413         r = RegEnumValueW( key, iIndex, name, &name_sz,
1414                            NULL, &type, (LPBYTE)val, &val_sz );
1415         if (r == ERROR_SUCCESS)
1416             break;
1417         if (r != ERROR_MORE_DATA)
1418             goto end;
1419
1420         if (type != REG_MULTI_SZ)
1421         {
1422             ERR("component data has wrong type (%d)\n", type);
1423             goto end;
1424         }
1425
1426         r = ERROR_OUTOFMEMORY;
1427         if ((name_sz+1) >= name_max)
1428         {
1429             name_max *= 2;
1430             msi_free( name );
1431             name = msi_alloc( name_max * sizeof (WCHAR) );
1432             if (!name)
1433                 goto end;
1434             continue;
1435         }
1436         if (val_sz > val_max)
1437         {
1438             val_max = val_sz + sizeof (WCHAR);
1439             msi_free( val );
1440             val = msi_alloc( val_max * sizeof (WCHAR) );
1441             if (!val)
1442                 goto end;
1443             continue;
1444         }
1445         ERR("should be enough data, but isn't %d %d\n", name_sz, val_sz );
1446         goto end;
1447     }
1448
1449     ofs = 0;
1450     r = MsiDecomposeDescriptorW( val, NULL, NULL, NULL, &ofs );
1451     if (r != ERROR_SUCCESS)
1452         goto end;
1453
1454     TRACE("Providing %s and %s\n", debugstr_w(name), debugstr_w(val+ofs));
1455
1456     r = msi_strcpy_to_awstring( name, lpQualBuf, pcchQual );
1457     r2 = msi_strcpy_to_awstring( val+ofs, lpAppBuf, pcchAppBuf );
1458
1459     if (r2 != ERROR_SUCCESS)
1460         r = r2;
1461
1462 end:
1463     msi_free(val);
1464     msi_free(name);
1465     RegCloseKey(key);
1466
1467     return r;
1468 }
1469
1470 /*************************************************************************
1471  *  MsiEnumComponentQualifiersA [MSI.@]
1472  */
1473 UINT WINAPI MsiEnumComponentQualifiersA( LPCSTR szComponent, DWORD iIndex,
1474                 LPSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1475                 LPSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1476 {
1477     awstring qual, appdata;
1478     LPWSTR comp;
1479     UINT r;
1480
1481     TRACE("%s %08x %p %p %p %p\n", debugstr_a(szComponent), iIndex,
1482           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1483           pcchApplicationDataBuf);
1484
1485     comp = strdupAtoW( szComponent );
1486     if (szComponent && !comp)
1487         return ERROR_OUTOFMEMORY;
1488
1489     qual.unicode = FALSE;
1490     qual.str.a = lpQualifierBuf;
1491
1492     appdata.unicode = FALSE;
1493     appdata.str.a = lpApplicationDataBuf;
1494
1495     r = MSI_EnumComponentQualifiers( comp, iIndex,
1496               &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1497     msi_free( comp );
1498     return r;
1499 }
1500
1501 /*************************************************************************
1502  *  MsiEnumComponentQualifiersW [MSI.@]
1503  */
1504 UINT WINAPI MsiEnumComponentQualifiersW( LPCWSTR szComponent, DWORD iIndex,
1505                 LPWSTR lpQualifierBuf, LPDWORD pcchQualifierBuf,
1506                 LPWSTR lpApplicationDataBuf, LPDWORD pcchApplicationDataBuf )
1507 {
1508     awstring qual, appdata;
1509
1510     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
1511           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
1512           pcchApplicationDataBuf);
1513
1514     qual.unicode = TRUE;
1515     qual.str.w = lpQualifierBuf;
1516
1517     appdata.unicode = TRUE;
1518     appdata.str.w = lpApplicationDataBuf;
1519
1520     return MSI_EnumComponentQualifiers( szComponent, iIndex,
1521                  &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1522 }
1523
1524 /*************************************************************************
1525  *  MsiEnumRelatedProductsW   [MSI.@]
1526  *
1527  */
1528 UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
1529                                     DWORD iProductIndex, LPWSTR lpProductBuf)
1530 {
1531     UINT r;
1532     HKEY hkey;
1533     DWORD dwSize = SQUISH_GUID_SIZE;
1534     WCHAR szKeyName[SQUISH_GUID_SIZE];
1535
1536     TRACE("%s %u %u %p\n", debugstr_w(szUpgradeCode), dwReserved,
1537           iProductIndex, lpProductBuf);
1538
1539     if (NULL == szUpgradeCode)
1540         return ERROR_INVALID_PARAMETER;
1541     if (NULL == lpProductBuf)
1542         return ERROR_INVALID_PARAMETER;
1543
1544     r = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
1545     if (r != ERROR_SUCCESS)
1546         return ERROR_NO_MORE_ITEMS;
1547
1548     r = RegEnumValueW(hkey, iProductIndex, szKeyName, &dwSize, NULL, NULL, NULL, NULL);
1549     if( r == ERROR_SUCCESS )
1550         unsquash_guid(szKeyName, lpProductBuf);
1551     RegCloseKey(hkey);
1552
1553     return r;
1554 }
1555
1556 /*************************************************************************
1557  *  MsiEnumRelatedProductsA   [MSI.@]
1558  *
1559  */
1560 UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
1561                                     DWORD iProductIndex, LPSTR lpProductBuf)
1562 {
1563     LPWSTR szwUpgradeCode = NULL;
1564     WCHAR productW[GUID_SIZE];
1565     UINT r;
1566
1567     TRACE("%s %u %u %p\n", debugstr_a(szUpgradeCode), dwReserved,
1568           iProductIndex, lpProductBuf);
1569
1570     if (szUpgradeCode)
1571     {
1572         szwUpgradeCode = strdupAtoW( szUpgradeCode );
1573         if( !szwUpgradeCode )
1574             return ERROR_OUTOFMEMORY;
1575     }
1576
1577     r = MsiEnumRelatedProductsW( szwUpgradeCode, dwReserved,
1578                                  iProductIndex, productW );
1579     if (r == ERROR_SUCCESS)
1580     {
1581         WideCharToMultiByte( CP_ACP, 0, productW, GUID_SIZE,
1582                              lpProductBuf, GUID_SIZE, NULL, NULL );
1583     }
1584     msi_free( szwUpgradeCode);
1585     return r;
1586 }
1587
1588 /***********************************************************************
1589  * MsiEnumPatchesExA            [MSI.@]
1590  */
1591 UINT WINAPI MsiEnumPatchesExA(LPCSTR szProductCode, LPCSTR szUserSid,
1592         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPSTR szPatchCode,
1593         LPSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
1594         LPSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
1595 {
1596     LPWSTR prodcode = NULL;
1597     LPWSTR usersid = NULL;
1598     LPWSTR targsid = NULL;
1599     WCHAR patch[GUID_SIZE];
1600     WCHAR targprod[GUID_SIZE];
1601     DWORD len;
1602     UINT r;
1603
1604     TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
1605           debugstr_a(szProductCode), debugstr_a(szUserSid), dwContext, dwFilter,
1606           dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
1607           szTargetUserSid, pcchTargetUserSid);
1608
1609     if (szTargetUserSid && !pcchTargetUserSid)
1610         return ERROR_INVALID_PARAMETER;
1611
1612     if (szProductCode) prodcode = strdupAtoW(szProductCode);
1613     if (szUserSid) usersid = strdupAtoW(szUserSid);
1614
1615     r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1616                           patch, targprod, pdwTargetProductContext,
1617                           NULL, &len);
1618     if (r != ERROR_SUCCESS)
1619         goto done;
1620
1621     WideCharToMultiByte(CP_ACP, 0, patch, -1, szPatchCode,
1622                         GUID_SIZE, NULL, NULL);
1623     WideCharToMultiByte(CP_ACP, 0, targprod, -1, szTargetProductCode,
1624                         GUID_SIZE, NULL, NULL);
1625
1626     if (!szTargetUserSid)
1627     {
1628         if (pcchTargetUserSid)
1629             *pcchTargetUserSid = len;
1630
1631         goto done;
1632     }
1633
1634     targsid = msi_alloc(++len * sizeof(WCHAR));
1635     if (!targsid)
1636     {
1637         r = ERROR_OUTOFMEMORY;
1638         goto done;
1639     }
1640
1641     r = MsiEnumPatchesExW(prodcode, usersid, dwContext, dwFilter, dwIndex,
1642                           patch, targprod, pdwTargetProductContext,
1643                           targsid, &len);
1644     if (r != ERROR_SUCCESS || !szTargetUserSid)
1645         goto done;
1646
1647     WideCharToMultiByte(CP_ACP, 0, targsid, -1, szTargetUserSid,
1648                         *pcchTargetUserSid, NULL, NULL);
1649
1650     len = lstrlenW(targsid);
1651     if (*pcchTargetUserSid < len + 1)
1652     {
1653         r = ERROR_MORE_DATA;
1654         *pcchTargetUserSid = len * sizeof(WCHAR);
1655     }
1656     else
1657         *pcchTargetUserSid = len;
1658
1659 done:
1660     msi_free(prodcode);
1661     msi_free(usersid);
1662     msi_free(targsid);
1663
1664     return r;
1665 }
1666
1667 static UINT msi_get_patch_state(LPCWSTR prodcode, LPCWSTR usersid,
1668                                 LPWSTR patch, MSIPATCHSTATE *state)
1669 {
1670     DWORD type, val, size;
1671     HKEY prod, hkey = 0;
1672     HKEY udpatch = 0;
1673     LONG res;
1674     UINT r = ERROR_NO_MORE_ITEMS;
1675
1676     static const WCHAR szPatches[] = {'P','a','t','c','h','e','s',0};
1677     static const WCHAR szState[] = {'S','t','a','t','e',0};
1678
1679     *state = MSIPATCHSTATE_INVALID;
1680
1681     /* FIXME: usersid might not be current user */
1682     r = MSIREG_OpenUserDataProductKey(prodcode, NULL, &prod, FALSE);
1683     if (r != ERROR_SUCCESS)
1684         return ERROR_NO_MORE_ITEMS;
1685
1686     res = RegOpenKeyExW(prod, szPatches, 0, KEY_READ, &hkey);
1687     if (res != ERROR_SUCCESS)
1688         goto done;
1689
1690     res = RegOpenKeyExW(hkey, patch, 0, KEY_READ, &udpatch);
1691     if (res != ERROR_SUCCESS)
1692         goto done;
1693
1694     size = sizeof(DWORD);
1695     res = RegGetValueW(udpatch, NULL, szState, RRF_RT_DWORD, &type, &val, &size);
1696     if (res != ERROR_SUCCESS ||
1697         val < MSIPATCHSTATE_APPLIED || val > MSIPATCHSTATE_REGISTERED)
1698     {
1699         r = ERROR_BAD_CONFIGURATION;
1700         goto done;
1701     }
1702
1703     *state = val;
1704     r = ERROR_SUCCESS;
1705
1706 done:
1707     RegCloseKey(udpatch);
1708     RegCloseKey(hkey);
1709     RegCloseKey(prod);
1710
1711     return r;
1712 }
1713
1714 static UINT msi_check_product_patches(LPCWSTR prodcode, LPCWSTR usersid,
1715         MSIINSTALLCONTEXT context, DWORD filter, DWORD index, DWORD *idx,
1716         LPWSTR patch, LPWSTR targetprod, MSIINSTALLCONTEXT *targetctx,
1717         LPWSTR targetsid, DWORD *sidsize)
1718 {
1719     MSIPATCHSTATE state;
1720     LPWSTR ptr, patches = NULL;
1721     HKEY prod, patchkey = 0;
1722     HKEY localprod = 0, localpatch = 0;
1723     DWORD type, size;
1724     LONG res;
1725     UINT temp, r = ERROR_NO_MORE_ITEMS;
1726
1727     static const WCHAR szPatches[] = {'P','a','t','c','h','e','s',0};
1728     static const WCHAR szState[] = {'S','t','a','t','e',0};
1729     static const WCHAR szEmpty[] = {0};
1730
1731     if (MSIREG_OpenProductKey(prodcode, context, &prod, FALSE) != ERROR_SUCCESS)
1732         return ERROR_NO_MORE_ITEMS;
1733
1734     size = 0;
1735     res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type, NULL,
1736                        &size);
1737     if (res != ERROR_SUCCESS)
1738         goto done;
1739
1740     if (type != REG_MULTI_SZ)
1741     {
1742         r = ERROR_BAD_CONFIGURATION;
1743         goto done;
1744     }
1745
1746     patches = msi_alloc(size);
1747     if (!patches)
1748     {
1749         r = ERROR_OUTOFMEMORY;
1750         goto done;
1751     }
1752
1753     res = RegGetValueW(prod, szPatches, szPatches, RRF_RT_ANY, &type,
1754                        patches, &size);
1755     if (res != ERROR_SUCCESS)
1756         goto done;
1757
1758     ptr = patches;
1759     for (ptr = patches; *ptr && r == ERROR_NO_MORE_ITEMS; ptr += lstrlenW(ptr))
1760     {
1761         if (!unsquash_guid(ptr, patch))
1762         {
1763             r = ERROR_BAD_CONFIGURATION;
1764             goto done;
1765         }
1766
1767         size = 0;
1768         res = RegGetValueW(prod, szPatches, ptr, RRF_RT_REG_SZ,
1769                            &type, NULL, &size);
1770         if (res != ERROR_SUCCESS)
1771             continue;
1772
1773         if (context == MSIINSTALLCONTEXT_USERMANAGED)
1774         {
1775             if (!(filter & MSIPATCHSTATE_APPLIED))
1776             {
1777                 temp = msi_get_patch_state(prodcode, usersid, ptr, &state);
1778                 if (temp == ERROR_BAD_CONFIGURATION)
1779                 {
1780                     r = ERROR_BAD_CONFIGURATION;
1781                     goto done;
1782                 }
1783
1784                 if (temp != ERROR_SUCCESS || !(filter & state))
1785                     continue;
1786             }
1787         }
1788         else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
1789         {
1790             if (!(filter & MSIPATCHSTATE_APPLIED))
1791             {
1792                 temp = msi_get_patch_state(prodcode, usersid, ptr, &state);
1793                 if (temp == ERROR_BAD_CONFIGURATION)
1794                 {
1795                     r = ERROR_BAD_CONFIGURATION;
1796                     goto done;
1797                 }
1798
1799                 if (temp != ERROR_SUCCESS || !(filter & state))
1800                     continue;
1801             }
1802             else
1803             {
1804                 temp = MSIREG_OpenUserDataPatchKey(ptr, &patchkey, FALSE);
1805                 RegCloseKey(patchkey);
1806                 if (temp != ERROR_SUCCESS)
1807                     continue;
1808             }
1809         }
1810         else if (context == MSIINSTALLCONTEXT_MACHINE)
1811         {
1812             usersid = szEmpty;
1813
1814             if (MSIREG_OpenUserDataProductKey(prodcode, szLocalSid, &localprod, FALSE) == ERROR_SUCCESS &&
1815                 RegOpenKeyExW(localprod, szPatches, 0, KEY_READ, &localpatch) == ERROR_SUCCESS &&
1816                 RegOpenKeyExW(localpatch, ptr, 0, KEY_READ, &patchkey) == ERROR_SUCCESS)
1817             {
1818                 res = RegGetValueW(patchkey, NULL, szState, RRF_RT_REG_DWORD,
1819                                    &type, &state, &size);
1820
1821                 if (!(filter & state))
1822                     res = ERROR_NO_MORE_ITEMS;
1823
1824                 RegCloseKey(patchkey);
1825             }
1826
1827             RegCloseKey(localpatch);
1828             RegCloseKey(localprod);
1829
1830             if (res != ERROR_SUCCESS)
1831                 continue;
1832         }
1833
1834         if (*idx < index)
1835         {
1836             (*idx)++;
1837             continue;
1838         }
1839
1840         r = ERROR_SUCCESS;
1841         lstrcpyW(targetprod, prodcode);
1842
1843         if (targetctx)
1844             *targetctx = context;
1845
1846         if (targetsid)
1847         {
1848             lstrcpynW(targetsid, usersid, *sidsize);
1849             if (lstrlenW(usersid) >= *sidsize)
1850                 r = ERROR_MORE_DATA;
1851         }
1852
1853         if (sidsize)
1854         {
1855             *sidsize = lstrlenW(usersid);
1856             if (!targetsid)
1857                 *sidsize *= sizeof(WCHAR);
1858         }
1859     }
1860
1861 done:
1862     RegCloseKey(prod);
1863     msi_free(patches);
1864
1865     return r;
1866 }
1867
1868 /***********************************************************************
1869  * MsiEnumPatchesExW            [MSI.@]
1870  */
1871 UINT WINAPI MsiEnumPatchesExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
1872         DWORD dwContext, DWORD dwFilter, DWORD dwIndex, LPWSTR szPatchCode,
1873         LPWSTR szTargetProductCode, MSIINSTALLCONTEXT *pdwTargetProductContext,
1874         LPWSTR szTargetUserSid, LPDWORD pcchTargetUserSid)
1875 {
1876     WCHAR squished_pc[GUID_SIZE];
1877     DWORD idx = 0;
1878     UINT r;
1879
1880     static int last_index = 0;
1881
1882     TRACE("(%s, %s, %d, %d, %d, %p, %p, %p, %p, %p)\n",
1883           debugstr_w(szProductCode), debugstr_w(szUserSid), dwContext, dwFilter,
1884           dwIndex, szPatchCode, szTargetProductCode, pdwTargetProductContext,
1885           szTargetUserSid, pcchTargetUserSid);
1886
1887     if (!szProductCode || !squash_guid(szProductCode, squished_pc))
1888         return ERROR_INVALID_PARAMETER;
1889
1890     if (!lstrcmpW(szUserSid, szLocalSid))
1891         return ERROR_INVALID_PARAMETER;
1892
1893     if (dwContext & MSIINSTALLCONTEXT_MACHINE && szUserSid)
1894         return ERROR_INVALID_PARAMETER;
1895
1896     if (dwContext <= MSIINSTALLCONTEXT_NONE ||
1897         dwContext > MSIINSTALLCONTEXT_ALL)
1898         return ERROR_INVALID_PARAMETER;
1899
1900     if (dwFilter <= MSIPATCHSTATE_INVALID || dwFilter > MSIPATCHSTATE_ALL)
1901         return ERROR_INVALID_PARAMETER;
1902
1903     if (dwIndex && dwIndex - last_index != 1)
1904         return ERROR_INVALID_PARAMETER;
1905
1906     if (dwIndex == 0)
1907         last_index = 0;
1908
1909     if (dwContext & MSIINSTALLCONTEXT_USERMANAGED)
1910     {
1911         r = msi_check_product_patches(szProductCode, szUserSid,
1912                                       MSIINSTALLCONTEXT_USERMANAGED, dwFilter,
1913                                       dwIndex, &idx, szPatchCode,
1914                                       szTargetProductCode,
1915                                       pdwTargetProductContext,
1916                                       szTargetUserSid, pcchTargetUserSid);
1917         if (r != ERROR_NO_MORE_ITEMS)
1918             goto done;
1919     }
1920
1921     if (dwContext & MSIINSTALLCONTEXT_USERUNMANAGED)
1922     {
1923         r = msi_check_product_patches(szProductCode, szUserSid,
1924                                       MSIINSTALLCONTEXT_USERUNMANAGED, dwFilter,
1925                                       dwIndex, &idx, szPatchCode,
1926                                       szTargetProductCode,
1927                                       pdwTargetProductContext,
1928                                       szTargetUserSid, pcchTargetUserSid);
1929         if (r != ERROR_NO_MORE_ITEMS)
1930             goto done;
1931     }
1932
1933     if (dwContext & MSIINSTALLCONTEXT_MACHINE)
1934     {
1935         r = msi_check_product_patches(szProductCode, szUserSid,
1936                                       MSIINSTALLCONTEXT_MACHINE, dwFilter,
1937                                       dwIndex, &idx, szPatchCode,
1938                                       szTargetProductCode,
1939                                       pdwTargetProductContext,
1940                                       szTargetUserSid, pcchTargetUserSid);
1941         if (r != ERROR_NO_MORE_ITEMS)
1942             goto done;
1943     }
1944
1945 done:
1946     if (r == ERROR_SUCCESS)
1947         last_index = dwIndex;
1948
1949     return r;
1950 }
1951
1952 /***********************************************************************
1953  * MsiEnumPatchesA            [MSI.@]
1954  */
1955 UINT WINAPI MsiEnumPatchesA(LPCSTR szProduct, DWORD iPatchIndex,
1956         LPSTR lpPatchBuf, LPSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
1957 {
1958     LPWSTR product, transforms = NULL;
1959     WCHAR patch[GUID_SIZE];
1960     DWORD len;
1961     UINT r;
1962
1963     TRACE("(%s %d %p %p %p)\n", debugstr_a(szProduct), iPatchIndex,
1964           lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
1965
1966     if (!szProduct || !lpPatchBuf || !lpTransformsBuf || !pcchTransformsBuf)
1967         return ERROR_INVALID_PARAMETER;
1968
1969     product = strdupAtoW(szProduct);
1970     if (!product)
1971         return ERROR_OUTOFMEMORY;
1972
1973     len = 0;
1974     r = MsiEnumPatchesW(product, iPatchIndex, patch, patch, &len);
1975     if (r != ERROR_MORE_DATA)
1976         goto done;
1977
1978     transforms = msi_alloc(len);
1979     if (!transforms)
1980     {
1981         r = ERROR_OUTOFMEMORY;
1982         goto done;
1983     }
1984
1985     r = MsiEnumPatchesW(product, iPatchIndex, patch, transforms, &len);
1986     if (r != ERROR_SUCCESS)
1987         goto done;
1988
1989     WideCharToMultiByte(CP_ACP, 0, patch, -1, lpPatchBuf,
1990                         GUID_SIZE, NULL, NULL);
1991
1992     WideCharToMultiByte(CP_ACP, 0, transforms, -1, lpTransformsBuf,
1993                         *pcchTransformsBuf - 1, NULL, NULL);
1994
1995     len = lstrlenW(transforms);
1996     if (*pcchTransformsBuf < len + 1)
1997     {
1998         r = ERROR_MORE_DATA;
1999         lpTransformsBuf[*pcchTransformsBuf - 1] = '\0';
2000         *pcchTransformsBuf = len * sizeof(WCHAR);
2001     }
2002     else
2003         *pcchTransformsBuf = len;
2004
2005 done:
2006     msi_free(transforms);
2007     msi_free(product);
2008
2009     return r;
2010 }
2011
2012 /***********************************************************************
2013  * MsiEnumPatchesW            [MSI.@]
2014  */
2015 UINT WINAPI MsiEnumPatchesW( LPCWSTR szProduct, DWORD iPatchIndex,
2016         LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, LPDWORD pcchTransformsBuf)
2017 {
2018     FIXME("%s %d %p %p %p\n", debugstr_w(szProduct),
2019           iPatchIndex, lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
2020     return ERROR_NO_MORE_ITEMS;
2021 }
2022
2023 UINT WINAPI MsiEnumProductsExA( LPCSTR szProductCode, LPCSTR szUserSid,
2024         DWORD dwContext, DWORD dwIndex, CHAR szInstalledProductCode[39],
2025         MSIINSTALLCONTEXT* pdwInstalledContext, LPSTR szSid, LPDWORD pcchSid)
2026 {
2027     FIXME("%s %s %d %d %p %p %p %p\n", debugstr_a(szProductCode), debugstr_a(szUserSid),
2028           dwContext, dwIndex, szInstalledProductCode, pdwInstalledContext,
2029           szSid, pcchSid);
2030     return ERROR_NO_MORE_ITEMS;
2031 }
2032
2033 UINT WINAPI MsiEnumProductsExW( LPCWSTR szProductCode, LPCWSTR szUserSid,
2034         DWORD dwContext, DWORD dwIndex, WCHAR szInstalledProductCode[39],
2035         MSIINSTALLCONTEXT* pdwInstalledContext, LPWSTR szSid, LPDWORD pcchSid)
2036 {
2037     FIXME("%s %s %d %d %p %p %p %p\n", debugstr_w(szProductCode), debugstr_w(szUserSid),
2038           dwContext, dwIndex, szInstalledProductCode, pdwInstalledContext,
2039           szSid, pcchSid);
2040     return ERROR_NO_MORE_ITEMS;
2041 }