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
  40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  41
  42
  43 /*
  44  * This module will be all the helper functions for registry access by the
  45  * installer bits.
  46  */
  47 static const WCHAR szUserFeatures_fmt[] = {
  48 'S','o','f','t','w','a','r','e','\\',
  49 'M','i','c','r','o','s','o','f','t','\\',
  50 'I','n','s','t','a','l','l','e','r','\\',
  51 'F','e','a','t','u','r','e','s','\\',
  52 '%','s',0};
  53
  54 static const WCHAR szInstaller_Features[] = {
  55 'S','o','f','t','w','a','r','e','\\',
  56 'M','i','c','r','o','s','o','f','t','\\',
  57 'W','i','n','d','o','w','s','\\',
  58 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  59 'I','n','s','t','a','l','l','e','r','\\',
  60 'F','e','a','t','u','r','e','s',0 };
  61
  62 static const WCHAR szInstaller_Features_fmt[] = {
  63 'S','o','f','t','w','a','r','e','\\',
  64 'M','i','c','r','o','s','o','f','t','\\',
  65 'W','i','n','d','o','w','s','\\',
  66 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  67 'I','n','s','t','a','l','l','e','r','\\',
  68 'F','e','a','t','u','r','e','s','\\',
  69 '%','s',0};
  70
  71 static const WCHAR szInstaller_Components[] = {
  72 'S','o','f','t','w','a','r','e','\\',
  73 'M','i','c','r','o','s','o','f','t','\\',
  74 'W','i','n','d','o','w','s','\\',
  75 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  76 'I','n','s','t','a','l','l','e','r','\\',
  77 'C','o','m','p','o','n','e','n','t','s',0 };
  78
  79 static const WCHAR szInstaller_Components_fmt[] = {
  80 'S','o','f','t','w','a','r','e','\\',
  81 'M','i','c','r','o','s','o','f','t','\\',
  82 'W','i','n','d','o','w','s','\\',
  83 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  84 'I','n','s','t','a','l','l','e','r','\\',
  85 'C','o','m','p','o','n','e','n','t','s','\\',
  86 '%','s',0};
  87
  88 static const WCHAR szUser_Components_fmt[] = {
  89 'S','o','f','t','w','a','r','e','\\',
  90 'M','i','c','r','o','s','o','f','t','\\',
  91 'I','n','s','t','a','l','l','e','r','\\',
  92 'C','o','m','p','o','n','e','n','t','s','\\',
  93 '%','s',0};
  94
  95 static const WCHAR szUninstall_fmt[] = {
  96 'S','o','f','t','w','a','r','e','\\',
  97 'M','i','c','r','o','s','o','f','t','\\',
  98 'W','i','n','d','o','w','s','\\',
  99 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 100 'U','n','i','n','s','t','a','l','l','\\',
 101 '%','s',0 };
 102
 103 static const WCHAR szUserProduct_fmt[] = {
 104 'S','o','f','t','w','a','r','e','\\',
 105 'M','i','c','r','o','s','o','f','t','\\',
 106 'I','n','s','t','a','l','l','e','r','\\',
 107 'P','r','o','d','u','c','t','s','\\',
 108 '%','s',0};
 109
 110 static const WCHAR szInstaller_Products[] = {
 111 'S','o','f','t','w','a','r','e','\\',
 112 'M','i','c','r','o','s','o','f','t','\\',
 113 'W','i','n','d','o','w','s','\\',
 114 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 115 'I','n','s','t','a','l','l','e','r','\\',
 116 'P','r','o','d','u','c','t','s',0};
 117
 118 static const WCHAR szInstaller_Products_fmt[] = {
 119 'S','o','f','t','w','a','r','e','\\',
 120 'M','i','c','r','o','s','o','f','t','\\',
 121 'W','i','n','d','o','w','s','\\',
 122 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 123 'I','n','s','t','a','l','l','e','r','\\',
 124 'P','r','o','d','u','c','t','s','\\',
 125 '%','s',0};
 126
 127 static const WCHAR szInstaller_UpgradeCodes[] = {
 128 'S','o','f','t','w','a','r','e','\\',
 129 'M','i','c','r','o','s','o','f','t','\\',
 130 'W','i','n','d','o','w','s','\\',
 131 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 132 'I','n','s','t','a','l','l','e','r','\\',
 133 'U','p','g','r','a','d','e','C','o','d','e','s',0};
 134
 135 static const WCHAR szInstaller_UpgradeCodes_fmt[] = {
 136 'S','o','f','t','w','a','r','e','\\',
 137 'M','i','c','r','o','s','o','f','t','\\',
 138 'W','i','n','d','o','w','s','\\',
 139 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 140 'I','n','s','t','a','l','l','e','r','\\',
 141 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
 142 '%','s',0};
 143
 144 static const WCHAR szInstaller_UserUpgradeCodes[] = {
 145 'S','o','f','t','w','a','r','e','\\',
 146 'M','i','c','r','o','s','o','f','t','\\',
 147 'I','n','s','t','a','l','l','e','r','\\',
 148 'U','p','g','r','a','d','e','C','o','d','e','s',0};
 149
 150 static const WCHAR szInstaller_UserUpgradeCodes_fmt[] = {
 151 'S','o','f','t','w','a','r','e','\\',
 152 'M','i','c','r','o','s','o','f','t','\\',
 153 'I','n','s','t','a','l','l','e','r','\\',
 154 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
 155 '%','s',0};
 156
 157
 158 #define SQUISH_GUID_SIZE 33
 159
 160 BOOL unsquash_guid(LPCWSTR in, LPWSTR out)
 161 {
 162     DWORD i,n=0;
 163
 164     out[n++]='{';
 165     for(i=0; i<8; i++)
 166         out[n++] = in[7-i];
 167     out[n++]='-';
 168     for(i=0; i<4; i++)
 169         out[n++] = in[11-i];
 170     out[n++]='-';
 171     for(i=0; i<4; i++)
 172         out[n++] = in[15-i];
 173     out[n++]='-';
 174     for(i=0; i<2; i++)
 175     {
 176         out[n++] = in[17+i*2];
 177         out[n++] = in[16+i*2];
 178     }
 179     out[n++]='-';
 180     for( ; i<8; i++)
 181     {
 182         out[n++] = in[17+i*2];
 183         out[n++] = in[16+i*2];
 184     }
 185     out[n++]='}';
 186     out[n]=0;
 187     return TRUE;
 188 }
 189
 190 BOOL squash_guid(LPCWSTR in, LPWSTR out)
 191 {
 192     DWORD i,n=1;
 193     GUID guid;
 194
 195     if (FAILED(CLSIDFromString((LPOLESTR)in, &guid)))
 196         return FALSE;
 197
 198     for(i=0; i<8; i++)
 199         out[7-i] = in[n++];
 200     n++;
 201     for(i=0; i<4; i++)
 202         out[11-i] = in[n++];
 203     n++;
 204     for(i=0; i<4; i++)
 205         out[15-i] = in[n++];
 206     n++;
 207     for(i=0; i<2; i++)
 208     {
 209         out[17+i*2] = in[n++];
 210         out[16+i*2] = in[n++];
 211     }
 212     n++;
 213     for( ; i<8; i++)
 214     {
 215         out[17+i*2] = in[n++];
 216         out[16+i*2] = in[n++];
 217     }
 218     out[32]=0;
 219     return TRUE;
 220 }
 221
 222
 223 /* tables for encoding and decoding base85 */
 224 static const unsigned char table_dec85[0x80] = {
 225 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 226 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 227 0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
 228 0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
 229 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
 230 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
 231 0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
 232 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
 233 };
 234
 235 static const char table_enc85[] =
 236 "!$%&'()*+,-.0123456789=?@ABCDEFGHIJKLMNO"
 237 "PQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwx"
 238 "yz{}~";
 239
 240 /*
 241  *  Converts a base85 encoded guid into a GUID pointer
 242  *  Base85 encoded GUIDs should be 20 characters long.
 243  *
 244  *  returns TRUE if successful, FALSE if not
 245  */
 246 BOOL decode_base85_guid( LPCWSTR str, GUID *guid )
 247 {
 248     DWORD i, val = 0, base = 1, *p;
 249
 250     if (!str)
 251         return FALSE;
 252
 253     p = (DWORD*) guid;
 254     for( i=0; i<20; i++ )
 255     {
 256         if( (i%5) == 0 )
 257         {
 258             val = 0;
 259             base = 1;
 260         }
 261         val += table_dec85[str[i]] * base;
 262         if( str[i] >= 0x80 )
 263             return FALSE;
 264         if( table_dec85[str[i]] == 0xff )
 265             return FALSE;
 266         if( (i%5) == 4 )
 267             p[i/5] = val;
 268         base *= 85;
 269     }
 270     return TRUE;
 271 }
 272
 273 /*
 274  *  Encodes a base85 guid given a GUID pointer
 275  *  Caller should provide a 21 character buffer for the encoded string.
 276  *
 277  *  returns TRUE if successful, FALSE if not
 278  */
 279 BOOL encode_base85_guid( GUID *guid, LPWSTR str )
 280 {
 281     unsigned int x, *p, i;
 282
 283     p = (unsigned int*) guid;
 284     for( i=0; i<4; i++ )
 285     {
 286         x = p[i];
 287         *str++ = table_enc85[x%85];
 288         x = x/85;
 289         *str++ = table_enc85[x%85];
 290         x = x/85;
 291         *str++ = table_enc85[x%85];
 292         x = x/85;
 293         *str++ = table_enc85[x%85];
 294         x = x/85;
 295         *str++ = table_enc85[x%85];
 296     }
 297     *str = 0;
 298
 299     return TRUE;
 300 }
 301
 302 DWORD msi_version_str_to_dword(LPCWSTR p)
 303 {
 304     DWORD major, minor = 0, build = 0, version = 0;
 305
 306     if (!p)
 307         return version;
 308
 309     major = atoiW(p);
 310
 311     p = strchrW(p, '.');
 312     if (p)
 313     {
 314         minor = atoiW(p+1);
 315         p = strchrW(p+1, '.');
 316         if (p)
 317             build = atoiW(p+1);
 318     }
 319
 320     return MAKELONG(build, MAKEWORD(minor, major));
 321 }
 322
 323 LPWSTR msi_version_dword_to_str(DWORD version)
 324 {
 325     const WCHAR fmt[] = { '%','u','.','%','u','.','%','u',0 };
 326     LPWSTR str = msi_alloc(20);
 327     sprintfW(str, fmt,
 328              (version&0xff000000)>>24,
 329              (version&0x00ff0000)>>16,
 330               version&0x0000ffff);
 331     return str;
 332 }
 333
 334 LONG msi_reg_set_val_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
 335 {
 336     DWORD len = value ? (lstrlenW(value) + 1) * sizeof (WCHAR) : 0;
 337     return RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)value, len );
 338 }
 339
 340 LONG msi_reg_set_val_multi_str( HKEY hkey, LPCWSTR name, LPCWSTR value )
 341 {
 342     LPCWSTR p = value;
 343     while (*p) p += lstrlenW(p) + 1;
 344     return RegSetValueExW( hkey, name, 0, REG_MULTI_SZ,
 345                            (const BYTE *)value, (p + 1 - value) * sizeof(WCHAR) );
 346 }
 347
 348 LONG msi_reg_set_val_dword( HKEY hkey, LPCWSTR name, DWORD val )
 349 {
 350     return RegSetValueExW( hkey, name, 0, REG_DWORD, (LPBYTE)&val, sizeof (DWORD) );
 351 }
 352
 353 LONG msi_reg_set_subkey_val( HKEY hkey, LPCWSTR path, LPCWSTR name, LPCWSTR val )
 354 {
 355     HKEY hsubkey = 0;
 356     LONG r;
 357
 358     r = RegCreateKeyW( hkey, path, &hsubkey );
 359     if (r != ERROR_SUCCESS)
 360         return r;
 361     r = msi_reg_set_val_str( hsubkey, name, val );
 362     RegCloseKey( hsubkey );
 363     return r;
 364 }
 365
 366 LPWSTR msi_reg_get_val_str( HKEY hkey, LPCWSTR name )
 367 {
 368     DWORD len = 0;
 369     LPWSTR val;
 370     LONG r;
 371
 372     r = RegQueryValueExW(hkey, name, NULL, NULL, NULL, &len);
 373     if (r != ERROR_SUCCESS)
 374         return NULL;
 375
 376     len += sizeof (WCHAR);
 377     val = msi_alloc( len );
 378     if (!val)
 379         return NULL;
 380     val[0] = 0;
 381     RegQueryValueExW(hkey, name, NULL, NULL, (LPBYTE) val, &len);
 382     return val;
 383 }
 384
 385 BOOL msi_reg_get_val_dword( HKEY hkey, LPCWSTR name, DWORD *val)
 386 {
 387     DWORD type, len = sizeof (DWORD);
 388     LONG r = RegQueryValueExW(hkey, name, NULL, &type, (LPBYTE) val, &len);
 389     return r == ERROR_SUCCESS && type == REG_DWORD;
 390 }
 391
 392 UINT MSIREG_OpenUninstallKey(LPCWSTR szProduct, HKEY* key, BOOL create)
 393 {
 394     UINT rc;
 395     WCHAR keypath[0x200];
 396     TRACE("%s\n",debugstr_w(szProduct));
 397
 398     sprintfW(keypath,szUninstall_fmt,szProduct);
 399
 400     if (create)
 401         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 402     else
 403         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key);
 404
 405     return rc;
 406 }
 407
 408 UINT MSIREG_OpenUserProductsKey(LPCWSTR szProduct, HKEY* key, BOOL create)
 409 {
 410     UINT rc;
 411     WCHAR squished_pc[GUID_SIZE];
 412     WCHAR keypath[0x200];
 413
 414     TRACE("%s\n",debugstr_w(szProduct));
 415     squash_guid(szProduct,squished_pc);
 416     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 417
 418     sprintfW(keypath,szUserProduct_fmt,squished_pc);
 419
 420     if (create)
 421         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
 422     else
 423         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
 424
 425     return rc;
 426 }
 427
 428 UINT MSIREG_OpenUserFeaturesKey(LPCWSTR szProduct, HKEY* key, BOOL create)
 429 {
 430     UINT rc;
 431     WCHAR squished_pc[GUID_SIZE];
 432     WCHAR keypath[0x200];
 433
 434     TRACE("%s\n",debugstr_w(szProduct));
 435     squash_guid(szProduct,squished_pc);
 436     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 437
 438     sprintfW(keypath,szUserFeatures_fmt,squished_pc);
 439
 440     if (create)
 441         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
 442     else
 443         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
 444
 445     return rc;
 446 }
 447
 448 UINT MSIREG_OpenFeatures(HKEY* key)
 449 {
 450     return RegCreateKeyW(HKEY_LOCAL_MACHINE,szInstaller_Features,key);
 451 }
 452
 453 UINT MSIREG_OpenFeaturesKey(LPCWSTR szProduct, HKEY* key, BOOL create)
 454 {
 455     UINT rc;
 456     WCHAR squished_pc[GUID_SIZE];
 457     WCHAR keypath[0x200];
 458
 459     TRACE("%s\n",debugstr_w(szProduct));
 460     squash_guid(szProduct,squished_pc);
 461     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 462
 463     sprintfW(keypath,szInstaller_Features_fmt,squished_pc);
 464
 465     if (create)
 466         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 467     else
 468         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 469
 470     return rc;
 471 }
 472
 473 UINT MSIREG_OpenComponents(HKEY* key)
 474 {
 475     return RegCreateKeyW(HKEY_LOCAL_MACHINE,szInstaller_Components,key);
 476 }
 477
 478 UINT MSIREG_OpenComponentsKey(LPCWSTR szComponent, HKEY* key, BOOL create)
 479 {
 480     UINT rc;
 481     WCHAR squished_cc[GUID_SIZE];
 482     WCHAR keypath[0x200];
 483
 484     TRACE("%s\n",debugstr_w(szComponent));
 485     squash_guid(szComponent,squished_cc);
 486     TRACE("squished (%s)\n", debugstr_w(squished_cc));
 487
 488     sprintfW(keypath,szInstaller_Components_fmt,squished_cc);
 489
 490     if (create)
 491         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 492     else
 493         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 494
 495     return rc;
 496 }
 497
 498 UINT MSIREG_OpenUserComponentsKey(LPCWSTR szComponent, HKEY* key, BOOL create)
 499 {
 500     UINT rc;
 501     WCHAR squished_cc[GUID_SIZE];
 502     WCHAR keypath[0x200];
 503
 504     TRACE("%s\n",debugstr_w(szComponent));
 505     squash_guid(szComponent,squished_cc);
 506     TRACE("squished (%s)\n", debugstr_w(squished_cc));
 507
 508     sprintfW(keypath,szUser_Components_fmt,squished_cc);
 509
 510     if (create)
 511         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
 512     else
 513         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
 514
 515     return rc;
 516 }
 517
 518 UINT MSIREG_OpenProductsKey(LPCWSTR szProduct, HKEY* key, BOOL create)
 519 {
 520     UINT rc;
 521     WCHAR squished_pc[GUID_SIZE];
 522     WCHAR keypath[0x200];
 523
 524     TRACE("%s\n",debugstr_w(szProduct));
 525     squash_guid(szProduct,squished_pc);
 526     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 527
 528     sprintfW(keypath,szInstaller_Products_fmt,squished_pc);
 529
 530     if (create)
 531         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 532     else
 533         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 534
 535     return rc;
 536 }
 537
 538 UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
 539 {
 540     UINT rc;
 541     WCHAR squished_pc[GUID_SIZE];
 542     WCHAR keypath[0x200];
 543
 544     TRACE("%s\n",debugstr_w(szUpgradeCode));
 545     squash_guid(szUpgradeCode,squished_pc);
 546     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 547
 548     sprintfW(keypath,szInstaller_UpgradeCodes_fmt,squished_pc);
 549
 550     if (create)
 551         rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 552     else
 553         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
 554
 555     return rc;
 556 }
 557
 558 UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
 559 {
 560     UINT rc;
 561     WCHAR squished_pc[GUID_SIZE];
 562     WCHAR keypath[0x200];
 563
 564     TRACE("%s\n",debugstr_w(szUpgradeCode));
 565     squash_guid(szUpgradeCode,squished_pc);
 566     TRACE("squished (%s)\n", debugstr_w(squished_pc));
 567
 568     sprintfW(keypath,szInstaller_UserUpgradeCodes_fmt,squished_pc);
 569
 570     if (create)
 571         rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key);
 572     else
 573         rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key);
 574
 575     return rc;
 576 }
 577
 578
 579 /*************************************************************************
 580  *  MsiDecomposeDescriptorW   [MSI.@]
 581  *
 582  * Decomposes an MSI descriptor into product, feature and component parts.
 583  * An MSI descriptor is a string of the form:
 584  *   [base 85 guid] [feature code] '>' [base 85 guid]
 585  *
 586  * PARAMS
 587  *   szDescriptor  [I]  the descriptor to decompose
 588  *   szProduct     [O]  buffer of MAX_FEATURE_CHARS+1 for the product guid
 589  *   szFeature     [O]  buffer of MAX_FEATURE_CHARS+1 for the feature code
 590  *   szComponent   [O]  buffer of MAX_FEATURE_CHARS+1 for the component guid
 591  *   pUsed         [O]  the length of the descriptor
 592  *
 593  * RETURNS
 594  *   ERROR_SUCCESS             if everything worked correctly
 595  *   ERROR_INVALID_PARAMETER   if the descriptor was invalid
 596  *
 597  */
 598 UINT WINAPI MsiDecomposeDescriptorW( LPCWSTR szDescriptor, LPWSTR szProduct,
 599                 LPWSTR szFeature, LPWSTR szComponent, DWORD *pUsed )
 600 {
 601     UINT r, len;
 602     LPWSTR p;
 603     GUID product, component;
 604
 605     TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
 606           szFeature, szComponent, pUsed);
 607
 608     r = decode_base85_guid( szDescriptor, &product );
 609     if( !r )
 610         return ERROR_INVALID_PARAMETER;
 611
 612     TRACE("product %s\n", debugstr_guid( &product ));
 613
 614     p = strchrW(&szDescriptor[20],'>');
 615     if( !p )
 616         return ERROR_INVALID_PARAMETER;
 617
 618     len = (p - &szDescriptor[20]);
 619     if( len > MAX_FEATURE_CHARS )
 620         return ERROR_INVALID_PARAMETER;
 621
 622     TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
 623
 624     r = decode_base85_guid( p+1, &component );
 625     if( !r )
 626         return ERROR_INVALID_PARAMETER;
 627
 628     TRACE("component %s\n", debugstr_guid( &component ));
 629
 630     if (szProduct)
 631         StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
 632     if (szComponent)
 633         StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
 634     if (szFeature)
 635     {
 636         memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
 637         szFeature[len] = 0;
 638     }
 639     len = ( &p[21] - szDescriptor );
 640
 641     TRACE("length = %d\n", len);
 642     *pUsed = len;
 643
 644     return ERROR_SUCCESS;
 645 }
 646
 647 UINT WINAPI MsiDecomposeDescriptorA( LPCSTR szDescriptor, LPSTR szProduct,
 648                 LPSTR szFeature, LPSTR szComponent, DWORD *pUsed )
 649 {
 650     WCHAR product[MAX_FEATURE_CHARS+1];
 651     WCHAR feature[MAX_FEATURE_CHARS+1];
 652     WCHAR component[MAX_FEATURE_CHARS+1];
 653     LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
 654     UINT r;
 655
 656     TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
 657           szFeature, szComponent, pUsed);
 658
 659     str = strdupAtoW( szDescriptor );
 660     if( szDescriptor && !str )
 661         return ERROR_OUTOFMEMORY;
 662
 663     if (szProduct)
 664         p = product;
 665     if (szFeature)
 666         f = feature;
 667     if (szComponent)
 668         c = component;
 669
 670     r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
 671
 672     if (r == ERROR_SUCCESS)
 673     {
 674         WideCharToMultiByte( CP_ACP, 0, p, -1,
 675                              szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
 676         WideCharToMultiByte( CP_ACP, 0, f, -1,
 677                              szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
 678         WideCharToMultiByte( CP_ACP, 0, c, -1,
 679                              szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
 680     }
 681
 682     msi_free( str );
 683
 684     return r;
 685 }
 686
 687 UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
 688 {
 689     DWORD r;
 690     WCHAR szwGuid[GUID_SIZE];
 691
 692     TRACE("%d %p\n", index, lpguid);
 693
 694     if (NULL == lpguid)
 695         return ERROR_INVALID_PARAMETER;
 696     r = MsiEnumProductsW(index, szwGuid);
 697     if( r == ERROR_SUCCESS )
 698         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
 699
 700     return r;
 701 }
 702
 703 UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
 704 {
 705     HKEY hkeyFeatures = 0;
 706     DWORD r;
 707     WCHAR szKeyName[SQUISH_GUID_SIZE];
 708
 709     TRACE("%d %p\n", index, lpguid);
 710
 711     if (NULL == lpguid)
 712         return ERROR_INVALID_PARAMETER;
 713
 714     r = MSIREG_OpenFeatures(&hkeyFeatures);
 715     if( r != ERROR_SUCCESS )
 716         return ERROR_NO_MORE_ITEMS;
 717
 718     r = RegEnumKeyW(hkeyFeatures, index, szKeyName, SQUISH_GUID_SIZE);
 719     if( r == ERROR_SUCCESS )
 720         unsquash_guid(szKeyName, lpguid);
 721     RegCloseKey(hkeyFeatures);
 722
 723     return r;
 724 }
 725
 726 UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index,
 727       LPSTR szFeature, LPSTR szParent)
 728 {
 729     DWORD r;
 730     WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
 731     LPWSTR szwProduct = NULL;
 732
 733     TRACE("%s %d %p %p\n", debugstr_a(szProduct), index, szFeature, szParent);
 734
 735     if( szProduct )
 736     {
 737         szwProduct = strdupAtoW( szProduct );
 738         if( !szwProduct )
 739             return ERROR_OUTOFMEMORY;
 740     }
 741
 742     r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
 743     if( r == ERROR_SUCCESS )
 744     {
 745         WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
 746                             szFeature, GUID_SIZE, NULL, NULL);
 747         WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
 748                             szParent, GUID_SIZE, NULL, NULL);
 749     }
 750
 751     msi_free( szwProduct);
 752
 753     return r;
 754 }
 755
 756 UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index,
 757       LPWSTR szFeature, LPWSTR szParent)
 758 {
 759     HKEY hkeyProduct = 0;
 760     DWORD r, sz;
 761
 762     TRACE("%s %d %p %p\n", debugstr_w(szProduct), index, szFeature, szParent);
 763
 764     if( !szProduct )
 765         return ERROR_INVALID_PARAMETER;
 766
 767     r = MSIREG_OpenFeaturesKey(szProduct,&hkeyProduct,FALSE);
 768     if( r != ERROR_SUCCESS )
 769         return ERROR_NO_MORE_ITEMS;
 770
 771     sz = GUID_SIZE;
 772     r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
 773     RegCloseKey(hkeyProduct);
 774
 775     return r;
 776 }
 777
 778 UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
 779 {
 780     DWORD r;
 781     WCHAR szwGuid[GUID_SIZE];
 782
 783     TRACE("%d %p\n", index, lpguid);
 784
 785     r = MsiEnumComponentsW(index, szwGuid);
 786     if( r == ERROR_SUCCESS )
 787         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
 788
 789     return r;
 790 }
 791
 792 UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
 793 {
 794     HKEY hkeyComponents = 0;
 795     DWORD r;
 796     WCHAR szKeyName[SQUISH_GUID_SIZE];
 797
 798     TRACE("%d %p\n", index, lpguid);
 799
 800     r = MSIREG_OpenComponents(&hkeyComponents);
 801     if( r != ERROR_SUCCESS )
 802         return ERROR_NO_MORE_ITEMS;
 803
 804     r = RegEnumKeyW(hkeyComponents, index, szKeyName, SQUISH_GUID_SIZE);
 805     if( r == ERROR_SUCCESS )
 806         unsquash_guid(szKeyName, lpguid);
 807     RegCloseKey(hkeyComponents);
 808
 809     return r;
 810 }
 811
 812 UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
 813 {
 814     DWORD r;
 815     WCHAR szwProduct[GUID_SIZE];
 816     LPWSTR szwComponent = NULL;
 817
 818     TRACE("%s %d %p\n", debugstr_a(szComponent), index, szProduct);
 819
 820     if( szComponent )
 821     {
 822         szwComponent = strdupAtoW( szComponent );
 823         if( !szwComponent )
 824             return ERROR_OUTOFMEMORY;
 825     }
 826
 827     r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
 828     if( r == ERROR_SUCCESS )
 829     {
 830         WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
 831                             szProduct, GUID_SIZE, NULL, NULL);
 832     }
 833
 834     msi_free( szwComponent);
 835
 836     return r;
 837 }
 838
 839 UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
 840 {
 841     HKEY hkeyComp = 0;
 842     DWORD r, sz;
 843     WCHAR szValName[SQUISH_GUID_SIZE];
 844
 845     TRACE("%s %d %p\n", debugstr_w(szComponent), index, szProduct);
 846
 847     r = MSIREG_OpenComponentsKey(szComponent,&hkeyComp,FALSE);
 848     if( r != ERROR_SUCCESS )
 849         return ERROR_NO_MORE_ITEMS;
 850
 851     sz = SQUISH_GUID_SIZE;
 852     r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
 853     if( r == ERROR_SUCCESS )
 854         unsquash_guid(szValName, szProduct);
 855
 856     RegCloseKey(hkeyComp);
 857
 858     return r;
 859 }
 860
 861 static UINT WINAPI MSI_EnumComponentQualifiers( LPCWSTR szComponent, DWORD iIndex,
 862                 awstring *lpQualBuf, DWORD* pcchQual,
 863                 awstring *lpAppBuf, DWORD* pcchAppBuf )
 864 {
 865     DWORD name_sz, val_sz, name_max, val_max, type, ofs;
 866     LPWSTR name = NULL, val = NULL;
 867     UINT r, r2;
 868     HKEY key;
 869
 870     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
 871           lpQualBuf, pcchQual, lpAppBuf, pcchAppBuf);
 872
 873     if (!szComponent)
 874         return ERROR_INVALID_PARAMETER;
 875
 876     r = MSIREG_OpenUserComponentsKey( szComponent, &key, FALSE );
 877     if (r != ERROR_SUCCESS)
 878         return ERROR_UNKNOWN_COMPONENT;
 879
 880     /* figure out how big the name is we want to return */
 881     name_max = 0x10;
 882     r = ERROR_OUTOFMEMORY;
 883     name = msi_alloc( name_max * sizeof(WCHAR) );
 884     if (!name)
 885         goto end;
 886
 887     val_max = 0x10;
 888     r = ERROR_OUTOFMEMORY;
 889     val = msi_alloc( val_max );
 890     if (!val)
 891         goto end;
 892
 893     /* loop until we allocate enough memory */
 894     while (1)
 895     {
 896         name_sz = name_max;
 897         val_sz = val_max;
 898         r = RegEnumValueW( key, iIndex, name, &name_sz,
 899                            NULL, &type, (LPBYTE)val, &val_sz );
 900         if (r == ERROR_SUCCESS)
 901             break;
 902         if (r != ERROR_MORE_DATA)
 903             goto end;
 904
 905         if (type != REG_MULTI_SZ)
 906         {
 907             ERR("component data has wrong type (%d)\n", type);
 908             goto end;
 909         }
 910
 911         r = ERROR_OUTOFMEMORY;
 912         if ((name_sz+1) >= name_max)
 913         {
 914             name_max *= 2;
 915             msi_free( name );
 916             name = msi_alloc( name_max * sizeof (WCHAR) );
 917             if (!name)
 918                 goto end;
 919             continue;
 920         }
 921         if (val_sz > val_max)
 922         {
 923             val_max = val_sz + sizeof (WCHAR);
 924             msi_free( val );
 925             val = msi_alloc( val_max * sizeof (WCHAR) );
 926             if (!val)
 927                 goto end;
 928             continue;
 929         }
 930         ERR("should be enough data, but isn't %d %d\n", name_sz, val_sz );
 931         goto end;
 932     }
 933
 934     ofs = 0;
 935     r = MsiDecomposeDescriptorW( val, NULL, NULL, NULL, &ofs );
 936     if (r != ERROR_SUCCESS)
 937         goto end;
 938
 939     TRACE("Providing %s and %s\n", debugstr_w(name), debugstr_w(val+ofs));
 940
 941     r = msi_strcpy_to_awstring( name, lpQualBuf, pcchQual );
 942     r2 = msi_strcpy_to_awstring( val+ofs, lpAppBuf, pcchAppBuf );
 943
 944     if (r2 != ERROR_SUCCESS)
 945         r = r2;
 946
 947 end:
 948     msi_free(val);
 949     msi_free(name);
 950     RegCloseKey(key);
 951
 952     return r;
 953 }
 954
 955 /*************************************************************************
 956  *  MsiEnumComponentQualifiersA [MSI.@]
 957  */
 958 UINT WINAPI MsiEnumComponentQualifiersA( LPCSTR szComponent, DWORD iIndex,
 959                 LPSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
 960                 LPSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf )
 961 {
 962     awstring qual, appdata;
 963     LPWSTR comp;
 964     UINT r;
 965
 966     TRACE("%s %08x %p %p %p %p\n", debugstr_a(szComponent), iIndex,
 967           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
 968           pcchApplicationDataBuf);
 969
 970     comp = strdupAtoW( szComponent );
 971     if (szComponent && !comp)
 972         return ERROR_OUTOFMEMORY;
 973
 974     qual.unicode = FALSE;
 975     qual.str.a = lpQualifierBuf;
 976
 977     appdata.unicode = FALSE;
 978     appdata.str.a = lpApplicationDataBuf;
 979
 980     r = MSI_EnumComponentQualifiers( comp, iIndex,
 981               &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
 982     msi_free( comp );
 983     return r;
 984 }
 985
 986 /*************************************************************************
 987  *  MsiEnumComponentQualifiersW [MSI.@]
 988  */
 989 UINT WINAPI MsiEnumComponentQualifiersW( LPCWSTR szComponent, DWORD iIndex,
 990                 LPWSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
 991                 LPWSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf )
 992 {
 993     awstring qual, appdata;
 994
 995     TRACE("%s %08x %p %p %p %p\n", debugstr_w(szComponent), iIndex,
 996           lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
 997           pcchApplicationDataBuf);
 998
 999     qual.unicode = TRUE;
1000     qual.str.w = lpQualifierBuf;
1001
1002     appdata.unicode = TRUE;
1003     appdata.str.w = lpApplicationDataBuf;
1004
1005     return MSI_EnumComponentQualifiers( szComponent, iIndex,
1006                  &qual, pcchQualifierBuf, &appdata, pcchApplicationDataBuf );
1007 }
1008
1009 /*************************************************************************
1010  *  MsiEnumRelatedProductsW   [MSI.@]
1011  *
1012  */
1013 UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
1014                                     DWORD iProductIndex, LPWSTR lpProductBuf)
1015 {
1016     UINT r;
1017     HKEY hkey;
1018     WCHAR szKeyName[SQUISH_GUID_SIZE];
1019
1020     TRACE("%s %u %u %p\n", debugstr_w(szUpgradeCode), dwReserved,
1021           iProductIndex, lpProductBuf);
1022
1023     if (NULL == szUpgradeCode)
1024         return ERROR_INVALID_PARAMETER;
1025     if (NULL == lpProductBuf)
1026         return ERROR_INVALID_PARAMETER;
1027
1028     r = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
1029     if (r != ERROR_SUCCESS)
1030         return ERROR_NO_MORE_ITEMS;
1031
1032     r = RegEnumKeyW(hkey, iProductIndex, szKeyName, SQUISH_GUID_SIZE);
1033     if( r == ERROR_SUCCESS )
1034         unsquash_guid(szKeyName, lpProductBuf);
1035     RegCloseKey(hkey);
1036
1037     return r;
1038 }
1039
1040 /*************************************************************************
1041  *  MsiEnumRelatedProductsA   [MSI.@]
1042  *
1043  */
1044 UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
1045                                     DWORD iProductIndex, LPSTR lpProductBuf)
1046 {
1047     LPWSTR szwUpgradeCode = NULL;
1048     WCHAR productW[GUID_SIZE];
1049     UINT r;
1050
1051     TRACE("%s %u %u %p\n", debugstr_a(szUpgradeCode), dwReserved,
1052           iProductIndex, lpProductBuf);
1053
1054     if (szUpgradeCode)
1055     {
1056         szwUpgradeCode = strdupAtoW( szUpgradeCode );
1057         if( !szwUpgradeCode )
1058             return ERROR_OUTOFMEMORY;
1059     }
1060
1061     r = MsiEnumRelatedProductsW( szwUpgradeCode, dwReserved,
1062                                  iProductIndex, productW );
1063     if (r == ERROR_SUCCESS)
1064     {
1065         WideCharToMultiByte( CP_ACP, 0, productW, GUID_SIZE,
1066                              lpProductBuf, GUID_SIZE, NULL, NULL );
1067     }
1068     msi_free( szwUpgradeCode);
1069     return r;
1070 }
1071
1072 /***********************************************************************
1073  * MsiEnumPatchesA            [MSI.@]
1074  */
1075 UINT WINAPI MsiEnumPatchesA( LPCSTR szProduct, DWORD iPatchIndex,
1076         LPSTR lpPatchBuf, LPSTR lpTransformsBuf, DWORD* pcchTransformsBuf)
1077 {
1078     FIXME("%s %d %p %p %p\n", debugstr_a(szProduct),
1079           iPatchIndex, lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
1080     return ERROR_NO_MORE_ITEMS;
1081 }
1082
1083 /***********************************************************************
1084  * MsiEnumPatchesW            [MSI.@]
1085  */
1086 UINT WINAPI MsiEnumPatchesW( LPCWSTR szProduct, DWORD iPatchIndex,
1087         LPWSTR lpPatchBuf, LPWSTR lpTransformsBuf, DWORD* pcchTransformsBuf)
1088 {
1089     FIXME("%s %d %p %p %p\n", debugstr_w(szProduct),
1090           iPatchIndex, lpPatchBuf, lpTransformsBuf, pcchTransformsBuf);
1091     return ERROR_NO_MORE_ITEMS;
1092 }