dlls/msi/msi.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2002 Mike McCormack for Codeweavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #define NONAMELESSUNION
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winreg.h"
  28 #include "shlwapi.h"
  29 #include "wine/debug.h"
  30 #include "msi.h"
  31 #include "msiquery.h"
  32 #include "msipriv.h"
  33 #include "objidl.h"
  34 #include "wincrypt.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  37
  38 const WCHAR szInstaller[] = {
  39 'S','o','f','t','w','a','r','e','\\',
  40 'M','i','c','r','o','s','o','f','t','\\',
  41 'W','i','n','d','o','w','s','\\',
  42 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  43 'I','n','s','t','a','l','l','e','r',0 };
  44
  45 const WCHAR szFeatures[] = {
  46 'F','e','a','t','u','r','e','s',0 };
  47 const WCHAR szComponents[] = {
  48 'C','o','m','p','o','n','e','n','t','s',0 };
  49
  50 /*
  51  *  .MSI  file format
  52  *
  53  *  A .msi file is a structured storage file.
  54  *  It should contain a number of streams.
  55  */
  56
  57 BOOL unsquash_guid(LPCWSTR in, LPWSTR out)
  58 {
  59     DWORD i,n=0;
  60
  61     out[n++]='{';
  62     for(i=0; i<8; i++)
  63         out[n++] = in[7-i];
  64     out[n++]='-';
  65     for(i=0; i<4; i++)
  66         out[n++] = in[11-i];
  67     out[n++]='-';
  68     for(i=0; i<4; i++)
  69         out[n++] = in[15-i];
  70     out[n++]='-';
  71     for(i=0; i<2; i++)
  72     {
  73         out[n++] = in[17+i*2];
  74         out[n++] = in[16+i*2];
  75     }
  76     out[n++]='-';
  77     for( ; i<8; i++)
  78     {
  79         out[n++] = in[17+i*2];
  80         out[n++] = in[16+i*2];
  81     }
  82     out[n++]='}';
  83     out[n]=0;
  84     return TRUE;
  85 }
  86
  87 BOOL squash_guid(LPCWSTR in, LPWSTR out)
  88 {
  89     DWORD i,n=0;
  90
  91     if(in[n++] != '{')
  92         return FALSE;
  93     for(i=0; i<8; i++)
  94         out[7-i] = in[n++];
  95     if(in[n++] != '-')
  96         return FALSE;
  97     for(i=0; i<4; i++)
  98         out[11-i] = in[n++];
  99     if(in[n++] != '-')
 100         return FALSE;
 101     for(i=0; i<4; i++)
 102         out[15-i] = in[n++];
 103     if(in[n++] != '-')
 104         return FALSE;
 105     for(i=0; i<2; i++)
 106     {
 107         out[17+i*2] = in[n++];
 108         out[16+i*2] = in[n++];
 109     }
 110     if(in[n++] != '-')
 111         return FALSE;
 112     for( ; i<8; i++)
 113     {
 114         out[17+i*2] = in[n++];
 115         out[16+i*2] = in[n++];
 116     }
 117     out[32]=0;
 118     if(in[n++] != '}')
 119         return FALSE;
 120     if(in[n])
 121         return FALSE;
 122     return TRUE;
 123 }
 124
 125 VOID MSI_CloseDatabase( VOID *arg )
 126 {
 127     MSIDATABASE *db = (MSIDATABASE *) arg;
 128
 129     free_cached_tables( db );
 130     IStorage_Release( db->storage );
 131 }
 132
 133 UINT WINAPI MsiOpenDatabaseA(
 134                LPCSTR szDBPath, LPCSTR szPersist, MSIHANDLE *phDB)
 135 {
 136     HRESULT r = ERROR_FUNCTION_FAILED;
 137     LPWSTR szwDBPath = NULL, szwPersist = NULL;
 138
 139     TRACE("%s %s %p\n", debugstr_a(szDBPath), debugstr_a(szPersist), phDB);
 140
 141     if( szDBPath )
 142     {
 143         szwDBPath = HEAP_strdupAtoW( GetProcessHeap(), 0, szDBPath );
 144         if( !szwDBPath )
 145             goto end;
 146     }
 147
 148     if( szPersist )
 149     {
 150         szwPersist = HEAP_strdupAtoW( GetProcessHeap(), 0, szPersist );
 151         if( !szwPersist )
 152             goto end;
 153     }
 154
 155     r = MsiOpenDatabaseW( szwDBPath, szwPersist, phDB );
 156
 157 end:
 158     if( szwPersist )
 159         HeapFree( GetProcessHeap(), 0, szwPersist );
 160     if( szwDBPath )
 161         HeapFree( GetProcessHeap(), 0, szwDBPath );
 162
 163     return r;
 164 }
 165
 166 UINT WINAPI MsiOpenDatabaseW(
 167               LPCWSTR szDBPath, LPCWSTR szPersist, MSIHANDLE *phDB)
 168 {
 169     IStorage *stg = NULL;
 170     HRESULT r;
 171     MSIHANDLE handle;
 172     MSIDATABASE *db;
 173     UINT ret;
 174
 175     TRACE("%s %s %p\n",debugstr_w(szDBPath),debugstr_w(szPersist), phDB);
 176
 177     if( !phDB )
 178         return ERROR_INVALID_PARAMETER;
 179
 180     r = StgOpenStorage( szDBPath, NULL, STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 181     if( FAILED( r ) )
 182     {
 183         FIXME("open failed r = %08lx!\n",r);
 184         return ERROR_FUNCTION_FAILED;
 185     }
 186
 187     handle = alloc_msihandle(MSIHANDLETYPE_DATABASE, sizeof (MSIDATABASE), MSI_CloseDatabase );
 188     if( !handle )
 189     {
 190         FIXME("Failed to allocate a handle\n");
 191         ret = ERROR_FUNCTION_FAILED;
 192         goto end;
 193     }
 194
 195     db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
 196     if( !db )
 197     {
 198         FIXME("Failed to get handle pointer \n");
 199         ret = ERROR_FUNCTION_FAILED;
 200         goto end;
 201     }
 202     db->storage = stg;
 203     ret = load_string_table( db, &db->strings);
 204     if( ret != ERROR_SUCCESS )
 205         goto end;
 206
 207     *phDB = handle;
 208
 209     IStorage_AddRef( stg );
 210 end:
 211     if( stg )
 212         IStorage_Release( stg );
 213
 214     return ret;
 215 }
 216
 217 UINT WINAPI MsiOpenProductA(LPCSTR szProduct, MSIHANDLE *phProduct)
 218 {
 219     FIXME("%s %p\n",debugstr_a(szProduct), phProduct);
 220     return ERROR_CALL_NOT_IMPLEMENTED;
 221 }
 222
 223 UINT WINAPI MsiOpenProductW(LPCWSTR szProduct, MSIHANDLE *phProduct)
 224 {
 225     FIXME("%s %p\n",debugstr_w(szProduct), phProduct);
 226     return ERROR_CALL_NOT_IMPLEMENTED;
 227 }
 228
 229 UINT WINAPI MsiOpenPackageA(LPCSTR szPackage, MSIHANDLE *phPackage)
 230 {
 231     FIXME("%s %p\n",debugstr_a(szPackage), phPackage);
 232     return ERROR_CALL_NOT_IMPLEMENTED;
 233 }
 234
 235 UINT WINAPI MsiOpenPackageW(LPCWSTR szPackage, MSIHANDLE *phPackage)
 236 {
 237     FIXME("%s %p\n",debugstr_w(szPackage), phPackage);
 238     return ERROR_CALL_NOT_IMPLEMENTED;
 239 }
 240
 241 UINT WINAPI MsiOpenPackageExA(LPCSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
 242 {
 243     FIXME("%s 0x%08lx %p\n",debugstr_a(szPackage), dwOptions, phPackage);
 244     return ERROR_CALL_NOT_IMPLEMENTED;
 245 }
 246
 247 UINT WINAPI MsiOpenPackageExW(LPCWSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
 248 {
 249     FIXME("%s 0x%08lx %p\n",debugstr_w(szPackage), dwOptions, phPackage);
 250     return ERROR_CALL_NOT_IMPLEMENTED;
 251 }
 252
 253 UINT WINAPI MsiAdvertiseProductA(LPCSTR szPackagePath, LPCSTR szScriptfilePath, LPCSTR szTransforms, LANGID lgidLanguage)
 254 {
 255     FIXME("%s %s %s 0x%08x\n",debugstr_a(szPackagePath), debugstr_a(szScriptfilePath), debugstr_a(szTransforms), lgidLanguage);
 256     return ERROR_CALL_NOT_IMPLEMENTED;
 257 }
 258
 259 UINT WINAPI MsiAdvertiseProductW(LPCWSTR szPackagePath, LPCWSTR szScriptfilePath, LPCWSTR szTransforms, LANGID lgidLanguage)
 260 {
 261     FIXME("%s %s %s 0x%08x\n",debugstr_w(szPackagePath), debugstr_w(szScriptfilePath), debugstr_w(szTransforms), lgidLanguage);
 262     return ERROR_CALL_NOT_IMPLEMENTED;
 263 }
 264
 265 UINT WINAPI MsiAdvertiseProductExA(
 266     LPCSTR szPackagePath, LPCSTR szScriptfilePath, LPCSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
 267 {
 268     FIXME("%s %s %s 0x%08x 0x%08lx 0x%08lx\n",
 269         debugstr_a(szPackagePath), debugstr_a(szScriptfilePath), debugstr_a(szTransforms), lgidLanguage, dwPlatform, dwOptions);
 270     return ERROR_CALL_NOT_IMPLEMENTED;
 271 }
 272
 273 UINT WINAPI MsiAdvertiseProductExW(
 274     LPCWSTR szPackagePath, LPCWSTR szScriptfilePath, LPCWSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
 275 {
 276     FIXME("%s %s %s 0x%08x 0x%08lx 0x%08lx\n",
 277         debugstr_w(szPackagePath), debugstr_w(szScriptfilePath), debugstr_w(szTransforms), lgidLanguage, dwPlatform, dwOptions);
 278     return ERROR_CALL_NOT_IMPLEMENTED;
 279 }
 280
 281 UINT WINAPI MsiInstallProductA(LPCSTR szPackagePath, LPCSTR szCommandLine)
 282 {
 283     LPWSTR szwPath = NULL, szwCommand = NULL;
 284     UINT r = ERROR_FUNCTION_FAILED; /* FIXME: check return code */
 285
 286     TRACE("%s %s\n",debugstr_a(szPackagePath), debugstr_a(szCommandLine));
 287
 288     if( szPackagePath )
 289     {
 290         szwPath = HEAP_strdupAtoW(GetProcessHeap(),0,szPackagePath);
 291         if( szwPath == NULL )
 292             goto end;
 293     }
 294
 295     if( szCommandLine )
 296     {
 297         szwCommand = HEAP_strdupAtoW(GetProcessHeap(),0,szCommandLine);
 298         if( szwCommand == NULL )
 299             goto end;
 300     }
 301
 302     r = MsiInstallProductW( szwPath, szwCommand );
 303
 304 end:
 305     if( szwPath )
 306         HeapFree( GetProcessHeap(), 0, szwPath );
 307
 308     if( szwCommand )
 309         HeapFree( GetProcessHeap(), 0, szwCommand );
 310
 311     return r;
 312 }
 313
 314 UINT WINAPI MsiInstallProductW(LPCWSTR szPackagePath, LPCWSTR szCommandLine)
 315 {
 316     FIXME("%s %s\n",debugstr_w(szPackagePath), debugstr_w(szCommandLine));
 317
 318     return ERROR_CALL_NOT_IMPLEMENTED;
 319 }
 320
 321 UINT WINAPI MsiConfigureProductA(
 322               LPCSTR szProduct, int iInstallLevel, INSTALLSTATE eInstallState)
 323 {
 324     FIXME("%s %d %d\n",debugstr_a(szProduct), iInstallLevel, eInstallState);
 325     return ERROR_CALL_NOT_IMPLEMENTED;
 326 }
 327
 328 UINT WINAPI MsiConfigureProductW(
 329               LPCWSTR szProduct, int iInstallLevel, INSTALLSTATE eInstallState)
 330 {
 331     FIXME("%s %d %d\n",debugstr_w(szProduct), iInstallLevel, eInstallState);
 332     return ERROR_CALL_NOT_IMPLEMENTED;
 333 }
 334
 335 UINT WINAPI MsiGetProductCodeA(LPCSTR szComponent, LPSTR szBuffer)
 336 {
 337     FIXME("%s %s\n",debugstr_a(szComponent), debugstr_a(szBuffer));
 338     return ERROR_CALL_NOT_IMPLEMENTED;
 339 }
 340
 341 UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
 342 {
 343     FIXME("%s %s\n",debugstr_w(szComponent), debugstr_w(szBuffer));
 344     return ERROR_CALL_NOT_IMPLEMENTED;
 345 }
 346
 347 UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute, LPSTR szBuffer, DWORD *pcchValueBuf)
 348 {
 349     FIXME("%s %s %p %p\n",debugstr_a(szProduct), debugstr_a(szAttribute), szBuffer, pcchValueBuf);
 350     return ERROR_CALL_NOT_IMPLEMENTED;
 351 }
 352
 353 UINT WINAPI MsiGetProductInfoW(LPCWSTR szProduct, LPCWSTR szAttribute, LPWSTR szBuffer, DWORD *pcchValueBuf)
 354 {
 355     FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szAttribute), szBuffer, pcchValueBuf);
 356     return ERROR_CALL_NOT_IMPLEMENTED;
 357 }
 358
 359 UINT WINAPI MsiDatabaseImportA(LPCSTR szFolderPath, LPCSTR szFilename)
 360 {
 361     FIXME("%s %s\n",debugstr_a(szFolderPath), debugstr_a(szFilename));
 362     return ERROR_CALL_NOT_IMPLEMENTED;
 363 }
 364
 365 UINT WINAPI MsiDatabaseImportW(LPCWSTR szFolderPath, LPCWSTR szFilename)
 366 {
 367     FIXME("%s %s\n",debugstr_w(szFolderPath), debugstr_w(szFilename));
 368     return ERROR_CALL_NOT_IMPLEMENTED;
 369 }
 370
 371 UINT WINAPI MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, BOOL fAppend)
 372 {
 373     FIXME("%08lx %s %d\n", dwLogMode, debugstr_a(szLogFile), fAppend);
 374     return ERROR_SUCCESS;
 375     /* return ERROR_CALL_NOT_IMPLEMENTED; */
 376 }
 377
 378 UINT WINAPI MsiEnableLogW(DWORD dwLogMode, LPCWSTR szLogFile, BOOL fAppend)
 379 {
 380     FIXME("%08lx %s %d\n", dwLogMode, debugstr_w(szLogFile), fAppend);
 381     return ERROR_CALL_NOT_IMPLEMENTED;
 382 }
 383
 384 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
 385 {
 386     FIXME("%s\n", debugstr_a(szProduct));
 387     return 0;
 388 }
 389
 390 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
 391 {
 392     FIXME("%s\n", debugstr_w(szProduct));
 393     return 0;
 394 }
 395
 396 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
 397 {
 398     FIXME("%08x %p\n", dwUILevel, phWnd);
 399     return dwUILevel;
 400 }
 401
 402 UINT WINAPI MsiLoadStringA(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e, DWORD f)
 403 {
 404     FIXME("%08lx %08lx %08lx %08lx %08lx %08lx\n",a,b,c,d,e,f);
 405     return ERROR_CALL_NOT_IMPLEMENTED;
 406 }
 407
 408 UINT WINAPI MsiLoadStringW(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e, DWORD f)
 409 {
 410     FIXME("%08lx %08lx %08lx %08lx %08lx %08lx\n",a,b,c,d,e,f);
 411     return ERROR_CALL_NOT_IMPLEMENTED;
 412 }
 413
 414 UINT WINAPI MsiMessageBoxA(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e, DWORD f)
 415 {
 416     FIXME("%08lx %08lx %08lx %08lx %08lx %08lx\n",a,b,c,d,e,f);
 417     return ERROR_CALL_NOT_IMPLEMENTED;
 418 }
 419
 420 UINT WINAPI MsiMessageBoxW(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e, DWORD f)
 421 {
 422     FIXME("%08lx %08lx %08lx %08lx %08lx %08lx\n",a,b,c,d,e,f);
 423     return ERROR_CALL_NOT_IMPLEMENTED;
 424 }
 425
 426 UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
 427 {
 428     DWORD r;
 429     WCHAR szwGuid[GUID_SIZE];
 430
 431     TRACE("%ld %p\n",index,lpguid);
 432
 433     r = MsiEnumProductsW(index, szwGuid);
 434     if( r == ERROR_SUCCESS )
 435         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
 436
 437     return r;
 438 }
 439
 440 UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
 441 {
 442     HKEY hkey = 0, hkeyFeatures = 0;
 443     DWORD r;
 444     WCHAR szKeyName[33];
 445
 446     TRACE("%ld %p\n",index,lpguid);
 447
 448     r = RegOpenKeyW(HKEY_LOCAL_MACHINE, szInstaller, &hkey);
 449     if( r != ERROR_SUCCESS )
 450         goto end;
 451
 452     r = RegOpenKeyW(hkey, szFeatures, &hkeyFeatures);
 453     if( r != ERROR_SUCCESS )
 454         goto end;
 455
 456     r = RegEnumKeyW(hkeyFeatures, index, szKeyName, GUID_SIZE);
 457
 458     unsquash_guid(szKeyName, lpguid);
 459
 460 end:
 461
 462     if( hkeyFeatures )
 463         RegCloseKey(hkeyFeatures);
 464     if( hkey )
 465         RegCloseKey(hkey);
 466
 467     return r;
 468 }
 469
 470 UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index,
 471       LPSTR szFeature, LPSTR szParent)
 472 {
 473     DWORD r;
 474     WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
 475     LPWSTR szwProduct = NULL;
 476
 477     TRACE("%s %ld %p %p\n",debugstr_a(szProduct),index,szFeature,szParent);
 478
 479     if( szProduct )
 480     {
 481         szwProduct = HEAP_strdupAtoW(GetProcessHeap(),0,szProduct);
 482         if( !szwProduct )
 483             return ERROR_FUNCTION_FAILED;
 484     }
 485
 486     r = MsiEnumFeaturesW(szProduct?szwProduct:NULL,
 487                          index, szwFeature, szwParent);
 488     if( r == ERROR_SUCCESS )
 489     {
 490         WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
 491                             szFeature, GUID_SIZE, NULL, NULL);
 492         WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
 493                             szParent, GUID_SIZE, NULL, NULL);
 494     }
 495
 496     if( szwProduct )
 497         HeapFree( GetProcessHeap(), 0, szwProduct);
 498
 499     return r;
 500 }
 501
 502 UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index,
 503       LPWSTR szFeature, LPWSTR szParent)
 504 {
 505     HKEY hkey = 0, hkeyFeatures = 0, hkeyProduct = 0;
 506     DWORD r, sz;
 507     WCHAR szRegName[GUID_SIZE];
 508
 509     TRACE("%s %ld %p %p\n",debugstr_w(szProduct),index,szFeature,szParent);
 510
 511     if( !squash_guid(szProduct, szRegName) )
 512         return ERROR_INVALID_PARAMETER;
 513
 514     r = RegOpenKeyW(HKEY_LOCAL_MACHINE, szInstaller, &hkey);
 515     if( r != ERROR_SUCCESS )
 516         goto end;
 517
 518     r = RegOpenKeyW(hkey, szFeatures, &hkeyFeatures);
 519     if( r != ERROR_SUCCESS )
 520         goto end;
 521
 522     r = RegOpenKeyW(hkeyFeatures, szRegName, &hkeyProduct);
 523     if( r != ERROR_SUCCESS )
 524         goto end;
 525
 526     sz = GUID_SIZE;
 527     r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
 528
 529 end:
 530     if( hkeyProduct )
 531         RegCloseKey(hkeyProduct);
 532     if( hkeyFeatures )
 533         RegCloseKey(hkeyFeatures);
 534     if( hkey )
 535         RegCloseKey(hkey);
 536
 537     return r;
 538 }
 539
 540 UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
 541 {
 542     DWORD r;
 543     WCHAR szwGuid[GUID_SIZE];
 544
 545     TRACE("%ld %p\n",index,lpguid);
 546
 547     r = MsiEnumComponentsW(index, szwGuid);
 548     if( r == ERROR_SUCCESS )
 549         WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
 550
 551     return r;
 552 }
 553
 554 UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
 555 {
 556     HKEY hkey = 0, hkeyComponents = 0;
 557     DWORD r;
 558     WCHAR szKeyName[33];
 559
 560     TRACE("%ld %p\n",index,lpguid);
 561
 562     r = RegOpenKeyW(HKEY_LOCAL_MACHINE, szInstaller, &hkey);
 563     if( r != ERROR_SUCCESS )
 564         goto end;
 565
 566     r = RegOpenKeyW(hkey, szComponents, &hkeyComponents);
 567     if( r != ERROR_SUCCESS )
 568         goto end;
 569
 570     r = RegEnumKeyW(hkeyComponents, index, szKeyName, GUID_SIZE);
 571
 572     unsquash_guid(szKeyName, lpguid);
 573
 574 end:
 575
 576     if( hkeyComponents )
 577         RegCloseKey(hkeyComponents);
 578     if( hkey )
 579         RegCloseKey(hkey);
 580
 581     return r;
 582 }
 583
 584 UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
 585 {
 586     DWORD r;
 587     WCHAR szwProduct[GUID_SIZE];
 588     LPWSTR szwComponent = NULL;
 589
 590     TRACE("%s %ld %p\n",debugstr_a(szComponent),index,szProduct);
 591
 592     if( szComponent )
 593     {
 594         szwComponent = HEAP_strdupAtoW(GetProcessHeap(),0,szComponent);
 595         if( !szwComponent )
 596             return ERROR_FUNCTION_FAILED;
 597     }
 598
 599     r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
 600     if( r == ERROR_SUCCESS )
 601     {
 602         WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
 603                             szProduct, GUID_SIZE, NULL, NULL);
 604     }
 605
 606     if( szwComponent )
 607         HeapFree( GetProcessHeap(), 0, szwComponent);
 608
 609     return r;
 610 }
 611
 612 UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
 613 {
 614     HKEY hkey = 0, hkeyComponents = 0, hkeyComp = 0;
 615     DWORD r, sz;
 616     WCHAR szRegName[GUID_SIZE], szValName[GUID_SIZE];
 617
 618     TRACE("%s %ld %p\n",debugstr_w(szComponent),index,szProduct);
 619
 620     if( !squash_guid(szComponent, szRegName) )
 621         return ERROR_INVALID_PARAMETER;
 622
 623     r = RegOpenKeyW(HKEY_LOCAL_MACHINE, szInstaller, &hkey);
 624     if( r != ERROR_SUCCESS )
 625         goto end;
 626
 627     r = RegOpenKeyW(hkey, szComponents, &hkeyComponents);
 628     if( r != ERROR_SUCCESS )
 629         goto end;
 630
 631     r = RegOpenKeyW(hkeyComponents, szRegName, &hkeyComp);
 632     if( r != ERROR_SUCCESS )
 633         goto end;
 634
 635     sz = GUID_SIZE;
 636     r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
 637     if( r != ERROR_SUCCESS )
 638         goto end;
 639
 640     unsquash_guid(szValName, szProduct);
 641
 642 end:
 643     if( hkeyComp )
 644         RegCloseKey(hkeyComp);
 645     if( hkeyComponents )
 646         RegCloseKey(hkeyComponents);
 647     if( hkey )
 648         RegCloseKey(hkey);
 649
 650     return r;
 651 }
 652
 653 UINT WINAPI MsiEnumComponentQualifiersA(
 654     LPSTR szComponent, DWORD iIndex, LPSTR lpQualifierBuf, DWORD* pcchQualifierBuf, LPSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf)
 655 {
 656 FIXME("%s 0x%08lx %p %p %p %p\n", debugstr_a(szComponent), iIndex, lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf, pcchApplicationDataBuf);
 657     return ERROR_CALL_NOT_IMPLEMENTED;
 658 }
 659
 660 UINT WINAPI MsiEnumComponentQualifiersW(
 661     LPWSTR szComponent, DWORD iIndex, LPWSTR lpQualifierBuf, DWORD* pcchQualifierBuf, LPWSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf)
 662 {
 663 FIXME("%s 0x%08lx %p %p %p %p\n", debugstr_w(szComponent), iIndex, lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf, pcchApplicationDataBuf);
 664     return ERROR_CALL_NOT_IMPLEMENTED;
 665 }
 666
 667 UINT WINAPI MsiProvideAssemblyA(
 668     LPCSTR szAssemblyName, LPCSTR szAppContext, DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf, DWORD* pcchPathBuf)
 669 {
 670     FIXME("%s %s 0x%08lx 0x%08lx %p %p\n",
 671         debugstr_a(szAssemblyName),  debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf, pcchPathBuf);
 672     return ERROR_CALL_NOT_IMPLEMENTED;
 673 }
 674
 675 UINT WINAPI MsiProvideAssemblyW(
 676     LPCWSTR szAssemblyName, LPCWSTR szAppContext, DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf, DWORD* pcchPathBuf)
 677 {
 678     FIXME("%s %s 0x%08lx 0x%08lx %p %p\n",
 679         debugstr_w(szAssemblyName),  debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf, pcchPathBuf);
 680     return ERROR_CALL_NOT_IMPLEMENTED;
 681 }
 682
 683 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor, LPSTR szPath, DWORD *pcchPath, DWORD *pcchArgs )
 684 {
 685     FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
 686     return ERROR_CALL_NOT_IMPLEMENTED;
 687 }
 688
 689 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor, LPWSTR szPath, DWORD *pcchPath, DWORD *pcchArgs )
 690 {
 691     FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
 692     return ERROR_CALL_NOT_IMPLEMENTED;
 693 }
 694
 695 HRESULT WINAPI MsiGetFileSignatureInformationA(
 696   LPCSTR szSignedObjectPath, DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, BYTE* pbHashData, DWORD* pcbHashData)
 697 {
 698     FIXME("%s 0x%08lx %p %p %p\n", debugstr_a(szSignedObjectPath), dwFlags, ppcCertContext, pbHashData, pcbHashData);
 699     return ERROR_CALL_NOT_IMPLEMENTED;
 700 }
 701
 702 HRESULT WINAPI MsiGetFileSignatureInformationW(
 703   LPCWSTR szSignedObjectPath, DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, BYTE* pbHashData, DWORD* pcbHashData)
 704 {
 705     FIXME("%s 0x%08lx %p %p %p\n", debugstr_w(szSignedObjectPath), dwFlags, ppcCertContext, pbHashData, pcbHashData);
 706     return ERROR_CALL_NOT_IMPLEMENTED;
 707 }
 708
 709 HRESULT WINAPI MSI_DllGetVersion(DLLVERSIONINFO *pdvi)
 710 {
 711     TRACE("%p\n",pdvi);
 712
 713     if (pdvi->cbSize != sizeof(DLLVERSIONINFO))
 714         return E_INVALIDARG;
 715
 716     pdvi->dwMajorVersion = MSI_MAJORVERSION;
 717     pdvi->dwMinorVersion = MSI_MINORVERSION;
 718     pdvi->dwBuildNumber = MSI_BUILDNUMBER;
 719     pdvi->dwPlatformID = 1;
 720
 721     return S_OK;
 722 }
 723
 724 BOOL WINAPI MSI_DllCanUnloadNow(void)
 725 {
 726     return FALSE;
 727 }